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