| blob | aa56f292c54754f60f9dac66a23e9b4276fbb87a |
1 ;;; edebug.el --- a source-level debugger for Emacs Lisp
3 ;; Copyright (C) 1988,'89,'90,'91,'92,'93,'94,'95 Free Software Foundation, Inc
5 ;; Author: Daniel LaLiberte <liberte@cs.uiuc.edu>
6 ;; Keywords: lisp, tools, maint
8 ;; LCD Archive Entry:
9 ;; edebug|Daniel LaLiberte|liberte@cs.uiuc.edu
10 ;; |A source level debugger for Emacs Lisp.
11 ;; |$Date: 1996/05/29 17:16:52 $|$Revision: 3.7 $|~/modes/edebug.el|
13 ;; This file is part of GNU Emacs.
15 ;; GNU Emacs is free software; you can redistribute it and/or modify
16 ;; it under the terms of the GNU General Public License as published by
17 ;; the Free Software Foundation; either version 2, or (at your option)
18 ;; any later version.
20 ;; GNU Emacs is distributed in the hope that it will be useful,
21 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
22 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 ;; GNU General Public License for more details.
25 ;; You should have received a copy of the GNU General Public License
26 ;; along with GNU Emacs; see the file COPYING. If not, write to the
27 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
28 ;; Boston, MA 02111-1307, USA.
30 ;;; Commentary:
32 ;; This minor mode allows programmers to step through Emacs Lisp
33 ;; source code while executing functions. You can also set
34 ;; breakpoints, trace (stopping at each expression), evaluate
35 ;; expressions as if outside Edebug, reevaluate and display a list of
36 ;; expressions, trap errors normally caught by debug, and display a
37 ;; debug style backtrace.
39 ;;; Installation
40 ;; =============
42 ;; Put edebug.el in some directory in your load-path and
43 ;; byte-compile it. Also read the beginning of edebug-epoch.el,
44 ;; cl-specs.el, and edebug-cl-read.el if they apply to you.
46 ;; Unless you are using Emacs 19 which is already set up to use Edebug,
47 ;; put the following forms in your .emacs file.
48 ;; (define-key emacs-lisp-mode-map "\C-xx" 'edebug-eval-top-level-form)
49 ;; (autoload 'edebug-eval-top-level-form "edebug")
51 ;; If you wish to change the default edebug global command prefix, change:
52 ;; (setq edebug-global-prefix "\C-xX")
54 ;; Other options, are described in the manual.
56 ;; In previous versions of Edebug, users were directed to set
57 ;; `debugger' to `edebug-debug'. This is no longer necessary
58 ;; since Edebug automatically sets it whenever Edebug is active.
60 ;;; Minimal Instructions
61 ;; =====================
63 ;; First evaluate a defun with C-xx, then run the function. Step
64 ;; through the code with SPC, mark breakpoints with b, go until a
65 ;; breakpoint is reached with g, and quit execution with q. Use the
66 ;; "?" command in edebug to describe other commands. See edebug.tex
67 ;; or the Emacs 19 Lisp Reference Manual for more instructions.
69 ;; Send me your enhancements, ideas, bugs, or fixes.
70 ;; For bugs, you can call edebug-submit-bug-report if you have reporter.el.
71 ;; There is an edebug mailing list if you want to keep up
72 ;; with the latest developments. Requests to: edebug-request@cs.uiuc.edu
74 ;; Daniel LaLiberte 217-398-4114
75 ;; University of Illinois, Urbana-Champaign
76 ;; Department of Computer Science
77 ;; 1304 W Springfield
78 ;; Urbana, IL 61801
80 ;; uiucdcs!liberte
81 ;; liberte@cs.uiuc.edu
83 ;; For the early revision history, see edebug-history.
85 ;;; Code:
94 ;; Emacs 18 doesn't have defalias.
99 ;;; Bug reporting
104 "Submit, via mail, a bug report on edebug."
109 edebug-maintainer-address
112 'edebug-all-defs
113 'edebug-all-forms
114 'edebug-eval-macro-args
115 'edebug-stop-before-symbols
116 'edebug-save-windows
117 'edebug-save-displayed-buffer-points
118 'edebug-initial-mode
119 'edebug-trace
120 'edebug-test-coverage
121 'edebug-continue-kbd-macro
122 'edebug-print-length
123 'edebug-print-level
124 'edebug-print-circle
125 ))))
127 ;;; Options
130 "*Functions to call before edebug is used.
131 Each time it is set to a new value, Edebug will call those functions
132 once and then `edebug-setup-hook' is reset to nil. You could use this
133 to load up Edebug specifications associated with a package you are
137 "*If non-nil, evaluation of any defining forms will instrument for Edebug.
138 This applies to `eval-defun', `eval-region', `eval-buffer', and
139 `eval-current-buffer'. `eval-region' is also called by
140 `eval-last-sexp', and `eval-print-last-sexp'.
142 You can use the command `edebug-all-defs' to toggle the value of this
143 variable. You may wish to make it local to each buffer with
144 \(make-local-variable 'edebug-all-defs) in your
148 "*Non-nil evaluation of all forms will instrument for Edebug.
149 This doesn't apply to loading or evaluations in the minibuffer.
153 "*Non-nil means all macro call arguments may be evaluated.
154 If this variable is nil, the default, Edebug will *not* wrap
155 macro call arguments as if they will be evaluated.
156 For each macro, a `edebug-form-spec' overrides this option.
157 So to specify exceptions for macros that have some arguments evaluated
158 and some not, you should specify an `edebug-form-spec'.
163 "*Non-nil causes Edebug to stop before symbols as well as after.
164 In any case, a breakpoint or interrupt may stop before a symbol.
169 "*If non-nil, Edebug saves and restores the window configuration.
170 That takes some time, so if your program does not care what happens to
171 the window configurations, it is better to set this variable to nil.
173 If the value is a list, only the listed windows are saved and
174 restored.
179 "*If non-nil, save and restore point in all displayed buffers.
181 Saving and restoring point in other buffers is necessary if you are
182 debugging code that changes the point of a buffer which is displayed
183 in a non-selected window. If Edebug or the user then selects the
184 window, the buffer's point will be changed to the window's point.
186 Saving and restoring point in all buffers is expensive, since it
187 requires selecting each window twice, so enable this only if you need
191 "*Initial execution mode for Edebug, if non-nil. If this variable
192 is non-@code{nil}, it specifies the initial execution mode for Edebug
193 when it is first activated. Possible values are step, next, go,
197 "*Non-nil means display a trace of function entry and exit.
198 Tracing output is displayed in a buffer named `*edebug-trace*', one
199 function entry or exit per line, indented by the recursion level.
201 You can customize by replacing functions `edebug-print-trace-before'
205 "*If non-nil, Edebug tests coverage of all expressions debugged.
206 This is done by comparing the result of each expression
207 with the previous result. Coverage is considered OK if two different
208 results are found.
210 Use `edebug-display-freq-count' to display the frequency count and
214 "*If non-nil, continue defining or executing any keyboard macro.
226 "*Non-nil if Edebug should unwrap results of expressions.
227 This is useful when debugging macros where the results of expressions
228 are instrumented expressions. But don't do this when results might be
232 "*Value bound to `debug-on-error' while Edebug is active.
234 If `debug-on-error' is non-nil, that value is still used.
236 If the value is a list of signal names, Edebug will stop when any of
237 these errors are signaled from Lisp code whether or not the signal is
238 handled by a `condition-case'. This option is useful for debugging
239 signals that *are* handled since they would otherwise be missed.
246 "*If non-nil, an expression to test for at every stop point.
249 ;;; Form spec utilities.
251 ;;;###autoload
253 "Set the edebug-form-spec property of SYMBOL according to SPEC.
254 Both SYMBOL and SPEC are unevaluated. The SPEC can be 0, t, a symbol
255 \(naming a function), or a list."
259 "For compatibility with old version. Use `def-edebug-spec' instead."
264 ;; Get the spec of symbol resolving all indirection.
266 indirect)
269 ;; (edebug-trace "indirection: %s" edebug-form-spec)
271 edebug-form-spec
272 ))
274 ;;; Utilities
276 ;; Define edebug-gensym - from old cl.el
281 "Generate a fresh uninterned symbol.
282 There is an optional argument, PREFIX. PREFIX is the
283 string that begins the new name. Most people take just the default,
284 except when debugging needs suggest otherwise."
294 newsymbol))
296 ;; Only used by CL-like code.
298 "Return t if OBJECT is a keyword.
299 A keyword is a symbol that starts with `:'."
304 "Return t if OBJECT is a lambda list keyword.
305 A lambda list keyword is a symbol that starts with `&'."
311 ;; Return the last sexp before point in current buffer.
312 ;; Assumes Emacs Lisp syntax is active.
322 "Return a list of windows, in order of `next-window'."
323 ;; This doesn't work for epoch.
333 "Return non-nil if WINDOW is visible."
341 ;; Not used.
343 "Return t if there are two windows."
351 object)
354 "Return the macro named by OBJECT, or nil if it is not a macro."
359 object))
362 "Returns the function named by OBJECT, or nil if it is not a function."
369 object))
372 ;; Return the ALIST sorted with comparison function FUNCTION.
373 ;; This uses 'sort so the sorting is destructive.
378 ;;(def-edebug-spec edebug-save-restriction t)
380 ;; Not used. If it is used, def-edebug-spec must be defined before use.
382 "Evaluate BODY while saving the current buffers restriction.
383 BODY may change buffer outside of current restriction, unlike
384 save-restriction. BODY may change the current buffer,
385 and the restriction will be restored to the original buffer,
386 and the current buffer remains current.
387 Return the result of the last expression in BODY."
396 ;;; Display
402 ;; Like pop-to-buffer, but select window where BUFFER was last shown.
403 ;; Select WINDOW if it provided and it still exists. Otherwise,
404 ;; if buffer is currently shown in several windows, choose one.
405 ;; Otherwise, find a new window, possibly splitting one.
408 window
416 ;; (message "next window: %s" (next-window)) (sit-for 1)
418 ;; Don't select trace window
419 nil
423 ;; Selecting the window does not set the buffer until command loop.
424 ;;(set-buffer buffer)
425 )
429 ;; Return a list of buffer point pairs, for all displayed buffers.
434 buffer)
440 buffer-point-list)))
444 ;; Restore the buffer-points created by edebug-get-displayed-buffer-points.
451 buffer-points)
455 ;; Get either a full window configuration or some window information.
464 which-windows)
468 ;; Set either a full window configuration or some window information.
481 one-window-info))))
482 window-info)
490 ;;; Redefine read and eval functions
491 ;; read is redefined to maybe instrument forms.
492 ;; eval-defun is redefined to check edebug-all-forms and edebug-all-defs.
494 ;; Use the Lisp version of eval-region.
497 ;; Save the original read function
502 "Read one Lisp expression as text from STREAM, return as Lisp object.
503 If STREAM is nil, use the value of `standard-input' (which see).
504 STREAM or the value of `standard-input' may be:
505 a buffer (read from point and advance it)
506 a marker (read from where it points and advance it)
507 a function (call it with no arguments for each character,
508 call it with a char as argument to push a char back)
509 a string (takes text from string, starting at the beginning)
510 t (read text line using minibuffer and use it).
512 This version, from Edebug, maybe instruments the expression. But the
513 STREAM must be the current buffer to do so. Whether it instruments is
514 also dependent on the values of `edebug-all-defs' and
515 `edebug-all-forms'."
524 ;; We should somehow arrange to be able to do this
525 ;; without actually replacing the eval-defun command.
527 "Evaluate the top-level form containing point, or after point.
529 This version, from Edebug, has the following differences: With a
530 prefix argument instrument the code for Edebug. If `edebug-all-defs' is
531 non-nil, then the code is instrumented *unless* there is a prefix
532 argument. If instrumenting, it prints: `Edebug: FUNCTIONNAME'.
533 Otherwise, it prints in the minibuffer."
547 edebug-result)))
550 ;;;###autoload
553 ;;;###autoload
555 "Evaluate a top level form, such as a defun or defmacro.
556 This is like `eval-defun', but the code is always instrumented for Edebug.
557 Print its name in the minibuffer and leave point where it is,
558 or if an error occurs, leave point after it with mark at the original point."
561 ;; Bind edebug-all-forms only while reading, not while evalling
562 ;; but this causes problems while edebugging edebug.
574 ;; Recover point, but only if no error occurred.
578 ;; Compatibility with old versions.
582 "Toggle edebugging of all definitions."
590 "Toggle edebugging of all forms."
599 ;; Don't install if already installed.
612 ;;; Edebug internal data
614 ;; The internal data that is needed for edebugging is kept in the
615 ;; buffer-local variable `edebug-form-data'.
620 ;; A list of entries associating symbols with buffer regions.
621 ;; This is an automatic buffer local variable. Each entry looks like:
622 ;; @code{(@var{symbol} @var{begin-marker} @var{end-marker}). The markers
623 ;; are at the beginning and end of an entry level form and @var{symbol} is
624 ;; a symbol that holds all edebug related information for the form on its
625 ;; property list.
627 ;; In the future, the symbol will be irrelevant and edebug data will
628 ;; be stored in the definitions themselves rather than in the property
629 ;; list of a symbol.
649 ;; Find the edebug form data entry which is closest to PNT.
650 ;; If END-POINT is supplied, match must be exact.
651 ;; Return `nil' if none found.
653 closest-entry
666 closest-entry entry))))
667 closest-entry))
669 ;; Also need to find all contained entries,
670 ;; and find an entry given a symbol, which should be just assq.
673 ;; Return the edebug data symbol of the form where point is in.
674 ;; If point is not inside a edebuggable form, cause error.
679 ;; Make NEW-ENTRY the first element in the `edebug-form-data' list.
684 ;; If non-nil, clear ENTRY out of the form data.
685 ;; Maybe clear the markers and delete the symbol's edebug property?
688 ;; Instead of this, we could just find all contained forms.
689 ;; (put (car entry) 'edebug nil) ;
690 ;; (mapcar 'edebug-clear-form-data-entry ; dangerous
691 ;; (get (car entry) 'edebug-dependents))
692 ;; (set-marker (nth 1 entry) nil)
693 ;; (set-marker (nth 2 entry) nil)
696 ;;; Parser utilities
699 ;; Signal an invalid-read-syntax with ARGS.
704 ;; Lookup table for significant characters indicating the class of the
705 ;; token that follows. This is not a \"real\" syntax table.
722 ;; We treat numbers as symbols, because of confusion with -, -1, and 1-.
723 ;; We don't care about any other chars since they won't be seen.
724 table))
727 ;; Move to the next token and return its class. We only care about
728 ;; lparen, rparen, dot, quote, backquote, comma, string, char, vector,
729 ;; or symbol.
735 ;; Leave point before the next token, skipping white space and comments.
738 ;; \r is counted as a comment terminator to support selective display.
743 ;; Mostly obsolete reader; still used in one case.
746 ;; Read one sexp from the current buffer starting at point.
747 ;; Leave point immediately after it. A sexp can be a list or atom.
748 ;; An atom is a symbol (or number), character, string, or vector.
749 ;; This works for reading anything legitimate, but it
750 ;; is gummed up by parser inconsistencies (bugs?)
753 ;; read goes one too far if a (possibly quoted) string or symbol
754 ;; is immediately followed by non-whitespace.
773 ;;; Offsets for reader
775 ;; Define a structure to represent offset positions of expressions.
776 ;; Each offset structure looks like: (before . after) for constituents,
777 ;; or for structures that have elements: (before <subexpressions> . after)
778 ;; where the <subexpressions> are the offset structures for subexpressions
779 ;; including the head of a list.
782 ;; Stack of offset structures in reverse order of the nesting.
783 ;; This is used to get back to previous levels.
787 ;; We must store whether we just read a list with a dotted form that
788 ;; is itself a list. This structure will be condensed, so the offsets
789 ;; must also be condensed.
793 ;; Reinitialize offset recording.
797 ;; Add a new offset pair with POINT as the before offset.
802 ;; Otherwise, we are at the top level, so initialize.
804 edebug-offsets-stack nil
805 edebug-read-dotted-list nil))
806 ;; Cons the new offset to the front of the stack.
808 edebug-current-offset new-offset)
809 ))
812 ;; Finalize the current offset struct by reversing it and
813 ;; store POINT as the after offset.
815 ;; Just reverse the offsets of all subexpressions.
818 ;; We just read a list after a dot, which will be abbreviated out.
820 ;; Drop the corresponding offset pair.
821 ;; That is, nconc the reverse of the rest of the offsets
822 ;; with the cdr of last offset.
827 ;; Now append the point using nconc.
829 ;; Pop the stack.
834 ;; Ignore the last created offset pair.
848 ;;; Reader for Emacs Lisp.
850 ;; Uses edebug-next-token-class (and edebug-skip-whitespace) above.
861 ))
865 func
870 ;; anything else, just read it.
872 )))
877 ;; loses for escaped chars
889 ;; Turn 'thing into (quote thing)
896 ;; Turn `thing into (\` thing)
899 ;; Generate the same structure of offsets we would have
900 ;; if the resulting list appeared verbatim in the input text.
907 "Non-nil if reading the inside of a new-style backquote with no parens around it.
908 Value of nil means reading the inside of an old-style backquote construct
909 which is surrounded by an extra set of parentheses.
913 ;; Turn ,thing into (\, thing). Handle ,@ and ,. also.
923 ;; Generate the same structure of offsets we would have
924 ;; if the resulting list appeared verbatim in the input text.
932 ;; Turn #'thing into (function thing)
952 ;; Call edebug-storing-offsets here so that we
953 ;; produce the same offsets we would have had
954 ;; if the backquote were an ordinary symbol.
956 elements))))
967 ))
968 elements)
970 ))
980 ))
982 ;;; Cursors for traversal of list and vector elements with offsets.
987 ;; Return a new cursor for EXPRESSIONS with OFFSETS.
993 ;; Set the CURSOR's EXPRESSIONS and OFFSETS to the given.
994 ;; Return the cursor.
997 cursor)
1000 ;; Copy the cursor using the same object and offsets.
1009 ;; Return non-nil if CURSOR is empty - meaning no more elements.
1013 ;; Return the top element at the cursor.
1014 ;; Assumes not empty.
1018 ;; Check if a dotted form is required.
1020 ;; Check if there is at least one more argument.
1022 ;; Return that top element.
1026 ;; Return the top offset pair corresponding to the top element.
1030 ;; Advance and return the cursor to the next element and offset.
1031 ;; throw no-match if empty before moving.
1032 ;; This is a violation of the cursor encapsulation, but
1033 ;; there is plenty of that going on while matching.
1034 ;; The following test should always fail.
1039 cursor)
1043 ;; Return the before offset of the cursor.
1044 ;; If there is nothing left in the offsets,
1045 ;; return one less than the offset itself,
1046 ;; which is the after offset for a list.
1053 ;; Return the after offset of the cursor object.
1057 offset))
1059 ;;; The Parser
1061 ;; The top level function for parsing forms is
1062 ;; edebug-read-and-maybe-wrap-form; it calls all the rest. It checks the
1063 ;; syntax a bit and leaves point at any error it finds, but otherwise
1064 ;; should appear to work like eval-defun.
1066 ;; The basic plan is to surround each expression with a call to
1067 ;; the edebug debugger together with indexes into a table of positions of
1068 ;; all expressions. Thus an expression "exp" becomes:
1070 ;; (edebug-after (edebug-before 1) 2 exp)
1072 ;; When this is evaluated, first point is moved to the beginning of
1073 ;; exp at offset 1 of the current function. The expression is
1074 ;; evaluated, which may cause more edebug calls, and then point is
1075 ;; moved to offset 2 after the end of exp.
1077 ;; The highest level expressions of the function are wrapped in a call to
1078 ;; edebug-enter, which supplies the function name and the actual
1079 ;; arguments to the function. See functions edebug-enter, edebug-before,
1080 ;; and edebug-after for more details.
1082 ;; Dynamically bound vars, left unbound, but globally declared.
1083 ;; This is to quiet the byte compiler.
1085 ;; Window data of the highest definition being wrapped.
1086 ;; This data is shared by all embedded definitions.
1101 ;; Read a form and wrap it with edebug calls, if the conditions are right.
1102 ;; Here we just catch any no-match not caught below and signal an error.
1104 ;; Run the setup hook.
1109 edebug-top-window-data
1110 edebug-def-name;; make sure it is locally nil
1111 ;; I don't like these here!!
1112 edebug-&optional
1113 edebug-&rest
1114 edebug-gate
1115 edebug-best-error
1116 edebug-error-point
1117 no-match
1118 ;; Do this once here instead of several times.
1124 nil))
1127 result))
1132 def-kind
1133 defining-form-p
1134 def-name
1135 ;; These offset things don't belong here, but to support recursive
1136 ;; calls to edebug-read, they need to be here.
1137 edebug-offsets
1138 edebug-offsets-stack
1139 edebug-current-offset ; reset to nil
1140 )
1144 ;; Find out if this is a defining form from first symbol
1149 ;; This is incorrect in general!! But OK most of the time.
1154 ;;;(message "all defs: %s all forms: %s" edebug-all-defs edebug-all-forms)
1158 ;; If it is a defining form and we are edebugging defs,
1159 ;; then let edebug-list-form start it.
1165 cursor
1170 ;; Not edebugging this form, so reset the symbol's edebug
1171 ;; property to be just a marker at the definition's source code.
1172 ;; This only works for defs with simple names.
1174 ;; Also nil out dependent defs.
1181 ;; If all forms are being edebugged, explicitly wrap it.
1187 cursor
1190 nil)))
1192 ;; Not a defining form, and not edebugging.
1194 ))
1200 ;; Currently def-form sets this to nil; def-body sets it to t.
1203 ;; Return a unique symbol for the variable used to store the
1204 ;; status of interactive-p for this function.
1209 "Wrap the FORMS of a definition body."
1218 ;; Generate the enter wrapper for some forms of a definition.
1219 ;; This is not to be used for the body of other forms, e.g. `while',
1220 ;; since it wraps the list of forms with a call to `edebug-enter'.
1221 ;; Uses the dynamically bound vars edebug-def-name and edebug-def-args.
1222 ;; Do this after parsing since that may find a name.
1229 ;; Doesn't work with more than one def-body!!
1230 ;; But the list will just be reversed.
1234 )))
1243 ;; modifies edebug-offset-index and edebug-offset-list
1244 ;; accesses edebug-func-marc and buffer point
1246 edebug-offset-index
1248 edebug-offset-list)
1253 ;; Return the edebug form for the current function at offset BEFORE-INDEX
1254 ;; given FORM. Looks like:
1255 ;; (edebug-after (edebug-before BEFORE-INDEX) AFTER-INDEX FORM)
1256 ;; Also increment the offset index for subsequent use.
1257 ;; if (not edebug-stop-before-symbols) and form is a symbol,
1258 ;; then don't call edebug-before.
1261 after-index form))
1264 ;; Like edebug-make-before-and-after-form, but only after.
1269 "Return the unwrapped SEXP or return it as is if it is not wrapped.
1270 The SEXP might be the result of wrapping a body, which is a list of
1271 expressions; a `progn' form will be returned enclosing these forms."
1282 )
1283 sexp))
1286 "Return the sexp recursively unwrapped."
1293 new-sexp)))
1297 ;; Process the defining form, starting outside the form.
1298 ;; The speclist is a generated list spec that looks like:
1299 ;; (("def-symbol" defining-form-spec-sans-&define))
1300 ;; Skip the first offset.
1304 cursor
1306 speclist))
1310 ;; Wrap a form, usually a defining form, but any evaluated one.
1311 ;; If speclist is non-nil, this is being called by edebug-defining-form.
1312 ;; Otherwise it is being called from edebug-read-and-maybe-wrap-form1.
1313 ;; This is a hack, but I havent figured out a simpler way yet.
1315 ;; Set this marker before parsing.
1319 ;; Buffer must be current-buffer for this to work:
1324 result
1325 ;; For definitions.
1326 ;; (edebug-containing-def-name edebug-def-name)
1327 ;; Get name from form-data, if any.
1329 edebug-def-name
1330 edebug-def-args
1331 edebug-def-interactive
1332 edebug-inside-func;; whether wrapped code executes inside a function.
1333 )
1339 ;; else wrap as an enter-form.
1342 ;; Set the name here if it was not set by edebug-make-enter-wrapper.
1346 ;; Add this def as a dependent of containing def. Buggy.
1354 ;; Create a form-data-entry or modify existing entry's markers.
1355 ;; In the latter case, pointers to the entry remain eq.
1359 edebug-def-name
1360 edebug-form-begin-marker
1361 ;; Buffer must be current-buffer.
1363 ))
1365 form-data-entry edebug-def-name ;; in case name is changed
1366 form-begin form-end))
1368 ;; (message "defining: %s" edebug-def-name) (sit-for 2)
1371 ;;(debug edebug-def-name)
1373 ;; Destructively reverse edebug-offset-list and make vector from it.
1376 ;; Side effects on the property list of edebug-def-name.
1380 ;; Set up the initial window data.
1388 ;; Store the edebug data in symbol's property list.
1390 ;; A struct or vector would be better here!!
1392 nil ; clear breakpoints
1393 edebug-offset-list
1394 edebug-top-window-data
1395 ))
1396 result
1397 )))
1401 ;; Create initial frequency count vector.
1402 ;; For each stop point, the counter is incremented each time it is visited.
1408 ;; Create initial coverage vector.
1409 ;; Only need one per expression, but it is simpler to use stop points.
1415 ;; Return the instrumented form for the following form.
1416 ;; Add the point offsets to the edebug-offset-list for the form.
1422 ;; The first offset for a list form is for the list form itself.
1424 form
1428 ;; Find out if this is a defining form from first symbol.
1429 ;; An indirect spec would not work here, yet.
1432 new-cursor
1436 ;; Wrap a regular form.
1440 ;; After processing the list form, the new-cursor is left
1441 ;; with the offset after the form.
1443 )))
1447 ;; Check for constant symbols that don't get wrapped.
1450 form)
1452 ;; This option may go away.
1456 form
1458 ))
1463 ;; Anything else is self-evaluating.
1472 ;; Process the arguments of a list form given that head of form is a symbol.
1473 ;; Helper for edebug-list-form
1479 ;; It is a speclist.
1486 ; but leave it in for compatibility.
1487 ))
1488 ;; No edebug-form-spec provided.
1498 ;; Return an instrumented form built from the list form.
1499 ;; The after offset will be left in the cursor after processing the form.
1501 ;; Prevent backtracking whenever instrumenting.
1503 ;; A list form is never optional because it matches anything.
1506 ;; Skip the first offset.
1517 ;; Special case: replace (interactive-p) with variable
1528 ;; Process anonymous function and args.
1529 ;; This assumes no anonymous macros.
1534 ))
1536 ;;; Matching of specs.
1544 ;;; Failure to match
1546 ;; This throws to no-match, if there are higher alternatives.
1547 ;; Otherwise it signals an error. The place of the error is found
1548 ;; with the two before- and after-offset functions.
1551 ;; Throw a no-match, or signal an error immediately if gate is active.
1552 ;; Remember this point in case we need to report this error.
1565 ;; Top level spec matching function.
1566 ;; Used also at each lower level of specs.
1568 edebug-&rest
1569 edebug-best-error
1570 edebug-error-point
1572 )
1577 ;; Match one spec, which is not a keyword &-spec.
1583 ))
1587 ;; Append results of matching the list of specs.
1588 ;; The first spec is handled and the remainder-handler handles the rest.
1596 ;; Is the spec dotted?
1601 ;; Is the form dotted?
1605 ;; Cancel dotted spec and dotted form.
1609 ;; Wrap the form in a list, (by changing the cursor??)...
1611 ;; and process normally, then unwrap the result.
1618 ;;(message "spec = %s first char = %s" spec first-char) (sit-for 1)
1632 ;; Define specs for all the symbol specs with functions used to process them.
1633 ;; Perhaps we shouldn't be doing this with edebug-form-specs since the
1634 ;; user may want to define macros or functions with the same names.
1635 ;; We could use an internal obarray for these primitive specs.
1652 ;; Less frequently used:
1653 ;; (function . edebug-match-function)
1659 ;; (nil . edebug-match-nil) not this one - special case it.
1660 ))
1663 ;; Match a symbol spec.
1668 ;; It is an indirect spec.
1670 ;; Otherwise it should be the symbol name of a function.
1671 ;; There could be a bug here - maybe need to do edebug-match bindings.
1679 ;; Special case for edebug-`.
1687 )))
1698 ;; Currently identical to edebug-match-form.
1699 ;; This is for common lisp setf-style place arguments.
1704 ;; Keep matching until one spec fails.
1716 ;; Returning nil means no no-match was thrown.
1717 nil))
1718 result
1719 ;; no-match, but don't fail; just reset cursor and return nil.
1721 nil)))
1726 ;; Reuse the &optional handler with this as the remainder handler.
1730 ;; Repeatedly use specs until failure.
1732 edebug-best-error
1733 edebug-error-point)
1738 ;; Keep matching until one spec succeeds, and return its results.
1739 ;; If none match, fail.
1740 ;; This needs to be optimized since most specs spend time here.
1749 edebug-best-error
1750 edebug-error-point)
1751 ;; Doesn't support e.g. &or symbolp &rest form
1753 ;; Match failed, so reset and try again.
1755 ;; Reset the cursor for the next match.
1757 ;; All failed.
1759 ))
1763 ;; If any specs match, then fail
1768 nil))
1769 ;; This means something matched, so it is a no match.
1771 ;; This means nothing matched, so it is OK.
1778 ;; Following specs must look like (<name> <spec>) ...
1779 ;; where <name> is the name of a keyword, and spec is its spec.
1780 ;; This really doesn't save much over the expanded form and takes time.
1782 cursor
1787 specs))))
1791 ;; Simply set the gate to prevent backtracking at this level.
1793 nil)
1797 ;; The spec is a list, but what kind of list, and what context?
1799 ;; After dotted spec but form did not contain dot,
1800 ;; so match list spec elements as if spliced in.
1804 ;; If it matched, really clear the dotted-spec flag.
1813 ;; Special case: spec quotes a symbol to match.
1814 ;; Change in future. Use "..." instead.
1819 form)
1826 ;; First offset is for the list form itself.
1827 ;; Treat nil as empty list.
1829 specs))
1833 ;; Special case: match a vector with the specs.
1842 )))
1846 ;; Match a sublist of specs.
1848 ;;edebug-best-error
1849 ;;edebug-error-point
1850 )
1852 ;; match with edebug-match-specs so edebug-best-error is not bound.
1857 ;; A failed &rest or &optional spec may leave some args.
1859 )))))
1866 ;; Since it matched, failure means immediate error, unless &optional.
1870 )))
1873 ;; There must be nothing left to match a nil.
1876 nil))
1883 ;; Match a defining form.
1884 ;; Normally, &define is interpreted specially other places.
1885 ;; This should only be called inside of a spec list to match the remainder
1886 ;; of the current list. e.g. ("lambda" &define args def-body)
1888 cursor
1890 ;; Find the last offset in the list.
1893 offsets)
1894 specs))
1897 ;; The expression must be a function.
1898 ;; This will match any list form that begins with a symbol
1899 ;; that has an edebug-form-spec beginning with &define. In
1900 ;; practice, only lambda expressions should be used.
1901 ;; I could add a &lambda specification to avoid confusion.
1908 ;; Find out if this is a defining form from first symbol.
1919 )))
1923 ;; Set the edebug-def-name bound in edebug-defining-form.
1925 ;; Maybe strings and numbers could be used.
1930 ;; Construct a new name by appending to previous name.
1932 name))
1937 ;; Set the edebug-def-name to the spec.
1940 ;; Construct a new name by appending to previous name.
1942 spec))
1943 nil)
1946 ;; set the def-args bound in edebug-defining-form
1956 ;; Like form but the form is wrapped in edebug-enter form.
1957 ;; The form is assumed to be executing outside of the function context.
1958 ;; This is a hack for now, since a def-form might execute inside as well.
1959 ;; Not to be used otherwise.
1964 ;; Like body but body is wrapped in edebug-enter form.
1965 ;; The body is assumed to be executing inside of the function context.
1966 ;; Not to be used otherwise.
1971 ;;;; Edebug Form Specs
1972 ;;; ==========================================================
1973 ;;; See cl-specs.el for common lisp specs.
1975 ;;;;* Spec for def-edebug-spec
1976 ;;; Out of date.
1979 "Return non-nil if OBJECT is a symbol with an edebug-form-spec property."
1984 ;; Top level is different from lower levels.
1989 ;; A list must have something in it, or it is nil, a symbolp
1993 (&or
1997 edebug-spec-list
1998 stringp
2000 ;; [edebug-keywordp gate edebug-spec] ;; need edebug-keywordp for this.
2001 edebug-spec-p ;; Including all the special ones e.g. form.
2002 symbolp;; a predicate
2003 ))
2006 ;;;* Emacs special forms and some functions.
2008 ;; quote expects only one argument, although it allows any number.
2011 ;; The standard defining forms.
2016 (&define name lambda-list
2019 def-body))
2029 )))
2034 ;; A function-form is for an argument that may be a function or a form.
2035 ;; This specially recognizes anonymous functions quoted with quote.
2037 ;; form at the end could also handle "function",
2038 ;; but recognize it specially to avoid wrapping function forms.
2041 ;; function expects a symbol or a lambda or macro expression
2042 ;; A macro is allowed by Emacs.
2045 ;; lambda is a macro in emacs 19.
2049 def-body))
2051 ;; A macro expression is a lambda expression with "macro" prepended.
2054 ;; (def-edebug-spec anonymous-form ((&or ["lambda" lambda] ["macro" macro])))
2056 ;; Standard functions that take function-forms arguments.
2065 body))
2076 form
2082 ;; Supports quotes inside backquotes,
2083 ;; but only at the top level inside unquotes.
2085 (&or
2088 ;; If you use dotted forms in backquotes, replace the previous line
2089 ;; with the following. This takes quite a bit more stack space, however.
2090 ;; (backquote-form . [&or nil backquote-form])
2092 sexp))
2094 ;; Special version of backquote that instruments backquoted forms
2095 ;; destined to be evaluated, usually as the result of a
2096 ;; macroexpansion. Backquoted code can only have unquotes (, and ,@)
2097 ;; in places where list forms are allowed, and predicates. If the
2098 ;; backquote is used in a macro, unquoted code that come from
2099 ;; arguments must be instrumented, if at all, with def-form not def-body.
2101 ;; We could assume that all forms (not nested in other forms)
2102 ;; in arguments of macros should be def-forms, whether or not the macros
2103 ;; are defined with edebug-` but this would be expensive.
2105 ;; ,@ might have some problems.
2110 ;; Assume immediate quote in unquotes mean backquote at next higher level.
2115 ;; New byte compiler.
2121 ;; Anything else?
2124 ;; Some miscellaneous specs for macros in public packages.
2125 ;; Send me yours.
2127 ;; advice.el by Hans Chalupsky (hans@cs.buffalo.edu)
2133 ;; "activation" "deactivation"]
2134 name ;; name of advice
2136 )
2139 def-body))
2141 ;;; The debugger itself
2145 ;;; add minor-mode-alist entry
2148 minor-mode-alist)))
2151 ;; Stack of active functions evaluated via edebug.
2152 ;; Should be nil at the top level.
2155 ;; Index of last edebug-stack item.
2158 ;; Stack of offset indices of visited edebug sexps.
2159 ;; Should be nil at the top level.
2160 ;; Each function adds one cons. Top is modified with setcar.
2164 ;; Non-nil if edebug has already been entered at this recursive edit level.
2165 ;; This should stay nil at the top level.
2166 )
2168 ;; Should these be options?
2170 ;; Name of function to use for debugging when error or quit occurs.
2171 ;; Set this to 'debug if you want to debug edebug.
2172 )
2175 ;; Dynamically bound variables, declared globally but left unbound.
2200 ;; Emacs 19
2207 ;;; Handling signals
2211 ;; We should use advise for this!!
2214 "Signal an error. Args are SIGNAL-NAME, and associated DATA.
2215 A signal name is a symbol with an `error-conditions' property
2216 that is a list of condition names.
2217 A handler for any of those names will get to handle this signal.
2218 The symbol `error' should always be one of them.
2220 DATA should be a list. Its elements are printed as part of the error message.
2221 If the signal is handled, DATA is made available to the handler.
2222 See `condition-case'.
2224 This is the Edebug replacement for the standard `signal'. It should
2225 only be active while Edebug is. It checks `debug-on-error' to see
2226 whether it should call the debugger. When execution is resumed, the
2227 error is signaled again."
2230 ;; If we reach here without another non-local exit, then send signal again.
2231 ;; i.e. the signal is not continuable, yet.
2235 ;;; Entering Edebug
2238 ;; Entering FUNC. The arguments are ARGS, and the body is BODY.
2239 ;; Setup edebug variables and evaluate BODY. This function is called
2240 ;; when a function evaluated with edebug-eval-top-level-form is entered.
2241 ;; Return the result of BODY.
2243 ;; Is this the first time we are entering edebug since
2244 ;; lower-level recursive-edit command?
2245 ;; More precisely, this tests whether Edebug is currently active.
2248 ;; Binding max-lisp-eval-depth here is OK,
2249 ;; but not inside an unwind-protect.
2250 ;; Doing it here also keeps it from growing too large.
2257 ;; Binding these may not be the right thing to do.
2258 ;; We want to allow the global values to be changed.
2262 ;; Lexical bindings must be uncompiled for this to work.
2265 ;; Save the outside value of executing macro. (here??)
2272 ;; within edebug unless edebug-continue-kbd-macro is
2273 ;; non-nil. Again, local binding may not be best.
2277 ;; Disable command hooks. This is essential when
2278 ;; a hook function is instrumented - to avoid infinite loop.
2279 ;; This may be more than we need, however.
2284 edebug-initial-mode
2285 edebug-execution-mode)
2286 edebug-next-execution-mode nil)
2287 ;; Bind signal to edebug-signal only while Edebug is active.
2292 ;; Reset global variables in case outside value was changed.
2294 pre-command-hook edebug-outside-pre-command-hook
2295 post-command-hook edebug-outside-post-command-hook
2296 post-command-idle-hook edebug-outside-post-command-idle-hook
2297 )))
2307 )
2316 )))
2321 edebug-result)
2331 "Print MSG in *edebug-trace* before and after evaluating BODY.
2332 The result of BODY is also printed."
2334 edebug-result)
2341 "Function called to print trace info before expression evaluation.
2342 MSG is printed after `::::{ '."
2347 "Function called to print trace info after expression evaluation.
2348 MSG is printed after `::::} '."
2355 ;; Debug current function given BEFORE position.
2356 ;; Called from functions compiled with edebug-eval-top-level-form.
2357 ;; Return the before index.
2360 ;; Increment frequency count
2367 edebug-before-index)
2370 ;; Do nothing.
2371 )
2374 ;; Debug current function given AFTER position and VALUE.
2375 ;; Called from functions compiled with edebug-eval-top-level-form.
2376 ;; Return VALUE.
2379 ;; Increment frequency count
2386 ;; Just return result.
2387 edebug-value
2389 ))
2392 ;; Do nothing but return the value.
2393 edebug-value)
2399 ;; This is not used, yet.
2413 ;; Test if a different result.
2418 ;; Dynamically declared unbound variables.
2431 ;; Check breakpoints and pending input.
2432 ;; If edebug display should be updated, call edebug-display.
2433 ;; Return edebug-value.
2446 ;;; (edebug-trace "exp: %s" edebug-value)
2447 ;; Test whether we should break.
2456 ;; Delete the breakpoint.
2461 ;; Display if mode is not go, continue, or Continue-fast
2462 ;; or break, or input is pending,
2464 edebug-break
2468 edebug-value
2469 ))
2472 ;; window-start now stored with each function.
2473 ;;(defvar edebug-window-start nil)
2474 ;; Remember where each buffers' window starts between edebug calls.
2475 ;; This is to avoid spurious recentering.
2476 ;; Does this still need to be buffer-local??
2477 ;;(setq-default edebug-window-start nil)
2478 ;;(make-variable-buffer-local 'edebug-window-start)
2481 ;; Dynamically declared unbound vars
2497 ;; Emacs 19 adds an arg to mark and mark-marker.
2503 ;; Setup windows for edebug, determine mode, maybe enter recursive-edit.
2504 ;; Uses local variables of edebug-enter, edebug-before, edebug-after
2505 ;; and edebug-debugger.
2507 edebug-stop ; should we enter recursive-edit
2510 edebug-buffer-outside-point ; current point in edebug-buffer
2511 ;; window displaying edebug-buffer
2517 edebug-outside-windows ; window or screen configuration
2518 edebug-buffer-points
2520 edebug-eval-buffer ; declared here so we can kill it below
2523 edebug-trace-window
2524 edebug-trace-window-start
2533 ;; any others??
2534 )
2540 ;; Compute result string now before windows are modified.
2544 ;; Save windows now before we modify them.
2551 ;; First move the edebug buffer point to edebug-point
2552 ;; so that window start doesn't get changed when we display it.
2553 ;; I don't know if this is going to help.
2554 ;;(set-buffer edebug-buffer)
2555 ;;(goto-char edebug-point)
2557 ;; If edebug-buffer is not currently displayed,
2558 ;; first find a window for it.
2562 ;; Now display eval list, if any.
2563 ;; This is done after the pop to edebug-buffer
2564 ;; so that buffer-window correspondence is correct after quitting.
2566 ;; The evaluation list better not have deleted edebug-window-data.
2574 ;; Check whether positions are up-to-date.
2575 ;; This assumes point is never before symbol.
2579 edebug-function)
2580 )))
2585 ;; Test if there is input, not including keyboard macros.
2589 edebug-stop t)
2591 ;; (discard-input) ; is this unfriendly??
2592 ))
2593 ;; Now display arrow based on mode.
2598 ;; Display error message
2609 edebug-global-break-condition
2610 edebug-global-break-result))
2613 edebug-break-condition
2614 edebug-break-result))
2623 ;; Display result of previous evaluation.
2635 ;; not edebug-break
2640 )
2647 ;; (setq edebug-execution-mode 'step)
2648 ;; (edebug-overlay-arrow) ; This doesn't always show up.
2651 ;; Reset the edebug-window-data to whatever it is now.
2655 ;; Remember window-start for edebug-buffer, if still displayed.
2661 ;; Save trace window point before restoring outside windows.
2662 ;; Could generalize this for other buffers.
2669 ;; Restore windows before continuing.
2674 ;; Restore displayed buffer points.
2675 ;; Needed even if restoring windows because
2676 ;; window-points are not restored. (should they be??)
2680 ;; Unrestore trace window's window-point.
2683 edebug-trace-window-start))
2685 ;; Unrestore edebug-buffer's window-start, if displayed.
2692 ;; Unrestore edebug-buffer's window-point.
2693 ;; Needed in addition to setting the buffer point
2694 ;; - otherwise quitting doesn't leave point as is.
2695 ;; But this causes point to not be restored at times.
2696 ;; Also, it may not be a visible window.
2697 ;; (set-window-point window edebug-point)
2698 )))
2700 ;; Unrestore edebug-buffer's point. Rerestored below.
2701 ;; (goto-char edebug-point) ;; in edebug-buffer
2702 )
2703 ;; Since we may be in a save-excursion, in case of quit,
2704 ;; reselect the outside window only.
2705 ;; Only needed if we are not recovering windows??
2710 ;; Restore current buffer always, in case application needs it.
2712 ;; Restore point, and mark.
2713 ;; Needed even if restoring windows because
2714 ;; that doesn't restore point and mark in the current buffer.
2715 ;; But don't restore point if edebug-buffer is current buffer.
2719 ;; Does zmacs-regions need to be nil while doing set-marker?
2722 ;; None of the following is done if quit or signal occurs.
2724 ;; Restore edebug-buffer's outside point.
2725 ;; (edebug-trace "restore edebug-buffer point: %s"
2726 ;; edebug-buffer-outside-point)
2731 ;; ... nothing more.
2732 )
2733 ;; Reset global variables to outside values in case they were changed.
2735 overlay-arrow-position edebug-outside-o-a-p
2736 overlay-arrow-string edebug-outside-o-a-s
2737 cursor-in-echo-area edebug-outside-c-i-e-a)
2738 )))
2742 ;; Number of recursive edits started by edebug.
2743 ;; Should be 0 at the top level.
2746 ;; Value of recursion-depth when edebug was called.
2748 ;; Dynamically declared unbound vars
2762 ;; Note: here we have defvars for variables that are
2763 ;; built-in in certain versions.
2764 ;; Each defvar makes a difference
2765 ;; in versions where the variable is *not* built-in.
2767 ;; Emacs 18
2770 ;; Lucid Emacs
2774 ;; Emacs 19.
2782 ;; Disable byte compiler warnings about unread-command-char and -event
2783 ;; (maybe works with byte-compile-version 2.22 at least)
2795 ;; Start up a recursive edit inside of edebug.
2796 ;; The current buffer is the edebug-buffer, which is put into edebug-mode.
2797 ;; Assume that none of the variables below are buffer-local.
2799 ;; match-data must be done in the outside buffer
2805 ;;(edebug-number-of-recursions (1+ edebug-number-of-recursions))
2807 edebug-entered ; bind locally to nil
2809 edebug-backtrace-buffer ; each recursive edit gets its own
2810 ;; The window configuration may be saved and restored
2811 ;; during a recursive-edit
2812 edebug-inside-windows
2834 )
2838 ;; Declare global values local but using the same global value.
2839 ;; We could set these to the values for previous edebug call.
2845 ;; Assume no edebug command sets unread-command-char.
2848 ;; More for Emacs 19
2857 ;; Bind again to outside values.
2861 ;; Don't keep defining a kbd macro.
2865 ;; others??
2866 )
2881 ;; Do the following, even if quit occurs.
2885 ;; Could be an option to keep eval display up.
2888 ;; Remember selected-window after recursive-edit.
2889 ;; (setq edebug-inside-window (selected-window))
2893 ;; Recursive edit may have changed buffers,
2894 ;; so set it back before exiting let.
2902 )
2903 ;; gotta have a buffer to let its buffer local variables be set
2907 ;; Reset global vars to outside values, in case they have been changed.
2909 last-command-char edebug-outside-last-command-char
2910 last-command-event edebug-outside-last-command-event
2911 last-command edebug-outside-last-command
2912 this-command edebug-outside-this-command
2913 unread-command-char edebug-outside-unread-command-char
2914 unread-command-event edebug-outside-unread-command-event
2915 unread-command-events edebug-outside-unread-command-events
2916 last-input-char edebug-outside-last-input-char
2917 last-input-event edebug-outside-last-input-event
2918 last-event-frame edebug-outside-last-event-frame
2919 last-nonmenu-event edebug-outside-last-nonmenu-event
2920 track-mouse edebug-outside-track-mouse
2922 standard-output edebug-outside-standard-output
2923 standard-input edebug-outside-standard-input
2924 defining-kbd-macro edebug-outside-defining-kbd-macro
2925 ))
2926 ))
2929 ;;; Display related functions
2932 ;; If pos is not visible, adjust current window to fit following context.
2933 ;;; (message "window: %s old-start: %s window-start: %s pos: %s"
2934 ;;; (selected-window) old-start (window-start) (point)) (sit-for 5)
2937 ;; First try old-start
2942 ;; (message "resetting window start") (sit-for 2)
2949 ))
2965 )
2969 ;; Set up the overlay arrow at beginning-of-line in current buffer.
2970 ;; The arrow string is derived from edebug-arrow-alist and
2971 ;; edebug-execution-mode.
2980 "Toggle the saving and restoring of all windows.
2981 Also, each time you toggle it on, the inside and outside window
2982 configurations become the same as the current configuration."
2989 edebug-save-windows))))
2999 edebug-save-windows))
3000 ;; Problem: what about outside windows that are deleted inside?
3004 "Toggle the saving and restoring of the selected window.
3005 Also, each time you toggle it on, the inside and outside window
3006 configurations become the same as the current configuration."
3010 ;; Save all outside windows except the selected one.
3011 ;; Remove (selected-window) from outside-windows.
3018 edebug-outside-windows))
3031 "Toggle the saving and restoring of windows.
3032 With prefix, toggle for just the selected window.
3033 Otherwise, toggle for all windows."
3041 "Show the debug windows and where we stopped in the program."
3045 ;; Restore the window configuration to what it last was inside.
3046 ;; But it is not always set. - experiment
3047 ;;(if edebug-inside-windows
3048 ;; (edebug-set-windows edebug-inside-windows))
3053 "Change to the outside window configuration."
3066 "Bounce the point in the outside current buffer.
3067 If prefix arg is supplied, sit for that many seconds before returning.
3068 The default is one second."
3073 ;; If the buffer's currently displayed, avoid set-window-configuration.
3085 ;; Joe Wells, here is a start at your idea of adding a buffer to the internal
3086 ;; display list. Still need to use this list in edebug-display.
3092 "Toggle display of a buffer inside of edebug."
3102 ;;; Breakpoint related functions
3105 ;; Return (function . index) of the nearest edebug stop point.
3112 ;; pull out parts of edebug-data.
3114 ;; (edebug-breakpoints (car (cdr edebug-data)))
3119 ;; skip backwards until non-whitespace, or bol
3122 edebug-def-mark))
3123 len i)
3124 ;; the offsets are in order so we can do a linear search
3131 ;; return the relevant info
3134 edebug-def-name)
3135 )))
3139 "Move point to the next breakpoint, or first if none past point."
3147 ;; pull out parts of edebug-data
3151 breakpoint)
3161 ;; goto the first breakpoint
3174 ))))))
3178 "Modify the breakpoint for the form at point or after it according
3179 to FLAG: set if t, clear if nil. Then move to that point.
3180 If CONDITION or TEMPORARY are non-nil, add those attributes to
3181 the breakpoint. "
3188 ;; pull out parts of edebug-data
3192 present)
3193 ;; delete it either way
3198 ;; add it to the list and resort
3203 edebug-breakpoints) '<))
3206 edebug-def-name condition)
3214 ))))
3217 "Set the breakpoint of nearest sexp.
3218 With prefix argument, make it a temporary breakpoint."
3223 "Clear the breakpoint of nearest sexp."
3228 ;; For emacs 18, no read-expression-history
3230 "Set a conditional breakpoint at nearest sexp.
3231 The condition is evaluated in the outside context.
3232 With prefix argument, make it a temporary breakpoint."
3233 ;; (interactive "P\nxCondition: ")
3236 current-prefix-arg
3237 ;; Edit previous condition as follows, but it is cumbersome:
3256 "Global Condition: "
3261 ;;; Mode switching functions
3264 ;; Set the edebug mode to MODE.
3265 ;; Display SHORTMSG, or MSG if not within edebug.
3270 ;; Continue execution
3272 ;; This is not terribly useful!!
3280 "Proceed to next stop point."
3285 "Proceed to next `after' stop point."
3290 "Go, evaluating until break.
3291 With prefix ARG, set temporary break at current point and go."
3298 "Go, evaluating without debugging."
3305 "Begin trace mode."
3310 "Trace with no wait at each step."
3316 "Begin continue mode."
3322 "Trace with no wait at each step."
3327 ;; ------------------------------------------------------------
3328 ;; The following use the mode changing commands and breakpoints.
3332 "Proceed to this stop point."
3338 "Stop execution and do not continue.
3339 Useful for exiting from trace or continue loop."
3345 "Proceed to the exit of the next expression to be evaluated."
3353 "Proceed from the current point to the end of the ARGth sexp ahead.
3354 If there are not ARG sexps ahead, then do edebug-step-out."
3358 ;; Call forward-sexp repeatedly until done or failure.
3363 )))
3366 "Proceed from the current point to the end of the containing sexp.
3367 If there is no containing sexp that is not the top level defun,
3368 go to the end of the last sexp, or if that is the same point, then step."
3374 ;; Is there still a containing expression?
3378 ;; At top level - 1, so first check if there are more sexps at this level.
3380 ;; (up-list 1)
3385 )))))
3388 ;; Func should be a function symbol.
3389 ;; Return the function symbol, or nil if not instrumented.
3394 ;; It is uninstrumented, so instrument it.
3399 func))
3402 func)
3404 ;; We could try harder, e.g. do a tags search.
3406 nil))))
3409 "Instrument the definition of the function or macro about to be called.
3410 Do this when stopped before the form or it will be too late.
3411 One side effect of using this command is that the next time the
3412 function or macro is called, Edebug will be called there as well."
3427 "Step into the definition of the function or macro about to be called.
3428 This first does `edebug-instrument-callee' to ensure that it is
3429 instrumented. Then it does `edebug-on-entry' and switches to `go' mode."
3438 "Cause Edebug to stop when FUNCTION is called.
3439 With prefix argument, make this temporary so it is automatically
3440 cancelled the first time the function is entered."
3442 ;; Could store this in the edebug data instead.
3453 ;; Also need edebug-cancel-debug-on-entry
3456 "Request FUNCTION to invoke debugger each time it is called.
3457 If the user continues, FUNCTION's execution proceeds.
3458 Works by modifying the definition of FUNCTION,
3459 which must be written in Lisp, not predefined.
3460 Use `cancel-debug-on-entry' to cancel the effect of this command.
3461 Redefining FUNCTION also does that.
3463 This version is from Edebug. If the function is instrumented for
3464 Edebug, it calls `edebug-on-entry'"
3473 "Set mode to Go-nonstop, and exit to top-level.
3474 This is useful for exiting even if unwind-protect code may be executed."
3480 ;;(defun edebug-exit-out ()
3481 ;; "Go until the current function exits."
3482 ;; (interactive)
3483 ;; (edebug-set-mode 'exiting "Exit..."))
3486 ;;; The following initial mode setting definitions are not used yet.
3496 )
3501 "Ask for the initial mode of the enclosing function.
3502 The mode is requested via the key that would be used to set the mode in
3503 edebug-mode."
3507 edebug-mode-map))
3509 edebug-initial-mode))
3512 "Change initial edebug mode for %s from %s (%s) to (enter key): "
3513 this-function
3514 old-mode
3517 keymap 'firstonly
3518 ))))
3520 )
3527 this-function mode))
3529 )))
3531 ;;; Evaluation of expressions
3536 "Evaluate an expression list in the outside context.
3537 Return the result of the last expression."
3541 ;; After excursion, we will
3542 ;; restore to current window configuration.
3545 ;; Restore outside windows.
3549 ;; (use-local-map edebug-outside-map)
3551 ;; Restore outside context.
3574 ;; See edebug-display
3578 )
3587 ;; Back to edebug-buffer. Restore rest of inside context.
3588 ;; (use-local-map edebug-inside-map)
3590 ;; Restore inside windows.
3593 ;; Save values that may have been changed.
3595 edebug-outside-last-command-char last-command-char
3596 edebug-outside-last-command-event last-command-event
3597 edebug-outside-last-command last-command
3598 edebug-outside-this-command this-command
3599 edebug-outside-unread-command-char unread-command-char
3600 edebug-outside-unread-command-event unread-command-event
3601 edebug-outside-unread-command-events unread-command-events
3602 edebug-outside-last-input-char last-input-char
3603 edebug-outside-last-input-event last-input-event
3604 edebug-outside-last-event-frame last-event-frame
3605 edebug-outside-last-nonmenu-event last-nonmenu-event
3606 edebug-outside-track-mouse track-mouse
3607 edebug-outside-standard-output standard-output
3608 edebug-outside-standard-input standard-input
3610 edebug-outside-executing-macro executing-kbd-macro
3611 edebug-outside-defining-kbd-macro defining-kbd-macro
3612 edebug-outside-pre-command-hook pre-command-hook
3613 edebug-outside-post-command-hook post-command-hook
3614 edebug-outside-post-command-idle-hook post-command-idle-hook
3616 edebug-outside-o-a-p overlay-arrow-position
3617 edebug-outside-o-a-s overlay-arrow-string
3618 edebug-outside-c-i-e-a cursor-in-echo-area
3620 )))
3625 ;; Are there cl lexical variables active?
3631 ;; Evaluate EXPR safely.
3632 ;; If there is an error, a string is returned describing the error.
3639 ;;; Printing
3641 ;; Replace printing functions.
3643 ;; obsolete names
3649 "Replace print functions used by Edebug with custom versions."
3650 ;; Modifying the custom print functions, or changing print-length,
3651 ;; print-level, print-circle, custom-print-list or custom-print-vector
3652 ;; have immediate effect.
3664 "Replace edebug custom print functions with internal versions."
3673 ;; Default print functions are the same as Emacs'.
3678 ;; Print an error message like command level does.
3679 ;; This also prints the error name if it has no error-message.
3684 ;; continuing after an error may
3685 ;; complain about edebug-arg. why??
3689 ;; Define here in case they are not already defined.
3693 ;; Alternatively, we could change the definition of
3694 ;; edebug-safe-prin1-to-string to only use these if defined.
3718 "Print the previous result."
3722 ;;; Read, Eval and Print
3725 "Evaluate an expression in the outside environment.
3726 If interactive, prompt for the expression.
3727 Print result in minibuffer."
3735 "Evaluate sexp before point in the outside environment;
3736 print value in minibuffer."
3741 "Evaluate sexp before point in the outside environment;
3742 print value into current buffer."
3750 ;; princ the string to get rid of quotes.
3753 ))
3755 ;;; Edebug Minor Mode
3757 ;; Global GUD bindings for all emacs-lisp-mode buffers.
3766 nil
3769 ;; control
3779 ;;(define-key edebug-mode-map "f" 'edebug-forward) not implemented
3787 ;; quitting and stopping
3793 ;; breakpoints
3800 ;; evaluation
3806 ;; views
3813 ;; misc
3819 ;; statistics
3822 ;; GUD bindings
3832 ))
3834 ;; Autoloading these global bindings doesn't make sense because
3835 ;; they cannot be used anyway unless Edebug is already loaded and active.
3844 nil
3858 ;; breakpoints
3864 ;; views
3868 ;; quitting
3873 ;; statistics
3875 )
3882 "Mode for Emacs Lisp buffers while in Edebug.
3884 In addition to all Emacs Lisp commands (except those that modify the
3885 buffer) there are local and global key bindings to several Edebug
3889 Also see bindings for the eval list buffer, *edebug*.
3891 The edebug buffer commands:
3894 Global commands prefixed by `global-edebug-prefix':
3897 Options:
3898 edebug-setup-hook
3899 edebug-all-defs
3900 edebug-all-forms
3901 edebug-save-windows
3902 edebug-save-displayed-buffer-points
3903 edebug-initial-mode
3904 edebug-trace
3905 edebug-test-coverage
3906 edebug-continue-kbd-macro
3907 edebug-print-length
3908 edebug-print-level
3909 edebug-print-circle
3910 edebug-on-error
3911 edebug-on-quit
3912 edebug-on-signal
3913 edebug-unwrap-results
3914 edebug-global-break-condition
3915 "
3918 ;;; edebug eval list mode
3920 ;; A list of expressions and their evaluations is displayed in *edebug*.
3923 "Return a list of evaluations of edebug-eval-list"
3924 ;; Assumes in outside environment.
3925 ;; Don't do any edebug things now.
3931 ;; Assumes edebug-eval-buffer exists.
3945 ))
3953 ;; Should generalize this to be callable outside of edebug
3954 ;; with calls in user functions, e.g. (edebug-eval-display)
3957 "Display expressions and evaluations in EVAL-LIST.
3958 It modifies the context by popping up the eval display."
3963 )))
3966 "Redisplay eval list in outside environment.
3967 May only be called from within edebug-recursive-edit."
3971 ))
3980 "Replace the evaluation list with the sexps now in the eval buffer."
3983 new-list)
3985 ;; get the first expression
4007 "Delete the item under point and redisplay."
4008 ;; could add arg to do repeatedly
4024 nil
4032 )
4036 "Mode for evaluation list buffer while in Edebug.
4038 In addition to all Interactive Emacs Lisp commands there are local and
4039 global key bindings to several Edebug specific commands. E.g.
4043 Eval list buffer commands:
4046 Global commands prefixed by global-edebug-prefix:
4048 "
4054 ;;; Interface with standard debugger.
4056 ;; (setq debugger 'edebug) ; to use the edebug debugger
4057 ;; (setq debugger 'debug) ; use the standard debugger
4059 ;; Note that debug and its utilities must be byte-compiled to work,
4060 ;; since they depend on the backtrace looking a certain way. But
4061 ;; edebug is not dependent on this, yet.
4064 "Replacement for debug.
4065 If we are running an edebugged function,
4066 show where we last were. Otherwise call debug normally."
4067 ;; (message "entered: %s depth: %s edebug-recursion-depth: %s"
4068 ;; edebug-entered (recursion-depth) edebug-recursion-depth) (sit-for 1)
4073 ;; Bind variables required by edebug-display
4075 edebug-breakpoints
4076 edebug-break-data
4077 edebug-break-condition
4078 edebug-global-break
4080 )
4083 nil
4084 edebug-value))
4086 ;; Otherwise call debug normally.
4087 ;; Still need to remove extraneous edebug calls from stack.
4089 ))
4093 "Display a non-working backtrace. Better than nothing..."
4099 ;; else, could just display edebug-backtrace-buffer
4100 )
4105 last-ok-point)
4108 ;; Clean up the backtrace.
4109 ;; Not quite right for current edebug scheme.
4116 ;; Delete interspersed edebug internals.
4121 ;; Previous lines may contain code, so just delete this line
4129 )))
4130 )))))
4132 \f
4133 ;;; Trace display
4136 "In buffer BUF-NAME, display FMT and ARGS at the end and make it visible.
4137 The buffer is created if it does not exist.
4138 You must include newlines in FMT to break lines, but one newline is appended."
4139 ;; e.g.
4140 ;; (edebug-trace-display "*trace-point*"
4141 ;; "saving: point = %s window-start = %s"
4142 ;; (point) (window-start))
4146 buf-window)
4147 ;; (message "before pop-to-buffer") (sit-for 1)
4153 ;; Make it visible.
4157 ;; (set-window-point buf-window (point))
4158 ;; (edebug-sit-for 0)
4162 buf-name)
4166 "Convenience call to edebug-trace-display using edebug-trace-buffer"
4169 \f
4170 ;;; Frequency count and coverage
4173 "Display the frequency count data for each line of the current
4174 definition. The frequency counts are inserted as comment lines after
4175 each line, and you can undo all insertions with one `undo' command.
4177 The counts are inserted starting under the `(' before an expression
4178 or the `)' after an expression, or on the last char of a symbol.
4179 The counts are only displayed when they differ from previous counts on
4180 the same line.
4182 If coverage is being tested, whenever all known results of an expression
4183 are `eq', the char `=' will be appended after the count
4184 for that expression. Note that this is always the case for an
4185 expression only evaluated once.
4187 To clear the frequency count and coverage data for a definition,
4188 reinstrument it."
4202 )
4204 ;; Traverse in reverse order so offsets are correct.
4206 ;; Start at last expression in line.
4210 last-index i)
4212 ;; Find all indexes on same line.
4215 ;; Insert all the indices for this line.
4218 first-index i ; really last index for line above this one.
4221 ;; i == first-index still
4242 "Temporarily display the frequency count data for the current definition.
4243 It is removed when you hit any char."
4244 ;; This seems not to work with Emacs 18.59. It undoes too far.
4252 \f
4253 ;;; Menus
4259 ;; We have to require easymenu (even for Emacs 18) just so
4260 ;; the easy-menu-define macro call is compiled correctly.
4265 "----"
4275 "----"
4280 "----"
4310 "----"
4316 ))
4319 \f
4320 ;;; Emacs version specific code
4322 ;;; The default for all above is Emacs 18, because it is easier to compile
4323 ;;; Emacs 18 code in Emacs 19 than vice versa. This default will
4324 ;;; change once most people are using Emacs 19 or derivatives.
4326 ;; Epoch specific code is in a separate file: edebug-epoch.el.
4328 ;; The byte-compiler will complain about changes in number of arguments
4329 ;; to functions like mark and read-from-minibuffer. These warnings
4330 ;; may be ignored because the right call should always be made.
4336 ;; Mark takes an argument in Emacs 19.
4340 ;; Use minibuffer-history when reading expressions.
4345 "Set a conditional breakpoint at nearest sexp.
4346 The condition is evaluated in the outside context.
4347 With prefix argument, make it a temporary breakpoint."
4348 ;; (interactive "P\nxCondition: ")
4351 current-prefix-arg
4352 ;; Read condition as follows; getting previous condition is cumbersome:
4362 ;; Prepend the current condition, if any.
4365 read-expression-history)))
4368 "Condition: " nil read-expression-map t
4371 ))))))
4375 "Evaluate an expression in the outside environment.
4376 If interactive, prompt for the expression.
4377 Print result in minibuffer."
4379 "Eval: " nil read-expression-map t
4389 )
4394 ;; We need to bind zmacs-regions to nil around all calls to `mark' and
4395 ;; `mark-marker' but don't bind it to nil before entering a recursive edit,
4396 ;; that is, don't interfere with the binding the user might see while
4397 ;; executing a command.
4415 )
4430 \f
4431 ;;; Byte-compiler
4433 ;; Extension for bytecomp to resolve undefined function references.
4434 ;; Requires new byte compiler.
4436 ;; Reenable byte compiler warnings about unread-command-char and -event.
4437 ;; Disabled before edebug-recursive-edit.
4441 edebug-unread-command-char-warning))
4444 edebug-unread-command-event-warning)))
4447 ;; The body of eval-when-compile seems to get evaluated with eval-defun.
4448 ;; We only want to evaluate when actually byte compiling.
4449 ;; But it is OK to evaluate as long as byte-compiler has been loaded.
4453 "Say it is OK for the named functions to be unresolved."
4459 byte-compile-unresolved-functions))))
4460 funcs)
4461 nil)
4464 "Say it is OK for the named variables to be referenced."
4470 vars)
4471 nil)
4474 "Say it is OK for the named variables to be assigned."
4480 vars)
4481 nil)
4485 edebug-gensym ;; also in cl.el
4486 ;; Interfaces to standard functions.
4487 edebug-original-eval-defun
4488 edebug-original-read
4489 edebug-get-buffer-window
4490 edebug-mark
4491 edebug-mark-marker
4492 edebug-input-pending-p
4493 edebug-sit-for
4494 edebug-prin1-to-string
4495 edebug-format
4496 edebug-original-signal
4497 ;; lemacs
4498 zmacs-deactivate-region
4499 popup-menu
4500 ;; CL
4501 cl-macroexpand-all
4502 ;; And believe it or not, the byte compiler doesn't know about:
4503 byte-compile-resolve-functions
4504 ))
4508 read-expression-map))
4513 )))
4515 \f
4516 ;;; Autoloading of Edebug accessories
4521 ;; The following causes cl-specs to be loaded if you load cl.el.
4525 ;;; edebug-cl-read and cl-read are available from liberte@cs.uiuc.edu
4529 ;; The following causes edebug-cl-read to be loaded when you load cl-read.el.
4533 \f
4534 ;;; Finalize Loading
4536 ;;; Finally, hook edebug into the rest of Emacs.
4537 ;;; There are probably some other things that could go here.
4539 ;; Install edebug read and eval functions.
4544 ;;; edebug.el ends here