| blob | 7e4d244f5e2124d93a543c383918c9dc18a021a9 |
1 ;;; edebug.el --- a source-level debugger for Emacs Lisp -*- lexical-binding: t -*-
3 ;; Copyright (C) 1988-1995, 1997, 1999-2018 Free Software Foundation,
4 ;; Inc.
6 ;; Author: Daniel LaLiberte <liberte@holonexus.org>
7 ;; Maintainer: emacs-devel@gnu.org
8 ;; Keywords: lisp, tools, maint
10 ;; This file is part of GNU Emacs.
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 3 of the License, or
15 ;; (at your option) any later version.
17 ;; GNU Emacs is distributed in the hope that it will be useful,
18 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 ;; GNU General Public License for more details.
22 ;; You should have received a copy of the GNU General Public License
23 ;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
25 ;;; Commentary:
27 ;; This minor mode allows programmers to step through Emacs Lisp
28 ;; source code while executing functions. You can also set
29 ;; breakpoints, trace (stopping at each expression), evaluate
30 ;; expressions as if outside Edebug, reevaluate and display a list of
31 ;; expressions, trap errors normally caught by debug, and display a
32 ;; debug style backtrace.
34 ;;; Minimal Instructions
35 ;; =====================
37 ;; First evaluate a defun with C-M-x, then run the function. Step
38 ;; through the code with SPC, mark breakpoints with b, go until a
39 ;; breakpoint is reached with g, and quit execution with q. Use the
40 ;; "?" command in edebug to describe other commands.
41 ;; See the Emacs Lisp Reference Manual for more details.
43 ;; If you wish to change the default edebug global command prefix, change:
44 ;; (setq edebug-global-prefix "\C-xX")
46 ;; Edebug was written by
47 ;; Daniel LaLiberte
48 ;; GTE Labs
49 ;; 40 Sylvan Rd
50 ;; Waltham, MA 02254
51 ;; liberte@holonexus.org
53 ;;; Code:
59 ;;; Options
62 "A source-level debugger for Emacs Lisp."
67 "Functions to call before edebug is used.
68 Each time it is set to a new value, Edebug will call those functions
69 once and then reset `edebug-setup-hook' to nil. You could use this
70 to load up Edebug specifications associated with a package you are
71 using, but only when you also use Edebug."
75 ;; edebug-all-defs and edebug-all-forms need to be autoloaded
76 ;; because the byte compiler binds them; as a result, if edebug
77 ;; is first loaded for a require in a compilation, they will be left unbound.
79 ;;;###autoload
81 "If non-nil, evaluating defining forms instruments for Edebug.
82 This applies to `eval-defun', `eval-region', `eval-buffer', and
83 `eval-current-buffer'. `eval-region' is also called by
84 `eval-last-sexp', and `eval-print-last-sexp'.
86 You can use the command `edebug-all-defs' to toggle the value of this
87 variable. You may wish to make it local to each buffer with
89 `emacs-lisp-mode-hook'."
93 ;; edebug-all-defs and edebug-all-forms need to be autoloaded
94 ;; because the byte compiler binds them; as a result, if edebug
95 ;; is first loaded for a require in a compilation, they will be left unbound.
97 ;;;###autoload
99 "Non-nil means evaluation of all forms will instrument for Edebug.
100 This doesn't apply to loading or evaluations in the minibuffer.
101 Use the command `edebug-all-forms' to toggle the value of this option."
106 "Non-nil means all macro call arguments may be evaluated.
107 If this variable is nil, the default, Edebug will *not* wrap
108 macro call arguments as if they will be evaluated.
109 For each macro, an `edebug-form-spec' overrides this option.
110 So to specify exceptions for macros that have some arguments evaluated
111 and some not, use `def-edebug-spec' to specify an `edebug-form-spec'."
116 "Maximum recursion depth when instrumenting code.
117 This limit is intended to stop recursion if an Edebug specification
118 contains an infinite loop. When Edebug is instrumenting code
119 containing very large quoted lists, it may reach this limit and give
121 Make this limit larger to countermand that, but you may also need to
122 increase `max-lisp-eval-depth' and `max-specpdl-size'."
128 "If non-nil, Edebug saves and restores the window configuration.
129 That takes some time, so if your program does not care what happens to
130 the window configurations, it is better to set this variable to nil.
132 If the value is a list, only the listed windows are saved and
133 restored.
135 `edebug-toggle-save-windows' may be used to change this variable."
140 "If non-nil, save and restore point in all displayed buffers.
142 Saving and restoring point in other buffers is necessary if you are
143 debugging code that changes the point of a buffer that is displayed
144 in a non-selected window. If Edebug or the user then selects the
145 window, the buffer's point will be changed to the window's point.
147 Saving and restoring point in all buffers is expensive, since it
148 requires selecting each window twice, so enable this only if you
149 need it."
154 "Initial execution mode for Edebug, if non-nil.
155 If this variable is non-nil, it specifies the initial execution mode
156 for Edebug when it is first activated. Possible values are step, next,
157 go, Go-nonstop, trace, Trace-fast, continue, and Continue-fast."
165 "Non-nil means display a trace of function entry and exit.
166 Tracing output is displayed in a buffer named `*edebug-trace*', one
167 function entry or exit per line, indented by the recursion level.
169 You can customize by replacing functions `edebug-print-trace-before'
170 and `edebug-print-trace-after'."
175 "If non-nil, Edebug tests coverage of all expressions debugged.
176 This is done by comparing the result of each expression with the
177 previous result. Coverage is considered OK if two different
178 results are found.
180 Use `edebug-display-freq-count' to display the frequency count and
181 coverage information for a definition."
186 "If non-nil, continue defining or executing any keyboard macro.
187 Use this with caution since it is not debugged."
193 "If non-nil, default value of `print-length' for printing results in Edebug."
197 "If non-nil, default value of `print-level' for printing results in Edebug."
201 "If non-nil, default value of `print-circle' for printing results in Edebug."
206 "Non-nil if Edebug should unwrap results of expressions.
207 That is, Edebug will try to remove its own instrumentation from the result.
208 This is useful when debugging macros where the results of expressions
209 are instrumented expressions. But don't do this when results might be
210 circular or an infinite loop will result."
215 "Value bound to `debug-on-error' while Edebug is active.
217 If `debug-on-error' is non-nil, that value is still used.
219 If the value is a list of signal names, Edebug will stop when any of
220 these errors are signaled from Lisp code whether or not the signal is
221 handled by a `condition-case'. This option is useful for debugging
222 signals that *are* handled since they would otherwise be missed.
223 After execution is resumed, the error is signaled again."
232 "Value bound to `debug-on-quit' while Edebug is active."
237 "If non-nil, an expression to test for at every stop point.
238 If the result is non-nil, then break. Errors are ignored."
240 :risky t
244 "Number of seconds to pause when execution mode is `trace' or `continue'."
249 "Whether or not to pause for `edebug-sit-for-seconds' on reaching a break."
254 ;;; Form spec utilities.
257 ;; Get the spec of symbol resolving all indirection.
265 ;; (edebug-trace "indirection: %s" edebug-form-spec)
267 spec))
269 ;;;###autoload
271 "Return t if SPEC uses only extant spec symbols.
272 An extant spec symbol is a symbol that is not a function and has a
273 `edebug-form-spec' property."
279 t))
283 ;;; Utilities
286 "Return t if OBJECT is a lambda list keyword.
287 A lambda list keyword is a symbol that starts with `&'."
293 ;; Return the last sexp before point in current buffer.
294 ;; Assumes Emacs Lisp syntax is active.
304 "Return a list of windows, in order of `next-window'."
305 ;; This doesn't work for epoch.
310 ;; Not used.
312 "Return t if there are two windows."
318 ;; Return the ALIST sorted with comparison function FUNCTION.
319 ;; This uses 'sort so the sorting is destructive.
324 ;; Not used.
326 "Evaluate BODY while saving the current buffers restriction.
327 BODY may change buffer outside of current restriction, unlike
328 save-restriction. BODY may change the current buffer,
329 and the restriction will be restored to the original buffer,
330 and the current buffer remains current.
331 Return the result of the last expression in BODY."
340 ;;; Display
346 ;; Like pop-to-buffer, but select window where BUFFER was last shown.
347 ;; Select WINDOW if it is provided and still exists. Otherwise,
348 ;; if buffer is currently shown in several windows, choose one.
349 ;; Otherwise, find a new window, possibly splitting one.
350 ;; FIXME: We should probably just be using `pop-to-buffer'.
355 window)
357 ;; Selected window already displays BUFFER.
361 ;; When there's one window only, split it.
368 ;; Found a non-dedicated window not showing
369 ;; `edebug-trace-buffer', use it.
371 ;; All windows are dedicated or show `edebug-trace-buffer', split
372 ;; selected one.
379 ;; Return a list of buffer point pairs, for all displayed buffers.
385 list))))
386 list))
390 ;; Restore the buffer-points created by edebug-get-displayed-buffer-points.
396 buffer-points)))
399 ;; Get either a full window configuration or some window information.
408 which-windows)
412 ;; Set either a full window configuration or some window information.
424 one-window-info)))
425 window-info)
428 ;;; Redefine read and eval functions
429 ;; read is redefined to maybe instrument forms.
430 ;; eval-defun is redefined to check edebug-all-forms and edebug-all-defs.
433 "Read one Lisp expression as text from STREAM, return as Lisp object.
434 If STREAM is nil, use the value of `standard-input' (which see).
435 STREAM or the value of `standard-input' may be:
436 a buffer (read from point and advance it)
437 a marker (read from where it points and advance it)
438 a function (call it with no arguments for each character,
439 call it with a char as argument to push a char back)
440 a string (takes text from string, starting at the beginning)
441 t (read text line using minibuffer and use it).
443 This version, from Edebug, maybe instruments the expression. But the
444 STREAM must be the current buffer to do so. Whether it instruments is
445 also dependent on the values of the option `edebug-all-defs' and
446 the option `edebug-all-forms'."
454 ;; We should somehow arrange to be able to do this
455 ;; without actually replacing the eval-defun command.
457 "Evaluate the top-level form containing point, or after point.
459 If the current defun is actually a call to `defvar', then reset the
460 variable using its initial value expression even if the variable
461 already has some other value. (Normally `defvar' does not change the
462 variable's value if it already has a value.) Treat `defcustom'
463 similarly. Reinitialize the face according to `defface' specification.
465 With a prefix argument, instrument the code for Edebug.
467 Setting option `edebug-all-defs' to a non-nil value reverses the meaning
468 of the prefix argument. Code is then instrumented when this function is
469 invoked without a prefix argument.
471 If acting on a `defun' for FUNCTION, and the function was instrumented,
472 `Edebug: FUNCTION' is printed in the minibuffer. If not instrumented,
473 just FUNCTION is printed.
475 If not acting on a `defun', the result of evaluation is displayed in
476 the minibuffer."
484 ;; This should be consistent with `eval-defun-1', but not the
485 ;; same, since that gets a macroexpanded form.
488 ;; Force variable to be bound.
492 ;; Force variable to be bound.
493 ;; FIXME: Shouldn't this use the :setter or :initializer?
496 ;; Reset the face.
501 ;; See comments in `eval-defun-1' for purpose of code below
514 edebug-result)))
517 ;;;###autoload
520 ;;;###autoload
522 "Evaluate the top level form point is in, stepping through with Edebug.
523 This is like `eval-defun' except that it steps the code for Edebug
524 before evaluating it. It displays the value in the echo area
525 using `eval-expression' (which see).
527 If you do this on a function definition such as a defun or defmacro,
528 it defines the function and instruments its definition for Edebug,
529 so it will do Edebug stepping when called later. It displays
530 `Edebug: FUNCTION' in the echo area to indicate that FUNCTION is now
531 instrumented for Edebug.
533 If the current defun is actually a call to `defvar' or `defcustom',
534 evaluating it this way resets the variable using its initial value
535 expression even if the variable already has some other value.
536 \(Normally `defvar' and `defcustom' do not alter the value if there
537 already is one.)"
540 ;; Bind edebug-all-forms only while reading, not while evalling
541 ;; but this causes problems while edebugging edebug.
554 ;; Recover point, but only if no error occurred.
558 ;; Compatibility with old versions.
561 ;;;###autoload
563 "Toggle edebugging of all definitions."
570 ;;;###autoload
572 "Toggle edebugging of all forms."
589 ;;; Edebug internal data
591 ;; The internal data that is needed for edebugging is kept in the
592 ;; buffer-local variable `edebug-form-data'.
595 "A list of entries associating symbols with buffer regions.
596 Each entry is an `edebug--form-data' struct with fields:
597 SYMBOL, BEGIN-MARKER, and END-MARKER. The markers
598 are at the beginning and end of an entry level form and SYMBOL is
599 a symbol that holds all edebug related information for the form on its
600 property list.
602 In the future (haha!), the symbol will be irrelevant and edebug data will
603 be stored in the definitions themselves rather than in the property
607 ;; Some callers expect accessors to return nil when passed nil.
611 name begin end)
619 ;; Find the edebug form data entry which is closest to PNT.
620 ;; If END-POINT is supplied, match must be exact.
621 ;; Return nil if none found.
623 closest-entry
636 closest-entry entry))))
637 closest-entry))
639 ;; Also need to find all contained entries,
640 ;; and find an entry given a symbol, which should be just assq.
643 "Return the edebug data symbol of the form where point is in.
644 If point is not inside an edebuggable form, signal an error."
649 ;; Make NEW-ENTRY the first element in the `edebug-form-data' list.
654 "If non-nil, clear ENTRY out of the form data.
655 Maybe clear the markers and delete the symbol's edebug property?"
658 ;; Instead of this, we could just find all contained forms.
659 ;; (put (car entry) 'edebug nil) ;
660 ;; (mapcar #'edebug-clear-form-data-entry ; dangerous
661 ;; (get (car entry) 'edebug-dependents))
662 ;; (set-marker (nth 1 entry) nil)
663 ;; (set-marker (nth 2 entry) nil)
666 ;;; Parser utilities
669 ;; Signal an invalid-read-syntax with ARGS.
674 ;; Lookup table for significant characters indicating the class of the
675 ;; token that follows. This is not a \"real\" syntax table.
692 ;; We treat numbers as symbols, because of confusion with -, -1, and 1-.
693 ;; We don't care about any other chars since they won't be seen.
694 table))
697 ;; Move to the next token and return its class. We only care about
698 ;; lparen, rparen, dot, quote, backquote, comma, string, char, vector,
699 ;; or symbol.
708 'symbol
713 ;; Leave point before the next token, skipping white space and comments.
720 ;; Mostly obsolete reader; still used in one case.
723 ;; Read one sexp from the current buffer starting at point.
724 ;; Leave point immediately after it. A sexp can be a list or atom.
725 ;; An atom is a symbol (or number), character, string, or vector.
726 ;; This works for reading anything legitimate, but it
727 ;; is gummed up by parser inconsistencies (bugs?)
730 ;; read goes one too far if a (possibly quoted) string or symbol
731 ;; is immediately followed by non-whitespace.
743 ;;; Offsets for reader
745 ;; Define a structure to represent offset positions of expressions.
746 ;; Each offset structure looks like: (before . after) for constituents,
747 ;; or for structures that have elements: (before <subexpressions> . after)
748 ;; where the <subexpressions> are the offset structures for subexpressions
749 ;; including the head of a list.
752 ;; Stack of offset structures in reverse order of the nesting.
753 ;; This is used to get back to previous levels.
757 ;; The association list of objects read with the #n=object form.
758 ;; Each member of the list has the form (n . object), and is used to
759 ;; look up the object for the corresponding #n# construct.
762 ;; We must store whether we just read a list with a dotted form that
763 ;; is itself a list. This structure will be condensed, so the offsets
764 ;; must also be condensed.
768 ;; Reinitialize offset recording.
772 ;; Add a new offset pair with POINT as the before offset.
777 ;; Otherwise, we are at the top level, so initialize.
779 edebug-offsets-stack nil
780 edebug-read-dotted-list nil))
781 ;; Cons the new offset to the front of the stack.
783 edebug-current-offset new-offset)
784 ))
787 ;; Finalize the current offset struct by reversing it and
788 ;; store POINT as the after offset.
790 ;; Just reverse the offsets of all subexpressions.
793 ;; We just read a list after a dot, which will be abbreviated out.
795 ;; Drop the corresponding offset pair.
796 ;; That is, nconc the reverse of the rest of the offsets
797 ;; with the cdr of last offset.
802 ;; Now append the point using nconc.
804 ;; Pop the stack.
809 ;; Ignore the last created offset pair.
821 ;;; Reader for Emacs Lisp.
823 ;; Uses edebug-next-token-class (and edebug-skip-whitespace) above.
834 ))
841 ;; anything else, just read it.
843 stream))))
849 ;; Turn 'thing into (quote thing)
856 ;; Turn `thing into (\` thing)
863 ;; Turn ,thing into (\, thing). Handle ,@ and ,. also.
873 ;; Generate the same structure of offsets we would have
874 ;; if the resulting list appeared verbatim in the input text.
880 "Read from STREAM a Lisp object beginning with #.
881 Turn #'thing into (function thing) and handle the read syntax for
882 circular objects. Let `read' read everything else."
901 ;; Make a placeholder for #n# to use temporarily.
905 ;; Read the object and then replace the placeholder
906 ;; with the object itself, wherever it occurs.
912 ;; #n# returns a previously read object.
917 ;; Let read handle errors, radix notation, and anything else.
936 ))
937 elements)
939 ))
949 ))
951 ;;; Cursors for traversal of list and vector elements with offsets.
957 ;; Return a new cursor for EXPRESSIONS with OFFSETS.
963 ;; Set the CURSOR's EXPRESSIONS and OFFSETS to the given.
964 ;; Return the cursor.
967 cursor)
970 ;; Copy the cursor using the same object and offsets.
979 ;; Return non-nil if CURSOR is empty - meaning no more elements.
983 ;; Return the top element at the cursor.
984 ;; Assumes not empty.
988 ;; Check if a dotted form is required.
990 ;; Check if there is at least one more argument.
992 ;; Return that top element.
996 ;; Return the top offset pair corresponding to the top element.
1000 ;; Advance and return the cursor to the next element and offset.
1001 ;; throw no-match if empty before moving.
1002 ;; This is a violation of the cursor encapsulation, but
1003 ;; there is plenty of that going on while matching.
1004 ;; The following test should always fail.
1009 cursor)
1013 ;; Return the before offset of the cursor.
1014 ;; If there is nothing left in the offsets,
1015 ;; return one less than the offset itself,
1016 ;; which is the after offset for a list.
1023 ;; Return the after offset of the cursor object.
1027 offset))
1029 ;;; The Parser
1031 ;; The top level function for parsing forms is
1032 ;; edebug-read-and-maybe-wrap-form; it calls all the rest. It checks the
1033 ;; syntax a bit and leaves point at any error it finds, but otherwise
1034 ;; should appear to work like eval-defun.
1036 ;; The basic plan is to surround each expression with a call to
1037 ;; the edebug debugger together with indexes into a table of positions of
1038 ;; all expressions. Thus an expression "exp" becomes:
1040 ;; (edebug-after (edebug-before 1) 2 exp)
1042 ;; When this is evaluated, first point is moved to the beginning of
1043 ;; exp at offset 1 of the current function. The expression is
1044 ;; evaluated, which may cause more edebug calls, and then point is
1045 ;; moved to offset 2 after the end of exp.
1047 ;; The highest level expressions of the function are wrapped in a call to
1048 ;; edebug-enter, which supplies the function name and the actual
1049 ;; arguments to the function. See functions edebug-enter, edebug-before,
1050 ;; and edebug-after for more details.
1052 ;; Dynamically bound vars, left unbound, but globally declared.
1053 ;; This is to quiet the byte compiler.
1055 ;; Window data of the highest definition being wrapped.
1056 ;; This data is shared by all embedded definitions.
1071 ;; Read a form and wrap it with edebug calls, if the conditions are right.
1072 ;; Here we just catch any no-match not caught below and signal an error.
1074 ;; Run the setup hook.
1075 ;; If it gets an error, make it nil.
1082 edebug-top-window-data
1083 edebug-def-name;; make sure it is locally nil
1084 ;; I don't like these here!!
1085 edebug-&optional
1086 edebug-&rest
1087 edebug-gate
1088 edebug-best-error
1089 edebug-error-point
1090 ;; Do this once here instead of several times.
1096 nil)))
1099 result))
1104 def-kind
1105 defining-form-p
1106 def-name
1107 ;; These offset things don't belong here, but to support recursive
1108 ;; calls to edebug-read, they need to be here.
1109 edebug-offsets
1110 edebug-offsets-stack
1111 edebug-current-offset ; reset to nil
1112 edebug-read-objects
1113 )
1117 ;; Find out if this is a defining form from first symbol
1122 ;; This is incorrect in general!! But OK most of the time.
1127 ;;;(message "all defs: %s all forms: %s" edebug-all-defs edebug-all-forms)
1131 ;; If it is a defining form and we are edebugging defs,
1132 ;; then let edebug-list-form start it.
1138 cursor
1143 ;; Not edebugging this form, so reset the symbol's edebug
1144 ;; property to be just a marker at the definition's source code.
1145 ;; This only works for defs with simple names.
1147 ;; Also nil out dependent defs.
1154 ;; If all forms are being edebugged, explicitly wrap it.
1160 cursor
1163 nil)))
1165 ;; Not a defining form, and not edebugging.
1167 ))
1173 ;; Currently def-form sets this to nil; def-body sets it to t.
1176 ;; Return a unique symbol for the variable used to store the
1177 ;; status of interactive-p for this function.
1182 "Wrap the FORMS of a definition body."
1191 ;; Generate the enter wrapper for some forms of a definition.
1192 ;; This is not to be used for the body of other forms, e.g. `while',
1193 ;; since it wraps the list of forms with a call to `edebug-enter'.
1194 ;; Uses the dynamically bound vars edebug-def-name and edebug-def-args.
1195 ;; Do this after parsing since that may find a name.
1202 ;; Doesn't work with more than one def-body!!
1203 ;; But the list will just be reversed.
1207 ))
1216 ;; Modifies edebug-offset-index and edebug-offset-list
1217 ;; accesses edebug-func-marc and buffer point.
1219 edebug-offset-index
1221 edebug-offset-list)
1226 ;; Return the edebug form for the current function at offset BEFORE-INDEX
1227 ;; given FORM. Looks like:
1228 ;; (edebug-after (edebug-before BEFORE-INDEX) AFTER-INDEX FORM)
1229 ;; Also increment the offset index for subsequent use.
1233 ;; Like edebug-make-before-and-after-form, but only after.
1238 "Return the unwrapped SEXP or return it as is if it is not wrapped.
1239 The SEXP might be the result of wrapping a body, which is a list of
1240 expressions; a `progn' form will be returned enclosing these forms."
1248 )
1249 sexp))
1252 "Return the SEXP recursively unwrapped."
1259 new-sexp)))
1263 ;; Process the defining form, starting outside the form.
1264 ;; The speclist is a generated list spec that looks like:
1265 ;; (("def-symbol" defining-form-spec-sans-&define))
1266 ;; Skip the first offset.
1270 cursor
1272 speclist))
1276 ;; Wrap a form, usually a defining form, but any evaluated one.
1277 ;; If speclist is non-nil, this is being called by edebug-defining-form.
1278 ;; Otherwise it is being called from edebug-read-and-maybe-wrap-form1.
1279 ;; This is a hack, but I haven't figured out a simpler way yet.
1281 ;; Set this marker before parsing.
1285 ;; Buffer must be current-buffer for this to work:
1290 result
1291 ;; For definitions.
1292 ;; (edebug-containing-def-name edebug-def-name)
1293 ;; Get name from form-data, if any.
1295 edebug-def-name
1296 edebug-def-args
1297 edebug-def-interactive
1298 edebug-inside-func;; whether wrapped code executes inside a function.
1299 )
1305 ;; else wrap as an enter-form.
1308 ;; Set the name here if it was not set by edebug-make-enter-wrapper.
1312 ;; Add this def as a dependent of containing def. Buggy.
1320 ;; Create a form-data-entry or modify existing entry's markers.
1321 ;; In the latter case, pointers to the entry remain eq.
1325 edebug-def-name
1326 edebug-form-begin-marker
1327 ;; Buffer must be current-buffer.
1329 ))
1331 form-data-entry edebug-def-name ;; in case name is changed
1332 form-begin form-end))
1334 ;; (message "defining: %s" edebug-def-name) (sit-for 2)
1337 ;;(debug edebug-def-name)
1339 ;; Destructively reverse edebug-offset-list and make vector from it.
1342 ;; Side effects on the property list of edebug-def-name.
1346 ;; Set up the initial window data.
1354 ;; Store the edebug data in symbol's property list.
1356 ;; A struct or vector would be better here!!
1358 nil ; clear breakpoints
1359 edebug-offset-list
1360 edebug-top-window-data
1361 ))
1362 result
1363 )))
1367 ;; Create initial frequency count vector.
1368 ;; For each stop point, the counter is incremented each time it is visited.
1374 ;; Create initial coverage vector.
1375 ;; Only need one per expression, but it is simpler to use stop points.
1381 ;; Return the instrumented form for the following form.
1382 ;; Add the point offsets to the edebug-offset-list for the form.
1388 ;; The first offset for a list form is for the list form itself.
1390 form
1394 ;; Find out if this is a defining form from first symbol.
1395 ;; An indirect spec would not work here, yet.
1398 new-cursor
1402 ;; Wrap a regular form.
1406 ;; After processing the list form, the new-cursor is left
1407 ;; with the offset after the form.
1409 )))
1413 ;; Check for constant symbols that don't get wrapped.
1416 form)
1421 ;; Anything else is self-evaluating.
1430 ;; Process the arguments of a list form given that head of form is a symbol.
1431 ;; Helper for edebug-list-form
1437 ;; It is a speclist.
1444 ; but leave it in for compatibility.
1445 ))
1446 ;; No edebug-form-spec provided.
1456 ;; Return an instrumented form built from the list form.
1457 ;; The after offset will be left in the cursor after processing the form.
1459 ;; Prevent backtracking whenever instrumenting.
1461 ;; A list form is never optional because it matches anything.
1464 ;; Skip the first offset.
1472 ;; Special case: replace (interactive-p) with variable
1482 ;; The head of a form should normally be a symbol or a lambda
1483 ;; expression but it can also be an unquote form to be filled
1484 ;; before evaluation. We evaluate the arguments anyway, on the
1485 ;; assumption that the unquote form will place a proper function
1486 ;; name (rather than a macro name).
1488 ;; Process anonymous function and args.
1489 ;; This assumes no anonymous macros.
1494 ))
1496 ;;; Matching of specs.
1501 ;;; Failure to match
1503 ;; This throws to no-match, if there are higher alternatives.
1504 ;; Otherwise it signals an error. The place of the error is found
1505 ;; with the two before- and after-offset functions.
1508 ;; Throw a no-match, or signal an error immediately if gate is active.
1509 ;; Remember this point in case we need to report this error.
1522 ;; Top level spec matching function.
1523 ;; Used also at each lower level of specs.
1525 edebug-&rest
1526 edebug-best-error
1527 edebug-error-point
1529 )
1534 ;; Match one spec, which is not a keyword &-spec.
1540 ))
1544 ;; Append results of matching the list of specs.
1545 ;; The first spec is handled and the remainder-handler handles the rest.
1553 ;; Is the spec dotted?
1558 ;; The reason for processing here &optional, &rest, and vectors
1559 ;; which might contain them even when the form is dotted is to
1560 ;; allow them to match nothing, so we can advance to the dotted
1561 ;; part of the spec.
1565 ;; (message "%scursor=%s specs=%s"
1566 ;; (make-string edebug-matching-depth ?|) cursor (car specs))
1579 ;; The first match result may not be a list, which can happen
1580 ;; when matching the tail of a dotted list. In that case
1581 ;; there is no remainder.
1585 match)))
1587 ;; Must be a dotted form, with no remaining &rest or &optional specs to
1588 ;; match.
1592 ;; Cancel dotted spec and dotted form.
1596 ;; Wrap the form in a list, by changing the cursor.
1598 ;; Process normally, then unwrap the result.
1601 ;; Define specs for all the symbol specs with functions used to process them.
1602 ;; Perhaps we shouldn't be doing this with edebug-form-specs since the
1603 ;; user may want to define macros or functions with the same names.
1604 ;; We could use an internal obarray for these primitive specs.
1618 ;; Less frequently used:
1619 ;; (function . edebug-match-function)
1626 ;; (nil . edebug-match-nil) not this one - special case it.
1627 ))
1631 ;; Match a symbol spec.
1636 ;; It is an indirect spec.
1638 ;; Otherwise it should be the symbol name of a function.
1639 ;; There could be a bug here - maybe need to do edebug-match bindings.
1647 ;; Special case for edebug-`.
1655 )))
1666 ;; Currently identical to edebug-match-form.
1667 ;; This is for common lisp setf-style place arguments.
1672 ;; Keep matching until one spec fails.
1684 ;; Returning nil means no no-match was thrown.
1685 nil))
1686 result
1687 ;; no-match, but don't fail; just reset cursor and return nil.
1689 nil)))
1694 ;; Reuse the &optional handler with this as the remainder handler.
1698 ;; Repeatedly use specs until failure.
1700 edebug-best-error
1701 edebug-error-point)
1706 ;; Keep matching until one spec succeeds, and return its results.
1707 ;; If none match, fail.
1708 ;; This needs to be optimized since most specs spend time here.
1717 edebug-best-error
1718 edebug-error-point)
1719 ;; Doesn't support e.g. &or symbolp &rest form
1721 ;; Match failed, so reset and try again.
1723 ;; Reset the cursor for the next match.
1725 ;; All failed.
1727 ))
1731 ;; If any specs match, then fail
1736 nil))
1737 ;; This means something matched, so it is a no match.
1739 ;; This means nothing matched, so it is OK.
1746 ;; Following specs must look like (<name> <spec>) ...
1747 ;; where <name> is the name of a keyword, and spec is its spec.
1748 ;; This really doesn't save much over the expanded form and takes time.
1750 cursor
1755 specs))))
1759 ;; Simply set the gate to prevent backtracking at this level.
1761 nil)
1765 ;; The spec is a list, but what kind of list, and what context?
1767 ;; After dotted spec but form did not contain dot,
1768 ;; so match list spec elements as if spliced in.
1772 ;; If it matched, really clear the dotted-spec flag.
1781 ;; Special case: spec quotes a symbol to match.
1782 ;; Change in future. Use "..." instead.
1787 form)
1793 ;; Special case: match a vector with the specs.
1805 ;; First offset is for the list form itself.
1806 ;; Treat nil as empty list.
1808 specs))
1812 )))
1816 ;; Match a sublist of specs.
1818 ;;edebug-best-error
1819 ;;edebug-error-point
1820 )
1822 ;; match with edebug-match-specs so edebug-best-error is not bound.
1827 ;; A failed &rest or &optional spec may leave some args.
1829 )))))
1836 ;; Since it matched, failure means immediate error, unless &optional.
1840 )))
1843 ;; There must be nothing left to match a nil.
1846 nil))
1853 ;; Match a defining form.
1854 ;; Normally, &define is interpreted specially other places.
1855 ;; This should only be called inside of a spec list to match the remainder
1856 ;; of the current list. e.g. ("lambda" &define args def-body)
1858 cursor
1860 ;; Find the last offset in the list.
1863 offsets)
1864 specs))
1867 ;; The expression must be a function.
1868 ;; This will match any list form that begins with a symbol
1869 ;; that has an edebug-form-spec beginning with &define. In
1870 ;; practice, only lambda expressions should be used.
1871 ;; I could add a &lambda specification to avoid confusion.
1878 ;; Find out if this is a defining form from first symbol.
1889 )))
1893 ;; Set the edebug-def-name bound in edebug-defining-form.
1895 ;; Maybe strings and numbers could be used.
1900 ;; Construct a new name by appending to previous name.
1902 name))
1907 ;; Set the edebug-def-name to the spec.
1910 ;; Construct a new name by appending to previous name.
1912 spec))
1913 nil)
1919 ;; Append the arguments to edebug-def-name.
1926 ;; set the def-args bound in edebug-defining-form
1936 ;; Like form but the form is wrapped in edebug-enter form.
1937 ;; The form is assumed to be executing outside of the function context.
1938 ;; This is a hack for now, since a def-form might execute inside as well.
1939 ;; Not to be used otherwise.
1944 ;; Like body but body is wrapped in edebug-enter form.
1945 ;; The body is assumed to be executing inside of the function context.
1946 ;; Not to be used otherwise.
1949 ;; If there's no form, there's nothing to wrap!
1950 ;; This happens to handle bug#20281, tho maybe a better fix would be to
1951 ;; improve the `defun' spec.
1956 ;;;; Edebug Form Specs
1957 ;;; ==========================================================
1959 ;;;;* Spec for def-edebug-spec
1960 ;;; Out of date.
1963 "Return non-nil if OBJECT is a symbol with an edebug-form-spec property."
1968 ;; Top level is different from lower levels.
1973 ;; A list must have something in it, or it is nil, a symbolp
1977 (&or
1981 edebug-spec-list
1982 stringp
1985 edebug-spec-p ;; Including all the special ones e.g. form.
1986 symbolp;; a predicate
1987 ))
1990 ;;;* Emacs special forms and some functions.
1992 ;; quote expects only one argument, although it allows any number.
1995 ;; The standard defining forms.
2000 (&define name lambda-list lambda-doc
2003 def-body))
2005 ;; FIXME: Improve `declare' so we can Edebug gv-expander and
2006 ;; gv-setter declarations.
2007 (&define name lambda-list lambda-doc
2016 )))
2025 ;; A function-form is for an argument that may be a function or a form.
2026 ;; This specially recognizes anonymous functions quoted with quote.
2028 ;; form at the end could also handle "function",
2029 ;; but recognize it specially to avoid wrapping function forms.
2032 ;; function expects a symbol or a lambda or macro expression
2033 ;; A macro is allowed by Emacs.
2036 ;; A macro expression is a lambda expression with "macro" prepended.
2039 ;; (def-edebug-spec anonymous-form ((&or ["lambda" lambda] ["macro" macro])))
2041 ;; Standard functions that take function-forms arguments.
2043 ;; FIXME? The manual uses this form (maybe that's just for illustration?):
2044 ;; (def-edebug-spec let
2045 ;; ((&rest &or symbolp (gate symbolp &optional form))
2046 ;; body))
2049 body))
2060 form
2066 ;; Supports quotes inside backquotes,
2067 ;; but only at the top level inside unquotes.
2069 (&or
2071 ;; The simple version:
2072 ;; (backquote-form &rest backquote-form)
2073 ;; doesn't handle (a . ,b). The straightforward fix:
2074 ;; (backquote-form . [&or nil backquote-form])
2075 ;; uses up too much stack space.
2076 ;; Note that `(foo . ,@bar) is not valid, so we don't need to handle it.
2079 ;; If you use dotted forms in backquotes, replace the previous line
2080 ;; with the following. This takes quite a bit more stack space, however.
2081 ;; (backquote-form . [&or nil backquote-form])
2083 sexp))
2085 ;; Special version of backquote that instruments backquoted forms
2086 ;; destined to be evaluated, usually as the result of a
2087 ;; macroexpansion. Backquoted code can only have unquotes (, and ,@)
2088 ;; in places where list forms are allowed, and predicates. If the
2089 ;; backquote is used in a macro, unquoted code that come from
2090 ;; arguments must be instrumented, if at all, with def-form not def-body.
2092 ;; We could assume that all forms (not nested in other forms)
2093 ;; in arguments of macros should be def-forms, whether or not the macros
2094 ;; are defined with edebug-` but this would be expensive.
2096 ;; ,@ might have some problems.
2101 ;; Assume immediate quote in unquotes mean backquote at next higher level.
2106 ;; New byte compiler.
2111 ;; Anything else?
2113 ;;; The debugger itself
2118 ;; Stack of active functions evaluated via edebug.
2119 ;; Should be nil at the top level.
2122 ;; Index of last edebug-stack item.
2125 ;; Stack of offset indices of visited edebug sexps.
2126 ;; Should be nil at the top level.
2127 ;; Each function adds one cons. Top is modified with setcar.
2131 ;; Non-nil if edebug has already been entered at this recursive edit level.
2132 ;; This should stay nil at the top level.
2133 )
2135 ;; Should these be options?
2137 ;; Name of function to use for debugging when error or quit occurs.
2138 ;; Set this to 'debug if you want to debug edebug.
2139 )
2142 ;; Dynamically bound variables, declared globally but left unbound.
2157 ;;; Handling signals
2160 "Signal an error. Args are SIGNAL-NAME, and associated DATA.
2161 A signal name is a symbol with an `error-conditions' property
2162 that is a list of condition names.
2163 A handler for any of those names will get to handle this signal.
2164 The symbol `error' should always be one of them.
2166 DATA should be a list. Its elements are printed as part of the error message.
2167 If the signal is handled, DATA is made available to the handler.
2168 See `condition-case'.
2170 This is the Edebug replacement for the standard `signal'. It should
2171 only be active while Edebug is. It checks `debug-on-error' to see
2172 whether it should call the debugger. When execution is resumed, the
2173 error is signaled again."
2176 ;; If we reach here without another non-local exit, then send signal again.
2177 ;; i.e. the signal is not continuable, yet.
2178 ;; Avoid infinite recursion.
2182 ;;; Entering Edebug
2185 ;; Entering FUNC. The arguments are ARGS, and the body is BODY.
2186 ;; Setup edebug variables and evaluate BODY. This function is called
2187 ;; when a function evaluated with edebug-eval-top-level-form is entered.
2188 ;; Return the result of BODY.
2190 ;; Is this the first time we are entering edebug since
2191 ;; lower-level recursive-edit command?
2192 ;; More precisely, this tests whether Edebug is currently active.
2196 ;; Binding max-lisp-eval-depth here is OK,
2197 ;; but not inside an unwind-protect.
2198 ;; Doing it here also keeps it from growing too large.
2205 ;; Binding these may not be the right thing to do.
2206 ;; We want to allow the global values to be changed.
2212 edebug-initial-mode
2213 edebug-execution-mode)
2214 edebug-next-execution-mode nil)
2225 )
2234 ))))
2237 "Return a cons cell describing the status of VAR's current binding.
2238 The purpose of this function is so you can properly undo
2239 subsequent changes to the same binding, by passing the status
2240 cons cell to `edebug-restore-status'. The status cons cell
2241 has the form (LOCUS . VALUE), where LOCUS can be a buffer
2242 \(for a buffer-local binding), or nil (if the default binding is current)."
2247 "Reset VAR based on STATUS.
2248 STATUS should be a list returned by `edebug-var-status'."
2262 edebug-result)
2272 "Print MSG in *edebug-trace* before and after evaluating BODY.
2273 The result of BODY is also printed."
2275 edebug-result)
2282 "Function called to print trace info before expression evaluation.
2283 MSG is printed after `::::{ '."
2288 "Function called to print trace info after expression evaluation.
2289 MSG is printed after `::::} '."
2297 ;; Debug current function given BEFORE position.
2298 ;; Called from functions compiled with edebug-eval-top-level-form.
2299 ;; Return the before index.
2302 ;; Increment frequency count
2309 before-index)
2312 ;; Do nothing.
2313 )
2317 value
2318 ;; Debug current function given AFTER position and VALUE.
2319 ;; Called from functions compiled with edebug-eval-top-level-form.
2320 ;; Return VALUE.
2323 ;; Increment frequency count
2330 ;; Just return result.
2331 value
2333 )))
2336 ;; Do nothing but return the value.
2337 value)
2343 ;; This is not used, yet.
2357 ;; Test if a different result.
2362 ;; Dynamically declared unbound variables.
2375 ;; Don't really try to enter edebug within an eval from redisplay.
2376 value
2377 ;; Check breakpoints and pending input.
2378 ;; If edebug display should be updated, call edebug--display.
2379 ;; Return value.
2392 ;;(edebug-trace "exp: %s" value)
2393 ;; Test whether we should break.
2402 ;; Delete the breakpoint.
2407 ;; Display if mode is not go, continue, or Continue-fast
2408 ;; or break, or input is pending,
2410 edebug-break
2414 value)))
2417 ;; window-start now stored with each function.
2418 ;;(defvar edebug-window-start nil)
2419 ;; Remember where each buffers' window starts between edebug calls.
2420 ;; This is to avoid spurious recentering.
2421 ;; Does this still need to be buffer-local??
2422 ;;(setq-default edebug-window-start nil)
2423 ;;(make-variable-buffer-local 'edebug-window-start)
2426 ;; Dynamically declared unbound vars
2440 ;; Emacs 19 adds an arg to mark and mark-marker.
2444 ;; edebug--display-1 is too big, we should split it. This function
2445 ;; here was just introduced to avoid making edebug--display-1
2446 ;; yet a bit deeper.
2451 ;; The buffer holding the source has been killed.
2452 ;; Let's at least show a backtrace so the user can figure out
2453 ;; which function we're talking about.
2455 ;; Setup windows for edebug, determine mode, maybe enter recursive-edit.
2456 ;; Uses local variables of edebug-enter, edebug-before, edebug-after
2457 ;; and edebug-debugger.
2460 edebug-stop ; Should we enter recursive-edit?
2463 edebug-buffer-outside-point ; current point in edebug-buffer
2464 ;; window displaying edebug-buffer
2470 edebug-outside-windows ; Window or screen configuration.
2471 edebug-buffer-points
2473 edebug-eval-buffer ; Declared here so we can kill it below.
2476 edebug-trace-window
2477 edebug-trace-window-start
2484 ;; any others??
2485 )
2491 ;; Compute result string now before windows are modified.
2495 ;; Save windows now before we modify them.
2502 ;; First move the edebug buffer point to edebug-point
2503 ;; so that window start doesn't get changed when we display it.
2504 ;; I don't know if this is going to help.
2505 ;;(set-buffer edebug-buffer)
2506 ;;(goto-char edebug-point)
2508 ;; If edebug-buffer is not currently displayed,
2509 ;; first find a window for it.
2513 ;; Now display eval list, if any.
2514 ;; This is done after the pop to edebug-buffer
2515 ;; so that buffer-window correspondence is correct after quitting.
2517 ;; The evaluation list better not have deleted edebug-window-data.
2525 ;; Check whether positions are up-to-date.
2526 ;; This assumes point is never before symbol.
2529 edebug-function)
2530 ))
2532 ;; Make sure we bind those in the right buffer (bug#16410).
2535 ;; Now display arrow based on mode.
2540 ;; Display error message
2551 edebug-global-break-condition
2552 edebug-global-break-result))
2555 edebug-break-condition
2556 edebug-break-result))
2565 ;; Display result of previous evaluation.
2567 edebug-sit-on-break
2579 ;; not edebug-break
2598 ;; Reset the edebug-window-data to whatever it is now.
2602 ;; Remember window-start for edebug-buffer, if still displayed.
2608 ;; Save trace window point before restoring outside windows.
2609 ;; Could generalize this for other buffers.
2617 ;; Restore windows before continuing.
2622 ;; Restore displayed buffer points.
2623 ;; Needed even if restoring windows because
2624 ;; window-points are not restored. (should they be??)
2628 ;; Unrestore trace window's window-point.
2631 edebug-trace-window-start))
2633 ;; Unrestore edebug-buffer's window-start, if displayed.
2640 ;; Unrestore edebug-buffer's window-point.
2641 ;; Needed in addition to setting the buffer point
2642 ;; - otherwise quitting doesn't leave point as is.
2643 ;; But can this causes point to not be restored.
2644 ;; Also, it may not be a visible window.
2645 ;; (set-window-point window edebug-point)
2646 )))
2648 ;; Unrestore edebug-buffer's point. Rerestored below.
2649 ;; (goto-char edebug-point) ;; in edebug-buffer
2650 )
2651 ;; Since we may be in a save-excursion, in case of quit,
2652 ;; reselect the outside window only.
2653 ;; Only needed if we are not recovering windows??
2658 ;; Restore current buffer always, in case application needs it.
2661 ;; Restore point, and mark.
2662 ;; Needed even if restoring windows because
2663 ;; that doesn't restore point and mark in the current buffer.
2664 ;; But don't restore point if edebug-buffer is current buffer.
2668 ;; Does zmacs-regions need to be nil while doing set-marker?
2671 ;; None of the following is done if quit or signal occurs.
2673 ;; Restore edebug-buffer's outside point.
2674 ;; (edebug-trace "restore edebug-buffer point: %s"
2675 ;; edebug-buffer-outside-point)
2678 ;; ... nothing more.
2679 )
2680 ;; Could be an option to keep eval display up.
2683 ;; Reset global variables to outside values in case they were changed.
2685 )))
2689 ;; Number of recursive edits started by edebug.
2690 ;; Should be 0 at the top level.
2693 ;; Value of recursion-depth when edebug was called.
2695 ;; Dynamically declared unbound vars
2702 ;; Start up a recursive edit inside of edebug.
2703 ;; The current buffer is the edebug-buffer, which is put into edebug-mode.
2704 ;; Assume that none of the variables below are buffer-local.
2710 ;;(edebug-number-of-recursions (1+ edebug-number-of-recursions))
2712 edebug-entered ; bind locally to nil
2714 edebug-backtrace-buffer ; each recursive edit gets its own
2715 ;; The window configuration may be saved and restored
2716 ;; during a recursive-edit
2717 edebug-inside-windows
2718 )
2722 ;; Declare global values local but using the same global value.
2723 ;; We could set these to the values for previous edebug call.
2728 ;; More for Emacs 19
2738 ;; Don't keep reading from an executing kbd macro
2739 ;; within edebug unless edebug-continue-kbd-macro is
2740 ;; non-nil. Again, local binding may not be best.
2744 ;; Don't get confused by the user's keymap changes.
2748 ;; Bind again to outside values.
2752 ;; Don't keep defining a kbd macro.
2756 ;; others??
2757 )
2769 ;; Do the following, even if quit occurs.
2774 ;; Remember selected-window after recursive-edit.
2775 ;; (setq edebug-inside-window (selected-window))
2779 ;; Recursive edit may have changed buffers,
2780 ;; so set it back before exiting let.
2788 ;; gotta have a buffer to let its buffer local variables be set
2791 )))
2794 ;;; Display related functions
2805 )
2809 ;; Set up the overlay arrow at beginning-of-line in current buffer.
2810 ;; The arrow string is derived from edebug-arrow-alist and
2811 ;; edebug-execution-mode.
2820 "Toggle the saving and restoring of all windows.
2821 Also, each time you toggle it on, the inside and outside window
2822 configurations become the same as the current configuration."
2829 edebug-save-windows))))
2839 edebug-save-windows))
2840 ;; Problem: what about outside windows that are deleted inside?
2844 "Toggle the saving and restoring of the selected window.
2845 Also, each time you toggle it on, the inside and outside window
2846 configurations become the same as the current configuration."
2850 ;; Save all outside windows except the selected one.
2851 ;; Remove (selected-window) from outside-windows.
2858 edebug-outside-windows))
2871 "Toggle the saving and restoring of windows.
2872 With prefix, toggle for just the selected window.
2873 Otherwise, toggle for all windows."
2880 "Show the debug windows and where we stopped in the program."
2884 ;; Restore the window configuration to what it last was inside.
2885 ;; But it is not always set. - experiment
2886 ;;(if edebug-inside-windows
2887 ;; (edebug-set-windows edebug-inside-windows))
2892 "Change to the outside window configuration.
2893 Use `edebug-where' to return."
2906 "Bounce the point in the outside current buffer.
2907 If prefix argument ARG is supplied, sit for that many seconds
2908 before returning. The default is one second."
2913 ;; If the buffer's currently displayed, avoid set-window-configuration.
2925 ;; Joe Wells, here is a start at your idea of adding a buffer to the internal
2926 ;; display list. Still need to use this list in edebug--display.
2932 "Toggle display of a buffer inside of edebug."
2942 ;;; Breakpoint related functions
2945 ;; Return (function . index) of the nearest edebug stop point.
2952 ;; pull out parts of edebug-data.
2954 ;; (edebug-breakpoints (car (cdr edebug-data)))
2959 ;; skip backwards until non-whitespace, or bol
2962 edebug-def-mark))
2963 len i)
2964 ;; the offsets are in order so we can do a linear search
2971 ;; return the relevant info
2974 edebug-def-name)
2975 )))
2979 "Move point to the next breakpoint, or first if none past point."
2987 ;; pull out parts of edebug-data
2991 breakpoint)
3001 ;; goto the first breakpoint
3014 ))))))
3018 "Modify the breakpoint for the form at point or after it.
3019 Set it if FLAG is non-nil, clear it otherwise. Then move to that point.
3020 If CONDITION or TEMPORARY are non-nil, add those attributes to
3021 the breakpoint."
3028 ;; pull out parts of edebug-data
3032 present)
3033 ;; delete it either way
3038 ;; add it to the list and resort
3043 edebug-breakpoints) '<))
3046 edebug-def-name condition)
3054 ))))
3057 "Set the breakpoint of nearest sexp.
3058 With prefix argument, make it a temporary breakpoint."
3063 "Clear the breakpoint of nearest sexp."
3069 "Set `edebug-global-break-condition' to EXPRESSION."
3075 "Global Condition: " initial read-expression-map t
3082 ;;; Mode switching functions
3085 ;; Set the edebug mode to MODE.
3086 ;; Display SHORTMSG, or MSG if not within edebug.
3091 ;; Continue execution
3093 ;; This is not terribly useful!!
3101 "Proceed to next stop point."
3106 "Proceed to next `after' stop point."
3111 "Go, evaluating until break.
3112 With prefix ARG, set temporary break at current point and go."
3119 "Go, evaluating without debugging.
3120 You can use `edebug-stop', or any editing command, to stop."
3127 "Begin trace mode.
3128 Pauses for `edebug-sit-for-seconds' at each stop point."
3133 "Trace with no wait at each step.
3134 Updates the display at each stop point, but does not pause."
3140 "Begin continue mode.
3141 Pauses for `edebug-sit-for-seconds' at each break point."
3147 "Trace with no wait at each step.
3148 Updates the display at each break point, but does not pause."
3153 ;; ------------------------------------------------------------
3154 ;; The following use the mode changing commands and breakpoints.
3158 "Proceed to first stop-point at or after current position of point."
3164 "Stop execution and do not continue.
3165 Useful for exiting from trace or continue loop."
3171 "Proceed to the exit of the next expression to be evaluated."
3179 "Proceed from the current point to the end of the ARGth sexp ahead.
3180 If there are not ARG sexps ahead, then do `edebug-step-out'."
3184 ;; Call forward-sexp repeatedly until done or failure.
3189 )))
3192 "Proceed from the current point to the end of the containing sexp.
3193 If there is no containing sexp that is not the top level defun,
3194 go to the end of the last sexp, or if that is the same point, then step."
3200 ;; Is there still a containing expression?
3204 ;; At top level - 1, so first check if there are more sexps at this level.
3206 ;; (up-list 1)
3211 )))))
3214 "Instrument the function or generic method FUNC.
3215 Return the list of function symbols which were instrumented.
3216 This may be simply (FUNC) for a normal function, or a list of
3217 generated symbols for methods. If a function or method to
3218 instrument cannot be found, signal an error."
3223 symbols)
3234 symbols))
3236 ;; It is uninstrumented, so instrument it.
3254 "Instrument the definition of the function or macro about to be called.
3255 Do this when stopped before the form or it will be too late.
3256 One side effect of using this command is that the next time the
3257 function or macro is called, Edebug will be called there as well.
3258 If the callee is a generic function, Edebug will instrument all
3259 the methods, not just the one which is about to be called. Return
3260 the list of symbols which were instrumented."
3275 "Step into the definition of the function, macro or method about to be called.
3276 This first does `edebug-instrument-callee' to ensure that it is
3277 instrumented. Then it does `edebug-on-entry' and switches to `go' mode."
3286 "Cause Edebug to stop when FUNCTION is called.
3287 With prefix argument, make this temporary so it is automatically
3288 canceled the first time the function is entered."
3290 ;; Could store this in the edebug data instead.
3299 ;; Also need edebug-cancel-debug-on-entry
3302 "If the function is instrumented for Edebug, call `edebug-on-entry'."
3310 "Set mode to Go-nonstop, and exit to top-level.
3311 This is useful for exiting even if `unwind-protect' code may be executed."
3316 ;;(defun edebug-exit-out ()
3317 ;; "Go until the current function exits."
3318 ;; (interactive)
3319 ;; (edebug-set-mode 'exiting "Exit..."))
3335 "Set the initial execution mode of Edebug.
3336 The mode is requested via the key that would be used to set the mode in
3337 edebug-mode."
3342 "Change initial edebug mode from %s (%c) to (enter key): "
3343 old-mode
3349 edebug-initial-mode-alist))))
3356 ;;; Evaluation of expressions
3359 "Evaluate an expression list in the outside context.
3360 Return the result of the last expression."
3361 ;; Only restores the non-variables context since all the variables let-bound
3362 ;; by Edebug will be properly reset to the appropriate context's value by
3363 ;; backtrace-eval.
3368 ;; After excursion, we will
3369 ;; restore to current window configuration.
3372 ;; Restore outside windows.
3377 ;; Restore outside context.
3380 ;; FIXME: This restoring of edebug-outside-buffer and
3381 ;; edebug-outside-point is redundant now that backtrace-eval does it
3382 ;; for us.
3389 ;; Back to edebug-buffer. Restore rest of inside context.
3390 ;; (use-local-map edebug-inside-map)
3392 ;; Restore inside windows.
3395 ;; Save values that may have been changed.
3399 ;; Restore the outside saved values; don't alter
3400 ;; the outside binding loci.
3407 ;; Evaluate EXPR safely.
3408 ;; If there is an error, a string is returned describing the error.
3415 ;;; Printing
3419 ;; Print an error message like command level does.
3420 ;; This also prints the error name if it has no error-message.
3425 ;; continuing after an error may
3426 ;; complain about edebug-arg. why??
3431 ;; Alternatively, we could change the definition of
3432 ;; edebug-safe-prin1-to-string to only use these if defined.
3452 "Print the previous result."
3456 ;;; Read, Eval and Print
3463 "Evaluate an expression in the outside environment.
3464 If interactive, prompt for the expression.
3465 Print result in minibuffer."
3467 "Eval: " nil read-expression-map t
3476 "Evaluate sexp before point in the outside environment.
3477 Print value in minibuffer."
3482 "Evaluate sexp before point in outside environment; insert value.
3483 This prints the value into current buffer."
3491 ;; princ the string to get rid of quotes.
3494 ))
3496 ;;; Edebug Minor Mode
3499 "If non-nil, inhibit Edebug bindings on the C-x C-a key.
3500 By default, loading the `edebug' library causes these bindings to
3506 ;; Global GUD bindings for all emacs-lisp-mode buffers.
3512 ;; The following isn't a GUD binding.
3517 ;; control
3527 ;;(define-key map "f" 'edebug-forward) not implemented
3535 ;; quitting and stopping
3541 ;; breakpoints
3548 ;; evaluation
3554 ;; views
3561 ;; misc
3567 ;; statistics
3570 ;; GUD bindings
3580 map))
3582 ;; Autoloading these global bindings doesn't make sense because
3583 ;; they cannot be used anyway unless Edebug is already loaded and active.
3599 ;; breakpoints
3605 ;; views
3609 ;; quitting
3614 ;; statistics
3616 map)
3624 "Describe `edebug-mode'."
3631 "Mode for Emacs Lisp buffers while in Edebug.
3633 In addition to all Emacs Lisp commands (except those that modify the
3634 buffer) there are local and global key bindings to several Edebug
3638 Also see bindings for the eval list buffer *edebug* in `edebug-eval-mode'.
3640 The edebug buffer commands:
3643 Global commands prefixed by `global-edebug-prefix':
3646 Options:
3647 `edebug-setup-hook'
3648 `edebug-all-defs'
3649 `edebug-all-forms'
3650 `edebug-save-windows'
3651 `edebug-save-displayed-buffer-points'
3652 `edebug-initial-mode'
3653 `edebug-trace'
3654 `edebug-test-coverage'
3655 `edebug-continue-kbd-macro'
3656 `edebug-print-length'
3657 `edebug-print-level'
3658 `edebug-print-circle'
3659 `edebug-on-error'
3660 `edebug-on-quit'
3661 `edebug-on-signal'
3662 `edebug-unwrap-results'
3663 `edebug-global-break-condition'"
3665 :keymap edebug-mode-map
3666 ;; If the user kills the buffer in which edebug is currently active,
3667 ;; exit to top level, because the edebug command loop can't usefully
3668 ;; continue running in such a case.
3669 ;;
3681 edebug--mode-saved-vars)
3683 ;; Append `edebug-kill-buffer' to the hook to avoid interfering with
3684 ;; other entries that are unguarded against deleted buffer.
3688 "Used on `kill-buffer-hook' when Edebug is operating in a buffer of Lisp code."
3691 ;;; edebug eval list mode
3693 ;; A list of expressions and their evaluations is displayed in *edebug*.
3696 "Return a list of evaluations of `edebug-eval-list'."
3697 ;; Assumes in outside environment.
3698 ;; Don't do any edebug things now.
3704 ;; Assumes edebug-eval-buffer exists.
3715 ))
3722 ;; Should generalize this to be callable outside of edebug
3723 ;; with calls in user functions, e.g. (edebug-eval-display)
3726 "Display expressions and evaluations in EVAL-RESULT-LIST.
3727 It modifies the context by popping up the eval display."
3733 "Redisplay eval list in outside environment.
3734 May only be called from within `edebug--recursive-edit'."
3738 ))
3748 "Replace the evaluation list with the sexps now in the eval buffer."
3751 new-list)
3753 ;; get the first expression
3775 "Delete the item under point and redisplay."
3776 ;; could add arg to do repeatedly
3796 map)
3802 "Mode for evaluation list buffer while in Edebug.
3804 In addition to all Interactive Emacs Lisp commands there are local and
3805 global key bindings to several Edebug specific commands. E.g.
3809 Eval list buffer commands:
3812 Global commands prefixed by `global-edebug-prefix':
3815 ;;; Interface with standard debugger.
3817 ;; (setq debugger 'edebug) ; to use the edebug debugger
3818 ;; (setq debugger 'debug) ; use the standard debugger
3820 ;; Note that debug and its utilities must be byte-compiled to work,
3821 ;; since they depend on the backtrace looking a certain way. But
3822 ;; edebug is not dependent on this, yet.
3825 "Replacement for `debug'.
3826 If we are running an edebugged function, show where we last were.
3827 Otherwise call `debug' normally."
3828 ;;(message "entered: %s depth: %s edebug-recursion-depth: %s"
3829 ;; edebug-entered (recursion-depth) edebug-recursion-depth) (sit-for 1)
3835 ;; Bind variables required by edebug--display.
3836 edebug-breakpoints
3837 edebug-break-data
3838 edebug-break-condition
3839 edebug-global-break
3841 )
3844 nil
3845 value))
3847 ;; Otherwise call debug normally.
3848 ;; Still need to remove extraneous edebug calls from stack.
3850 ))
3854 "Display a non-working backtrace. Better than nothing..."
3860 ;; Else, could just display edebug-backtrace-buffer.
3861 )
3866 last-ok-point)
3869 ;; Clean up the backtrace.
3870 ;; Not quite right for current edebug scheme.
3877 ;; Delete interspersed edebug internals.
3882 ;; Previous lines may contain code, so just delete this line.
3888 "^ (edebug"
3892 )))
3893 )))))
3895 \f
3896 ;;; Trace display
3899 "In buffer BUF-NAME, display FMT and ARGS at the end and make it visible.
3900 The buffer is created if it does not exist.
3901 You must include newlines in FMT to break lines, but one newline is appended."
3902 ;; e.g.
3903 ;; (edebug-trace-display "*trace-point*"
3904 ;; "saving: point = %s window-start = %s"
3905 ;; (point) (window-start))
3909 buf-window)
3910 ;; (message "before pop-to-buffer") (sit-for 1)
3916 ;; Make it visible.
3920 ;; (set-window-point buf-window (point))
3921 ;; (sit-for 0)
3925 buf-name)
3929 "Convenience call to `edebug-trace-display' using `edebug-trace-buffer'."
3932 \f
3933 ;;; Frequency count and coverage
3935 ;; FIXME should this use overlays instead?
3936 ;; Definitely, IMO. The current business with undo in
3937 ;; edebug-temp-display-freq-count is horrid.
3939 "Display the frequency count data for each line of the current definition.
3940 The frequency counts are inserted as comment lines after each line,
3941 and you can undo all insertions with one `undo' command.
3943 The counts are inserted starting under the `(' before an expression
3944 or the `)' after an expression, or on the last char of a symbol.
3945 The counts are only displayed when they differ from previous counts on
3946 the same line.
3948 If coverage is being tested, whenever all known results of an expression
3949 are `eq', the char `=' will be appended after the count
3950 for that expression. Note that this is always the case for an
3951 expression only evaluated once.
3953 To clear the frequency count and coverage data for a definition,
3954 reinstrument it."
3968 )
3970 ;; Traverse in reverse order so offsets are correct.
3972 ;; Start at last expression in line.
3976 last-index i)
3978 ;; Find all indexes on same line.
3981 ;; Insert all the indices for this line.
3984 first-index i ; Really, last index for line above this one.
3987 ;; i == first-index still
4007 ;; FIXME this does not work very well. Eg if you press an arrow key,
4008 ;; or make a mouse-click, it fails with "Non-character input-event".
4010 "Temporarily display the frequency count data for the current definition.
4011 It is removed when you hit any char."
4012 ;; This seems not to work with Emacs 18.59. It undoes too far.
4019 ;; Yuck! This doesn't seem to work at all for me.
4022 \f
4023 ;;; Menus
4029 ;; We have to require easymenu (even for Emacs 18) just so
4030 ;; the easy-menu-define macro call is compiled correctly.
4044 "----"
4049 "----"
4081 "----"
4091 ))
4094 \f
4095 ;;; Emacs version specific code
4103 "Set a conditional breakpoint at nearest sexp.
4104 The condition is evaluated in the outside context.
4105 With prefix argument, make it a temporary breakpoint."
4106 ;; (interactive "P\nxCondition: ")
4109 current-prefix-arg
4110 ;; Read condition as follows; getting previous condition is cumbersome:
4122 "Condition: " initial read-expression-map t
4129 \f
4130 ;;; Autoloading of Edebug accessories
4132 ;; edebug-cl-read and cl-read are available from liberte@cs.uiuc.edu
4138 ;; The following causes edebug-cl-read to be loaded when you load cl-read.el.
4141 \f
4142 ;;; Finalize Loading
4144 ;; When edebugging a function, some of the sub-expressions are
4145 ;; wrapped in (edebug-enter (lambda () ..)), so we need to teach
4146 ;; called-interactively-p that calls within the inner lambda should refer to
4147 ;; the outside function.
4154 ;; `edebug-enter' calls itself on its first invocation.
4159 ;; Finally, hook edebug into the rest of Emacs.
4160 ;; There are probably some other things that could go here.
4162 ;; Install edebug read and eval functions.
4166 "Unload the Edebug source level debugger."
4171 ;; We still want to run unload-feature to completion
4177 ;; Continue standard unloading.
4178 nil)
4181 ;;; edebug.el ends here