]> code.delx.au - gnu-emacs/blob - lisp/emacs-lisp/edebug.el
* emacs-lisp/edebug.el (edebug-safe-prin1-to-string): Capture
[gnu-emacs] / lisp / emacs-lisp / edebug.el
1 ;;; edebug.el --- a source-level debugger for Emacs Lisp
2
3 ;; Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1997, 1999,
4 ;; 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
5
6 ;; Author: Daniel LaLiberte <liberte@holonexus.org>
7 ;; Maintainer: FSF
8 ;; Keywords: lisp, tools, maint
9
10 ;; This file is part of GNU Emacs.
11
12 ;; GNU Emacs is free software; you can redistribute it and/or modify
13 ;; it under the terms of the GNU General Public License as published by
14 ;; the Free Software Foundation; either version 2, or (at your option)
15 ;; any later version.
16
17 ;; GNU Emacs is distributed in the hope that it will be useful,
18 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 ;; GNU General Public License for more details.
21
22 ;; You should have received a copy of the GNU General Public License
23 ;; along with GNU Emacs; see the file COPYING. If not, write to the
24 ;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
25 ;; Boston, MA 02110-1301, USA.
26
27 ;;; Commentary:
28
29 ;; This minor mode allows programmers to step through Emacs Lisp
30 ;; source code while executing functions. You can also set
31 ;; breakpoints, trace (stopping at each expression), evaluate
32 ;; expressions as if outside Edebug, reevaluate and display a list of
33 ;; expressions, trap errors normally caught by debug, and display a
34 ;; debug style backtrace.
35
36 ;;; Minimal Instructions
37 ;; =====================
38
39 ;; First evaluate a defun with C-M-x, then run the function. Step
40 ;; through the code with SPC, mark breakpoints with b, go until a
41 ;; breakpoint is reached with g, and quit execution with q. Use the
42 ;; "?" command in edebug to describe other commands.
43 ;; See the Emacs Lisp Reference Manual for more details.
44
45 ;; If you wish to change the default edebug global command prefix, change:
46 ;; (setq edebug-global-prefix "\C-xX")
47
48 ;; Edebug was written by
49 ;; Daniel LaLiberte
50 ;; GTE Labs
51 ;; 40 Sylvan Rd
52 ;; Waltham, MA 02254
53 ;; liberte@holonexus.org
54
55 ;;; Code:
56
57 ;;; Bug reporting
58
59 (defalias 'edebug-submit-bug-report 'report-emacs-bug)
60
61 ;;; Options
62
63 (defgroup edebug nil
64 "A source-level debugger for Emacs Lisp."
65 :group 'lisp)
66
67
68 (defcustom edebug-setup-hook nil
69 "*Functions to call before edebug is used.
70 Each time it is set to a new value, Edebug will call those functions
71 once and then `edebug-setup-hook' is reset to nil. You could use this
72 to load up Edebug specifications associated with a package you are
73 using but only when you also use Edebug."
74 :type 'hook
75 :group 'edebug)
76
77 ;; edebug-all-defs and edebug-all-forms need to be autoloaded
78 ;; because the byte compiler binds them; as a result, if edebug
79 ;; is first loaded for a require in a compilation, they will be left unbound.
80
81 ;;;###autoload
82 (defcustom edebug-all-defs nil
83 "*If non-nil, evaluating defining forms instruments for Edebug.
84 This applies to `eval-defun', `eval-region', `eval-buffer', and
85 `eval-current-buffer'. `eval-region' is also called by
86 `eval-last-sexp', and `eval-print-last-sexp'.
87
88 You can use the command `edebug-all-defs' to toggle the value of this
89 variable. You may wish to make it local to each buffer with
90 \(make-local-variable 'edebug-all-defs) in your
91 `emacs-lisp-mode-hook'."
92 :type 'boolean
93 :group 'edebug)
94
95 ;; edebug-all-defs and edebug-all-forms need to be autoloaded
96 ;; because the byte compiler binds them; as a result, if edebug
97 ;; is first loaded for a require in a compilation, they will be left unbound.
98
99 ;;;###autoload
100 (defcustom edebug-all-forms nil
101 "*Non-nil evaluation of all forms will instrument for Edebug.
102 This doesn't apply to loading or evaluations in the minibuffer.
103 Use the command `edebug-all-forms' to toggle the value of this option."
104 :type 'boolean
105 :group 'edebug)
106
107 (defcustom edebug-eval-macro-args nil
108 "*Non-nil means all macro call arguments may be evaluated.
109 If this variable is nil, the default, Edebug will *not* wrap
110 macro call arguments as if they will be evaluated.
111 For each macro, a `edebug-form-spec' overrides this option.
112 So to specify exceptions for macros that have some arguments evaluated
113 and some not, you should specify an `edebug-form-spec'."
114 :type 'boolean
115 :group 'edebug)
116
117 (defcustom edebug-save-windows t
118 "*If non-nil, Edebug saves and restores the window configuration.
119 That takes some time, so if your program does not care what happens to
120 the window configurations, it is better to set this variable to nil.
121
122 If the value is a list, only the listed windows are saved and
123 restored.
124
125 `edebug-toggle-save-windows' may be used to change this variable."
126 :type '(choice boolean (repeat string))
127 :group 'edebug)
128
129 (defcustom edebug-save-displayed-buffer-points nil
130 "*If non-nil, save and restore point in all displayed buffers.
131
132 Saving and restoring point in other buffers is necessary if you are
133 debugging code that changes the point of a buffer which is displayed
134 in a non-selected window. If Edebug or the user then selects the
135 window, the buffer's point will be changed to the window's point.
136
137 Saving and restoring point in all buffers is expensive, since it
138 requires selecting each window twice, so enable this only if you need
139 it."
140 :type 'boolean
141 :group 'edebug)
142
143 (defcustom edebug-initial-mode 'step
144 "*Initial execution mode for Edebug, if non-nil.
145 If this variable is non-nil, it specifies the initial execution mode
146 for Edebug when it is first activated. Possible values are step, next,
147 go, Go-nonstop, trace, Trace-fast, continue, and Continue-fast."
148 :type '(choice (const step) (const next) (const go)
149 (const Go-nonstop) (const trace)
150 (const Trace-fast) (const continue)
151 (const Continue-fast))
152 :group 'edebug)
153
154 (defcustom edebug-trace nil
155 "*Non-nil means display a trace of function entry and exit.
156 Tracing output is displayed in a buffer named `*edebug-trace*', one
157 function entry or exit per line, indented by the recursion level.
158
159 You can customize by replacing functions `edebug-print-trace-before'
160 and `edebug-print-trace-after'."
161 :type 'boolean
162 :group 'edebug)
163
164 (defcustom edebug-test-coverage nil
165 "*If non-nil, Edebug tests coverage of all expressions debugged.
166 This is done by comparing the result of each expression
167 with the previous result. Coverage is considered OK if two different
168 results are found.
169
170 Use `edebug-display-freq-count' to display the frequency count and
171 coverage information for a definition."
172 :type 'boolean
173 :group 'edebug)
174
175 (defcustom edebug-continue-kbd-macro nil
176 "*If non-nil, continue defining or executing any keyboard macro.
177 Use this with caution since it is not debugged."
178 :type 'boolean
179 :group 'edebug)
180
181
182 (defcustom edebug-print-length 50
183 "*Default value of `print-length' for printing results in Edebug."
184 :type 'integer
185 :group 'edebug)
186 (defcustom edebug-print-level 50
187 "*Default value of `print-level' for printing results in Edebug."
188 :type 'integer
189 :group 'edebug)
190 (defcustom edebug-print-circle t
191 "*Default value of `print-circle' for printing results in Edebug."
192 :type 'boolean
193 :group 'edebug)
194
195 (defcustom edebug-unwrap-results nil
196 "*Non-nil if Edebug should unwrap results of expressions.
197 This is useful when debugging macros where the results of expressions
198 are instrumented expressions. But don't do this when results might be
199 circular or an infinite loop will result."
200 :type 'boolean
201 :group 'edebug)
202
203 (defcustom edebug-on-error t
204 "*Value bound to `debug-on-error' while Edebug is active.
205
206 If `debug-on-error' is non-nil, that value is still used.
207
208 If the value is a list of signal names, Edebug will stop when any of
209 these errors are signaled from Lisp code whether or not the signal is
210 handled by a `condition-case'. This option is useful for debugging
211 signals that *are* handled since they would otherwise be missed.
212 After execution is resumed, the error is signaled again."
213 :type '(choice (const :tag "off")
214 (repeat :menu-tag "When"
215 :value (nil)
216 (symbol :format "%v"))
217 (const :tag "always" t))
218 :group 'edebug)
219
220 (defcustom edebug-on-quit t
221 "*Value bound to `debug-on-quit' while Edebug is active."
222 :type 'boolean
223 :group 'edebug)
224
225 (defcustom edebug-global-break-condition nil
226 "*If non-nil, an expression to test for at every stop point.
227 If the result is non-nil, then break. Errors are ignored."
228 :type 'sexp
229 :group 'edebug)
230
231 (defcustom edebug-sit-for-seconds 1
232 "*Number of seconds to pause when execution mode is `trace'."
233 :type 'number
234 :group 'edebug)
235
236 ;;; Form spec utilities.
237
238 ;;;###autoload
239 (defmacro def-edebug-spec (symbol spec)
240 "Set the `edebug-form-spec' property of SYMBOL according to SPEC.
241 Both SYMBOL and SPEC are unevaluated. The SPEC can be 0, t, a symbol
242 \(naming a function), or a list."
243 `(put (quote ,symbol) 'edebug-form-spec (quote ,spec)))
244
245 (defmacro def-edebug-form-spec (symbol spec-form)
246 "For compatibility with old version."
247 (def-edebug-spec symbol (eval spec-form)))
248 (make-obsolete 'def-edebug-form-spec 'def-edebug-spec "22.1")
249
250 (defun get-edebug-spec (symbol)
251 ;; Get the spec of symbol resolving all indirection.
252 (let ((edebug-form-spec (get symbol 'edebug-form-spec))
253 indirect)
254 (while (and (symbolp edebug-form-spec)
255 (setq indirect (get edebug-form-spec 'edebug-form-spec)))
256 ;; (edebug-trace "indirection: %s" edebug-form-spec)
257 (setq edebug-form-spec indirect))
258 edebug-form-spec
259 ))
260
261 ;;; Utilities
262
263 ;; Define edebug-gensym - from old cl.el
264 (defvar edebug-gensym-index 0
265 "Integer used by `edebug-gensym' to produce new names.")
266
267 (defun edebug-gensym (&optional prefix)
268 "Generate a fresh uninterned symbol.
269 There is an optional argument, PREFIX. PREFIX is the
270 string that begins the new name. Most people take just the default,
271 except when debugging needs suggest otherwise."
272 (if (null prefix)
273 (setq prefix "G"))
274 (let ((newsymbol nil)
275 (newname ""))
276 (while (not newsymbol)
277 (setq newname (concat prefix (int-to-string edebug-gensym-index)))
278 (setq edebug-gensym-index (+ edebug-gensym-index 1))
279 (if (not (intern-soft newname))
280 (setq newsymbol (make-symbol newname))))
281 newsymbol))
282
283 (defun edebug-lambda-list-keywordp (object)
284 "Return t if OBJECT is a lambda list keyword.
285 A lambda list keyword is a symbol that starts with `&'."
286 (and (symbolp object)
287 (= ?& (aref (symbol-name object) 0))))
288
289
290 (defun edebug-last-sexp ()
291 ;; Return the last sexp before point in current buffer.
292 ;; Assumes Emacs Lisp syntax is active.
293 (car
294 (read-from-string
295 (buffer-substring
296 (save-excursion
297 (forward-sexp -1)
298 (point))
299 (point)))))
300
301 (defun edebug-window-list ()
302 "Return a list of windows, in order of `next-window'."
303 ;; This doesn't work for epoch.
304 (let (window-list)
305 (walk-windows (lambda (w) (push w window-list)))
306 (nreverse window-list)))
307
308 ;; Not used.
309 '(defun edebug-two-window-p ()
310 "Return t if there are two windows."
311 (and (not (one-window-p))
312 (eq (selected-window)
313 (next-window (next-window (selected-window))))))
314
315 (defsubst edebug-lookup-function (object)
316 (while (and (symbolp object) (fboundp object))
317 (setq object (symbol-function object)))
318 object)
319
320 (defun edebug-macrop (object)
321 "Return the macro named by OBJECT, or nil if it is not a macro."
322 (setq object (edebug-lookup-function object))
323 (if (and (listp object)
324 (eq 'macro (car object))
325 (functionp (cdr object)))
326 object))
327
328 (defun edebug-sort-alist (alist function)
329 ;; Return the ALIST sorted with comparison function FUNCTION.
330 ;; This uses 'sort so the sorting is destructive.
331 (sort alist (function
332 (lambda (e1 e2)
333 (funcall function (car e1) (car e2))))))
334
335 ;;(def-edebug-spec edebug-save-restriction t)
336
337 ;; Not used. If it is used, def-edebug-spec must be defined before use.
338 '(defmacro edebug-save-restriction (&rest body)
339 "Evaluate BODY while saving the current buffers restriction.
340 BODY may change buffer outside of current restriction, unlike
341 save-restriction. BODY may change the current buffer,
342 and the restriction will be restored to the original buffer,
343 and the current buffer remains current.
344 Return the result of the last expression in BODY."
345 `(let ((edebug:s-r-beg (point-min-marker))
346 (edebug:s-r-end (point-max-marker)))
347 (unwind-protect
348 (progn ,@body)
349 (save-excursion
350 (set-buffer (marker-buffer edebug:s-r-beg))
351 (narrow-to-region edebug:s-r-beg edebug:s-r-end)))))
352
353 ;;; Display
354
355 (defconst edebug-trace-buffer "*edebug-trace*"
356 "Name of the buffer to put trace info in.")
357
358 (defun edebug-pop-to-buffer (buffer &optional window)
359 ;; Like pop-to-buffer, but select window where BUFFER was last shown.
360 ;; Select WINDOW if it provided and it still exists. Otherwise,
361 ;; if buffer is currently shown in several windows, choose one.
362 ;; Otherwise, find a new window, possibly splitting one.
363 (setq window (if (and (windowp window) (edebug-window-live-p window)
364 (eq (window-buffer window) buffer))
365 window
366 (if (eq (window-buffer (selected-window)) buffer)
367 (selected-window)
368 (edebug-get-buffer-window buffer))))
369 (if window
370 (select-window window)
371 (if (one-window-p)
372 (split-window))
373 ;; (message "next window: %s" (next-window)) (sit-for 1)
374 (if (eq (get-buffer-window edebug-trace-buffer) (next-window))
375 ;; Don't select trace window
376 nil
377 (select-window (next-window))))
378 (set-window-buffer (selected-window) buffer)
379 (set-window-hscroll (selected-window) 0);; should this be??
380 ;; Selecting the window does not set the buffer until command loop.
381 ;;(set-buffer buffer)
382 )
383
384
385 (defun edebug-get-displayed-buffer-points ()
386 ;; Return a list of buffer point pairs, for all displayed buffers.
387 (let (list)
388 (walk-windows (lambda (w)
389 (unless (eq w (selected-window))
390 (push (cons (window-buffer w)
391 (window-point w))
392 list))))
393 list))
394
395
396 (defun edebug-set-buffer-points (buffer-points)
397 ;; Restore the buffer-points created by edebug-get-displayed-buffer-points.
398 (save-current-buffer
399 (mapcar (lambda (buf-point)
400 (when (buffer-live-p (car buf-point))
401 (set-buffer (car buf-point))
402 (goto-char (cdr buf-point))))
403 buffer-points)))
404
405 (defun edebug-current-windows (which-windows)
406 ;; Get either a full window configuration or some window information.
407 (if (listp which-windows)
408 (mapcar (function (lambda (window)
409 (if (edebug-window-live-p window)
410 (list window
411 (window-buffer window)
412 (window-point window)
413 (window-start window)
414 (window-hscroll window)))))
415 which-windows)
416 (current-window-configuration)))
417
418 (defun edebug-set-windows (window-info)
419 ;; Set either a full window configuration or some window information.
420 (if (listp window-info)
421 (mapcar (function
422 (lambda (one-window-info)
423 (if one-window-info
424 (apply (function
425 (lambda (window buffer point start hscroll)
426 (if (edebug-window-live-p window)
427 (progn
428 (set-window-buffer window buffer)
429 (set-window-point window point)
430 (set-window-start window start)
431 (set-window-hscroll window hscroll)))))
432 one-window-info))))
433 window-info)
434 (set-window-configuration window-info)))
435
436 (defalias 'edebug-get-buffer-window 'get-buffer-window)
437 (defalias 'edebug-sit-for 'sit-for)
438 (defalias 'edebug-input-pending-p 'input-pending-p)
439
440
441 ;;; Redefine read and eval functions
442 ;; read is redefined to maybe instrument forms.
443 ;; eval-defun is redefined to check edebug-all-forms and edebug-all-defs.
444
445 ;; Save the original read function
446 (or (fboundp 'edebug-original-read)
447 (defalias 'edebug-original-read (symbol-function 'read)))
448
449 (defun edebug-read (&optional stream)
450 "Read one Lisp expression as text from STREAM, return as Lisp object.
451 If STREAM is nil, use the value of `standard-input' (which see).
452 STREAM or the value of `standard-input' may be:
453 a buffer (read from point and advance it)
454 a marker (read from where it points and advance it)
455 a function (call it with no arguments for each character,
456 call it with a char as argument to push a char back)
457 a string (takes text from string, starting at the beginning)
458 t (read text line using minibuffer and use it).
459
460 This version, from Edebug, maybe instruments the expression. But the
461 STREAM must be the current buffer to do so. Whether it instruments is
462 also dependent on the values of `edebug-all-defs' and
463 `edebug-all-forms'."
464 (or stream (setq stream standard-input))
465 (if (eq stream (current-buffer))
466 (edebug-read-and-maybe-wrap-form)
467 (edebug-original-read stream)))
468
469 (or (fboundp 'edebug-original-eval-defun)
470 (defalias 'edebug-original-eval-defun (symbol-function 'eval-defun)))
471
472 ;; We should somehow arrange to be able to do this
473 ;; without actually replacing the eval-defun command.
474 (defun edebug-eval-defun (edebug-it)
475 "Evaluate the top-level form containing point, or after point.
476
477 If the current defun is actually a call to `defvar', then reset the
478 variable using its initial value expression even if the variable
479 already has some other value. (Normally `defvar' does not change the
480 variable's value if it already has a value.) Treat `defcustom'
481 similarly. Reinitialize the face according to `defface' specification.
482
483 With a prefix argument, instrument the code for Edebug.
484
485 Setting `edebug-all-defs' to a non-nil value reverses the meaning of
486 the prefix argument. Code is then instrumented when this function is
487 invoked without a prefix argument
488
489 If acting on a `defun' for FUNCTION, and the function was
490 instrumented, `Edebug: FUNCTION' is printed in the minibuffer. If not
491 instrumented, just FUNCTION is printed.
492
493 If not acting on a `defun', the result of evaluation is displayed in
494 the minibuffer."
495 (interactive "P")
496 (let* ((edebugging (not (eq (not edebug-it) (not edebug-all-defs))))
497 (edebug-result)
498 (form
499 (let ((edebug-all-forms edebugging)
500 (edebug-all-defs (eq edebug-all-defs (not edebug-it))))
501 (edebug-read-top-level-form))))
502 ;; This should be consistent with `eval-defun-1', but not the
503 ;; same, since that gets a macroexpanded form.
504 (cond ((and (eq (car form) 'defvar)
505 (cdr-safe (cdr-safe form)))
506 ;; Force variable to be bound.
507 (makunbound (nth 1 form)))
508 ((and (eq (car form) 'defcustom)
509 (default-boundp (nth 1 form)))
510 ;; Force variable to be bound.
511 (set-default (nth 1 form) (eval (nth 2 form))))
512 ((eq (car form) 'defface)
513 ;; Reset the face.
514 (setq face-new-frame-defaults
515 (assq-delete-all (nth 1 form) face-new-frame-defaults))
516 (put (nth 1 form) 'face-defface-spec nil)
517 ;; See comments in `eval-defun-1' for purpose of code below
518 (setq form (prog1 `(prog1 ,form
519 (put ',(nth 1 form) 'saved-face
520 ',(get (nth 1 form) 'saved-face))
521 (put ',(nth 1 form) 'customized-face
522 ,(nth 2 form)))
523 (put (nth 1 form) 'saved-face nil)))))
524 (setq edebug-result (eval form))
525 (if (not edebugging)
526 (princ edebug-result)
527 edebug-result)))
528
529
530 ;;;###autoload
531 (defalias 'edebug-defun 'edebug-eval-top-level-form)
532
533 ;;;###autoload
534 (defun edebug-eval-top-level-form ()
535 "Evaluate the top level form point is in, stepping through with Edebug.
536 This is like `eval-defun' except that it steps the code for Edebug
537 before evaluating it. It displays the value in the echo area
538 using `eval-expression' (which see).
539
540 If you do this on a function definition
541 such as a defun or defmacro, it defines the function and instruments
542 its definition for Edebug, so it will do Edebug stepping when called
543 later. It displays `Edebug: FUNCTION' in the echo area to indicate
544 that FUNCTION is now instrumented for Edebug.
545
546 If the current defun is actually a call to `defvar' or `defcustom',
547 evaluating it this way resets the variable using its initial value
548 expression even if the variable already has some other value.
549 \(Normally `defvar' and `defcustom' do not alter the value if there
550 already is one.)"
551 (interactive)
552 (eval-expression
553 ;; Bind edebug-all-forms only while reading, not while evalling
554 ;; but this causes problems while edebugging edebug.
555 (let ((edebug-all-forms t)
556 (edebug-all-defs t))
557 (edebug-read-top-level-form))))
558
559
560 (defun edebug-read-top-level-form ()
561 (let ((starting-point (point)))
562 (end-of-defun)
563 (beginning-of-defun)
564 (prog1
565 (edebug-read-and-maybe-wrap-form)
566 ;; Recover point, but only if no error occurred.
567 (goto-char starting-point))))
568
569
570 ;; Compatibility with old versions.
571 (defalias 'edebug-all-defuns 'edebug-all-defs)
572
573 (defun edebug-all-defs ()
574 "Toggle edebugging of all definitions."
575 (interactive)
576 (setq edebug-all-defs (not edebug-all-defs))
577 (message "Edebugging all definitions is %s."
578 (if edebug-all-defs "on" "off")))
579
580
581 (defun edebug-all-forms ()
582 "Toggle edebugging of all forms."
583 (interactive)
584 (setq edebug-all-forms (not edebug-all-forms))
585 (message "Edebugging all forms is %s."
586 (if edebug-all-forms "on" "off")))
587
588
589 (defun edebug-install-read-eval-functions ()
590 (interactive)
591 ;; Don't install if already installed.
592 (unless load-read-function
593 (setq load-read-function 'edebug-read)
594 (defalias 'eval-defun 'edebug-eval-defun)))
595
596 (defun edebug-uninstall-read-eval-functions ()
597 (interactive)
598 (setq load-read-function nil)
599 (defalias 'eval-defun (symbol-function 'edebug-original-eval-defun)))
600
601
602 ;;; Edebug internal data
603
604 ;; The internal data that is needed for edebugging is kept in the
605 ;; buffer-local variable `edebug-form-data'.
606
607 (make-variable-buffer-local 'edebug-form-data)
608
609 (defvar edebug-form-data nil)
610 ;; A list of entries associating symbols with buffer regions.
611 ;; This is an automatic buffer local variable. Each entry looks like:
612 ;; @code{(@var{symbol} @var{begin-marker} @var{end-marker}). The markers
613 ;; are at the beginning and end of an entry level form and @var{symbol} is
614 ;; a symbol that holds all edebug related information for the form on its
615 ;; property list.
616
617 ;; In the future, the symbol will be irrelevant and edebug data will
618 ;; be stored in the definitions themselves rather than in the property
619 ;; list of a symbol.
620
621 (defun edebug-make-form-data-entry (symbol begin end)
622 (list symbol begin end))
623
624 (defsubst edebug-form-data-name (entry)
625 (car entry))
626
627 (defsubst edebug-form-data-begin (entry)
628 (nth 1 entry))
629
630 (defsubst edebug-form-data-end (entry)
631 (nth 2 entry))
632
633 (defsubst edebug-set-form-data-entry (entry name begin end)
634 (setcar entry name);; in case name is changed
635 (set-marker (nth 1 entry) begin)
636 (set-marker (nth 2 entry) end))
637
638 (defun edebug-get-form-data-entry (pnt &optional end-point)
639 ;; Find the edebug form data entry which is closest to PNT.
640 ;; If END-POINT is supplied, match must be exact.
641 ;; Return `nil' if none found.
642 (let ((rest edebug-form-data)
643 closest-entry
644 (closest-dist 999999)) ;; need maxint here
645 (while (and rest (< 0 closest-dist))
646 (let* ((entry (car rest))
647 (begin (edebug-form-data-begin entry))
648 (dist (- pnt begin)))
649 (setq rest (cdr rest))
650 (if (and (<= 0 dist)
651 (< dist closest-dist)
652 (or (not end-point)
653 (= end-point (edebug-form-data-end entry)))
654 (<= pnt (edebug-form-data-end entry)))
655 (setq closest-dist dist
656 closest-entry entry))))
657 closest-entry))
658
659 ;; Also need to find all contained entries,
660 ;; and find an entry given a symbol, which should be just assq.
661
662 (defun edebug-form-data-symbol ()
663 ;; Return the edebug data symbol of the form where point is in.
664 ;; If point is not inside a edebuggable form, cause error.
665 (or (edebug-form-data-name (edebug-get-form-data-entry (point)))
666 (error "Not inside instrumented form")))
667
668 (defun edebug-make-top-form-data-entry (new-entry)
669 ;; Make NEW-ENTRY the first element in the `edebug-form-data' list.
670 (edebug-clear-form-data-entry new-entry)
671 (setq edebug-form-data (cons new-entry edebug-form-data)))
672
673 (defun edebug-clear-form-data-entry (entry)
674 ;; If non-nil, clear ENTRY out of the form data.
675 ;; Maybe clear the markers and delete the symbol's edebug property?
676 (if entry
677 (progn
678 ;; Instead of this, we could just find all contained forms.
679 ;; (put (car entry) 'edebug nil) ;
680 ;; (mapcar 'edebug-clear-form-data-entry ; dangerous
681 ;; (get (car entry) 'edebug-dependents))
682 ;; (set-marker (nth 1 entry) nil)
683 ;; (set-marker (nth 2 entry) nil)
684 (setq edebug-form-data (delq entry edebug-form-data)))))
685
686 ;;; Parser utilities
687
688 (defun edebug-syntax-error (&rest args)
689 ;; Signal an invalid-read-syntax with ARGS.
690 (signal 'invalid-read-syntax args))
691
692
693 (defconst edebug-read-syntax-table
694 ;; Lookup table for significant characters indicating the class of the
695 ;; token that follows. This is not a \"real\" syntax table.
696 (let ((table (make-char-table 'syntax-table 'symbol))
697 (i 0))
698 (while (< i ?!)
699 (aset table i 'space)
700 (setq i (1+ i)))
701 (aset table ?\( 'lparen)
702 (aset table ?\) 'rparen)
703 (aset table ?\' 'quote)
704 (aset table ?\` 'backquote)
705 (aset table ?\, 'comma)
706 (aset table ?\" 'string)
707 (aset table ?\? 'char)
708 (aset table ?\[ 'lbracket)
709 (aset table ?\] 'rbracket)
710 (aset table ?\. 'dot)
711 (aset table ?\# 'hash)
712 ;; We treat numbers as symbols, because of confusion with -, -1, and 1-.
713 ;; We don't care about any other chars since they won't be seen.
714 table))
715
716 (defun edebug-next-token-class ()
717 ;; Move to the next token and return its class. We only care about
718 ;; lparen, rparen, dot, quote, backquote, comma, string, char, vector,
719 ;; or symbol.
720 (edebug-skip-whitespace)
721 (if (and (eq (following-char) ?.)
722 (save-excursion
723 (forward-char 1)
724 (or (and (eq (aref edebug-read-syntax-table (following-char))
725 'symbol)
726 (not (= (following-char) ?\;)))
727 (memq (following-char) '(?\, ?\.)))))
728 'symbol
729 (aref edebug-read-syntax-table (following-char))))
730
731
732 (defun edebug-skip-whitespace ()
733 ;; Leave point before the next token, skipping white space and comments.
734 (skip-chars-forward " \t\r\n\f")
735 (while (= (following-char) ?\;)
736 (skip-chars-forward "^\n") ; skip the comment
737 (skip-chars-forward " \t\r\n\f")))
738
739
740 ;; Mostly obsolete reader; still used in one case.
741
742 (defun edebug-read-sexp ()
743 ;; Read one sexp from the current buffer starting at point.
744 ;; Leave point immediately after it. A sexp can be a list or atom.
745 ;; An atom is a symbol (or number), character, string, or vector.
746 ;; This works for reading anything legitimate, but it
747 ;; is gummed up by parser inconsistencies (bugs?)
748 (let ((class (edebug-next-token-class)))
749 (cond
750 ;; read goes one too far if a (possibly quoted) string or symbol
751 ;; is immediately followed by non-whitespace.
752 ((eq class 'symbol) (edebug-original-read (current-buffer)))
753 ((eq class 'string) (edebug-original-read (current-buffer)))
754 ((eq class 'quote) (forward-char 1)
755 (list 'quote (edebug-read-sexp)))
756 ((eq class 'backquote)
757 (list '\` (edebug-read-sexp)))
758 ((eq class 'comma)
759 (list '\, (edebug-read-sexp)))
760 (t ; anything else, just read it.
761 (edebug-original-read (current-buffer))))))
762
763 ;;; Offsets for reader
764
765 ;; Define a structure to represent offset positions of expressions.
766 ;; Each offset structure looks like: (before . after) for constituents,
767 ;; or for structures that have elements: (before <subexpressions> . after)
768 ;; where the <subexpressions> are the offset structures for subexpressions
769 ;; including the head of a list.
770 (defvar edebug-offsets nil)
771
772 ;; Stack of offset structures in reverse order of the nesting.
773 ;; This is used to get back to previous levels.
774 (defvar edebug-offsets-stack nil)
775 (defvar edebug-current-offset nil) ; Top of the stack, for convenience.
776
777 ;; We must store whether we just read a list with a dotted form that
778 ;; is itself a list. This structure will be condensed, so the offsets
779 ;; must also be condensed.
780 (defvar edebug-read-dotted-list nil)
781
782 (defsubst edebug-initialize-offsets ()
783 ;; Reinitialize offset recording.
784 (setq edebug-current-offset nil))
785
786 (defun edebug-store-before-offset (point)
787 ;; Add a new offset pair with POINT as the before offset.
788 (let ((new-offset (list point)))
789 (if edebug-current-offset
790 (setcdr edebug-current-offset
791 (cons new-offset (cdr edebug-current-offset)))
792 ;; Otherwise, we are at the top level, so initialize.
793 (setq edebug-offsets new-offset
794 edebug-offsets-stack nil
795 edebug-read-dotted-list nil))
796 ;; Cons the new offset to the front of the stack.
797 (setq edebug-offsets-stack (cons new-offset edebug-offsets-stack)
798 edebug-current-offset new-offset)
799 ))
800
801 (defun edebug-store-after-offset (point)
802 ;; Finalize the current offset struct by reversing it and
803 ;; store POINT as the after offset.
804 (if (not edebug-read-dotted-list)
805 ;; Just reverse the offsets of all subexpressions.
806 (setcdr edebug-current-offset (nreverse (cdr edebug-current-offset)))
807
808 ;; We just read a list after a dot, which will be abbreviated out.
809 (setq edebug-read-dotted-list nil)
810 ;; Drop the corresponding offset pair.
811 ;; That is, nconc the reverse of the rest of the offsets
812 ;; with the cdr of last offset.
813 (setcdr edebug-current-offset
814 (nconc (nreverse (cdr (cdr edebug-current-offset)))
815 (cdr (car (cdr edebug-current-offset))))))
816
817 ;; Now append the point using nconc.
818 (setq edebug-current-offset (nconc edebug-current-offset point))
819 ;; Pop the stack.
820 (setq edebug-offsets-stack (cdr edebug-offsets-stack)
821 edebug-current-offset (car edebug-offsets-stack)))
822
823 (defun edebug-ignore-offset ()
824 ;; Ignore the last created offset pair.
825 (setcdr edebug-current-offset (cdr (cdr edebug-current-offset))))
826
827 (defmacro edebug-storing-offsets (point &rest body)
828 (declare (debug (form body)) (indent 1))
829 `(unwind-protect
830 (progn
831 (edebug-store-before-offset ,point)
832 ,@body)
833 (edebug-store-after-offset (point))))
834
835
836 ;;; Reader for Emacs Lisp.
837
838 ;; Uses edebug-next-token-class (and edebug-skip-whitespace) above.
839
840 (defconst edebug-read-alist
841 '((symbol . edebug-read-symbol)
842 (lparen . edebug-read-list)
843 (string . edebug-read-string)
844 (quote . edebug-read-quote)
845 (backquote . edebug-read-backquote)
846 (comma . edebug-read-comma)
847 (lbracket . edebug-read-vector)
848 (hash . edebug-read-function)
849 ))
850
851 (defun edebug-read-storing-offsets (stream)
852 (let (edebug-read-dotted-list) ; see edebug-store-after-offset
853 (edebug-storing-offsets (point)
854 (funcall
855 (or (cdr (assq (edebug-next-token-class) edebug-read-alist))
856 ;; anything else, just read it.
857 'edebug-original-read)
858 stream))))
859
860 (defun edebug-read-symbol (stream)
861 (edebug-original-read stream))
862
863 (defun edebug-read-string (stream)
864 (edebug-original-read stream))
865
866 (defun edebug-read-quote (stream)
867 ;; Turn 'thing into (quote thing)
868 (forward-char 1)
869 (list
870 (edebug-storing-offsets (1- (point)) 'quote)
871 (edebug-read-storing-offsets stream)))
872
873 (defvar edebug-read-backquote-level 0
874 "If non-zero, we're in a new-style backquote.
875 It should never be negative. This controls how we read comma constructs.")
876
877 (defun edebug-read-backquote (stream)
878 ;; Turn `thing into (\` thing)
879 (forward-char 1)
880 (list
881 (edebug-storing-offsets (1- (point)) '\`)
882 (let ((edebug-read-backquote-level (1+ edebug-read-backquote-level)))
883 (edebug-read-storing-offsets stream))))
884
885 (defun edebug-read-comma (stream)
886 ;; Turn ,thing into (\, thing). Handle ,@ and ,. also.
887 (let ((opoint (point)))
888 (forward-char 1)
889 (let ((symbol '\,))
890 (cond ((eq (following-char) ?\.)
891 (setq symbol '\,\.)
892 (forward-char 1))
893 ((eq (following-char) ?\@)
894 (setq symbol '\,@)
895 (forward-char 1)))
896 ;; Generate the same structure of offsets we would have
897 ;; if the resulting list appeared verbatim in the input text.
898 (if (zerop edebug-read-backquote-level)
899 (edebug-storing-offsets opoint symbol)
900 (list
901 (edebug-storing-offsets opoint symbol)
902 (let ((edebug-read-backquote-level (1- edebug-read-backquote-level)))
903 (edebug-read-storing-offsets stream)))))))
904
905 (defun edebug-read-function (stream)
906 ;; Turn #'thing into (function thing)
907 (forward-char 1)
908 (cond ((eq ?\' (following-char))
909 (forward-char 1)
910 (list
911 (edebug-storing-offsets (- (point) 2)
912 (if (featurep 'cl) 'function* 'function))
913 (edebug-read-storing-offsets stream)))
914 ((memq (following-char) '(?: ?B ?O ?X ?b ?o ?x ?1 ?2 ?3 ?4 ?5 ?6
915 ?7 ?8 ?9 ?0))
916 (backward-char 1)
917 (edebug-original-read stream))
918 (t (edebug-syntax-error "Bad char after #"))))
919
920 (defun edebug-read-list (stream)
921 (forward-char 1) ; skip \(
922 (prog1
923 (let ((elements))
924 (while (not (memq (edebug-next-token-class) '(rparen dot)))
925 (if (and (eq (edebug-next-token-class) 'backquote)
926 (null elements)
927 (zerop edebug-read-backquote-level))
928 (progn
929 ;; Old style backquote.
930 (forward-char 1) ; Skip backquote.
931 ;; Call edebug-storing-offsets here so that we
932 ;; produce the same offsets we would have had
933 ;; if the backquote were an ordinary symbol.
934 (push (edebug-storing-offsets (1- (point)) '\`) elements))
935 (push (edebug-read-storing-offsets stream) elements)))
936 (setq elements (nreverse elements))
937 (if (eq 'dot (edebug-next-token-class))
938 (let (dotted-form)
939 (forward-char 1) ; skip \.
940 (setq dotted-form (edebug-read-storing-offsets stream))
941 elements (nconc elements dotted-form)
942 (if (not (eq (edebug-next-token-class) 'rparen))
943 (edebug-syntax-error "Expected `)'"))
944 (setq edebug-read-dotted-list (listp dotted-form))
945 ))
946 elements)
947 (forward-char 1) ; skip \)
948 ))
949
950 (defun edebug-read-vector (stream)
951 (forward-char 1) ; skip \[
952 (prog1
953 (let ((elements))
954 (while (not (eq 'rbracket (edebug-next-token-class)))
955 (push (edebug-read-storing-offsets stream) elements))
956 (apply 'vector (nreverse elements)))
957 (forward-char 1) ; skip \]
958 ))
959
960 ;;; Cursors for traversal of list and vector elements with offsets.
961
962 (defvar edebug-dotted-spec nil)
963
964 (defun edebug-new-cursor (expressions offsets)
965 ;; Return a new cursor for EXPRESSIONS with OFFSETS.
966 (if (vectorp expressions)
967 (setq expressions (append expressions nil)))
968 (cons expressions offsets))
969
970 (defsubst edebug-set-cursor (cursor expressions offsets)
971 ;; Set the CURSOR's EXPRESSIONS and OFFSETS to the given.
972 ;; Return the cursor.
973 (setcar cursor expressions)
974 (setcdr cursor offsets)
975 cursor)
976
977 (defun edebug-copy-cursor (cursor)
978 ;; Copy the cursor using the same object and offsets.
979 (cons (car cursor) (cdr cursor)))
980
981 (defsubst edebug-cursor-expressions (cursor)
982 (car cursor))
983 (defsubst edebug-cursor-offsets (cursor)
984 (cdr cursor))
985
986 (defsubst edebug-empty-cursor (cursor)
987 ;; Return non-nil if CURSOR is empty - meaning no more elements.
988 (null (car cursor)))
989
990 (defsubst edebug-top-element (cursor)
991 ;; Return the top element at the cursor.
992 ;; Assumes not empty.
993 (car (car cursor)))
994
995 (defun edebug-top-element-required (cursor &rest error)
996 ;; Check if a dotted form is required.
997 (if edebug-dotted-spec (edebug-no-match cursor "Dot expected."))
998 ;; Check if there is at least one more argument.
999 (if (edebug-empty-cursor cursor) (apply 'edebug-no-match cursor error))
1000 ;; Return that top element.
1001 (edebug-top-element cursor))
1002
1003 (defsubst edebug-top-offset (cursor)
1004 ;; Return the top offset pair corresponding to the top element.
1005 (car (cdr cursor)))
1006
1007 (defun edebug-move-cursor (cursor)
1008 ;; Advance and return the cursor to the next element and offset.
1009 ;; throw no-match if empty before moving.
1010 ;; This is a violation of the cursor encapsulation, but
1011 ;; there is plenty of that going on while matching.
1012 ;; The following test should always fail.
1013 (if (edebug-empty-cursor cursor)
1014 (edebug-no-match cursor "Not enough arguments."))
1015 (setcar cursor (cdr (car cursor)))
1016 (setcdr cursor (cdr (cdr cursor)))
1017 cursor)
1018
1019
1020 (defun edebug-before-offset (cursor)
1021 ;; Return the before offset of the cursor.
1022 ;; If there is nothing left in the offsets,
1023 ;; return one less than the offset itself,
1024 ;; which is the after offset for a list.
1025 (let ((offset (edebug-cursor-offsets cursor)))
1026 (if (consp offset)
1027 (car (car offset))
1028 (1- offset))))
1029
1030 (defun edebug-after-offset (cursor)
1031 ;; Return the after offset of the cursor object.
1032 (let ((offset (edebug-top-offset cursor)))
1033 (while (consp offset)
1034 (setq offset (cdr offset)))
1035 offset))
1036
1037 ;;; The Parser
1038
1039 ;; The top level function for parsing forms is
1040 ;; edebug-read-and-maybe-wrap-form; it calls all the rest. It checks the
1041 ;; syntax a bit and leaves point at any error it finds, but otherwise
1042 ;; should appear to work like eval-defun.
1043
1044 ;; The basic plan is to surround each expression with a call to
1045 ;; the edebug debugger together with indexes into a table of positions of
1046 ;; all expressions. Thus an expression "exp" becomes:
1047
1048 ;; (edebug-after (edebug-before 1) 2 exp)
1049
1050 ;; When this is evaluated, first point is moved to the beginning of
1051 ;; exp at offset 1 of the current function. The expression is
1052 ;; evaluated, which may cause more edebug calls, and then point is
1053 ;; moved to offset 2 after the end of exp.
1054
1055 ;; The highest level expressions of the function are wrapped in a call to
1056 ;; edebug-enter, which supplies the function name and the actual
1057 ;; arguments to the function. See functions edebug-enter, edebug-before,
1058 ;; and edebug-after for more details.
1059
1060 ;; Dynamically bound vars, left unbound, but globally declared.
1061 ;; This is to quiet the byte compiler.
1062
1063 ;; Window data of the highest definition being wrapped.
1064 ;; This data is shared by all embedded definitions.
1065 (defvar edebug-top-window-data)
1066
1067 (defvar edebug-&optional)
1068 (defvar edebug-&rest)
1069 (defvar edebug-gate nil) ;; whether no-match forces an error.
1070
1071 (defvar edebug-def-name nil) ; name of definition, used by interactive-form
1072 (defvar edebug-old-def-name nil) ; previous name of containing definition.
1073
1074 (defvar edebug-error-point nil)
1075 (defvar edebug-best-error nil)
1076
1077
1078 (defun edebug-read-and-maybe-wrap-form ()
1079 ;; Read a form and wrap it with edebug calls, if the conditions are right.
1080 ;; Here we just catch any no-match not caught below and signal an error.
1081
1082 ;; Run the setup hook.
1083 ;; If it gets an error, make it nil.
1084 (let ((temp-hook edebug-setup-hook))
1085 (setq edebug-setup-hook nil)
1086 (run-hooks 'temp-hook))
1087
1088 (let (result
1089 edebug-top-window-data
1090 edebug-def-name;; make sure it is locally nil
1091 ;; I don't like these here!!
1092 edebug-&optional
1093 edebug-&rest
1094 edebug-gate
1095 edebug-best-error
1096 edebug-error-point
1097 no-match
1098 ;; Do this once here instead of several times.
1099 (max-lisp-eval-depth (+ 800 max-lisp-eval-depth))
1100 (max-specpdl-size (+ 2000 max-specpdl-size)))
1101 (setq no-match
1102 (catch 'no-match
1103 (setq result (edebug-read-and-maybe-wrap-form1))
1104 nil))
1105 (if no-match
1106 (apply 'edebug-syntax-error no-match))
1107 result))
1108
1109
1110 (defun edebug-read-and-maybe-wrap-form1 ()
1111 (let (spec
1112 def-kind
1113 defining-form-p
1114 def-name
1115 ;; These offset things don't belong here, but to support recursive
1116 ;; calls to edebug-read, they need to be here.
1117 edebug-offsets
1118 edebug-offsets-stack
1119 edebug-current-offset ; reset to nil
1120 )
1121 (save-excursion
1122 (if (and (eq 'lparen (edebug-next-token-class))
1123 (eq 'symbol (progn (forward-char 1) (edebug-next-token-class))))
1124 ;; Find out if this is a defining form from first symbol
1125 (setq def-kind (edebug-original-read (current-buffer))
1126 spec (and (symbolp def-kind) (get-edebug-spec def-kind))
1127 defining-form-p (and (listp spec)
1128 (eq '&define (car spec)))
1129 ;; This is incorrect in general!! But OK most of the time.
1130 def-name (if (and defining-form-p
1131 (eq 'name (car (cdr spec)))
1132 (eq 'symbol (edebug-next-token-class)))
1133 (edebug-original-read (current-buffer))))))
1134 ;;;(message "all defs: %s all forms: %s" edebug-all-defs edebug-all-forms)
1135 (cond
1136 (defining-form-p
1137 (if (or edebug-all-defs edebug-all-forms)
1138 ;; If it is a defining form and we are edebugging defs,
1139 ;; then let edebug-list-form start it.
1140 (let ((cursor (edebug-new-cursor
1141 (list (edebug-read-storing-offsets (current-buffer)))
1142 (list edebug-offsets))))
1143 (car
1144 (edebug-make-form-wrapper
1145 cursor
1146 (edebug-before-offset cursor)
1147 (1- (edebug-after-offset cursor))
1148 (list (cons (symbol-name def-kind) (cdr spec))))))
1149
1150 ;; Not edebugging this form, so reset the symbol's edebug
1151 ;; property to be just a marker at the definition's source code.
1152 ;; This only works for defs with simple names.
1153 (put def-name 'edebug (point-marker))
1154 ;; Also nil out dependent defs.
1155 '(mapcar (function
1156 (lambda (def)
1157 (put def-name 'edebug nil)))
1158 (get def-name 'edebug-dependents))
1159 (edebug-read-sexp)))
1160
1161 ;; If all forms are being edebugged, explicitly wrap it.
1162 (edebug-all-forms
1163 (let ((cursor (edebug-new-cursor
1164 (list (edebug-read-storing-offsets (current-buffer)))
1165 (list edebug-offsets))))
1166 (edebug-make-form-wrapper
1167 cursor
1168 (edebug-before-offset cursor)
1169 (edebug-after-offset cursor)
1170 nil)))
1171
1172 ;; Not a defining form, and not edebugging.
1173 (t (edebug-read-sexp)))
1174 ))
1175
1176
1177 (defvar edebug-def-args) ; args of defining form.
1178 (defvar edebug-def-interactive) ; is it an emacs interactive function?
1179 (defvar edebug-inside-func) ;; whether code is inside function context.
1180 ;; Currently def-form sets this to nil; def-body sets it to t.
1181
1182 (defun edebug-interactive-p-name ()
1183 ;; Return a unique symbol for the variable used to store the
1184 ;; status of interactive-p for this function.
1185 (intern (format "edebug-%s-interactive-p" edebug-def-name)))
1186
1187
1188 (defun edebug-wrap-def-body (forms)
1189 "Wrap the FORMS of a definition body."
1190 (if edebug-def-interactive
1191 `(let ((,(edebug-interactive-p-name)
1192 (interactive-p)))
1193 ,(edebug-make-enter-wrapper forms))
1194 (edebug-make-enter-wrapper forms)))
1195
1196
1197 (defun edebug-make-enter-wrapper (forms)
1198 ;; Generate the enter wrapper for some forms of a definition.
1199 ;; This is not to be used for the body of other forms, e.g. `while',
1200 ;; since it wraps the list of forms with a call to `edebug-enter'.
1201 ;; Uses the dynamically bound vars edebug-def-name and edebug-def-args.
1202 ;; Do this after parsing since that may find a name.
1203 (setq edebug-def-name
1204 (or edebug-def-name edebug-old-def-name (edebug-gensym "edebug-anon")))
1205 `(edebug-enter
1206 (quote ,edebug-def-name)
1207 ,(if edebug-inside-func
1208 `(list
1209 ;; Doesn't work with more than one def-body!!
1210 ;; But the list will just be reversed.
1211 ,@(nreverse edebug-def-args))
1212 'nil)
1213 (function (lambda () ,@forms))
1214 ))
1215
1216
1217 (defvar edebug-form-begin-marker) ; the mark for def being instrumented
1218
1219 (defvar edebug-offset-index) ; the next available offset index.
1220 (defvar edebug-offset-list) ; the list of offset positions.
1221
1222 (defun edebug-inc-offset (offset)
1223 ;; modifies edebug-offset-index and edebug-offset-list
1224 ;; accesses edebug-func-marc and buffer point
1225 (prog1
1226 edebug-offset-index
1227 (setq edebug-offset-list (cons (- offset edebug-form-begin-marker)
1228 edebug-offset-list)
1229 edebug-offset-index (1+ edebug-offset-index))))
1230
1231
1232 (defun edebug-make-before-and-after-form (before-index form after-index)
1233 ;; Return the edebug form for the current function at offset BEFORE-INDEX
1234 ;; given FORM. Looks like:
1235 ;; (edebug-after (edebug-before BEFORE-INDEX) AFTER-INDEX FORM)
1236 ;; Also increment the offset index for subsequent use.
1237 (list 'edebug-after
1238 (list 'edebug-before before-index)
1239 after-index form))
1240
1241 (defun edebug-make-after-form (form after-index)
1242 ;; Like edebug-make-before-and-after-form, but only after.
1243 (list 'edebug-after 0 after-index form))
1244
1245
1246 (defun edebug-unwrap (sexp)
1247 "Return the unwrapped SEXP or return it as is if it is not wrapped.
1248 The SEXP might be the result of wrapping a body, which is a list of
1249 expressions; a `progn' form will be returned enclosing these forms."
1250 (if (consp sexp)
1251 (cond
1252 ((eq 'edebug-after (car sexp))
1253 (nth 3 sexp))
1254 ((eq 'edebug-enter (car sexp))
1255 (let ((forms (nthcdr 2 (nth 1 (nth 3 sexp)))))
1256 (if (> (length forms) 1)
1257 (cons 'progn forms) ;; could return (values forms) instead.
1258 (car forms))))
1259 (t sexp);; otherwise it is not wrapped, so just return it.
1260 )
1261 sexp))
1262
1263 (defun edebug-unwrap* (sexp)
1264 "Return the sexp recursively unwrapped."
1265 (let ((new-sexp (edebug-unwrap sexp)))
1266 (while (not (eq sexp new-sexp))
1267 (setq sexp new-sexp
1268 new-sexp (edebug-unwrap sexp)))
1269 (if (consp new-sexp)
1270 (mapcar 'edebug-unwrap* new-sexp)
1271 new-sexp)))
1272
1273
1274 (defun edebug-defining-form (cursor form-begin form-end speclist)
1275 ;; Process the defining form, starting outside the form.
1276 ;; The speclist is a generated list spec that looks like:
1277 ;; (("def-symbol" defining-form-spec-sans-&define))
1278 ;; Skip the first offset.
1279 (edebug-set-cursor cursor (edebug-cursor-expressions cursor)
1280 (cdr (edebug-cursor-offsets cursor)))
1281 (edebug-make-form-wrapper
1282 cursor
1283 form-begin (1- form-end)
1284 speclist))
1285
1286 (defun edebug-make-form-wrapper (cursor form-begin form-end
1287 &optional speclist)
1288 ;; Wrap a form, usually a defining form, but any evaluated one.
1289 ;; If speclist is non-nil, this is being called by edebug-defining-form.
1290 ;; Otherwise it is being called from edebug-read-and-maybe-wrap-form1.
1291 ;; This is a hack, but I havent figured out a simpler way yet.
1292 (let* ((form-data-entry (edebug-get-form-data-entry form-begin form-end))
1293 ;; Set this marker before parsing.
1294 (edebug-form-begin-marker
1295 (if form-data-entry
1296 (edebug-form-data-begin form-data-entry)
1297 ;; Buffer must be current-buffer for this to work:
1298 (set-marker (make-marker) form-begin))))
1299
1300 (let (edebug-offset-list
1301 (edebug-offset-index 0)
1302 result
1303 ;; For definitions.
1304 ;; (edebug-containing-def-name edebug-def-name)
1305 ;; Get name from form-data, if any.
1306 (edebug-old-def-name (edebug-form-data-name form-data-entry))
1307 edebug-def-name
1308 edebug-def-args
1309 edebug-def-interactive
1310 edebug-inside-func;; whether wrapped code executes inside a function.
1311 )
1312
1313 (setq result
1314 (if speclist
1315 (edebug-match cursor speclist)
1316
1317 ;; else wrap as an enter-form.
1318 (edebug-make-enter-wrapper (list (edebug-form cursor)))))
1319
1320 ;; Set the name here if it was not set by edebug-make-enter-wrapper.
1321 (setq edebug-def-name
1322 (or edebug-def-name edebug-old-def-name (edebug-gensym "edebug-anon")))
1323
1324 ;; Add this def as a dependent of containing def. Buggy.
1325 '(if (and edebug-containing-def-name
1326 (not (get edebug-containing-def-name 'edebug-dependents)))
1327 (put edebug-containing-def-name 'edebug-dependents
1328 (cons edebug-def-name
1329 (get edebug-containing-def-name
1330 'edebug-dependents))))
1331
1332 ;; Create a form-data-entry or modify existing entry's markers.
1333 ;; In the latter case, pointers to the entry remain eq.
1334 (if (not form-data-entry)
1335 (setq form-data-entry
1336 (edebug-make-form-data-entry
1337 edebug-def-name
1338 edebug-form-begin-marker
1339 ;; Buffer must be current-buffer.
1340 (set-marker (make-marker) form-end)
1341 ))
1342 (edebug-set-form-data-entry
1343 form-data-entry edebug-def-name ;; in case name is changed
1344 form-begin form-end))
1345
1346 ;; (message "defining: %s" edebug-def-name) (sit-for 2)
1347 (edebug-make-top-form-data-entry form-data-entry)
1348 (message "Edebug: %s" edebug-def-name)
1349 ;;(debug edebug-def-name)
1350
1351 ;; Destructively reverse edebug-offset-list and make vector from it.
1352 (setq edebug-offset-list (vconcat (nreverse edebug-offset-list)))
1353
1354 ;; Side effects on the property list of edebug-def-name.
1355 (edebug-clear-frequency-count edebug-def-name)
1356 (edebug-clear-coverage edebug-def-name)
1357
1358 ;; Set up the initial window data.
1359 (if (not edebug-top-window-data) ;; if not already set, do it now.
1360 (let ((window ;; Find the best window for this buffer.
1361 (or (get-buffer-window (current-buffer))
1362 (selected-window))))
1363 (setq edebug-top-window-data
1364 (cons window (window-start window)))))
1365
1366 ;; Store the edebug data in symbol's property list.
1367 (put edebug-def-name 'edebug
1368 ;; A struct or vector would be better here!!
1369 (list edebug-form-begin-marker
1370 nil ; clear breakpoints
1371 edebug-offset-list
1372 edebug-top-window-data
1373 ))
1374 result
1375 )))
1376
1377
1378 (defun edebug-clear-frequency-count (name)
1379 ;; Create initial frequency count vector.
1380 ;; For each stop point, the counter is incremented each time it is visited.
1381 (put name 'edebug-freq-count
1382 (make-vector (length edebug-offset-list) 0)))
1383
1384
1385 (defun edebug-clear-coverage (name)
1386 ;; Create initial coverage vector.
1387 ;; Only need one per expression, but it is simpler to use stop points.
1388 (put name 'edebug-coverage
1389 (make-vector (length edebug-offset-list) 'unknown)))
1390
1391
1392 (defun edebug-form (cursor)
1393 ;; Return the instrumented form for the following form.
1394 ;; Add the point offsets to the edebug-offset-list for the form.
1395 (let* ((form (edebug-top-element-required cursor "Expected form"))
1396 (offset (edebug-top-offset cursor)))
1397 (prog1
1398 (cond
1399 ((consp form)
1400 ;; The first offset for a list form is for the list form itself.
1401 (if (eq 'quote (car form))
1402 form
1403 (let* ((head (car form))
1404 (spec (and (symbolp head) (get-edebug-spec head)))
1405 (new-cursor (edebug-new-cursor form offset)))
1406 ;; Find out if this is a defining form from first symbol.
1407 ;; An indirect spec would not work here, yet.
1408 (if (and (consp spec) (eq '&define (car spec)))
1409 (edebug-defining-form
1410 new-cursor
1411 (car offset);; before the form
1412 (edebug-after-offset cursor)
1413 (cons (symbol-name head) (cdr spec)))
1414 ;; Wrap a regular form.
1415 (edebug-make-before-and-after-form
1416 (edebug-inc-offset (car offset))
1417 (edebug-list-form new-cursor)
1418 ;; After processing the list form, the new-cursor is left
1419 ;; with the offset after the form.
1420 (edebug-inc-offset (edebug-cursor-offsets new-cursor))))
1421 )))
1422
1423 ((symbolp form)
1424 (cond
1425 ;; Check for constant symbols that don't get wrapped.
1426 ((or (memq form '(t nil))
1427 (keywordp form))
1428 form)
1429
1430 (t ;; just a variable
1431 (edebug-make-after-form form (edebug-inc-offset (cdr offset))))))
1432
1433 ;; Anything else is self-evaluating.
1434 (t form))
1435 (edebug-move-cursor cursor))))
1436
1437
1438 (defsubst edebug-forms (cursor) (edebug-match cursor '(&rest form)))
1439 (defsubst edebug-sexps (cursor) (edebug-match cursor '(&rest sexp)))
1440
1441 (defsubst edebug-list-form-args (head cursor)
1442 ;; Process the arguments of a list form given that head of form is a symbol.
1443 ;; Helper for edebug-list-form
1444 (let ((spec (get-edebug-spec head)))
1445 (cond
1446 (spec
1447 (cond
1448 ((consp spec)
1449 ;; It is a speclist.
1450 (let (edebug-best-error
1451 edebug-error-point);; This may not be needed.
1452 (edebug-match-sublist cursor spec)))
1453 ((eq t spec) (edebug-forms cursor))
1454 ((eq 0 spec) (edebug-sexps cursor))
1455 ((symbolp spec) (funcall spec cursor));; Not used by edebug,
1456 ; but leave it in for compatibility.
1457 ))
1458 ;; No edebug-form-spec provided.
1459 ((edebug-macrop head)
1460 (if edebug-eval-macro-args
1461 (edebug-forms cursor)
1462 (edebug-sexps cursor)))
1463 (t ;; Otherwise it is a function call.
1464 (edebug-forms cursor)))))
1465
1466
1467 (defun edebug-list-form (cursor)
1468 ;; Return an instrumented form built from the list form.
1469 ;; The after offset will be left in the cursor after processing the form.
1470 (let ((head (edebug-top-element-required cursor "Expected elements"))
1471 ;; Prevent backtracking whenever instrumenting.
1472 (edebug-gate t)
1473 ;; A list form is never optional because it matches anything.
1474 (edebug-&optional nil)
1475 (edebug-&rest nil))
1476 ;; Skip the first offset.
1477 (edebug-set-cursor cursor (edebug-cursor-expressions cursor)
1478 (cdr (edebug-cursor-offsets cursor)))
1479 (cond
1480 ((symbolp head)
1481 (cond
1482 ((null head) nil) ; () is legal.
1483 ((eq head 'interactive-p)
1484 ;; Special case: replace (interactive-p) with variable
1485 (setq edebug-def-interactive 'check-it)
1486 (edebug-move-cursor cursor)
1487 (edebug-interactive-p-name))
1488 (t
1489 (cons head (edebug-list-form-args
1490 head (edebug-move-cursor cursor))))))
1491
1492 ((consp head)
1493 (if (eq (car head) ',)
1494 ;; The head of a form should normally be a symbol or a lambda
1495 ;; expression but it can also be an unquote form to be filled
1496 ;; before evaluation. We evaluate the arguments anyway, on the
1497 ;; assumption that the unquote form will place a proper function
1498 ;; name (rather than a macro name).
1499 (edebug-match cursor '(("," def-form) body))
1500 ;; Process anonymous function and args.
1501 ;; This assumes no anonymous macros.
1502 (edebug-match-specs cursor '(lambda-expr body) 'edebug-match-specs)))
1503
1504 (t (edebug-syntax-error
1505 "Head of list form must be a symbol or lambda expression")))
1506 ))
1507
1508 ;;; Matching of specs.
1509
1510 (defvar edebug-after-dotted-spec nil)
1511
1512 (defvar edebug-matching-depth 0) ;; initial value
1513 (defconst edebug-max-depth 150) ;; maximum number of matching recursions.
1514
1515
1516 ;;; Failure to match
1517
1518 ;; This throws to no-match, if there are higher alternatives.
1519 ;; Otherwise it signals an error. The place of the error is found
1520 ;; with the two before- and after-offset functions.
1521
1522 (defun edebug-no-match (cursor &rest edebug-args)
1523 ;; Throw a no-match, or signal an error immediately if gate is active.
1524 ;; Remember this point in case we need to report this error.
1525 (setq edebug-error-point (or edebug-error-point
1526 (edebug-before-offset cursor))
1527 edebug-best-error (or edebug-best-error edebug-args))
1528 (if (and edebug-gate (not edebug-&optional))
1529 (progn
1530 (if edebug-error-point
1531 (goto-char edebug-error-point))
1532 (apply 'edebug-syntax-error edebug-args))
1533 (funcall 'throw 'no-match edebug-args)))
1534
1535
1536 (defun edebug-match (cursor specs)
1537 ;; Top level spec matching function.
1538 ;; Used also at each lower level of specs.
1539 (let (edebug-&optional
1540 edebug-&rest
1541 edebug-best-error
1542 edebug-error-point
1543 (edebug-gate edebug-gate) ;; locally bound to limit effect
1544 )
1545 (edebug-match-specs cursor specs 'edebug-match-specs)))
1546
1547
1548 (defun edebug-match-one-spec (cursor spec)
1549 ;; Match one spec, which is not a keyword &-spec.
1550 (cond
1551 ((symbolp spec) (edebug-match-symbol cursor spec))
1552 ((vectorp spec) (edebug-match cursor (append spec nil)))
1553 ((stringp spec) (edebug-match-string cursor spec))
1554 ((listp spec) (edebug-match-list cursor spec))
1555 ))
1556
1557
1558 (defun edebug-match-specs (cursor specs remainder-handler)
1559 ;; Append results of matching the list of specs.
1560 ;; The first spec is handled and the remainder-handler handles the rest.
1561 (let ((edebug-matching-depth
1562 (if (> edebug-matching-depth edebug-max-depth)
1563 (error "too deep - perhaps infinite loop in spec?")
1564 (1+ edebug-matching-depth))))
1565 (cond
1566 ((null specs) nil)
1567
1568 ;; Is the spec dotted?
1569 ((atom specs)
1570 (let ((edebug-dotted-spec t));; Containing spec list was dotted.
1571 (edebug-match-specs cursor (list specs) remainder-handler)))
1572
1573 ;; Is the form dotted?
1574 ((not (listp (edebug-cursor-expressions cursor)));; allow nil
1575 (if (not edebug-dotted-spec)
1576 (edebug-no-match cursor "Dotted spec required."))
1577 ;; Cancel dotted spec and dotted form.
1578 (let ((edebug-dotted-spec)
1579 (this-form (edebug-cursor-expressions cursor))
1580 (this-offset (edebug-cursor-offsets cursor)))
1581 ;; Wrap the form in a list, (by changing the cursor??)...
1582 (edebug-set-cursor cursor (list this-form) this-offset)
1583 ;; and process normally, then unwrap the result.
1584 (car (edebug-match-specs cursor specs remainder-handler))))
1585
1586 (t;; Process normally.
1587 (let* ((spec (car specs))
1588 (rest)
1589 (first-char (and (symbolp spec) (aref (symbol-name spec) 0))))
1590 ;;(message "spec = %s first char = %s" spec first-char) (sit-for 1)
1591 (nconc
1592 (cond
1593 ((eq ?& first-char);; "&" symbols take all following specs.
1594 (funcall (get-edebug-spec spec) cursor (cdr specs)))
1595 ((eq ?: first-char);; ":" symbols take one following spec.
1596 (setq rest (cdr (cdr specs)))
1597 (funcall (get-edebug-spec spec) cursor (car (cdr specs))))
1598 (t;; Any other normal spec.
1599 (setq rest (cdr specs))
1600 (edebug-match-one-spec cursor spec)))
1601 (funcall remainder-handler cursor rest remainder-handler)))))))
1602
1603
1604 ;; Define specs for all the symbol specs with functions used to process them.
1605 ;; Perhaps we shouldn't be doing this with edebug-form-specs since the
1606 ;; user may want to define macros or functions with the same names.
1607 ;; We could use an internal obarray for these primitive specs.
1608
1609 (dolist (pair '((&optional . edebug-match-&optional)
1610 (&rest . edebug-match-&rest)
1611 (&or . edebug-match-&or)
1612 (form . edebug-match-form)
1613 (sexp . edebug-match-sexp)
1614 (body . edebug-match-body)
1615 (&define . edebug-match-&define)
1616 (name . edebug-match-name)
1617 (:name . edebug-match-colon-name)
1618 (arg . edebug-match-arg)
1619 (def-body . edebug-match-def-body)
1620 (def-form . edebug-match-def-form)
1621 ;; Less frequently used:
1622 ;; (function . edebug-match-function)
1623 (lambda-expr . edebug-match-lambda-expr)
1624 (&not . edebug-match-&not)
1625 (&key . edebug-match-&key)
1626 (place . edebug-match-place)
1627 (gate . edebug-match-gate)
1628 ;; (nil . edebug-match-nil) not this one - special case it.
1629 ))
1630 (put (car pair) 'edebug-form-spec (cdr pair)))
1631
1632 (defun edebug-match-symbol (cursor symbol)
1633 ;; Match a symbol spec.
1634 (let* ((spec (get-edebug-spec symbol)))
1635 (cond
1636 (spec
1637 (if (consp spec)
1638 ;; It is an indirect spec.
1639 (edebug-match cursor spec)
1640 ;; Otherwise it should be the symbol name of a function.
1641 ;; There could be a bug here - maybe need to do edebug-match bindings.
1642 (funcall spec cursor)))
1643
1644 ((null symbol) ;; special case this.
1645 (edebug-match-nil cursor))
1646
1647 ((fboundp symbol) ; is it a predicate?
1648 (let ((sexp (edebug-top-element-required cursor "Expected" symbol)))
1649 ;; Special case for edebug-`.
1650 (if (and (listp sexp) (eq (car sexp) ',))
1651 (edebug-match cursor '(("," def-form)))
1652 (if (not (funcall symbol sexp))
1653 (edebug-no-match cursor symbol "failed"))
1654 (edebug-move-cursor cursor)
1655 (list sexp))))
1656 (t (error "%s is not a form-spec or function" symbol))
1657 )))
1658
1659
1660 (defun edebug-match-sexp (cursor)
1661 (list (prog1 (edebug-top-element-required cursor "Expected sexp")
1662 (edebug-move-cursor cursor))))
1663
1664 (defun edebug-match-form (cursor)
1665 (list (edebug-form cursor)))
1666
1667 (defalias 'edebug-match-place 'edebug-match-form)
1668 ;; Currently identical to edebug-match-form.
1669 ;; This is for common lisp setf-style place arguments.
1670
1671 (defsubst edebug-match-body (cursor) (edebug-forms cursor))
1672
1673 (defun edebug-match-&optional (cursor specs)
1674 ;; Keep matching until one spec fails.
1675 (edebug-&optional-wrapper cursor specs 'edebug-&optional-wrapper))
1676
1677 (defun edebug-&optional-wrapper (cursor specs remainder-handler)
1678 (let (result
1679 (edebug-&optional specs)
1680 (edebug-gate nil)
1681 (this-form (edebug-cursor-expressions cursor))
1682 (this-offset (edebug-cursor-offsets cursor)))
1683 (if (null (catch 'no-match
1684 (setq result
1685 (edebug-match-specs cursor specs remainder-handler))
1686 ;; Returning nil means no no-match was thrown.
1687 nil))
1688 result
1689 ;; no-match, but don't fail; just reset cursor and return nil.
1690 (edebug-set-cursor cursor this-form this-offset)
1691 nil)))
1692
1693
1694 (defun edebug-&rest-wrapper (cursor specs remainder-handler)
1695 (if (null specs) (setq specs edebug-&rest))
1696 ;; Reuse the &optional handler with this as the remainder handler.
1697 (edebug-&optional-wrapper cursor specs remainder-handler))
1698
1699 (defun edebug-match-&rest (cursor specs)
1700 ;; Repeatedly use specs until failure.
1701 (let ((edebug-&rest specs) ;; remember these
1702 edebug-best-error
1703 edebug-error-point)
1704 (edebug-&rest-wrapper cursor specs 'edebug-&rest-wrapper)))
1705
1706
1707 (defun edebug-match-&or (cursor specs)
1708 ;; Keep matching until one spec succeeds, and return its results.
1709 ;; If none match, fail.
1710 ;; This needs to be optimized since most specs spend time here.
1711 (let ((original-specs specs)
1712 (this-form (edebug-cursor-expressions cursor))
1713 (this-offset (edebug-cursor-offsets cursor)))
1714 (catch 'matched
1715 (while specs
1716 (catch 'no-match
1717 (throw 'matched
1718 (let (edebug-gate ;; only while matching each spec
1719 edebug-best-error
1720 edebug-error-point)
1721 ;; Doesn't support e.g. &or symbolp &rest form
1722 (edebug-match-one-spec cursor (car specs)))))
1723 ;; Match failed, so reset and try again.
1724 (setq specs (cdr specs))
1725 ;; Reset the cursor for the next match.
1726 (edebug-set-cursor cursor this-form this-offset))
1727 ;; All failed.
1728 (apply 'edebug-no-match cursor "Expected one of" original-specs))
1729 ))
1730
1731
1732 (defun edebug-match-&not (cursor specs)
1733 ;; If any specs match, then fail
1734 (if (null (catch 'no-match
1735 (let ((edebug-gate nil))
1736 (save-excursion
1737 (edebug-match-&or cursor specs)))
1738 nil))
1739 ;; This means something matched, so it is a no match.
1740 (edebug-no-match cursor "Unexpected"))
1741 ;; This means nothing matched, so it is OK.
1742 nil) ;; So, return nothing
1743
1744
1745 (def-edebug-spec &key edebug-match-&key)
1746
1747 (defun edebug-match-&key (cursor specs)
1748 ;; Following specs must look like (<name> <spec>) ...
1749 ;; where <name> is the name of a keyword, and spec is its spec.
1750 ;; This really doesn't save much over the expanded form and takes time.
1751 (edebug-match-&rest
1752 cursor
1753 (cons '&or
1754 (mapcar (function (lambda (pair)
1755 (vector (format ":%s" (car pair))
1756 (car (cdr pair)))))
1757 specs))))
1758
1759
1760 (defun edebug-match-gate (cursor)
1761 ;; Simply set the gate to prevent backtracking at this level.
1762 (setq edebug-gate t)
1763 nil)
1764
1765
1766 (defun edebug-match-list (cursor specs)
1767 ;; The spec is a list, but what kind of list, and what context?
1768 (if edebug-dotted-spec
1769 ;; After dotted spec but form did not contain dot,
1770 ;; so match list spec elements as if spliced in.
1771 (prog1
1772 (let ((edebug-dotted-spec))
1773 (edebug-match-specs cursor specs 'edebug-match-specs))
1774 ;; If it matched, really clear the dotted-spec flag.
1775 (setq edebug-dotted-spec nil))
1776 (let ((spec (car specs))
1777 (form (edebug-top-element-required cursor "Expected" specs)))
1778 (cond
1779 ((eq 'quote spec)
1780 (let ((spec (car (cdr specs))))
1781 (cond
1782 ((symbolp spec)
1783 ;; Special case: spec quotes a symbol to match.
1784 ;; Change in future. Use "..." instead.
1785 (if (not (eq spec form))
1786 (edebug-no-match cursor "Expected" spec))
1787 (edebug-move-cursor cursor)
1788 (setq edebug-gate t)
1789 form)
1790 (t
1791 (error "Bad spec: %s" specs)))))
1792
1793 ((listp form)
1794 (prog1
1795 (list (edebug-match-sublist
1796 ;; First offset is for the list form itself.
1797 ;; Treat nil as empty list.
1798 (edebug-new-cursor form (cdr (edebug-top-offset cursor)))
1799 specs))
1800 (edebug-move-cursor cursor)))
1801
1802 ((and (eq 'vector spec) (vectorp form))
1803 ;; Special case: match a vector with the specs.
1804 (let ((result (edebug-match-sublist
1805 (edebug-new-cursor
1806 form (cdr (edebug-top-offset cursor)))
1807 (cdr specs))))
1808 (edebug-move-cursor cursor)
1809 (list (apply 'vector result))))
1810
1811 (t (edebug-no-match cursor "Expected" specs)))
1812 )))
1813
1814
1815 (defun edebug-match-sublist (cursor specs)
1816 ;; Match a sublist of specs.
1817 (let (edebug-&optional
1818 ;;edebug-best-error
1819 ;;edebug-error-point
1820 )
1821 (prog1
1822 ;; match with edebug-match-specs so edebug-best-error is not bound.
1823 (edebug-match-specs cursor specs 'edebug-match-specs)
1824 (if (not (edebug-empty-cursor cursor))
1825 (if edebug-best-error
1826 (apply 'edebug-no-match cursor edebug-best-error)
1827 ;; A failed &rest or &optional spec may leave some args.
1828 (edebug-no-match cursor "Failed matching" specs)
1829 )))))
1830
1831
1832 (defun edebug-match-string (cursor spec)
1833 (let ((sexp (edebug-top-element-required cursor "Expected" spec)))
1834 (if (not (eq (intern spec) sexp))
1835 (edebug-no-match cursor "Expected" spec)
1836 ;; Since it matched, failure means immediate error, unless &optional.
1837 (setq edebug-gate t)
1838 (edebug-move-cursor cursor)
1839 (list sexp)
1840 )))
1841
1842 (defun edebug-match-nil (cursor)
1843 ;; There must be nothing left to match a nil.
1844 (if (not (edebug-empty-cursor cursor))
1845 (edebug-no-match cursor "Unmatched argument(s)")
1846 nil))
1847
1848
1849 (defun edebug-match-function (cursor)
1850 (error "Use function-form instead of function in edebug spec"))
1851
1852 (defun edebug-match-&define (cursor specs)
1853 ;; Match a defining form.
1854 ;; Normally, &define is interpreted specially other places.
1855 ;; This should only be called inside of a spec list to match the remainder
1856 ;; of the current list. e.g. ("lambda" &define args def-body)
1857 (edebug-make-form-wrapper
1858 cursor
1859 (edebug-before-offset cursor)
1860 ;; Find the last offset in the list.
1861 (let ((offsets (edebug-cursor-offsets cursor)))
1862 (while (consp offsets) (setq offsets (cdr offsets)))
1863 offsets)
1864 specs))
1865
1866 (defun edebug-match-lambda-expr (cursor)
1867 ;; The expression must be a function.
1868 ;; This will match any list form that begins with a symbol
1869 ;; that has an edebug-form-spec beginning with &define. In
1870 ;; practice, only lambda expressions should be used.
1871 ;; I could add a &lambda specification to avoid confusion.
1872 (let* ((sexp (edebug-top-element-required
1873 cursor "Expected lambda expression"))
1874 (offset (edebug-top-offset cursor))
1875 (head (and (consp sexp) (car sexp)))
1876 (spec (and (symbolp head) (get-edebug-spec head)))
1877 (edebug-inside-func nil))
1878 ;; Find out if this is a defining form from first symbol.
1879 (if (and (consp spec) (eq '&define (car spec)))
1880 (prog1
1881 (list
1882 (edebug-defining-form
1883 (edebug-new-cursor sexp offset)
1884 (car offset);; before the sexp
1885 (edebug-after-offset cursor)
1886 (cons (symbol-name head) (cdr spec))))
1887 (edebug-move-cursor cursor))
1888 (edebug-no-match cursor "Expected lambda expression")
1889 )))
1890
1891
1892 (defun edebug-match-name (cursor)
1893 ;; Set the edebug-def-name bound in edebug-defining-form.
1894 (let ((name (edebug-top-element-required cursor "Expected name")))
1895 ;; Maybe strings and numbers could be used.
1896 (if (not (symbolp name))
1897 (edebug-no-match cursor "Symbol expected for name of definition"))
1898 (setq edebug-def-name
1899 (if edebug-def-name
1900 ;; Construct a new name by appending to previous name.
1901 (intern (format "%s@%s" edebug-def-name name))
1902 name))
1903 (edebug-move-cursor cursor)
1904 (list name)))
1905
1906 (defun edebug-match-colon-name (cursor spec)
1907 ;; Set the edebug-def-name to the spec.
1908 (setq edebug-def-name
1909 (if edebug-def-name
1910 ;; Construct a new name by appending to previous name.
1911 (intern (format "%s@%s" edebug-def-name spec))
1912 spec))
1913 nil)
1914
1915 (defun edebug-match-arg (cursor)
1916 ;; set the def-args bound in edebug-defining-form
1917 (let ((edebug-arg (edebug-top-element-required cursor "Expected arg")))
1918 (if (or (not (symbolp edebug-arg))
1919 (edebug-lambda-list-keywordp edebug-arg))
1920 (edebug-no-match cursor "Bad argument:" edebug-arg))
1921 (edebug-move-cursor cursor)
1922 (setq edebug-def-args (cons edebug-arg edebug-def-args))
1923 (list edebug-arg)))
1924
1925 (defun edebug-match-def-form (cursor)
1926 ;; Like form but the form is wrapped in edebug-enter form.
1927 ;; The form is assumed to be executing outside of the function context.
1928 ;; This is a hack for now, since a def-form might execute inside as well.
1929 ;; Not to be used otherwise.
1930 (let ((edebug-inside-func nil))
1931 (list (edebug-make-enter-wrapper (list (edebug-form cursor))))))
1932
1933 (defun edebug-match-def-body (cursor)
1934 ;; Like body but body is wrapped in edebug-enter form.
1935 ;; The body is assumed to be executing inside of the function context.
1936 ;; Not to be used otherwise.
1937 (let ((edebug-inside-func t))
1938 (list (edebug-wrap-def-body (edebug-forms cursor)))))
1939
1940
1941 ;;;; Edebug Form Specs
1942 ;;; ==========================================================
1943 ;;; See cl-specs.el for common lisp specs.
1944
1945 ;;;;* Spec for def-edebug-spec
1946 ;;; Out of date.
1947
1948 (defun edebug-spec-p (object)
1949 "Return non-nil if OBJECT is a symbol with an edebug-form-spec property."
1950 (and (symbolp object)
1951 (get object 'edebug-form-spec)))
1952
1953 (def-edebug-spec def-edebug-spec
1954 ;; Top level is different from lower levels.
1955 (&define :name edebug-spec name
1956 &or "nil" edebug-spec-p "t" "0" (&rest edebug-spec)))
1957
1958 (def-edebug-spec edebug-spec-list
1959 ;; A list must have something in it, or it is nil, a symbolp
1960 ((edebug-spec . [&or nil edebug-spec])))
1961
1962 (def-edebug-spec edebug-spec
1963 (&or
1964 (vector &rest edebug-spec) ; matches a vector
1965 ("vector" &rest edebug-spec) ; matches a vector spec
1966 ("quote" symbolp)
1967 edebug-spec-list
1968 stringp
1969 [edebug-lambda-list-keywordp &rest edebug-spec]
1970 [keywordp gate edebug-spec]
1971 edebug-spec-p ;; Including all the special ones e.g. form.
1972 symbolp;; a predicate
1973 ))
1974
1975
1976 ;;;* Emacs special forms and some functions.
1977
1978 ;; quote expects only one argument, although it allows any number.
1979 (def-edebug-spec quote sexp)
1980
1981 ;; The standard defining forms.
1982 (def-edebug-spec defconst defvar)
1983 (def-edebug-spec defvar (symbolp &optional form stringp))
1984
1985 (def-edebug-spec defun
1986 (&define name lambda-list
1987 [&optional stringp]
1988 [&optional ("interactive" interactive)]
1989 def-body))
1990 (def-edebug-spec defmacro
1991 (&define name lambda-list [&optional ("declare" &rest sexp)] def-body))
1992
1993 (def-edebug-spec arglist lambda-list) ;; deprecated - use lambda-list.
1994
1995 (def-edebug-spec lambda-list
1996 (([&rest arg]
1997 [&optional ["&optional" arg &rest arg]]
1998 &optional ["&rest" arg]
1999 )))
2000
2001 (def-edebug-spec interactive
2002 (&optional &or stringp def-form))
2003
2004 ;; A function-form is for an argument that may be a function or a form.
2005 ;; This specially recognizes anonymous functions quoted with quote.
2006 (def-edebug-spec function-form
2007 ;; form at the end could also handle "function",
2008 ;; but recognize it specially to avoid wrapping function forms.
2009 (&or ([&or "quote" "function"] &or symbolp lambda-expr) form))
2010
2011 ;; function expects a symbol or a lambda or macro expression
2012 ;; A macro is allowed by Emacs.
2013 (def-edebug-spec function (&or symbolp lambda-expr))
2014
2015 ;; lambda is a macro in emacs 19.
2016 (def-edebug-spec lambda (&define lambda-list
2017 [&optional stringp]
2018 [&optional ("interactive" interactive)]
2019 def-body))
2020
2021 ;; A macro expression is a lambda expression with "macro" prepended.
2022 (def-edebug-spec macro (&define "lambda" lambda-list def-body))
2023
2024 ;; (def-edebug-spec anonymous-form ((&or ["lambda" lambda] ["macro" macro])))
2025
2026 ;; Standard functions that take function-forms arguments.
2027 (def-edebug-spec mapcar (function-form form))
2028 (def-edebug-spec mapconcat (function-form form form))
2029 (def-edebug-spec mapatoms (function-form &optional form))
2030 (def-edebug-spec apply (function-form &rest form))
2031 (def-edebug-spec funcall (function-form &rest form))
2032
2033 (def-edebug-spec let
2034 ((&rest &or (symbolp &optional form) symbolp)
2035 body))
2036
2037 (def-edebug-spec let* let)
2038
2039 (def-edebug-spec setq (&rest symbolp form))
2040 (def-edebug-spec setq-default setq)
2041
2042 (def-edebug-spec cond (&rest (&rest form)))
2043
2044 (def-edebug-spec condition-case
2045 (symbolp
2046 form
2047 &rest ([&or symbolp (&rest symbolp)] body)))
2048
2049
2050 (def-edebug-spec \` (backquote-form))
2051
2052 ;; Supports quotes inside backquotes,
2053 ;; but only at the top level inside unquotes.
2054 (def-edebug-spec backquote-form
2055 (&or
2056 ([&or "," ",@"] &or ("quote" backquote-form) form)
2057 ;; The simple version:
2058 ;; (backquote-form &rest backquote-form)
2059 ;; doesn't handle (a . ,b). The straightforward fix:
2060 ;; (backquote-form . [&or nil backquote-form])
2061 ;; uses up too much stack space.
2062 ;; Note that `(foo . ,@bar) is not legal, so we don't need to handle it.
2063 (backquote-form [&rest [&not ","] backquote-form]
2064 . [&or nil backquote-form])
2065 ;; If you use dotted forms in backquotes, replace the previous line
2066 ;; with the following. This takes quite a bit more stack space, however.
2067 ;; (backquote-form . [&or nil backquote-form])
2068 (vector &rest backquote-form)
2069 sexp))
2070
2071 ;; Special version of backquote that instruments backquoted forms
2072 ;; destined to be evaluated, usually as the result of a
2073 ;; macroexpansion. Backquoted code can only have unquotes (, and ,@)
2074 ;; in places where list forms are allowed, and predicates. If the
2075 ;; backquote is used in a macro, unquoted code that come from
2076 ;; arguments must be instrumented, if at all, with def-form not def-body.
2077
2078 ;; We could assume that all forms (not nested in other forms)
2079 ;; in arguments of macros should be def-forms, whether or not the macros
2080 ;; are defined with edebug-` but this would be expensive.
2081
2082 ;; ,@ might have some problems.
2083
2084 (defalias 'edebug-\` '\`) ;; same macro as regular backquote.
2085 (def-edebug-spec edebug-\` (def-form))
2086
2087 ;; Assume immediate quote in unquotes mean backquote at next higher level.
2088 (def-edebug-spec , (&or ("quote" edebug-\`) def-form))
2089 (def-edebug-spec ,@ (&define ;; so (,@ form) is never wrapped.
2090 &or ("quote" edebug-\`) def-form))
2091
2092 ;; New byte compiler.
2093 (def-edebug-spec defsubst defun)
2094 (def-edebug-spec dont-compile t)
2095 (def-edebug-spec eval-when-compile t)
2096 (def-edebug-spec eval-and-compile t)
2097
2098 (def-edebug-spec save-selected-window t)
2099 (def-edebug-spec save-current-buffer t)
2100 (def-edebug-spec delay-mode-hooks t)
2101 (def-edebug-spec with-temp-file t)
2102 (def-edebug-spec with-temp-message t)
2103 (def-edebug-spec with-syntax-table t)
2104 (def-edebug-spec push (form sexp))
2105 (def-edebug-spec pop (sexp))
2106
2107 (def-edebug-spec 1value (form))
2108 (def-edebug-spec noreturn (form))
2109
2110
2111 ;; Anything else?
2112
2113
2114 ;; Some miscellaneous specs for macros in public packages.
2115 ;; Send me yours.
2116
2117 ;; advice.el by Hans Chalupsky (hans@cs.buffalo.edu)
2118
2119 (def-edebug-spec ad-dolist ((symbolp form &optional form) body))
2120 (def-edebug-spec defadvice
2121 (&define name ;; thing being advised.
2122 (name ;; class is [&or "before" "around" "after"
2123 ;; "activation" "deactivation"]
2124 name ;; name of advice
2125 &rest sexp ;; optional position and flags
2126 )
2127 [&optional stringp]
2128 [&optional ("interactive" interactive)]
2129 def-body))
2130
2131 (def-edebug-spec easy-menu-define (symbolp body))
2132
2133 (def-edebug-spec with-custom-print body)
2134
2135 (def-edebug-spec sregexq (&rest sexp))
2136 (def-edebug-spec rx (&rest sexp))
2137
2138 ;;; The debugger itself
2139
2140 (defvar edebug-active nil) ;; Non-nil when edebug is active
2141
2142 ;;; add minor-mode-alist entry
2143 (or (assq 'edebug-active minor-mode-alist)
2144 (setq minor-mode-alist (cons (list 'edebug-active " *Debugging*")
2145 minor-mode-alist)))
2146
2147 (defvar edebug-stack nil)
2148 ;; Stack of active functions evaluated via edebug.
2149 ;; Should be nil at the top level.
2150
2151 (defvar edebug-stack-depth -1)
2152 ;; Index of last edebug-stack item.
2153
2154 (defvar edebug-offset-indices nil)
2155 ;; Stack of offset indices of visited edebug sexps.
2156 ;; Should be nil at the top level.
2157 ;; Each function adds one cons. Top is modified with setcar.
2158
2159
2160 (defvar edebug-entered nil
2161 ;; Non-nil if edebug has already been entered at this recursive edit level.
2162 ;; This should stay nil at the top level.
2163 )
2164
2165 ;; Should these be options?
2166 (defconst edebug-debugger 'edebug
2167 ;; Name of function to use for debugging when error or quit occurs.
2168 ;; Set this to 'debug if you want to debug edebug.
2169 )
2170
2171
2172 ;; Dynamically bound variables, declared globally but left unbound.
2173 (defvar edebug-function) ; the function being executed. change name!!
2174 (defvar edebug-args) ; the arguments of the function
2175 (defvar edebug-data) ; the edebug data for the function
2176 (defvar edebug-value) ; the result of the expression
2177 (defvar edebug-after-index)
2178 (defvar edebug-def-mark) ; the mark for the definition
2179 (defvar edebug-freq-count) ; the count of expression visits.
2180 (defvar edebug-coverage) ; the coverage results of each expression of function.
2181
2182 (defvar edebug-buffer) ; which buffer the function is in.
2183 (defvar edebug-result) ; the result of the function call returned by body
2184 (defvar edebug-outside-executing-macro)
2185 (defvar edebug-outside-defining-kbd-macro)
2186
2187 (defvar edebug-execution-mode 'step) ; Current edebug mode set by user.
2188 (defvar edebug-next-execution-mode nil) ; Use once instead of initial mode.
2189
2190 (defvar edebug-outside-debug-on-error) ; the value of debug-on-error outside
2191 (defvar edebug-outside-debug-on-quit) ; the value of debug-on-quit outside
2192
2193 (defvar edebug-outside-overriding-local-map)
2194 (defvar edebug-outside-overriding-terminal-local-map)
2195
2196 (defvar edebug-outside-pre-command-hook)
2197 (defvar edebug-outside-post-command-hook)
2198
2199 (defvar cl-lexical-debug) ;; Defined in cl.el
2200
2201 ;;; Handling signals
2202
2203 (defun edebug-signal (edebug-signal-name edebug-signal-data)
2204 "Signal an error. Args are SIGNAL-NAME, and associated DATA.
2205 A signal name is a symbol with an `error-conditions' property
2206 that is a list of condition names.
2207 A handler for any of those names will get to handle this signal.
2208 The symbol `error' should always be one of them.
2209
2210 DATA should be a list. Its elements are printed as part of the error message.
2211 If the signal is handled, DATA is made available to the handler.
2212 See `condition-case'.
2213
2214 This is the Edebug replacement for the standard `signal'. It should
2215 only be active while Edebug is. It checks `debug-on-error' to see
2216 whether it should call the debugger. When execution is resumed, the
2217 error is signaled again."
2218 (if (and (listp debug-on-error) (memq edebug-signal-name debug-on-error))
2219 (edebug 'error (cons edebug-signal-name edebug-signal-data)))
2220 ;; If we reach here without another non-local exit, then send signal again.
2221 ;; i.e. the signal is not continuable, yet.
2222 ;; Avoid infinite recursion.
2223 (let ((signal-hook-function nil))
2224 (signal edebug-signal-name edebug-signal-data)))
2225
2226 ;;; Entering Edebug
2227
2228 (defun edebug-enter (edebug-function edebug-args edebug-body)
2229 ;; Entering FUNC. The arguments are ARGS, and the body is BODY.
2230 ;; Setup edebug variables and evaluate BODY. This function is called
2231 ;; when a function evaluated with edebug-eval-top-level-form is entered.
2232 ;; Return the result of BODY.
2233
2234 ;; Is this the first time we are entering edebug since
2235 ;; lower-level recursive-edit command?
2236 ;; More precisely, this tests whether Edebug is currently active.
2237 (if (not edebug-entered)
2238 (let ((edebug-entered t)
2239 ;; Binding max-lisp-eval-depth here is OK,
2240 ;; but not inside an unwind-protect.
2241 ;; Doing it here also keeps it from growing too large.
2242 (max-lisp-eval-depth (+ 100 max-lisp-eval-depth)) ; too much??
2243 (max-specpdl-size (+ 200 max-specpdl-size))
2244
2245 (debugger edebug-debugger) ; only while edebug is active.
2246 (edebug-outside-debug-on-error debug-on-error)
2247 (edebug-outside-debug-on-quit debug-on-quit)
2248 ;; Binding these may not be the right thing to do.
2249 ;; We want to allow the global values to be changed.
2250 (debug-on-error (or debug-on-error edebug-on-error))
2251 (debug-on-quit edebug-on-quit)
2252
2253 ;; Lexical bindings must be uncompiled for this to work.
2254 (cl-lexical-debug t)
2255
2256 (edebug-outside-overriding-local-map overriding-local-map)
2257 (edebug-outside-overriding-terminal-local-map
2258 overriding-terminal-local-map)
2259
2260 ;; Save the outside value of executing macro. (here??)
2261 (edebug-outside-executing-macro executing-kbd-macro)
2262 (edebug-outside-pre-command-hook
2263 (edebug-var-status 'pre-command-hook))
2264 (edebug-outside-post-command-hook
2265 (edebug-var-status 'post-command-hook)))
2266 (unwind-protect
2267 (let (;; Don't keep reading from an executing kbd macro
2268 ;; within edebug unless edebug-continue-kbd-macro is
2269 ;; non-nil. Again, local binding may not be best.
2270 (executing-kbd-macro
2271 (if edebug-continue-kbd-macro executing-kbd-macro))
2272
2273 ;; Don't get confused by the user's keymap changes.
2274 (overriding-local-map nil)
2275 (overriding-terminal-local-map nil)
2276
2277 (signal-hook-function 'edebug-signal)
2278
2279 ;; Disable command hooks. This is essential when
2280 ;; a hook function is instrumented - to avoid infinite loop.
2281 ;; This may be more than we need, however.
2282 (pre-command-hook nil)
2283 (post-command-hook nil))
2284 (setq edebug-execution-mode (or edebug-next-execution-mode
2285 edebug-initial-mode
2286 edebug-execution-mode)
2287 edebug-next-execution-mode nil)
2288 (edebug-enter edebug-function edebug-args edebug-body))
2289 ;; Reset global variables in case outside value was changed.
2290 (setq executing-kbd-macro edebug-outside-executing-macro)
2291 (edebug-restore-status
2292 'post-command-hook edebug-outside-post-command-hook)
2293 (edebug-restore-status
2294 'pre-command-hook edebug-outside-pre-command-hook)))
2295
2296 (let* ((edebug-data (get edebug-function 'edebug))
2297 (edebug-def-mark (car edebug-data)) ; mark at def start
2298 (edebug-freq-count (get edebug-function 'edebug-freq-count))
2299 (edebug-coverage (get edebug-function 'edebug-coverage))
2300 (edebug-buffer (marker-buffer edebug-def-mark))
2301
2302 (edebug-stack (cons edebug-function edebug-stack))
2303 (edebug-offset-indices (cons 0 edebug-offset-indices))
2304 )
2305 (if (get edebug-function 'edebug-on-entry)
2306 (progn
2307 (setq edebug-execution-mode 'step)
2308 (if (eq (get edebug-function 'edebug-on-entry) 'temp)
2309 (put edebug-function 'edebug-on-entry nil))))
2310 (if edebug-trace
2311 (edebug-enter-trace edebug-body)
2312 (funcall edebug-body))
2313 )))
2314
2315 (defun edebug-var-status (var)
2316 "Return a cons cell describing the status of VAR's current binding.
2317 The purpose of this function is so you can properly undo
2318 subsequent changes to the same binding, by passing the status
2319 cons cell to `edebug-restore-status'. The status cons cell
2320 has the form (LOCUS . VALUE), where LOCUS can be a buffer
2321 \(for a buffer-local binding), a frame (for a frame-local binding),
2322 or nil (if the default binding is current)."
2323 (cons (variable-binding-locus var)
2324 (symbol-value var)))
2325
2326 (defun edebug-restore-status (var status)
2327 "Reset VAR based on STATUS.
2328 STATUS should be a list you got from `edebug-var-status'."
2329 (let ((locus (car status))
2330 (value (cdr status)))
2331 (cond ((bufferp locus)
2332 (if (buffer-live-p locus)
2333 (with-current-buffer locus
2334 (set var value))))
2335 ((framep locus)
2336 (modify-frame-parameters locus (list (cons var value))))
2337 (t
2338 (set var value)))))
2339
2340 (defun edebug-enter-trace (edebug-body)
2341 (let ((edebug-stack-depth (1+ edebug-stack-depth))
2342 edebug-result)
2343 (edebug-print-trace-before
2344 (format "%s args: %s" edebug-function edebug-args))
2345 (prog1 (setq edebug-result (funcall edebug-body))
2346 (edebug-print-trace-after
2347 (format "%s result: %s" edebug-function edebug-result)))))
2348
2349 (def-edebug-spec edebug-tracing (form body))
2350
2351 (defmacro edebug-tracing (msg &rest body)
2352 "Print MSG in *edebug-trace* before and after evaluating BODY.
2353 The result of BODY is also printed."
2354 `(let ((edebug-stack-depth (1+ edebug-stack-depth))
2355 edebug-result)
2356 (edebug-print-trace-before ,msg)
2357 (prog1 (setq edebug-result (progn ,@body))
2358 (edebug-print-trace-after
2359 (format "%s result: %s" ,msg edebug-result)))))
2360
2361 (defun edebug-print-trace-before (msg)
2362 "Function called to print trace info before expression evaluation.
2363 MSG is printed after `::::{ '."
2364 (edebug-trace-display
2365 edebug-trace-buffer "%s{ %s" (make-string edebug-stack-depth ?\:) msg))
2366
2367 (defun edebug-print-trace-after (msg)
2368 "Function called to print trace info after expression evaluation.
2369 MSG is printed after `::::} '."
2370 (edebug-trace-display
2371 edebug-trace-buffer "%s} %s" (make-string edebug-stack-depth ?\:) msg))
2372
2373
2374
2375 (defun edebug-slow-before (edebug-before-index)
2376 (unless edebug-active
2377 ;; Debug current function given BEFORE position.
2378 ;; Called from functions compiled with edebug-eval-top-level-form.
2379 ;; Return the before index.
2380 (setcar edebug-offset-indices edebug-before-index)
2381
2382 ;; Increment frequency count
2383 (aset edebug-freq-count edebug-before-index
2384 (1+ (aref edebug-freq-count edebug-before-index)))
2385
2386 (if (or (not (memq edebug-execution-mode '(Go-nonstop next)))
2387 (edebug-input-pending-p))
2388 (edebug-debugger edebug-before-index 'before nil)))
2389 edebug-before-index)
2390
2391 (defun edebug-fast-before (edebug-before-index)
2392 ;; Do nothing.
2393 )
2394
2395 (defun edebug-slow-after (edebug-before-index edebug-after-index edebug-value)
2396 (if edebug-active
2397 edebug-value
2398 ;; Debug current function given AFTER position and VALUE.
2399 ;; Called from functions compiled with edebug-eval-top-level-form.
2400 ;; Return VALUE.
2401 (setcar edebug-offset-indices edebug-after-index)
2402
2403 ;; Increment frequency count
2404 (aset edebug-freq-count edebug-after-index
2405 (1+ (aref edebug-freq-count edebug-after-index)))
2406 (if edebug-test-coverage (edebug-update-coverage))
2407
2408 (if (and (eq edebug-execution-mode 'Go-nonstop)
2409 (not (edebug-input-pending-p)))
2410 ;; Just return result.
2411 edebug-value
2412 (edebug-debugger edebug-after-index 'after edebug-value)
2413 )))
2414
2415 (defun edebug-fast-after (edebug-before-index edebug-after-index edebug-value)
2416 ;; Do nothing but return the value.
2417 edebug-value)
2418
2419 (defun edebug-run-slow ()
2420 (defalias 'edebug-before 'edebug-slow-before)
2421 (defalias 'edebug-after 'edebug-slow-after))
2422
2423 ;; This is not used, yet.
2424 (defun edebug-run-fast ()
2425 (defalias 'edebug-before 'edebug-fast-before)
2426 (defalias 'edebug-after 'edebug-fast-after))
2427
2428 (edebug-run-slow)
2429
2430
2431 (defun edebug-update-coverage ()
2432 (let ((old-result (aref edebug-coverage edebug-after-index)))
2433 (cond
2434 ((eq 'ok-coverage old-result))
2435 ((eq 'unknown old-result)
2436 (aset edebug-coverage edebug-after-index edebug-value))
2437 ;; Test if a different result.
2438 ((not (eq edebug-value old-result))
2439 (aset edebug-coverage edebug-after-index 'ok-coverage)))))
2440
2441
2442 ;; Dynamically declared unbound variables.
2443 (defvar edebug-arg-mode) ; the mode, either before, after, or error
2444 (defvar edebug-breakpoints)
2445 (defvar edebug-break-data) ; break data for current function.
2446 (defvar edebug-break) ; whether a break occurred.
2447 (defvar edebug-global-break) ; whether a global break occurred.
2448 (defvar edebug-break-condition) ; whether the breakpoint is conditional.
2449
2450 (defvar edebug-break-result nil)
2451 (defvar edebug-global-break-result nil)
2452
2453
2454 (defun edebug-debugger (edebug-offset-index edebug-arg-mode edebug-value)
2455 (if inhibit-redisplay
2456 ;; Don't really try to enter edebug within an eval from redisplay.
2457 edebug-value
2458 ;; Check breakpoints and pending input.
2459 ;; If edebug display should be updated, call edebug-display.
2460 ;; Return edebug-value.
2461 (let* ( ;; This needs to be here since breakpoints may be changed.
2462 (edebug-breakpoints (car (cdr edebug-data))) ; list of breakpoints
2463 (edebug-break-data (assq edebug-offset-index edebug-breakpoints))
2464 (edebug-break-condition (car (cdr edebug-break-data)))
2465 (edebug-global-break
2466 (if edebug-global-break-condition
2467 (condition-case nil
2468 (setq edebug-global-break-result
2469 (eval edebug-global-break-condition))
2470 (error nil))))
2471 (edebug-break))
2472
2473 ;;; (edebug-trace "exp: %s" edebug-value)
2474 ;; Test whether we should break.
2475 (setq edebug-break
2476 (or edebug-global-break
2477 (and edebug-break-data
2478 (or (not edebug-break-condition)
2479 (setq edebug-break-result
2480 (eval edebug-break-condition))))))
2481 (if (and edebug-break
2482 (nth 2 edebug-break-data)) ; is it temporary?
2483 ;; Delete the breakpoint.
2484 (setcdr edebug-data
2485 (cons (delq edebug-break-data edebug-breakpoints)
2486 (cdr (cdr edebug-data)))))
2487
2488 ;; Display if mode is not go, continue, or Continue-fast
2489 ;; or break, or input is pending,
2490 (if (or (not (memq edebug-execution-mode '(go continue Continue-fast)))
2491 edebug-break
2492 (edebug-input-pending-p))
2493 (edebug-display)) ; <--------------- display
2494
2495 edebug-value
2496 )))
2497
2498
2499 ;; window-start now stored with each function.
2500 ;;(defvar edebug-window-start nil)
2501 ;; Remember where each buffers' window starts between edebug calls.
2502 ;; This is to avoid spurious recentering.
2503 ;; Does this still need to be buffer-local??
2504 ;;(setq-default edebug-window-start nil)
2505 ;;(make-variable-buffer-local 'edebug-window-start)
2506
2507
2508 ;; Dynamically declared unbound vars
2509 (defvar edebug-point) ; the point in edebug buffer
2510 (defvar edebug-outside-buffer) ; the current-buffer outside of edebug
2511 (defvar edebug-outside-point) ; the point outside of edebug
2512 (defvar edebug-outside-mark) ; the mark outside of edebug
2513 (defvar edebug-window-data) ; window and window-start for current function
2514 (defvar edebug-outside-windows) ; outside window configuration
2515 (defvar edebug-eval-buffer) ; for the evaluation list.
2516 (defvar edebug-outside-o-a-p) ; outside overlay-arrow-position
2517 (defvar edebug-outside-o-a-s) ; outside overlay-arrow-string
2518 (defvar edebug-outside-c-i-e-a) ; outside cursor-in-echo-area
2519
2520 (defvar edebug-eval-list nil) ;; List of expressions to evaluate.
2521
2522 (defvar edebug-previous-result nil) ;; Last result returned.
2523
2524 ;; Emacs 19 adds an arg to mark and mark-marker.
2525 (defalias 'edebug-mark-marker 'mark-marker)
2526
2527
2528 (defun edebug-display ()
2529 (unless (marker-position edebug-def-mark)
2530 ;; The buffer holding the source has been killed.
2531 ;; Let's at least show a backtrace so the user can figure out
2532 ;; which function we're talking about.
2533 (debug))
2534 ;; Setup windows for edebug, determine mode, maybe enter recursive-edit.
2535 ;; Uses local variables of edebug-enter, edebug-before, edebug-after
2536 ;; and edebug-debugger.
2537 (let ((edebug-active t) ; for minor mode alist
2538 (edebug-with-timeout-suspend (with-timeout-suspend))
2539 edebug-stop ; should we enter recursive-edit
2540 (edebug-point (+ edebug-def-mark
2541 (aref (nth 2 edebug-data) edebug-offset-index)))
2542 edebug-buffer-outside-point ; current point in edebug-buffer
2543 ;; window displaying edebug-buffer
2544 (edebug-window-data (nth 3 edebug-data))
2545 (edebug-outside-window (selected-window))
2546 (edebug-outside-buffer (current-buffer))
2547 (edebug-outside-point (point))
2548 (edebug-outside-mark (edebug-mark))
2549 edebug-outside-windows ; window or screen configuration
2550 edebug-buffer-points
2551
2552 edebug-eval-buffer ; declared here so we can kill it below
2553 (edebug-eval-result-list (and edebug-eval-list
2554 (edebug-eval-result-list)))
2555 edebug-trace-window
2556 edebug-trace-window-start
2557
2558 (edebug-outside-o-a-p overlay-arrow-position)
2559 (edebug-outside-o-a-s overlay-arrow-string)
2560 (edebug-outside-c-i-e-a cursor-in-echo-area))
2561 (unwind-protect
2562 (let ((overlay-arrow-position overlay-arrow-position)
2563 (overlay-arrow-string overlay-arrow-string)
2564 (cursor-in-echo-area nil)
2565 ;; any others??
2566 )
2567 (if (not (buffer-name edebug-buffer))
2568 (let ((debug-on-error nil))
2569 (error "Buffer defining %s not found" edebug-function)))
2570
2571 (if (eq 'after edebug-arg-mode)
2572 ;; Compute result string now before windows are modified.
2573 (edebug-compute-previous-result edebug-value))
2574
2575 (if edebug-save-windows
2576 ;; Save windows now before we modify them.
2577 (setq edebug-outside-windows
2578 (edebug-current-windows edebug-save-windows)))
2579
2580 (if edebug-save-displayed-buffer-points
2581 (setq edebug-buffer-points (edebug-get-displayed-buffer-points)))
2582
2583 ;; First move the edebug buffer point to edebug-point
2584 ;; so that window start doesn't get changed when we display it.
2585 ;; I don't know if this is going to help.
2586 ;;(set-buffer edebug-buffer)
2587 ;;(goto-char edebug-point)
2588
2589 ;; If edebug-buffer is not currently displayed,
2590 ;; first find a window for it.
2591 (edebug-pop-to-buffer edebug-buffer (car edebug-window-data))
2592 (setcar edebug-window-data (selected-window))
2593
2594 ;; Now display eval list, if any.
2595 ;; This is done after the pop to edebug-buffer
2596 ;; so that buffer-window correspondence is correct after quitting.
2597 (edebug-eval-display edebug-eval-result-list)
2598 ;; The evaluation list better not have deleted edebug-window-data.
2599 (select-window (car edebug-window-data))
2600 (set-buffer edebug-buffer)
2601
2602 (setq edebug-buffer-outside-point (point))
2603 (goto-char edebug-point)
2604
2605 (if (eq 'before edebug-arg-mode)
2606 ;; Check whether positions are up-to-date.
2607 ;; This assumes point is never before symbol.
2608 (if (not (memq (following-char) '(?\( ?\# ?\` )))
2609 (let ((debug-on-error nil))
2610 (error "Source has changed - reevaluate definition of %s"
2611 edebug-function)
2612 )))
2613
2614 (setcdr edebug-window-data
2615 (edebug-adjust-window (cdr edebug-window-data)))
2616
2617 ;; Test if there is input, not including keyboard macros.
2618 (if (edebug-input-pending-p)
2619 (progn
2620 (setq edebug-execution-mode 'step
2621 edebug-stop t)
2622 (edebug-stop)
2623 ;; (discard-input) ; is this unfriendly??
2624 ))
2625 ;; Now display arrow based on mode.
2626 (edebug-overlay-arrow)
2627
2628 (cond
2629 ((eq 'error edebug-arg-mode)
2630 ;; Display error message
2631 (setq edebug-execution-mode 'step)
2632 (edebug-overlay-arrow)
2633 (beep)
2634 (if (eq 'quit (car edebug-value))
2635 (message "Quit")
2636 (edebug-report-error edebug-value)))
2637 (edebug-break
2638 (cond
2639 (edebug-global-break
2640 (message "Global Break: %s => %s"
2641 edebug-global-break-condition
2642 edebug-global-break-result))
2643 (edebug-break-condition
2644 (message "Break: %s => %s"
2645 edebug-break-condition
2646 edebug-break-result))
2647 ((not (eq edebug-execution-mode 'Continue-fast))
2648 (message "Break"))
2649 (t)))
2650
2651 (t (message "")))
2652
2653 (if (eq 'after edebug-arg-mode)
2654 (progn
2655 ;; Display result of previous evaluation.
2656 (if (and edebug-break
2657 (not (eq edebug-execution-mode 'Continue-fast)))
2658 (sit-for 1)) ; Show break message.
2659 (edebug-previous-result)))
2660
2661 (cond
2662 (edebug-break
2663 (cond
2664 ((eq edebug-execution-mode 'continue) (edebug-sit-for 1))
2665 ((eq edebug-execution-mode 'Continue-fast) (edebug-sit-for 0))
2666 (t (setq edebug-stop t))))
2667 ;; not edebug-break
2668 ((eq edebug-execution-mode 'trace)
2669 (edebug-sit-for edebug-sit-for-seconds)) ; Force update and pause.
2670 ((eq edebug-execution-mode 'Trace-fast)
2671 (edebug-sit-for 0)) ; Force update and continue.
2672 )
2673
2674 (unwind-protect
2675 (if (or edebug-stop
2676 (memq edebug-execution-mode '(step next))
2677 (eq edebug-arg-mode 'error))
2678 (progn
2679 ;; (setq edebug-execution-mode 'step)
2680 ;; (edebug-overlay-arrow) ; This doesn't always show up.
2681 (edebug-recursive-edit))) ; <---------- Recursive edit
2682
2683 ;; Reset the edebug-window-data to whatever it is now.
2684 (let ((window (if (eq (window-buffer) edebug-buffer)
2685 (selected-window)
2686 (edebug-get-buffer-window edebug-buffer))))
2687 ;; Remember window-start for edebug-buffer, if still displayed.
2688 (if window
2689 (progn
2690 (setcar edebug-window-data window)
2691 (setcdr edebug-window-data (window-start window)))))
2692
2693 ;; Save trace window point before restoring outside windows.
2694 ;; Could generalize this for other buffers.
2695 (setq edebug-trace-window (get-buffer-window edebug-trace-buffer))
2696 (if edebug-trace-window
2697 (setq edebug-trace-window-start
2698 (and edebug-trace-window
2699 (window-start edebug-trace-window))))
2700
2701 ;; Restore windows before continuing.
2702 (if edebug-save-windows
2703 (progn
2704 (edebug-set-windows edebug-outside-windows)
2705
2706 ;; Restore displayed buffer points.
2707 ;; Needed even if restoring windows because
2708 ;; window-points are not restored. (should they be??)
2709 (if edebug-save-displayed-buffer-points
2710 (edebug-set-buffer-points edebug-buffer-points))
2711
2712 ;; Unrestore trace window's window-point.
2713 (if edebug-trace-window
2714 (set-window-start edebug-trace-window
2715 edebug-trace-window-start))
2716
2717 ;; Unrestore edebug-buffer's window-start, if displayed.
2718 (let ((window (car edebug-window-data)))
2719 (if (and window (edebug-window-live-p window)
2720 (eq (window-buffer) edebug-buffer))
2721 (progn
2722 (set-window-start window (cdr edebug-window-data)
2723 'no-force)
2724 ;; Unrestore edebug-buffer's window-point.
2725 ;; Needed in addition to setting the buffer point
2726 ;; - otherwise quitting doesn't leave point as is.
2727 ;; But this causes point to not be restored at times.
2728 ;; Also, it may not be a visible window.
2729 ;; (set-window-point window edebug-point)
2730 )))
2731
2732 ;; Unrestore edebug-buffer's point. Rerestored below.
2733 ;; (goto-char edebug-point) ;; in edebug-buffer
2734 )
2735 ;; Since we may be in a save-excursion, in case of quit,
2736 ;; reselect the outside window only.
2737 ;; Only needed if we are not recovering windows??
2738 (if (edebug-window-live-p edebug-outside-window)
2739 (select-window edebug-outside-window))
2740 ) ; if edebug-save-windows
2741
2742 ;; Restore current buffer always, in case application needs it.
2743 (set-buffer edebug-outside-buffer)
2744 ;; Restore point, and mark.
2745 ;; Needed even if restoring windows because
2746 ;; that doesn't restore point and mark in the current buffer.
2747 ;; But don't restore point if edebug-buffer is current buffer.
2748 (if (not (eq edebug-buffer edebug-outside-buffer))
2749 (goto-char edebug-outside-point))
2750 (if (marker-buffer (edebug-mark-marker))
2751 ;; Does zmacs-regions need to be nil while doing set-marker?
2752 (set-marker (edebug-mark-marker) edebug-outside-mark))
2753 ) ; unwind-protect
2754 ;; None of the following is done if quit or signal occurs.
2755
2756 ;; Restore edebug-buffer's outside point.
2757 ;; (edebug-trace "restore edebug-buffer point: %s"
2758 ;; edebug-buffer-outside-point)
2759 (let ((current-buffer (current-buffer)))
2760 (set-buffer edebug-buffer)
2761 (goto-char edebug-buffer-outside-point)
2762 (set-buffer current-buffer))
2763 ;; ... nothing more.
2764 )
2765 (with-timeout-unsuspend edebug-with-timeout-suspend)
2766 ;; Reset global variables to outside values in case they were changed.
2767 (setq
2768 overlay-arrow-position edebug-outside-o-a-p
2769 overlay-arrow-string edebug-outside-o-a-s
2770 cursor-in-echo-area edebug-outside-c-i-e-a)
2771 )))
2772
2773
2774 (defvar edebug-number-of-recursions 0)
2775 ;; Number of recursive edits started by edebug.
2776 ;; Should be 0 at the top level.
2777
2778 (defvar edebug-recursion-depth 0)
2779 ;; Value of recursion-depth when edebug was called.
2780
2781 ;; Dynamically declared unbound vars
2782 (defvar edebug-outside-match-data) ; match data outside of edebug
2783 (defvar edebug-backtrace-buffer) ; each recursive edit gets its own
2784 (defvar edebug-inside-windows)
2785 (defvar edebug-interactive-p)
2786
2787 (defvar edebug-outside-map)
2788 (defvar edebug-outside-standard-output)
2789 (defvar edebug-outside-standard-input)
2790 (defvar edebug-outside-current-prefix-arg)
2791 (defvar edebug-outside-last-command-char)
2792 (defvar edebug-outside-last-command)
2793 (defvar edebug-outside-this-command)
2794 (defvar edebug-outside-last-input-char)
2795
2796 ;; Note: here we have defvars for variables that are
2797 ;; built-in in certain versions.
2798 ;; Each defvar makes a difference
2799 ;; in versions where the variable is *not* built-in.
2800
2801 ;; Emacs 18
2802 (defvar edebug-outside-unread-command-char)
2803
2804 ;; Emacs 19.
2805 (defvar edebug-outside-last-command-event)
2806 (defvar edebug-outside-unread-command-events)
2807 (defvar edebug-outside-last-input-event)
2808 (defvar edebug-outside-last-event-frame)
2809 (defvar edebug-outside-last-nonmenu-event)
2810 (defvar edebug-outside-track-mouse)
2811
2812 ;; Disable byte compiler warnings about unread-command-char and -event
2813 ;; (maybe works with byte-compile-version 2.22 at least)
2814 (defvar edebug-unread-command-char-warning)
2815 (defvar edebug-unread-command-event-warning)
2816 (eval-when-compile
2817 (setq edebug-unread-command-char-warning
2818 (get 'unread-command-char 'byte-obsolete-variable))
2819 (put 'unread-command-char 'byte-obsolete-variable nil))
2820
2821 (defun edebug-recursive-edit ()
2822 ;; Start up a recursive edit inside of edebug.
2823 ;; The current buffer is the edebug-buffer, which is put into edebug-mode.
2824 ;; Assume that none of the variables below are buffer-local.
2825 (let ((edebug-buffer-read-only buffer-read-only)
2826 ;; match-data must be done in the outside buffer
2827 (edebug-outside-match-data
2828 (save-excursion ; might be unnecessary now??
2829 (set-buffer edebug-outside-buffer) ; in case match buffer different
2830 (match-data)))
2831
2832 ;;(edebug-number-of-recursions (1+ edebug-number-of-recursions))
2833 (edebug-recursion-depth (recursion-depth))
2834 edebug-entered ; bind locally to nil
2835 (edebug-interactive-p nil) ; again non-interactive
2836 edebug-backtrace-buffer ; each recursive edit gets its own
2837 ;; The window configuration may be saved and restored
2838 ;; during a recursive-edit
2839 edebug-inside-windows
2840
2841 (edebug-outside-map (current-local-map))
2842
2843 (edebug-outside-standard-output standard-output)
2844 (edebug-outside-standard-input standard-input)
2845 (edebug-outside-defining-kbd-macro defining-kbd-macro)
2846
2847 (edebug-outside-last-command-char last-command-char)
2848 (edebug-outside-last-command last-command)
2849 (edebug-outside-this-command this-command)
2850 (edebug-outside-last-input-char last-input-char)
2851
2852 (edebug-outside-unread-command-char unread-command-char)
2853 (edebug-outside-current-prefix-arg current-prefix-arg)
2854
2855 (edebug-outside-last-input-event last-input-event)
2856 (edebug-outside-last-command-event last-command-event)
2857 (edebug-outside-unread-command-events unread-command-events)
2858 (edebug-outside-last-event-frame last-event-frame)
2859 (edebug-outside-last-nonmenu-event last-nonmenu-event)
2860 (edebug-outside-track-mouse track-mouse)
2861 )
2862
2863 (unwind-protect
2864 (let (
2865 ;; Declare global values local but using the same global value.
2866 ;; We could set these to the values for previous edebug call.
2867 (last-command-char last-command-char)
2868 (last-command last-command)
2869 (this-command this-command)
2870 (last-input-char last-input-char)
2871
2872 ;; Assume no edebug command sets unread-command-char.
2873 (unread-command-char -1)
2874 (current-prefix-arg nil)
2875
2876 ;; More for Emacs 19
2877 (last-input-event nil)
2878 (last-command-event nil)
2879 (unread-command-events nil)
2880 (last-event-frame nil)
2881 (last-nonmenu-event nil)
2882 (track-mouse nil)
2883
2884 ;; Bind again to outside values.
2885 (debug-on-error edebug-outside-debug-on-error)
2886 (debug-on-quit edebug-outside-debug-on-quit)
2887
2888 ;; Don't keep defining a kbd macro.
2889 (defining-kbd-macro
2890 (if edebug-continue-kbd-macro defining-kbd-macro))
2891
2892 ;; others??
2893 )
2894
2895 (if (and (eq edebug-execution-mode 'go)
2896 (not (memq edebug-arg-mode '(after error))))
2897 (message "Break"))
2898
2899 (setq buffer-read-only t)
2900 (setq signal-hook-function nil)
2901
2902 (edebug-mode)
2903 (unwind-protect
2904 (recursive-edit) ; <<<<<<<<<< Recursive edit
2905
2906 ;; Do the following, even if quit occurs.
2907 (setq signal-hook-function 'edebug-signal)
2908 (if edebug-backtrace-buffer
2909 (kill-buffer edebug-backtrace-buffer))
2910 ;; Could be an option to keep eval display up.
2911 (if edebug-eval-buffer (kill-buffer edebug-eval-buffer))
2912
2913 ;; Remember selected-window after recursive-edit.
2914 ;; (setq edebug-inside-window (selected-window))
2915
2916 (set-match-data edebug-outside-match-data)
2917
2918 ;; Recursive edit may have changed buffers,
2919 ;; so set it back before exiting let.
2920 (if (buffer-name edebug-buffer) ; if it still exists
2921 (progn
2922 (set-buffer edebug-buffer)
2923 (if (memq edebug-execution-mode '(go Go-nonstop))
2924 (edebug-overlay-arrow))
2925 (setq buffer-read-only edebug-buffer-read-only)
2926 (use-local-map edebug-outside-map)
2927 )
2928 ;; gotta have a buffer to let its buffer local variables be set
2929 (get-buffer-create " bogus edebug buffer"))
2930 ));; inner let
2931
2932 ;; Reset global vars to outside values, in case they have been changed.
2933 (setq
2934 last-command-char edebug-outside-last-command-char
2935 last-command-event edebug-outside-last-command-event
2936 last-command edebug-outside-last-command
2937 this-command edebug-outside-this-command
2938 unread-command-char edebug-outside-unread-command-char
2939 unread-command-events edebug-outside-unread-command-events
2940 current-prefix-arg edebug-outside-current-prefix-arg
2941 last-input-char edebug-outside-last-input-char
2942 last-input-event edebug-outside-last-input-event
2943 last-event-frame edebug-outside-last-event-frame
2944 last-nonmenu-event edebug-outside-last-nonmenu-event
2945 track-mouse edebug-outside-track-mouse
2946
2947 standard-output edebug-outside-standard-output
2948 standard-input edebug-outside-standard-input
2949 defining-kbd-macro edebug-outside-defining-kbd-macro
2950 ))
2951 ))
2952
2953
2954 ;;; Display related functions
2955
2956 (defun edebug-adjust-window (old-start)
2957 ;; If pos is not visible, adjust current window to fit following context.
2958 ;;; (message "window: %s old-start: %s window-start: %s pos: %s"
2959 ;;; (selected-window) old-start (window-start) (point)) (sit-for 5)
2960 (if (not (pos-visible-in-window-p))
2961 (progn
2962 ;; First try old-start
2963 (if old-start
2964 (set-window-start (selected-window) old-start))
2965 (if (not (pos-visible-in-window-p))
2966 (progn
2967 ;; (message "resetting window start") (sit-for 2)
2968 (set-window-start
2969 (selected-window)
2970 (save-excursion
2971 (forward-line
2972 (if (< (point) (window-start)) -1 ; one line before if in back
2973 (- (/ (window-height) 2)) ; center the line moving forward
2974 ))
2975 (beginning-of-line)
2976 (point)))))))
2977 (window-start))
2978
2979
2980
2981 (defconst edebug-arrow-alist
2982 '((Continue-fast . "=")
2983 (Trace-fast . "-")
2984 (continue . ">")
2985 (trace . "->")
2986 (step . "=>")
2987 (next . "=>")
2988 (go . "<>")
2989 (Go-nonstop . "..") ; not used
2990 )
2991 "Association list of arrows for each edebug mode.")
2992
2993 (defun edebug-overlay-arrow ()
2994 ;; Set up the overlay arrow at beginning-of-line in current buffer.
2995 ;; The arrow string is derived from edebug-arrow-alist and
2996 ;; edebug-execution-mode.
2997 (let ((pos (save-excursion (beginning-of-line) (point))))
2998 (setq overlay-arrow-string
2999 (cdr (assq edebug-execution-mode edebug-arrow-alist)))
3000 (setq overlay-arrow-position (make-marker))
3001 (set-marker overlay-arrow-position pos (current-buffer))))
3002
3003
3004 (defun edebug-toggle-save-all-windows ()
3005 "Toggle the saving and restoring of all windows.
3006 Also, each time you toggle it on, the inside and outside window
3007 configurations become the same as the current configuration."
3008 (interactive)
3009 (setq edebug-save-windows (not edebug-save-windows))
3010 (if edebug-save-windows
3011 (setq edebug-inside-windows
3012 (setq edebug-outside-windows
3013 (edebug-current-windows
3014 edebug-save-windows))))
3015 (message "Window saving is %s for all windows."
3016 (if edebug-save-windows "on" "off")))
3017
3018 (defmacro edebug-changing-windows (&rest body)
3019 `(let ((window (selected-window)))
3020 (setq edebug-inside-windows (edebug-current-windows t))
3021 (edebug-set-windows edebug-outside-windows)
3022 ,@body;; Code to change edebug-save-windows
3023 (setq edebug-outside-windows (edebug-current-windows
3024 edebug-save-windows))
3025 ;; Problem: what about outside windows that are deleted inside?
3026 (edebug-set-windows edebug-inside-windows)))
3027
3028 (defun edebug-toggle-save-selected-window ()
3029 "Toggle the saving and restoring of the selected window.
3030 Also, each time you toggle it on, the inside and outside window
3031 configurations become the same as the current configuration."
3032 (interactive)
3033 (cond
3034 ((eq t edebug-save-windows)
3035 ;; Save all outside windows except the selected one.
3036 ;; Remove (selected-window) from outside-windows.
3037 (edebug-changing-windows
3038 (setq edebug-save-windows (delq window (edebug-window-list)))))
3039
3040 ((memq (selected-window) edebug-save-windows)
3041 (setq edebug-outside-windows
3042 (delq (assq (selected-window) edebug-outside-windows)
3043 edebug-outside-windows))
3044 (setq edebug-save-windows
3045 (delq (selected-window) edebug-save-windows)))
3046 (t ; Save a new window.
3047 (edebug-changing-windows
3048 (setq edebug-save-windows (cons window edebug-save-windows)))))
3049
3050 (message "Window saving is %s for %s."
3051 (if (memq (selected-window) edebug-save-windows)
3052 "on" "off")
3053 (selected-window)))
3054
3055 (defun edebug-toggle-save-windows (arg)
3056 "Toggle the saving and restoring of windows.
3057 With prefix, toggle for just the selected window.
3058 Otherwise, toggle for all windows."
3059 (interactive "P")
3060 (if arg
3061 (edebug-toggle-save-selected-window)
3062 (edebug-toggle-save-all-windows)))
3063
3064
3065 (defun edebug-where ()
3066 "Show the debug windows and where we stopped in the program."
3067 (interactive)
3068 (if (not edebug-active)
3069 (error "Edebug is not active"))
3070 ;; Restore the window configuration to what it last was inside.
3071 ;; But it is not always set. - experiment
3072 ;;(if edebug-inside-windows
3073 ;; (edebug-set-windows edebug-inside-windows))
3074 (edebug-pop-to-buffer edebug-buffer)
3075 (goto-char edebug-point))
3076
3077 (defun edebug-view-outside ()
3078 "Change to the outside window configuration."
3079 (interactive)
3080 (if (not edebug-active)
3081 (error "Edebug is not active"))
3082 (setq edebug-inside-windows
3083 (edebug-current-windows edebug-save-windows))
3084 (edebug-set-windows edebug-outside-windows)
3085 (goto-char edebug-outside-point)
3086 (message "Window configuration outside of Edebug. Return with %s"
3087 (substitute-command-keys "\\<global-map>\\[edebug-where]")))
3088
3089
3090 (defun edebug-bounce-point (arg)
3091 "Bounce the point in the outside current buffer.
3092 If prefix arg is supplied, sit for that many seconds before returning.
3093 The default is one second."
3094 (interactive "p")
3095 (if (not edebug-active)
3096 (error "Edebug is not active"))
3097 (save-excursion
3098 ;; If the buffer's currently displayed, avoid set-window-configuration.
3099 (save-window-excursion
3100 (edebug-pop-to-buffer edebug-outside-buffer)
3101 (goto-char edebug-outside-point)
3102 (message "Current buffer: %s Point: %s Mark: %s"
3103 (current-buffer) (point)
3104 (if (marker-buffer (edebug-mark-marker))
3105 (marker-position (edebug-mark-marker)) "<not set>"))
3106 (edebug-sit-for arg)
3107 (edebug-pop-to-buffer edebug-buffer (car edebug-window-data)))))
3108
3109
3110 ;; Joe Wells, here is a start at your idea of adding a buffer to the internal
3111 ;; display list. Still need to use this list in edebug-display.
3112
3113 '(defvar edebug-display-buffer-list nil
3114 "List of buffers that edebug will display when it is active.")
3115
3116 '(defun edebug-display-buffer (buffer)
3117 "Toggle display of a buffer inside of edebug."
3118 (interactive "bBuffer: ")
3119 (let ((already-displaying (memq buffer edebug-display-buffer-list)))
3120 (setq edebug-display-buffer-list
3121 (if already-displaying
3122 (delq buffer edebug-display-buffer-list)
3123 (cons buffer edebug-display-buffer-list)))
3124 (message "Displaying %s %s" buffer
3125 (if already-displaying "off" "on"))))
3126
3127 ;;; Breakpoint related functions
3128
3129 (defun edebug-find-stop-point ()
3130 ;; Return (function . index) of the nearest edebug stop point.
3131 (let* ((edebug-def-name (edebug-form-data-symbol))
3132 (edebug-data
3133 (let ((data (get edebug-def-name 'edebug)))
3134 (if (or (null data) (markerp data))
3135 (error "%s is not instrumented for Edebug" edebug-def-name))
3136 data)) ; we could do it automatically, if data is a marker.
3137 ;; pull out parts of edebug-data.
3138 (edebug-def-mark (car edebug-data))
3139 ;; (edebug-breakpoints (car (cdr edebug-data)))
3140
3141 (offset-vector (nth 2 edebug-data))
3142 (offset (- (save-excursion
3143 (if (looking-at "[ \t]")
3144 ;; skip backwards until non-whitespace, or bol
3145 (skip-chars-backward " \t"))
3146 (point))
3147 edebug-def-mark))
3148 len i)
3149 ;; the offsets are in order so we can do a linear search
3150 (setq len (length offset-vector))
3151 (setq i 0)
3152 (while (and (< i len) (> offset (aref offset-vector i)))
3153 (setq i (1+ i)))
3154 (if (and (< i len)
3155 (<= offset (aref offset-vector i)))
3156 ;; return the relevant info
3157 (cons edebug-def-name i)
3158 (message "Point is not on an expression in %s."
3159 edebug-def-name)
3160 )))
3161
3162
3163 (defun edebug-next-breakpoint ()
3164 "Move point to the next breakpoint, or first if none past point."
3165 (interactive)
3166 (let ((edebug-stop-point (edebug-find-stop-point)))
3167 (if edebug-stop-point
3168 (let* ((edebug-def-name (car edebug-stop-point))
3169 (index (cdr edebug-stop-point))
3170 (edebug-data (get edebug-def-name 'edebug))
3171
3172 ;; pull out parts of edebug-data
3173 (edebug-def-mark (car edebug-data))
3174 (edebug-breakpoints (car (cdr edebug-data)))
3175 (offset-vector (nth 2 edebug-data))
3176 breakpoint)
3177 (if (not edebug-breakpoints)
3178 (message "No breakpoints in this function.")
3179 (let ((breaks edebug-breakpoints))
3180 (while (and breaks
3181 (<= (car (car breaks)) index))
3182 (setq breaks (cdr breaks)))
3183 (setq breakpoint
3184 (if breaks
3185 (car breaks)
3186 ;; goto the first breakpoint
3187 (car edebug-breakpoints)))
3188 (goto-char (+ edebug-def-mark
3189 (aref offset-vector (car breakpoint))))
3190
3191 (message "%s"
3192 (concat (if (nth 2 breakpoint)
3193 "Temporary " "")
3194 (if (car (cdr breakpoint))
3195 (format "Condition: %s"
3196 (edebug-safe-prin1-to-string
3197 (car (cdr breakpoint))))
3198 "")))
3199 ))))))
3200
3201
3202 (defun edebug-modify-breakpoint (flag &optional condition temporary)
3203 "Modify the breakpoint for the form at point or after it.
3204 Set it if FLAG is non-nil, clear it otherwise. Then move to that point.
3205 If CONDITION or TEMPORARY are non-nil, add those attributes to
3206 the breakpoint. "
3207 (let ((edebug-stop-point (edebug-find-stop-point)))
3208 (if edebug-stop-point
3209 (let* ((edebug-def-name (car edebug-stop-point))
3210 (index (cdr edebug-stop-point))
3211 (edebug-data (get edebug-def-name 'edebug))
3212
3213 ;; pull out parts of edebug-data
3214 (edebug-def-mark (car edebug-data))
3215 (edebug-breakpoints (car (cdr edebug-data)))
3216 (offset-vector (nth 2 edebug-data))
3217 present)
3218 ;; delete it either way
3219 (setq present (assq index edebug-breakpoints))
3220 (setq edebug-breakpoints (delq present edebug-breakpoints))
3221 (if flag
3222 (progn
3223 ;; add it to the list and resort
3224 (setq edebug-breakpoints
3225 (edebug-sort-alist
3226 (cons
3227 (list index condition temporary)
3228 edebug-breakpoints) '<))
3229 (if condition
3230 (message "Breakpoint set in %s with condition: %s"
3231 edebug-def-name condition)
3232 (message "Breakpoint set in %s" edebug-def-name)))
3233 (if present
3234 (message "Breakpoint unset in %s" edebug-def-name)
3235 (message "No breakpoint here")))
3236
3237 (setcar (cdr edebug-data) edebug-breakpoints)
3238 (goto-char (+ edebug-def-mark (aref offset-vector index)))
3239 ))))
3240
3241 (defun edebug-set-breakpoint (arg)
3242 "Set the breakpoint of nearest sexp.
3243 With prefix argument, make it a temporary breakpoint."
3244 (interactive "P")
3245 (edebug-modify-breakpoint t nil arg))
3246
3247 (defun edebug-unset-breakpoint ()
3248 "Clear the breakpoint of nearest sexp."
3249 (interactive)
3250 (edebug-modify-breakpoint nil))
3251
3252
3253 (defun edebug-set-global-break-condition (expression)
3254 (interactive
3255 (list
3256 (let ((initial (and edebug-global-break-condition
3257 (format "%s" edebug-global-break-condition))))
3258 (read-from-minibuffer
3259 "Global Condition: " initial read-expression-map t
3260 (if (equal (car read-expression-history) initial)
3261 '(read-expression-history . 1)
3262 'read-expression-history)))))
3263 (setq edebug-global-break-condition expression))
3264
3265
3266 ;;; Mode switching functions
3267
3268 (defun edebug-set-mode (mode shortmsg msg)
3269 ;; Set the edebug mode to MODE.
3270 ;; Display SHORTMSG, or MSG if not within edebug.
3271 (if (eq (1+ edebug-recursion-depth) (recursion-depth))
3272 (progn
3273 (setq edebug-execution-mode mode)
3274 (message shortmsg)
3275 ;; Continue execution
3276 (exit-recursive-edit))
3277 ;; This is not terribly useful!!
3278 (setq edebug-next-execution-mode mode)
3279 (message msg)))
3280
3281
3282 (defalias 'edebug-step-through-mode 'edebug-step-mode)
3283
3284 (defun edebug-step-mode ()
3285 "Proceed to next stop point."
3286 (interactive)
3287 (edebug-set-mode 'step "" "Edebug will stop at next stop point."))
3288
3289 (defun edebug-next-mode ()
3290 "Proceed to next `after' stop point."
3291 (interactive)
3292 (edebug-set-mode 'next "" "Edebug will stop after next eval."))
3293
3294 (defun edebug-go-mode (arg)
3295 "Go, evaluating until break.
3296 With prefix ARG, set temporary break at current point and go."
3297 (interactive "P")
3298 (if arg
3299 (edebug-set-breakpoint t))
3300 (edebug-set-mode 'go "Go..." "Edebug will go until break."))
3301
3302 (defun edebug-Go-nonstop-mode ()
3303 "Go, evaluating without debugging."
3304 (interactive)
3305 (edebug-set-mode 'Go-nonstop "Go-Nonstop..."
3306 "Edebug will not stop at breaks."))
3307
3308
3309 (defun edebug-trace-mode ()
3310 "Begin trace mode."
3311 (interactive)
3312 (edebug-set-mode 'trace "Tracing..." "Edebug will trace with pause."))
3313
3314 (defun edebug-Trace-fast-mode ()
3315 "Trace with no wait at each step."
3316 (interactive)
3317 (edebug-set-mode 'Trace-fast
3318 "Trace fast..." "Edebug will trace without pause."))
3319
3320 (defun edebug-continue-mode ()
3321 "Begin continue mode."
3322 (interactive)
3323 (edebug-set-mode 'continue "Continue..."
3324 "Edebug will pause at breakpoints."))
3325
3326 (defun edebug-Continue-fast-mode ()
3327 "Trace with no wait at each step."
3328 (interactive)
3329 (edebug-set-mode 'Continue-fast "Continue fast..."
3330 "Edebug will stop and go at breakpoints."))
3331
3332 ;; ------------------------------------------------------------
3333 ;; The following use the mode changing commands and breakpoints.
3334
3335
3336 (defun edebug-goto-here ()
3337 "Proceed to first stop-point at or after current position of point."
3338 (interactive)
3339 (edebug-go-mode t))
3340
3341
3342 (defun edebug-stop ()
3343 "Stop execution and do not continue.
3344 Useful for exiting from trace or continue loop."
3345 (interactive)
3346 (message "Stop"))
3347
3348
3349 '(defun edebug-forward ()
3350 "Proceed to the exit of the next expression to be evaluated."
3351 (interactive)
3352 (edebug-set-mode
3353 'forward "Forward"
3354 "Edebug will stop after exiting the next expression."))
3355
3356
3357 (defun edebug-forward-sexp (arg)
3358 "Proceed from the current point to the end of the ARGth sexp ahead.
3359 If there are not ARG sexps ahead, then do edebug-step-out."
3360 (interactive "p")
3361 (condition-case nil
3362 (let ((parse-sexp-ignore-comments t))
3363 ;; Call forward-sexp repeatedly until done or failure.
3364 (forward-sexp arg)
3365 (edebug-go-mode t))
3366 (error
3367 (edebug-step-out)
3368 )))
3369
3370 (defun edebug-step-out ()
3371 "Proceed from the current point to the end of the containing sexp.
3372 If there is no containing sexp that is not the top level defun,
3373 go to the end of the last sexp, or if that is the same point, then step."
3374 (interactive)
3375 (condition-case nil
3376 (let ((parse-sexp-ignore-comments t))
3377 (up-list 1)
3378 (save-excursion
3379 ;; Is there still a containing expression?
3380 (up-list 1))
3381 (edebug-go-mode t))
3382 (error
3383 ;; At top level - 1, so first check if there are more sexps at this level.
3384 (let ((start-point (point)))
3385 ;; (up-list 1)
3386 (down-list -1)
3387 (if (= (point) start-point)
3388 (edebug-step-mode) ; No more at this level, so step.
3389 (edebug-go-mode t)
3390 )))))
3391
3392 (defun edebug-instrument-function (func)
3393 ;; Func should be a function symbol.
3394 ;; Return the function symbol, or nil if not instrumented.
3395 (let ((func-marker (get func 'edebug)))
3396 (cond
3397 ((markerp func-marker)
3398 ;; It is uninstrumented, so instrument it.
3399 (with-current-buffer (marker-buffer func-marker)
3400 (goto-char func-marker)
3401 (edebug-eval-top-level-form)
3402 func))
3403 ((consp func-marker)
3404 (message "%s is already instrumented." func)
3405 func)
3406 (t
3407 (let ((loc (find-function-noselect func)))
3408 (with-current-buffer (car loc)
3409 (goto-char (cdr loc))
3410 (edebug-eval-top-level-form)
3411 func))))))
3412
3413 (defun edebug-instrument-callee ()
3414 "Instrument the definition of the function or macro about to be called.
3415 Do this when stopped before the form or it will be too late.
3416 One side effect of using this command is that the next time the
3417 function or macro is called, Edebug will be called there as well."
3418 (interactive)
3419 (if (not (looking-at "\("))
3420 (error "You must be before a list form")
3421 (let ((func
3422 (save-excursion
3423 (down-list 1)
3424 (if (looking-at "\(")
3425 (edebug-form-data-name
3426 (edebug-get-form-data-entry (point)))
3427 (edebug-original-read (current-buffer))))))
3428 (edebug-instrument-function func))))
3429
3430
3431 (defun edebug-step-in ()
3432 "Step into the definition of the function or macro about to be called.
3433 This first does `edebug-instrument-callee' to ensure that it is
3434 instrumented. Then it does `edebug-on-entry' and switches to `go' mode."
3435 (interactive)
3436 (let ((func (edebug-instrument-callee)))
3437 (if func
3438 (progn
3439 (edebug-on-entry func 'temp)
3440 (edebug-go-mode nil)))))
3441
3442 (defun edebug-on-entry (function &optional flag)
3443 "Cause Edebug to stop when FUNCTION is called.
3444 With prefix argument, make this temporary so it is automatically
3445 cancelled the first time the function is entered."
3446 (interactive "aEdebug on entry to: \nP")
3447 ;; Could store this in the edebug data instead.
3448 (put function 'edebug-on-entry (if flag 'temp t)))
3449
3450 (defun cancel-edebug-on-entry (function)
3451 (interactive "aEdebug on entry to: ")
3452 (put function 'edebug-on-entry nil))
3453
3454
3455 (if (not (fboundp 'edebug-original-debug-on-entry))
3456 (fset 'edebug-original-debug-on-entry (symbol-function 'debug-on-entry)))
3457 '(fset 'debug-on-entry 'edebug-debug-on-entry) ;; Should we do this?
3458 ;; Also need edebug-cancel-debug-on-entry
3459
3460 '(defun edebug-debug-on-entry (function)
3461 "Request FUNCTION to invoke debugger each time it is called.
3462 If the user continues, FUNCTION's execution proceeds.
3463 Works by modifying the definition of FUNCTION,
3464 which must be written in Lisp, not predefined.
3465 Use `cancel-debug-on-entry' to cancel the effect of this command.
3466 Redefining FUNCTION also does that.
3467
3468 This version is from Edebug. If the function is instrumented for
3469 Edebug, it calls `edebug-on-entry'."
3470 (interactive "aDebug on entry (to function): ")
3471 (let ((func-data (get function 'edebug)))
3472 (if (or (null func-data) (markerp func-data))
3473 (edebug-original-debug-on-entry function)
3474 (edebug-on-entry function))))
3475
3476
3477 (defun edebug-top-level-nonstop ()
3478 "Set mode to Go-nonstop, and exit to top-level.
3479 This is useful for exiting even if unwind-protect code may be executed."
3480 (interactive)
3481 (setq edebug-execution-mode 'Go-nonstop)
3482 (top-level))
3483
3484
3485 ;;(defun edebug-exit-out ()
3486 ;; "Go until the current function exits."
3487 ;; (interactive)
3488 ;; (edebug-set-mode 'exiting "Exit..."))
3489
3490
3491 ;;; The following initial mode setting definitions are not used yet.
3492
3493 '(defconst edebug-initial-mode-alist
3494 '((edebug-Continue-fast . Continue-fast)
3495 (edebug-Trace-fast . Trace-fast)
3496 (edebug-continue . continue)
3497 (edebug-trace . trace)
3498 (edebug-go . go)
3499 (edebug-step-through . step)
3500 (edebug-Go-nonstop . Go-nonstop)
3501 )
3502 "Association list between commands and the modes they set.")
3503
3504
3505 '(defun edebug-set-initial-mode ()
3506 "Ask for the initial mode of the enclosing function.
3507 The mode is requested via the key that would be used to set the mode in
3508 edebug-mode."
3509 (interactive)
3510 (let* ((this-function (edebug-which-function))
3511 (keymap (if (eq edebug-mode-map (current-local-map))
3512 edebug-mode-map))
3513 (old-mode (or (get this-function 'edebug-initial-mode)
3514 edebug-initial-mode))
3515 (key (read-key-sequence
3516 (format
3517 "Change initial edebug mode for %s from %s (%s) to (enter key): "
3518 this-function
3519 old-mode
3520 (where-is-internal
3521 (car (rassq old-mode edebug-initial-mode-alist))
3522 keymap 'firstonly
3523 ))))
3524 (mode (cdr (assq (key-binding key) edebug-initial-mode-alist)))
3525 )
3526 (if (and mode
3527 (or (get this-function 'edebug-initial-mode)
3528 (not (eq mode edebug-initial-mode))))
3529 (progn
3530 (put this-function 'edebug-initial-mode mode)
3531 (message "Initial mode for %s is now: %s"
3532 this-function mode))
3533 (error "Key must map to one of the mode changing commands")
3534 )))
3535
3536 ;;; Evaluation of expressions
3537
3538 (def-edebug-spec edebug-outside-excursion t)
3539
3540 (defmacro edebug-outside-excursion (&rest body)
3541 "Evaluate an expression list in the outside context.
3542 Return the result of the last expression."
3543 `(save-excursion ; of current-buffer
3544 (if edebug-save-windows
3545 (progn
3546 ;; After excursion, we will
3547 ;; restore to current window configuration.
3548 (setq edebug-inside-windows
3549 (edebug-current-windows edebug-save-windows))
3550 ;; Restore outside windows.
3551 (edebug-set-windows edebug-outside-windows)))
3552
3553 (set-buffer edebug-buffer) ; why?
3554 ;; (use-local-map edebug-outside-map)
3555 (set-match-data edebug-outside-match-data)
3556 ;; Restore outside context.
3557 (let (;; (edebug-inside-map (current-local-map)) ;; restore map??
3558 (last-command-char edebug-outside-last-command-char)
3559 (last-command-event edebug-outside-last-command-event)
3560 (last-command edebug-outside-last-command)
3561 (this-command edebug-outside-this-command)
3562 (unread-command-char edebug-outside-unread-command-char)
3563 (unread-command-events edebug-outside-unread-command-events)
3564 (current-prefix-arg edebug-outside-current-prefix-arg)
3565 (last-input-char edebug-outside-last-input-char)
3566 (last-input-event edebug-outside-last-input-event)
3567 (last-event-frame edebug-outside-last-event-frame)
3568 (last-nonmenu-event edebug-outside-last-nonmenu-event)
3569 (track-mouse edebug-outside-track-mouse)
3570 (standard-output edebug-outside-standard-output)
3571 (standard-input edebug-outside-standard-input)
3572
3573 (executing-kbd-macro edebug-outside-executing-macro)
3574 (defining-kbd-macro edebug-outside-defining-kbd-macro)
3575 ;; Get the values out of the saved statuses.
3576 (pre-command-hook (cdr edebug-outside-pre-command-hook))
3577 (post-command-hook (cdr edebug-outside-post-command-hook))
3578
3579 ;; See edebug-display
3580 (overlay-arrow-position edebug-outside-o-a-p)
3581 (overlay-arrow-string edebug-outside-o-a-s)
3582 (cursor-in-echo-area edebug-outside-c-i-e-a)
3583 )
3584 (unwind-protect
3585 (save-excursion ; of edebug-buffer
3586 (set-buffer edebug-outside-buffer)
3587 (goto-char edebug-outside-point)
3588 (if (marker-buffer (edebug-mark-marker))
3589 (set-marker (edebug-mark-marker) edebug-outside-mark))
3590 ,@body)
3591
3592 ;; Back to edebug-buffer. Restore rest of inside context.
3593 ;; (use-local-map edebug-inside-map)
3594 (if edebug-save-windows
3595 ;; Restore inside windows.
3596 (edebug-set-windows edebug-inside-windows))
3597
3598 ;; Save values that may have been changed.
3599 (setq
3600 edebug-outside-last-command-char last-command-char
3601 edebug-outside-last-command-event last-command-event
3602 edebug-outside-last-command last-command
3603 edebug-outside-this-command this-command
3604 edebug-outside-unread-command-char unread-command-char
3605 edebug-outside-unread-command-events unread-command-events
3606 edebug-outside-current-prefix-arg current-prefix-arg
3607 edebug-outside-last-input-char last-input-char
3608 edebug-outside-last-input-event last-input-event
3609 edebug-outside-last-event-frame last-event-frame
3610 edebug-outside-last-nonmenu-event last-nonmenu-event
3611 edebug-outside-track-mouse track-mouse
3612 edebug-outside-standard-output standard-output
3613 edebug-outside-standard-input standard-input
3614
3615 edebug-outside-executing-macro executing-kbd-macro
3616 edebug-outside-defining-kbd-macro defining-kbd-macro
3617
3618 edebug-outside-o-a-p overlay-arrow-position
3619 edebug-outside-o-a-s overlay-arrow-string
3620 edebug-outside-c-i-e-a cursor-in-echo-area
3621 )
3622
3623 ;; Restore the outside saved values; don't alter
3624 ;; the outside binding loci.
3625 (setcdr edebug-outside-pre-command-hook pre-command-hook)
3626 (setcdr edebug-outside-post-command-hook post-command-hook)
3627
3628 )) ; let
3629 ))
3630
3631 (defvar cl-debug-env nil) ;; defined in cl; non-nil when lexical env used.
3632
3633 (defun edebug-eval (edebug-expr)
3634 ;; Are there cl lexical variables active?
3635 (if cl-debug-env
3636 (eval (cl-macroexpand-all edebug-expr cl-debug-env))
3637 (eval edebug-expr)))
3638
3639 (defun edebug-safe-eval (edebug-expr)
3640 ;; Evaluate EXPR safely.
3641 ;; If there is an error, a string is returned describing the error.
3642 (condition-case edebug-err
3643 (edebug-eval edebug-expr)
3644 (error (edebug-format "%s: %s" ;; could
3645 (get (car edebug-err) 'error-message)
3646 (car (cdr edebug-err))))))
3647
3648 ;;; Printing
3649
3650 ;; Replace printing functions.
3651
3652 ;; obsolete names
3653 (define-obsolete-function-alias 'edebug-install-custom-print-funcs
3654 'edebug-install-custom-print "22.1")
3655 (define-obsolete-function-alias 'edebug-reset-print-funcs
3656 'edebug-uninstall-custom-print "22.1")
3657 (define-obsolete-function-alias 'edebug-uninstall-custom-print-funcs
3658 'edebug-uninstall-custom-print "22.1")
3659
3660 (defun edebug-install-custom-print ()
3661 "Replace print functions used by Edebug with custom versions."
3662 ;; Modifying the custom print functions, or changing print-length,
3663 ;; print-level, print-circle, custom-print-list or custom-print-vector
3664 ;; have immediate effect.
3665 (interactive)
3666 (require 'cust-print)
3667 (defalias 'edebug-prin1 'custom-prin1)
3668 (defalias 'edebug-print 'custom-print)
3669 (defalias 'edebug-prin1-to-string 'custom-prin1-to-string)
3670 (defalias 'edebug-format 'custom-format)
3671 (defalias 'edebug-message 'custom-message)
3672 "Installed")
3673
3674 (eval-and-compile
3675 (defun edebug-uninstall-custom-print ()
3676 "Replace edebug custom print functions with internal versions."
3677 (interactive)
3678 (defalias 'edebug-prin1 'prin1)
3679 (defalias 'edebug-print 'print)
3680 (defalias 'edebug-prin1-to-string 'prin1-to-string)
3681 (defalias 'edebug-format 'format)
3682 (defalias 'edebug-message 'message)
3683 "Uninstalled")
3684
3685 ;; Default print functions are the same as Emacs'.
3686 (edebug-uninstall-custom-print))
3687
3688
3689 (defun edebug-report-error (edebug-value)
3690 ;; Print an error message like command level does.
3691 ;; This also prints the error name if it has no error-message.
3692 (message "%s: %s"
3693 (or (get (car edebug-value) 'error-message)
3694 (format "peculiar error (%s)" (car edebug-value)))
3695 (mapconcat (function (lambda (edebug-arg)
3696 ;; continuing after an error may
3697 ;; complain about edebug-arg. why??
3698 (prin1-to-string edebug-arg)))
3699 (cdr edebug-value) ", ")))
3700
3701 ;; Define here in case they are not already defined.
3702 (defvar print-level nil)
3703 (defvar print-circle nil)
3704 (defvar print-readably) ;; defined by lemacs
3705 ;; Alternatively, we could change the definition of
3706 ;; edebug-safe-prin1-to-string to only use these if defined.
3707
3708 (defun edebug-safe-prin1-to-string (value)
3709 (let ((print-escape-newlines t)
3710 (print-length (or edebug-print-length print-length))
3711 (print-level (or edebug-print-level print-level))
3712 (print-circle (or edebug-print-circle print-circle))
3713 (print-readably nil)) ;; lemacs uses this.
3714 (condition-case nil
3715 (edebug-prin1-to-string value)
3716 (error "#Apparently circular structure#"))))
3717
3718 (defun edebug-compute-previous-result (edebug-previous-value)
3719 (if edebug-unwrap-results
3720 (setq edebug-previous-value
3721 (edebug-unwrap* edebug-previous-value)))
3722 (setq edebug-previous-result
3723 (concat "Result: "
3724 (edebug-safe-prin1-to-string edebug-previous-value)
3725 (eval-expression-print-format edebug-previous-value))))
3726
3727 (defun edebug-previous-result ()
3728 "Print the previous result."
3729 (interactive)
3730 (message "%s" edebug-previous-result))
3731
3732 ;;; Read, Eval and Print
3733
3734 (defun edebug-eval-expression (edebug-expr)
3735 "Evaluate an expression in the outside environment.
3736 If interactive, prompt for the expression.
3737 Print result in minibuffer."
3738 (interactive (list (read-from-minibuffer
3739 "Eval: " nil read-expression-map t
3740 'read-expression-history)))
3741 (princ
3742 (edebug-outside-excursion
3743 (setq values (cons (edebug-eval edebug-expr) values))
3744 (concat (edebug-safe-prin1-to-string (car values))
3745 (eval-expression-print-format (car values))))))
3746
3747 (defun edebug-eval-last-sexp ()
3748 "Evaluate sexp before point in the outside environment.
3749 Print value in minibuffer."
3750 (interactive)
3751 (edebug-eval-expression (edebug-last-sexp)))
3752
3753 (defun edebug-eval-print-last-sexp ()
3754 "Evaluate sexp before point in outside environment; insert value.
3755 This prints the value into current buffer."
3756 (interactive)
3757 (let* ((edebug-form (edebug-last-sexp))
3758 (edebug-result-string
3759 (edebug-outside-excursion
3760 (edebug-safe-prin1-to-string (edebug-safe-eval edebug-form))))
3761 (standard-output (current-buffer)))
3762 (princ "\n")
3763 ;; princ the string to get rid of quotes.
3764 (princ edebug-result-string)
3765 (princ "\n")
3766 ))
3767
3768 ;;; Edebug Minor Mode
3769
3770 (defvar gud-inhibit-global-bindings
3771 "*Non-nil means don't do global rebindings of C-x C-a subcommands.")
3772
3773 ;; Global GUD bindings for all emacs-lisp-mode buffers.
3774 (unless gud-inhibit-global-bindings
3775 (define-key emacs-lisp-mode-map "\C-x\C-a\C-s" 'edebug-step-mode)
3776 (define-key emacs-lisp-mode-map "\C-x\C-a\C-n" 'edebug-next-mode)
3777 (define-key emacs-lisp-mode-map "\C-x\C-a\C-c" 'edebug-go-mode)
3778 (define-key emacs-lisp-mode-map "\C-x\C-a\C-l" 'edebug-where))
3779
3780 (defvar edebug-mode-map
3781 (let ((map (copy-keymap emacs-lisp-mode-map)))
3782 ;; control
3783 (define-key map " " 'edebug-step-mode)
3784 (define-key map "n" 'edebug-next-mode)
3785 (define-key map "g" 'edebug-go-mode)
3786 (define-key map "G" 'edebug-Go-nonstop-mode)
3787 (define-key map "t" 'edebug-trace-mode)
3788 (define-key map "T" 'edebug-Trace-fast-mode)
3789 (define-key map "c" 'edebug-continue-mode)
3790 (define-key map "C" 'edebug-Continue-fast-mode)
3791
3792 ;;(define-key map "f" 'edebug-forward) not implemented
3793 (define-key map "f" 'edebug-forward-sexp)
3794 (define-key map "h" 'edebug-goto-here)
3795
3796 (define-key map "I" 'edebug-instrument-callee)
3797 (define-key map "i" 'edebug-step-in)
3798 (define-key map "o" 'edebug-step-out)
3799
3800 ;; quitting and stopping
3801 (define-key map "q" 'top-level)
3802 (define-key map "Q" 'edebug-top-level-nonstop)
3803 (define-key map "a" 'abort-recursive-edit)
3804 (define-key map "S" 'edebug-stop)
3805
3806 ;; breakpoints
3807 (define-key map "b" 'edebug-set-breakpoint)
3808 (define-key map "u" 'edebug-unset-breakpoint)
3809 (define-key map "B" 'edebug-next-breakpoint)
3810 (define-key map "x" 'edebug-set-conditional-breakpoint)
3811 (define-key map "X" 'edebug-set-global-break-condition)
3812
3813 ;; evaluation
3814 (define-key map "r" 'edebug-previous-result)
3815 (define-key map "e" 'edebug-eval-expression)
3816 (define-key map "\C-x\C-e" 'edebug-eval-last-sexp)
3817 (define-key map "E" 'edebug-visit-eval-list)
3818
3819 ;; views
3820 (define-key map "w" 'edebug-where)
3821 (define-key map "v" 'edebug-view-outside) ;; maybe obsolete??
3822 (define-key map "p" 'edebug-bounce-point)
3823 (define-key map "P" 'edebug-view-outside) ;; same as v
3824 (define-key map "W" 'edebug-toggle-save-windows)
3825
3826 ;; misc
3827 (define-key map "?" 'edebug-help)
3828 (define-key map "d" 'edebug-backtrace)
3829
3830 (define-key map "-" 'negative-argument)
3831
3832 ;; statistics
3833 (define-key map "=" 'edebug-temp-display-freq-count)
3834
3835 ;; GUD bindings
3836 (define-key map "\C-c\C-s" 'edebug-step-mode)
3837 (define-key map "\C-c\C-n" 'edebug-next-mode)
3838 (define-key map "\C-c\C-c" 'edebug-go-mode)
3839
3840 (define-key map "\C-x " 'edebug-set-breakpoint)
3841 (define-key map "\C-c\C-d" 'edebug-unset-breakpoint)
3842 (define-key map "\C-c\C-t"
3843 (lambda () (interactive) (edebug-set-breakpoint t)))
3844 (define-key map "\C-c\C-l" 'edebug-where)
3845 map))
3846
3847 ;; Autoloading these global bindings doesn't make sense because
3848 ;; they cannot be used anyway unless Edebug is already loaded and active.
3849
3850 (defvar global-edebug-prefix "\^XX"
3851 "Prefix key for global edebug commands, available from any buffer.")
3852
3853 (defvar global-edebug-map
3854 (let ((map (make-sparse-keymap)))
3855
3856 (define-key map " " 'edebug-step-mode)
3857 (define-key map "g" 'edebug-go-mode)
3858 (define-key map "G" 'edebug-Go-nonstop-mode)
3859 (define-key map "t" 'edebug-trace-mode)
3860 (define-key map "T" 'edebug-Trace-fast-mode)
3861 (define-key map "c" 'edebug-continue-mode)
3862 (define-key map "C" 'edebug-Continue-fast-mode)
3863
3864 ;; breakpoints
3865 (define-key map "b" 'edebug-set-breakpoint)
3866 (define-key map "u" 'edebug-unset-breakpoint)
3867 (define-key map "x" 'edebug-set-conditional-breakpoint)
3868 (define-key map "X" 'edebug-set-global-break-condition)
3869
3870 ;; views
3871 (define-key map "w" 'edebug-where)
3872 (define-key map "W" 'edebug-toggle-save-windows)
3873
3874 ;; quitting
3875 (define-key map "q" 'top-level)
3876 (define-key map "Q" 'edebug-top-level-nonstop)
3877 (define-key map "a" 'abort-recursive-edit)
3878
3879 ;; statistics
3880 (define-key map "=" 'edebug-display-freq-count)
3881 map)
3882 "Global map of edebug commands, available from any buffer.")
3883
3884 (global-unset-key global-edebug-prefix)
3885 (global-set-key global-edebug-prefix global-edebug-map)
3886
3887
3888 (defun edebug-help ()
3889 (interactive)
3890 (describe-function 'edebug-mode))
3891
3892 (defun edebug-mode ()
3893 "Mode for Emacs Lisp buffers while in Edebug.
3894
3895 In addition to all Emacs Lisp commands (except those that modify the
3896 buffer) there are local and global key bindings to several Edebug
3897 specific commands. E.g. `edebug-step-mode' is bound to \\[edebug-step-mode]
3898 in the Edebug buffer and \\<global-map>\\[edebug-step-mode] in any buffer.
3899
3900 Also see bindings for the eval list buffer, *edebug*.
3901
3902 The edebug buffer commands:
3903 \\{edebug-mode-map}
3904
3905 Global commands prefixed by `global-edebug-prefix':
3906 \\{global-edebug-map}
3907
3908 Options:
3909 edebug-setup-hook
3910 edebug-all-defs
3911 edebug-all-forms
3912 edebug-save-windows
3913 edebug-save-displayed-buffer-points
3914 edebug-initial-mode
3915 edebug-trace
3916 edebug-test-coverage
3917 edebug-continue-kbd-macro
3918 edebug-print-length
3919 edebug-print-level
3920 edebug-print-circle
3921 edebug-on-error
3922 edebug-on-quit
3923 edebug-on-signal
3924 edebug-unwrap-results
3925 edebug-global-break-condition
3926 "
3927 (use-local-map edebug-mode-map))
3928
3929 ;;; edebug eval list mode
3930
3931 ;; A list of expressions and their evaluations is displayed in *edebug*.
3932
3933 (defun edebug-eval-result-list ()
3934 "Return a list of evaluations of edebug-eval-list"
3935 ;; Assumes in outside environment.
3936 ;; Don't do any edebug things now.
3937 (let ((edebug-execution-mode 'Go-nonstop)
3938 (edebug-trace nil))
3939 (mapcar 'edebug-safe-eval edebug-eval-list)))
3940
3941 (defun edebug-eval-display-list (edebug-eval-result-list)
3942 ;; Assumes edebug-eval-buffer exists.
3943 (let ((edebug-eval-list-temp edebug-eval-list)
3944 (standard-output edebug-eval-buffer)
3945 (edebug-comment-line
3946 (format ";%s\n" (make-string (- (window-width) 2) ?-))))
3947 (set-buffer edebug-eval-buffer)
3948 (erase-buffer)
3949 (while edebug-eval-list-temp
3950 (prin1 (car edebug-eval-list-temp)) (terpri)
3951 (prin1 (car edebug-eval-result-list)) (terpri)
3952 (princ edebug-comment-line)
3953 (setq edebug-eval-list-temp (cdr edebug-eval-list-temp))
3954 (setq edebug-eval-result-list (cdr edebug-eval-result-list)))
3955 (edebug-pop-to-buffer edebug-eval-buffer)
3956 ))
3957
3958 (defun edebug-create-eval-buffer ()
3959 (if (not (and edebug-eval-buffer (buffer-name edebug-eval-buffer)))
3960 (progn
3961 (set-buffer (setq edebug-eval-buffer (get-buffer-create "*edebug*")))
3962 (edebug-eval-mode))))
3963
3964 ;; Should generalize this to be callable outside of edebug
3965 ;; with calls in user functions, e.g. (edebug-eval-display)
3966
3967 (defun edebug-eval-display (edebug-eval-result-list)
3968 "Display expressions and evaluations in EVAL-LIST.
3969 It modifies the context by popping up the eval display."
3970 (if edebug-eval-result-list
3971 (progn
3972 (edebug-create-eval-buffer)
3973 (edebug-eval-display-list edebug-eval-result-list)
3974 )))
3975
3976 (defun edebug-eval-redisplay ()
3977 "Redisplay eval list in outside environment.
3978 May only be called from within edebug-recursive-edit."
3979 (edebug-create-eval-buffer)
3980 (edebug-outside-excursion
3981 (edebug-eval-display-list (edebug-eval-result-list))
3982 ))
3983
3984 (defun edebug-visit-eval-list ()
3985 (interactive)
3986 (edebug-eval-redisplay)
3987 (edebug-pop-to-buffer edebug-eval-buffer))
3988
3989
3990 (defun edebug-update-eval-list ()
3991 "Replace the evaluation list with the sexps now in the eval buffer."
3992 (interactive)
3993 (let ((starting-point (point))
3994 new-list)
3995 (goto-char (point-min))
3996 ;; get the first expression
3997 (edebug-skip-whitespace)
3998 (if (not (eobp))
3999 (progn
4000 (forward-sexp 1)
4001 (setq new-list (cons (edebug-last-sexp) new-list))))
4002
4003 (while (re-search-forward "^;" nil t)
4004 (forward-line 1)
4005 (skip-chars-forward " \t\n\r")
4006 (if (and (/= ?\; (following-char))
4007 (not (eobp)))
4008 (progn
4009 (forward-sexp 1)
4010 (setq new-list (cons (edebug-last-sexp) new-list)))))
4011
4012 (setq edebug-eval-list (nreverse new-list))
4013 (edebug-eval-redisplay)
4014 (goto-char starting-point)))
4015
4016
4017 (defun edebug-delete-eval-item ()
4018 "Delete the item under point and redisplay."
4019 ;; could add arg to do repeatedly
4020 (interactive)
4021 (if (re-search-backward "^;" nil 'nofail)
4022 (forward-line 1))
4023 (delete-region
4024 (point) (progn (re-search-forward "^;" nil 'nofail)
4025 (beginning-of-line)
4026 (point)))
4027 (edebug-update-eval-list))
4028
4029
4030
4031 (defvar edebug-eval-mode-map nil
4032 "Keymap for Edebug Eval mode. Superset of Lisp Interaction mode.")
4033
4034 (unless edebug-eval-mode-map
4035 (setq edebug-eval-mode-map (make-sparse-keymap))
4036 (set-keymap-parent edebug-eval-mode-map lisp-interaction-mode-map)
4037
4038 (define-key edebug-eval-mode-map "\C-c\C-w" 'edebug-where)
4039 (define-key edebug-eval-mode-map "\C-c\C-d" 'edebug-delete-eval-item)
4040 (define-key edebug-eval-mode-map "\C-c\C-u" 'edebug-update-eval-list)
4041 (define-key edebug-eval-mode-map "\C-x\C-e" 'edebug-eval-last-sexp)
4042 (define-key edebug-eval-mode-map "\C-j" 'edebug-eval-print-last-sexp))
4043
4044 (put 'edebug-eval-mode 'mode-class 'special)
4045
4046 (define-derived-mode edebug-eval-mode lisp-interaction-mode "Edebug Eval"
4047 "Mode for evaluation list buffer while in Edebug.
4048
4049 In addition to all Interactive Emacs Lisp commands there are local and
4050 global key bindings to several Edebug specific commands. E.g.
4051 `edebug-step-mode' is bound to \\[edebug-step-mode] in the Edebug
4052 buffer and \\<global-map>\\[edebug-step-mode] in any buffer.
4053
4054 Eval list buffer commands:
4055 \\{edebug-eval-mode-map}
4056
4057 Global commands prefixed by global-edebug-prefix:
4058 \\{global-edebug-map}")
4059
4060 ;;; Interface with standard debugger.
4061
4062 ;; (setq debugger 'edebug) ; to use the edebug debugger
4063 ;; (setq debugger 'debug) ; use the standard debugger
4064
4065 ;; Note that debug and its utilities must be byte-compiled to work,
4066 ;; since they depend on the backtrace looking a certain way. But
4067 ;; edebug is not dependent on this, yet.
4068
4069 (defun edebug (&optional edebug-arg-mode &rest debugger-args)
4070 "Replacement for debug.
4071 If we are running an edebugged function,
4072 show where we last were. Otherwise call debug normally."
4073 ;; (message "entered: %s depth: %s edebug-recursion-depth: %s"
4074 ;; edebug-entered (recursion-depth) edebug-recursion-depth) (sit-for 1)
4075 (if (and edebug-entered ; anything active?
4076 (eq (recursion-depth) edebug-recursion-depth))
4077 (let (;; Where were we before the error occurred?
4078 (edebug-offset-index (car edebug-offset-indices))
4079 ;; Bind variables required by edebug-display
4080 (edebug-value (car debugger-args))
4081 edebug-breakpoints
4082 edebug-break-data
4083 edebug-break-condition
4084 edebug-global-break
4085 (edebug-break (null edebug-arg-mode)) ;; if called explicitly
4086 )
4087 (edebug-display)
4088 (if (eq edebug-arg-mode 'error)
4089 nil
4090 edebug-value))
4091
4092 ;; Otherwise call debug normally.
4093 ;; Still need to remove extraneous edebug calls from stack.
4094 (apply 'debug edebug-arg-mode debugger-args)
4095 ))
4096
4097
4098 (defun edebug-backtrace ()
4099 "Display a non-working backtrace. Better than nothing..."
4100 (interactive)
4101 (if (or (not edebug-backtrace-buffer)
4102 (null (buffer-name edebug-backtrace-buffer)))
4103 (setq edebug-backtrace-buffer
4104 (generate-new-buffer "*Backtrace*"))
4105 ;; else, could just display edebug-backtrace-buffer
4106 )
4107 (with-output-to-temp-buffer (buffer-name edebug-backtrace-buffer)
4108 (setq edebug-backtrace-buffer standard-output)
4109 (let ((print-escape-newlines t)
4110 (print-length 50)
4111 last-ok-point)
4112 (backtrace)
4113
4114 ;; Clean up the backtrace.
4115 ;; Not quite right for current edebug scheme.
4116 (set-buffer edebug-backtrace-buffer)
4117 (setq truncate-lines t)
4118 (goto-char (point-min))
4119 (setq last-ok-point (point))
4120 (if t (progn
4121
4122 ;; Delete interspersed edebug internals.
4123 (while (re-search-forward "^ \(?edebug" nil t)
4124 (beginning-of-line)
4125 (cond
4126 ((looking-at "^ \(edebug-after")
4127 ;; Previous lines may contain code, so just delete this line
4128 (setq last-ok-point (point))
4129 (forward-line 1)
4130 (delete-region last-ok-point (point)))
4131
4132 ((looking-at "^ edebug")
4133 (forward-line 1)
4134 (delete-region last-ok-point (point))
4135 )))
4136 )))))
4137
4138 \f
4139 ;;; Trace display
4140
4141 (defun edebug-trace-display (buf-name fmt &rest args)
4142 "In buffer BUF-NAME, display FMT and ARGS at the end and make it visible.
4143 The buffer is created if it does not exist.
4144 You must include newlines in FMT to break lines, but one newline is appended."
4145 ;; e.g.
4146 ;; (edebug-trace-display "*trace-point*"
4147 ;; "saving: point = %s window-start = %s"
4148 ;; (point) (window-start))
4149 (let* ((oldbuf (current-buffer))
4150 (selected-window (selected-window))
4151 (buffer (get-buffer-create buf-name))
4152 buf-window)
4153 ;; (message "before pop-to-buffer") (sit-for 1)
4154 (edebug-pop-to-buffer buffer)
4155 (setq truncate-lines t)
4156 (setq buf-window (selected-window))
4157 (goto-char (point-max))
4158 (insert (apply 'edebug-format fmt args) "\n")
4159 ;; Make it visible.
4160 (vertical-motion (- 1 (window-height)))
4161 (set-window-start buf-window (point))
4162 (goto-char (point-max))
4163 ;; (set-window-point buf-window (point))
4164 ;; (edebug-sit-for 0)
4165 (bury-buffer buffer)
4166 (select-window selected-window)
4167 (set-buffer oldbuf))
4168 buf-name)
4169
4170
4171 (defun edebug-trace (fmt &rest args)
4172 "Convenience call to edebug-trace-display using edebug-trace-buffer"
4173 (apply 'edebug-trace-display edebug-trace-buffer fmt args))
4174
4175 \f
4176 ;;; Frequency count and coverage
4177
4178 (defun edebug-display-freq-count ()
4179 "Display the frequency count data for each line of the current definition.
4180 The frequency counts are inserted as comment lines after
4181 each line, and you can undo all insertions with one `undo' command.
4182
4183 The counts are inserted starting under the `(' before an expression
4184 or the `)' after an expression, or on the last char of a symbol.
4185 The counts are only displayed when they differ from previous counts on
4186 the same line.
4187
4188 If coverage is being tested, whenever all known results of an expression
4189 are `eq', the char `=' will be appended after the count
4190 for that expression. Note that this is always the case for an
4191 expression only evaluated once.
4192
4193 To clear the frequency count and coverage data for a definition,
4194 reinstrument it."
4195 (interactive)
4196 (let* ((function (edebug-form-data-symbol))
4197 (counts (get function 'edebug-freq-count))
4198 (coverages (get function 'edebug-coverage))
4199 (data (get function 'edebug))
4200 (def-mark (car data)) ; mark at def start
4201 (edebug-points (nth 2 data))
4202 (i (1- (length edebug-points)))
4203 (last-index)
4204 (first-index)
4205 (start-of-line)
4206 (start-of-count-line)
4207 (last-count)
4208 )
4209 (save-excursion
4210 ;; Traverse in reverse order so offsets are correct.
4211 (while (<= 0 i)
4212 ;; Start at last expression in line.
4213 (goto-char (+ def-mark (aref edebug-points i)))
4214 (beginning-of-line)
4215 (setq start-of-line (- (point) def-mark)
4216 last-index i)
4217
4218 ;; Find all indexes on same line.
4219 (while (and (<= 0 (setq i (1- i)))
4220 (<= start-of-line (aref edebug-points i))))
4221 ;; Insert all the indices for this line.
4222 (forward-line 1)
4223 (setq start-of-count-line (point)
4224 first-index i ; really last index for line above this one.
4225 last-count -1) ; cause first count to always appear.
4226 (insert ";#")
4227 ;; i == first-index still
4228 (while (<= (setq i (1+ i)) last-index)
4229 (let ((count (aref counts i))
4230 (coverage (aref coverages i))
4231 (col (save-excursion
4232 (goto-char (+ (aref edebug-points i) def-mark))
4233 (- (current-column)
4234 (if (= ?\( (following-char)) 0 1)))))
4235 (insert (make-string
4236 (max 0 (- col (- (point) start-of-count-line))) ?\s)
4237 (if (and (< 0 count)
4238 (not (memq coverage
4239 '(unknown ok-coverage))))
4240 "=" "")
4241 (if (= count last-count) "" (int-to-string count))
4242 " ")
4243 (setq last-count count)))
4244 (insert "\n")
4245 (setq i first-index)))))
4246
4247 (defun edebug-temp-display-freq-count ()
4248 "Temporarily display the frequency count data for the current definition.
4249 It is removed when you hit any char."
4250 ;; This seems not to work with Emacs 18.59. It undoes too far.
4251 (interactive)
4252 (let ((buffer-read-only nil))
4253 (undo-boundary)
4254 (edebug-display-freq-count)
4255 (setq unread-command-char (read-char))
4256 (undo)))
4257
4258 \f
4259 ;;; Menus
4260
4261 (defun edebug-toggle (variable)
4262 (set variable (not (eval variable)))
4263 (message "%s: %s" variable (eval variable)))
4264
4265 ;; We have to require easymenu (even for Emacs 18) just so
4266 ;; the easy-menu-define macro call is compiled correctly.
4267 (require 'easymenu)
4268
4269 (defconst edebug-mode-menus
4270 '("Edebug"
4271 ["Stop" edebug-stop t]
4272 ["Step" edebug-step-mode t]
4273 ["Next" edebug-next-mode t]
4274 ["Trace" edebug-trace-mode t]
4275 ["Trace Fast" edebug-Trace-fast-mode t]
4276 ["Continue" edebug-continue-mode t]
4277 ["Continue Fast" edebug-Continue-fast-mode t]
4278 ["Go" edebug-go-mode t]
4279 ["Go Nonstop" edebug-Go-nonstop-mode t]
4280 "----"
4281 ["Help" edebug-help t]
4282 ["Abort" abort-recursive-edit t]
4283 ["Quit to Top Level" top-level t]
4284 ["Quit Nonstop" edebug-top-level-nonstop t]
4285 "----"
4286 ("Jumps"
4287 ["Forward Sexp" edebug-forward-sexp t]
4288 ["Step In" edebug-step-in t]
4289 ["Step Out" edebug-step-out t]
4290 ["Goto Here" edebug-goto-here t])
4291
4292 ("Breaks"
4293 ["Set Breakpoint" edebug-set-breakpoint t]
4294 ["Unset Breakpoint" edebug-unset-breakpoint t]
4295 ["Set Conditional Breakpoint" edebug-set-conditional-breakpoint t]
4296 ["Set Global Break Condition" edebug-set-global-break-condition t]
4297 ["Show Next Breakpoint" edebug-next-breakpoint t])
4298
4299 ("Views"
4300 ["Where am I?" edebug-where t]
4301 ["Bounce to Current Point" edebug-bounce-point t]
4302 ["View Outside Windows" edebug-view-outside t]
4303 ["Previous Result" edebug-previous-result t]
4304 ["Show Backtrace" edebug-backtrace t]
4305 ["Display Freq Count" edebug-display-freq-count t])
4306
4307 ("Eval"
4308 ["Expression" edebug-eval-expression t]
4309 ["Last Sexp" edebug-eval-last-sexp t]
4310 ["Visit Eval List" edebug-visit-eval-list t])
4311
4312 ("Options"
4313 ["Edebug All Defs" edebug-all-defs
4314 :style toggle :selected edebug-all-defs]
4315 ["Edebug All Forms" edebug-all-forms
4316 :style toggle :selected edebug-all-forms]
4317 "----"
4318 ["Tracing" (edebug-toggle 'edebug-trace)
4319 :style toggle :selected edebug-trace]
4320 ["Test Coverage" (edebug-toggle 'edebug-test-coverage)
4321 :style toggle :selected edebug-test-coverage]
4322 ["Save Windows" edebug-toggle-save-windows
4323 :style toggle :selected edebug-save-windows]
4324 ["Save Point"
4325 (edebug-toggle 'edebug-save-displayed-buffer-points)
4326 :style toggle :selected edebug-save-displayed-buffer-points]
4327 ))
4328 "Menus for Edebug.")
4329
4330 \f
4331 ;;; Emacs version specific code
4332
4333 (defalias 'edebug-window-live-p 'window-live-p)
4334
4335 (defun edebug-mark ()
4336 (mark t))
4337
4338 (defun edebug-set-conditional-breakpoint (arg condition)
4339 "Set a conditional breakpoint at nearest sexp.
4340 The condition is evaluated in the outside context.
4341 With prefix argument, make it a temporary breakpoint."
4342 ;; (interactive "P\nxCondition: ")
4343 (interactive
4344 (list
4345 current-prefix-arg
4346 ;; Read condition as follows; getting previous condition is cumbersome:
4347 (let ((edebug-stop-point (edebug-find-stop-point)))
4348 (if edebug-stop-point
4349 (let* ((edebug-def-name (car edebug-stop-point))
4350 (index (cdr edebug-stop-point))
4351 (edebug-data (get edebug-def-name 'edebug))
4352 (edebug-breakpoints (car (cdr edebug-data)))
4353 (edebug-break-data (assq index edebug-breakpoints))
4354 (edebug-break-condition (car (cdr edebug-break-data)))
4355 (initial (and edebug-break-condition
4356 (format "%s" edebug-break-condition))))
4357 (read-from-minibuffer
4358 "Condition: " initial read-expression-map t
4359 (if (equal (car read-expression-history) initial)
4360 '(read-expression-history . 1)
4361 'read-expression-history)))))))
4362 (edebug-modify-breakpoint t condition arg))
4363
4364 (easy-menu-define edebug-menu edebug-mode-map "Edebug menus" edebug-mode-menus)
4365 \f
4366 ;;; Byte-compiler
4367
4368 ;; Extension for bytecomp to resolve undefined function references.
4369 ;; Requires new byte compiler.
4370
4371 ;; Reenable byte compiler warnings about unread-command-char and -event.
4372 ;; Disabled before edebug-recursive-edit.
4373 (eval-when-compile
4374 (if edebug-unread-command-char-warning
4375 (put 'unread-command-char 'byte-obsolete-variable
4376 edebug-unread-command-char-warning)))
4377
4378 (eval-when-compile
4379 ;; The body of eval-when-compile seems to get evaluated with eval-defun.
4380 ;; We only want to evaluate when actually byte compiling.
4381 ;; But it is OK to evaluate as long as byte-compiler has been loaded.
4382 (if (featurep 'byte-compile) (progn
4383
4384 (defun byte-compile-resolve-functions (funcs)
4385 "Say it is OK for the named functions to be unresolved."
4386 (mapcar
4387 (function
4388 (lambda (func)
4389 (setq byte-compile-unresolved-functions
4390 (delq (assq func byte-compile-unresolved-functions)
4391 byte-compile-unresolved-functions))))
4392 funcs)
4393 nil)
4394
4395 '(defun byte-compile-resolve-free-references (vars)
4396 "Say it is OK for the named variables to be referenced."
4397 (mapcar
4398 (function
4399 (lambda (var)
4400 (setq byte-compile-free-references
4401 (delq var byte-compile-free-references))))
4402 vars)
4403 nil)
4404
4405 '(defun byte-compile-resolve-free-assignments (vars)
4406 "Say it is OK for the named variables to be assigned."
4407 (mapcar
4408 (function
4409 (lambda (var)
4410 (setq byte-compile-free-assignments
4411 (delq var byte-compile-free-assignments))))
4412 vars)
4413 nil)
4414
4415 (byte-compile-resolve-functions
4416 '(reporter-submit-bug-report
4417 edebug-gensym ;; also in cl.el
4418 ;; Interfaces to standard functions.
4419 edebug-original-eval-defun
4420 edebug-original-read
4421 edebug-get-buffer-window
4422 edebug-mark
4423 edebug-mark-marker
4424 edebug-input-pending-p
4425 edebug-sit-for
4426 edebug-prin1-to-string
4427 edebug-format
4428 ;; lemacs
4429 zmacs-deactivate-region
4430 popup-menu
4431 ;; CL
4432 cl-macroexpand-all
4433 ;; And believe it or not, the byte compiler doesn't know about:
4434 byte-compile-resolve-functions
4435 ))
4436
4437 '(byte-compile-resolve-free-references
4438 '(read-expression-history
4439 read-expression-map))
4440
4441 '(byte-compile-resolve-free-assignments
4442 '(read-expression-history))
4443
4444 )))
4445
4446 \f
4447 ;;; Autoloading of Edebug accessories
4448
4449 (if (featurep 'cl)
4450 (add-hook 'edebug-setup-hook
4451 (function (lambda () (require 'cl-specs))))
4452 ;; The following causes cl-specs to be loaded if you load cl.el.
4453 (add-hook 'cl-load-hook
4454 (function (lambda () (require 'cl-specs)))))
4455
4456 ;;; edebug-cl-read and cl-read are available from liberte@cs.uiuc.edu
4457 (if (featurep 'cl-read)
4458 (add-hook 'edebug-setup-hook
4459 (function (lambda () (require 'edebug-cl-read))))
4460 ;; The following causes edebug-cl-read to be loaded when you load cl-read.el.
4461 (add-hook 'cl-read-load-hooks
4462 (function (lambda () (require 'edebug-cl-read)))))
4463
4464 \f
4465 ;;; Finalize Loading
4466
4467 ;;; Finally, hook edebug into the rest of Emacs.
4468 ;;; There are probably some other things that could go here.
4469
4470 ;; Install edebug read and eval functions.
4471 (edebug-install-read-eval-functions)
4472
4473 (provide 'edebug)
4474
4475 ;;; arch-tag: 19c8d05c-4554-426e-ac72-e0fa1fcb0808
4476 ;;; edebug.el ends here