ikan Uploader :
Directory : /usr/share/emacs/25.2/lisp/emacs-lisp/
Upload File : |
| Current File : //usr/share/emacs/25.2/lisp/emacs-lisp/edebug.elc |
;ELC
;;; Compiled
;;; in Emacs version 25.2.1
;;; with all optimizations.
;;; This file uses dynamic docstrings, first added in Emacs 19.29.
;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(byte-code "\300\301!\210\300\302!\210\303\304\305\306\307\310%\210\311\312\313\314\315DD\316\317\320\307\304&\210\311\321\313\314\322DD\323\317\324\307\304&\210\311\325\313\314\326DD\327\317\324\307\304&\210\311\330\313\314\331DD\332\317\324\307\304&\210\311\333\313\314\334DD\335\317\336\307\304&\210\311\337\313\314\340DD\341\317\324\307\304&\210\311\342\313\314\343DD\344\317\345\307\304&\210\311\346\313\314\347DD\350\317\324\307\304&\210\311\351\313\314\352DD\353\317\324\307\304&\210\311\354\313\314\355DD\356\317\324\307\304&\210\311\357\313\314\360DD\361\317\362\307\304&\210\311\363\313\314\364DD\365\317\362\307\304&\210\311\366\313\314\367DD\370\317\324\307\304&\210\311\371\313\314\372DD\373\317\324\307\304&\210\311\374\313\314\375DD\376\317\377\307\304&\210\311\201@ \313\314\201A DD\201B \317\324\307\304&\210\311\201C \313\314\201D DD\201E \317\201F \201G \201H \307\304& \210\311\201I \313\314\201J DD\201K \317\201L \307\304&\207" [require macroexp cl-lib custom-declare-group edebug nil "A source-level debugger for Emacs Lisp." :group lisp custom-declare-variable edebug-setup-hook funcall function #[0 "\300\207" [nil] 1] "Functions to call before edebug is used.\nEach time it is set to a new value, Edebug will call those functions\nonce and then reset `edebug-setup-hook' to nil. You could use this\nto load up Edebug specifications associated with a package you are\nusing, but only when you also use Edebug." :type hook edebug-all-defs #[0 "\300\207" [nil] 1] "If non-nil, evaluating defining forms instruments for Edebug.\nThis applies to `eval-defun', `eval-region', `eval-buffer', and\n`eval-current-buffer'. `eval-region' is also called by\n`eval-last-sexp', and `eval-print-last-sexp'.\n\nYou can use the command `edebug-all-defs' to toggle the value of this\nvariable. You may wish to make it local to each buffer with\n(make-local-variable \\='edebug-all-defs) in your\n`emacs-lisp-mode-hook'." boolean edebug-all-forms #[0 "\300\207" [nil] 1] "Non-nil means evaluation of all forms will instrument for Edebug.\nThis doesn't apply to loading or evaluations in the minibuffer.\nUse the command `edebug-all-forms' to toggle the value of this option." edebug-eval-macro-args #[0 "\300\207" [nil] 1] "Non-nil means all macro call arguments may be evaluated.\nIf this variable is nil, the default, Edebug will *not* wrap\nmacro call arguments as if they will be evaluated.\nFor each macro, an `edebug-form-spec' overrides this option.\nSo to specify exceptions for macros that have some arguments evaluated\nand some not, use `def-edebug-spec' to specify an `edebug-form-spec'." edebug-save-windows #[0 "\300\207" [t] 1] "If non-nil, Edebug saves and restores the window configuration.\nThat takes some time, so if your program does not care what happens to\nthe window configurations, it is better to set this variable to nil.\n\nIf the value is a list, only the listed windows are saved and\nrestored.\n\n`edebug-toggle-save-windows' may be used to change this variable." (choice boolean (repeat string)) edebug-save-displayed-buffer-points #[0 "\300\207" [nil] 1] "If non-nil, save and restore point in all displayed buffers.\n\nSaving and restoring point in other buffers is necessary if you are\ndebugging code that changes the point of a buffer that is displayed\nin a non-selected window. If Edebug or the user then selects the\nwindow, the buffer's point will be changed to the window's point.\n\nSaving and restoring point in all buffers is expensive, since it\nrequires selecting each window twice, so enable this only if you\nneed it." edebug-initial-mode #[0 "\300\207" [step] 1] "Initial execution mode for Edebug, if non-nil.\nIf this variable is non-nil, it specifies the initial execution mode\nfor Edebug when it is first activated. Possible values are step, next,\ngo, Go-nonstop, trace, Trace-fast, continue, and Continue-fast." (choice (const step) (const next) (const go) (const Go-nonstop) (const trace) (const Trace-fast) (const continue) (const Continue-fast)) edebug-trace #[0 "\300\207" [nil] 1] "Non-nil means display a trace of function entry and exit.\nTracing output is displayed in a buffer named `*edebug-trace*', one\nfunction entry or exit per line, indented by the recursion level.\n\nYou can customize by replacing functions `edebug-print-trace-before'\nand `edebug-print-trace-after'." edebug-test-coverage #[0 "\300\207" [nil] 1] "If non-nil, Edebug tests coverage of all expressions debugged.\nThis is done by comparing the result of each expression with the\nprevious result. Coverage is considered OK if two different\nresults are found.\n\nUse `edebug-display-freq-count' to display the frequency count and\ncoverage information for a definition." edebug-continue-kbd-macro #[0 "\300\207" [nil] 1] "If non-nil, continue defining or executing any keyboard macro.\nUse this with caution since it is not debugged." edebug-print-length #[0 "\300\207" [50] 1] "If non-nil, default value of `print-length' for printing results in Edebug." integer edebug-print-level #[0 "\300\207" [50] 1] "If non-nil, default value of `print-level' for printing results in Edebug." edebug-print-circle #[0 "\300\207" [t] 1] "If non-nil, default value of `print-circle' for printing results in Edebug." edebug-unwrap-results #[0 "\300\207" [nil] 1] "Non-nil if Edebug should unwrap results of expressions.\nThat is, Edebug will try to remove its own instrumentation from the result.\nThis is useful when debugging macros where the results of expressions\nare instrumented expressions. But don't do this when results might be\ncircular or an infinite loop will result." edebug-on-error #[0 "\300\207" [t] 1] "Value bound to `debug-on-error' while Edebug is active.\n\nIf `debug-on-error' is non-nil, that value is still used.\n\nIf the value is a list of signal names, Edebug will stop when any of\nthese errors are signaled from Lisp code whether or not the signal is\nhandled by a `condition-case'. This option is useful for debugging\nsignals that *are* handled since they would otherwise be missed.\nAfter execution is resumed, the error is signaled again." (choice (const :tag "off") (repeat :menu-tag "When" :value (nil) (symbol :format "%v")) (const :tag "always" t)) edebug-on-quit #[0 "\300\207" [t] 1] "Value bound to `debug-on-quit' while Edebug is active." edebug-global-break-condition #[0 "\300\207" [nil] 1] "If non-nil, an expression to test for at every stop point.\nIf the result is non-nil, then break. Errors are ignored." sexp :risky t edebug-sit-for-seconds #[0 "\300\207" [1] 1] "Number of seconds to pause when execution mode is `trace' or `continue'." number] 10)
(defalias 'get-edebug-spec #[257 "\300\2119\203 \301\302\303#\211\262\203 \211\262\202 \207" [nil function-get edebug-form-spec macro] 7 "\n\n(fn SYMBOL)"])
#@156 Return t if SPEC uses only extant spec symbols.
An extant spec symbol is a symbol that is not a function and has a
`edebug-form-spec' property.
(fn SPEC)
(defalias 'edebug-basic-spec #[257 "\211<\203# \30023 \211\203 \301@!\204 \302\300\303\"\210\211A\262\202 \3040\207\2119\2053 \305!?\2053 \306\307\"\207" [basic edebug-basic-spec throw nil t functionp function-get edebug-form-spec] 4 (#$ . 7238)])
#@115 Return t if OBJECT is a lambda list keyword.
A lambda list keyword is a symbol that starts with `&'.
(fn OBJECT)
(defalias 'edebug-lambda-list-keywordp #[257 "\2119\205\f \300!\301H\302U\207" [symbol-name 0 38] 3 (#$ . 7655)])
(defalias 'edebug-last-sexp #[0 "\300\212\301\302!\210`)`{!@\207" [read-from-string forward-sexp -1] 3])
#@54 Return a list of windows, in order of `next-window'.
(defalias 'edebug-window-list #[0 "\300C\301\302\303\304\305\306!\307\"\310\311%!\210\211\242\237\207" [nil walk-windows make-byte-code 257 "\300\300\242B\240\207" vconcat vector [] 4 "\n\n(fn W)"] 8 (#$ . 7995)])
(defalias 'edebug-sort-alist #[514 "\300\301\302\303\304\305!\306\"\307\310%\"\207" [sort make-byte-code 514 "\300@@\"\207" vconcat vector [] 5 "\n\n(fn E1 E2)"] 10 "\n\n(fn ALIST FUNCTION)"])
#@42 Name of the buffer to put trace info in.
(defconst edebug-trace-buffer "*edebug-trace*" (#$ . 8469))
(defalias 'edebug-pop-to-buffer #[513 "\301!\203 \302!=\203 \211\202n \302 =\203 \303 \202n \304\305\"\206n \306\307!\2032 \310\311 !\202n \304!\3122e \313\314\307\"\211\205b \211@\211\303 =\204[ \211=\204[ \315!\204[ \316\312\"\210A\266\202\202= \2620\262\206n \310\311 !\262\317\"\210\320!\210\321\305\"\207" [edebug-trace-buffer edebug-window-live-p window-buffer selected-window get-buffer-window 0 one-window-p nomini split-window minibuffer-selected-window found window-list nil window-dedicated-p throw set-window-buffer select-window set-window-hscroll] 8 "\n\n(fn BUFFER &optional WINDOW)"])
(defalias 'edebug-get-displayed-buffer-points #[0 "\300C\301\302\303\304\305\306!\307\"\310\311%!\210\211\242\207" [nil walk-windows make-byte-code 257 "\211\301 =?\205 \300\302!\303!B\300\242B\240\207" vconcat vector [selected-window window-buffer window-point] 5 "\n\n(fn W)"] 8])
(defalias 'edebug-set-buffer-points #[257 "r\300\301\")\207" [mapcar #[257 "\300@!\205 \211@q\210\211Ab\207" [buffer-live-p] 3 "\n\n(fn BUF-POINT)"]] 4 "\n\n(fn BUFFER-POINTS)"])
(defalias 'edebug-current-windows #[257 "\211<\203\n \300\301\"\207\302 \207" [mapcar #[257 "\300!\205 \211\301!\302!\303!\304!\257\207" [edebug-window-live-p window-buffer window-point window-start window-hscroll] 7 "\n\n(fn WINDOW)"] current-window-configuration] 4 "\n\n(fn WHICH-WINDOWS)"])
(defalias 'edebug-set-windows #[257 "\211<\203\n \300\301\"\207\302!\207" [mapcar #[257 "\211\205 \300\301\"\207" [apply #[1285 "\300!\205 \301\"\210\302\"\210\303\"\210\304\"\207" [edebug-window-live-p set-window-buffer set-window-point set-window-start set-window-hscroll] 8 "\n\n(fn WINDOW BUFFER POINT START HSCROLL)"]] 4 "\n\n(fn ONE-WINDOW-INFO)"] set-window-configuration] 4 "\n\n(fn WINDOW-INFO)"])
#@773 Read one Lisp expression as text from STREAM, return as Lisp object.
If STREAM is nil, use the value of `standard-input' (which see).
STREAM or the value of `standard-input' may be:
a buffer (read from point and advance it)
a marker (read from where it points and advance it)
a function (call it with no arguments for each character,
call it with a char as argument to push a char back)
a string (takes text from string, starting at the beginning)
t (read text line using minibuffer and use it).
This version, from Edebug, maybe instruments the expression. But the
STREAM must be the current buffer to do so. Whether it instruments is
also dependent on the values of the option `edebug-all-defs' and
the option `edebug-all-forms'.
(fn ORIG &optional STREAM)
(defalias 'edebug--read #[513 "\211\204 \262\211p=\203 \301 \207\206 \302!\207" [standard-input edebug-read-and-maybe-wrap-form read] 4 (#$ . 10392)])
#@914 Evaluate the top-level form containing point, or after point.
If the current defun is actually a call to `defvar', then reset the
variable using its initial value expression even if the variable
already has some other value. (Normally `defvar' does not change the
variable's value if it already has a value.) Treat `defcustom'
similarly. Reinitialize the face according to `defface' specification.
With a prefix argument, instrument the code for Edebug.
Setting option `edebug-all-defs' to a non-nil value reverses the meaning
of the prefix argument. Code is then instrumented when this function is
invoked without a prefix argument.
If acting on a `defun' for FUNCTION, and the function was instrumented,
`Edebug: FUNCTION' is printed in the minibuffer. If not instrumented,
just FUNCTION is printed.
If not acting on a `defun', the result of evaluation is displayed in
the minibuffer.
(fn EDEBUG-IT)
(defalias 'edebug-eval-defun #[257 "\211??=?\305\211?=\306 *\211@\307=\203( \211\243\243\203( \310A@!\210\202\217 \211@\311=\203F \312A@!\203F \313A@\314\3158 \"\"\210\202\217 \211@\316=\203\217 \317A@\f\"\320A@\321\305#\210\320A@\322\3238#\210\324\320\325A@D\326\325A@\327NDF\320\325A@D\330\3158FF\320A@\327\305#\210\262\314\331! \"\204\254 \332 !\333 !\211\203\250 \334!\210\210\202\255 )\207" [edebug-all-defs edebug-result edebug-all-forms lexical-binding face-new-frame-defaults nil edebug-read-top-level-form defvar makunbound defcustom default-boundp set-default eval 2 defface assq-delete-all put face-defface-spec face-documentation 3 prog1 quote 'saved-face saved-face 'customized-face eval-sexp-add-defvars prin1 eval-expression-print-format princ] 11 (#$ . 11329) "P"])
(defalias 'edebug-defun 'edebug-eval-top-level-form)
#@813 Evaluate the top level form point is in, stepping through with Edebug.
This is like `eval-defun' except that it steps the code for Edebug
before evaluating it. It displays the value in the echo area
using `eval-expression' (which see).
If you do this on a function definition such as a defun or defmacro,
it defines the function and instruments its definition for Edebug,
so it will do Edebug stepping when called later. It displays
`Edebug: FUNCTION' in the echo area to indicate that FUNCTION is now
instrumented for Edebug.
If the current defun is actually a call to `defvar' or `defcustom',
evaluating it this way resets the variable using its initial value
expression even if the variable already has some other value.
(Normally `defvar' and `defcustom' do not alter the value if there
already is one.)
(defalias 'edebug-eval-top-level-form #[0 "\302\303\211\304\305 !*!\207" [edebug-all-defs edebug-all-forms eval-expression t eval-sexp-add-defvars edebug-read-top-level-form] 3 (#$ . 13113) nil])
(defalias 'edebug-read-top-level-form #[0 "`\300 \210\301 \210\302 b\210\207" [end-of-defun beginning-of-defun edebug-read-and-maybe-wrap-form] 3])
(defalias 'edebug-all-defuns 'edebug-all-defs)
#@39 Toggle edebugging of all definitions.
(defalias 'edebug-all-defs #[0 "?\301\302\203
\303\202 \304\"\207" [edebug-all-defs message "Edebugging all definitions is %s." "on" "off"] 3 (#$ . 14325) nil])
#@33 Toggle edebugging of all forms.
(defalias 'edebug-all-forms #[0 "?\301\302\203
\303\202 \304\"\207" [edebug-all-forms message "Edebugging all forms is %s." "on" "off"] 3 (#$ . 14535) nil])
(defalias 'edebug-install-read-eval-functions #[0 "\300\301\302\303B\304\305$\210\306\307\310\311#\207" [advice--add-function :around #[0 "\300\301!\207" [default-value load-read-function] 2] #[257 "\300\301\"\207" [set-default load-read-function] 4 "\n\n(fn GV--VAL)"] edebug--read nil advice-add eval-defun :override edebug-eval-defun] 5 nil nil])
(defalias 'edebug-uninstall-read-eval-functions #[0 "\300\301\302!\303\"\211\301\302!=\204 \304\302\"\210\210\305\306\307\"\207" [advice--remove-function default-value load-read-function edebug--read set-default advice-remove eval-defun edebug-eval-defun] 4 nil nil])
#@481 A list of entries associating symbols with buffer regions.
Each entry is an `edebug--form-data' struct with fields:
SYMBOL, BEGIN-MARKER, and END-MARKER. The markers
are at the beginning and end of an entry level form and SYMBOL is
a symbol that holds all edebug related information for the form on its
property list.
In the future (haha!), the symbol will be irrelevant and edebug data will
be stored in the definitions themselves rather than in the property
list of a symbol.
(defvar edebug-form-data nil (#$ . 15357))
(make-variable-buffer-local 'edebug-form-data)
(defalias 'edebug--form-data-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block edebug--form-data-name (declare (side-effect-free t)) (car cl-x)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"])
(put 'edebug--form-data-name 'compiler-macro 'edebug--form-data-name--cmacro)
(defalias 'edebug--form-data-name #[257 "\211@\207" [] 2 "\n\n(fn CL-X)"])
(function-put 'edebug--form-data-name 'side-effect-free t)
(defalias 'edebug--form-data-begin--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block edebug--form-data-begin (declare (side-effect-free t)) (nth 1 cl-x)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"])
(put 'edebug--form-data-begin 'compiler-macro 'edebug--form-data-begin--cmacro)
(defalias 'edebug--form-data-begin #[257 "\211A@\207" [] 2 "\n\n(fn CL-X)"])
(function-put 'edebug--form-data-begin 'side-effect-free t)
(defalias 'edebug--form-data-end--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block edebug--form-data-end (declare (side-effect-free t)) (nth 2 cl-x)) nil] 9 "\n\n(fn CL-WHOLE-ARG CL-X)"])
(put 'edebug--form-data-end 'compiler-macro 'edebug--form-data-end--cmacro)
(defalias 'edebug--form-data-end #[257 "\3008\207" [2] 3 "\n\n(fn CL-X)"])
(function-put 'edebug--form-data-end 'side-effect-free t)
(defalias 'edebug--make-form-data-entry--cmacro #[1028 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (name begin end) (cl-block edebug--make-form-data-entry "Constructor for objects of type `edebug--form-data'." (declare (side-effect-free t)) (list name begin end)) nil] 13 "\n\n(fn CL-WHOLE-ARG NAME BEGIN END)"])
(put 'edebug--make-form-data-entry 'compiler-macro 'edebug--make-form-data-entry--cmacro)
#@75 Constructor for objects of type `edebug--form-data'.
(fn NAME BEGIN END)
(defalias 'edebug--make-form-data-entry #[771 "E\207" [] 6 (#$ . 17670)])
(byte-code "\300\301\302\303#\210\304\305\306\211\307\306\310\311\312\306& \207" [function-put edebug--make-form-data-entry side-effect-free t cl-struct-define edebug--form-data nil list ((name) (begin) (end)) cl-struct-edebug--form-data-tags cl-struct-edebug--form-data] 10)
(defalias 'edebug-set-form-data-entry #[1028 "\211\240\266A@\300\223\210\3018\300\223\207" [nil 2] 7 "\n\n(fn ENTRY NAME BEGIN END)"])
(put 'edebug-set-form-data-entry 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'edebug-get-form-data-entry #[513 "\301\302\203H \303W\203H @\211A@ZA\262\303X\203C \211W\203C \2034 \3048U\203C \3048X\203C \211\262\262\266\202 \207" [edebug-form-data nil 999999 0 2] 11 "\n\n(fn PNT &optional END-POINT)"])
#@118 Return the edebug data symbol of the form where point is in.
If point is not inside a edebuggable form, cause error.
(defalias 'edebug-form-data-symbol #[0 "\300`!\211@\262\206
\301\302!\207" [edebug-get-form-data-entry error "Not inside instrumented form"] 2 (#$ . 18585)])
(defalias 'edebug-make-top-form-data-entry #[257 "\301!\210\211B\211\207" [edebug-form-data edebug-clear-form-data-entry] 3 "\n\n(fn NEW-ENTRY)"])
#@124 If non-nil, clear ENTRY out of the form data.
Maybe clear the markers and delete the symbol's edebug property?
(fn ENTRY)
(defalias 'edebug-clear-form-data-entry #[257 "\211\205\n \301\"\211\207" [edebug-form-data delq] 4 (#$ . 19019)])
(defalias 'edebug-syntax-error #[128 "\300\301\"\207" [signal invalid-read-syntax] 4 "\n\n(fn &rest ARGS)"])
(defconst edebug-read-syntax-table (byte-code "\300\301\302\"\303\211\304W\203 \305I\210\211T\262\202 \306\307I\210\310\311I\210\312\313I\210\314\315I\210\316\317I\210\320\321I\210\322\323I\210\324\325I\210\326\327I\210\330\331I\210\332\333I\210\207" [make-char-table syntax-table symbol 0 33 space 40 lparen 41 rparen 39 quote 96 backquote 44 comma 34 string 63 char 91 lbracket 93 rbracket 46 dot 35 hash] 5))
(defalias 'edebug-next-token-class #[0 "\301 \210g\302=\203% \212\303u\210gH\304=\203 g\305U?\206 g\306>)\203% \304\207gH\207" [edebug-read-syntax-table edebug-skip-whitespace 46 1 symbol 59 (44 46)] 2])
(defalias 'edebug-skip-whitespace #[0 "\300\301w\210g\302U\205 \303\301w\210\300\301w\210\202 \207" ["
\n\f" nil 59 "^\n"] 2])
(defalias 'edebug-read-sexp #[0 "\300 \211\301=\203 \302p!\202G \211\303=\203 \302p!\202G \211\304=\203* \305u\210\304\306 D\202G \211\307=\2037 \310\306 D\202G \211\311=\203D \312\306 D\202G \302p!\207" [edebug-next-token-class symbol read string quote 1 edebug-read-sexp backquote \` comma \,] 3])
(defvar edebug-offsets nil)
(defvar edebug-offsets-stack nil)
(defvar edebug-current-offset nil)
(defvar edebug-read-dotted-list nil)
(defalias 'edebug-initialize-offsets #[0 "\301\211\207" [edebug-current-offset nil] 2])
(put 'edebug-initialize-offsets 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'edebug-store-before-offset #[257 "\211C\203 AB\241\210\202 \211\304\211\211\nB\211\211\207" [edebug-current-offset edebug-offsets edebug-offsets-stack edebug-read-dotted-list nil] 6 "\n\n(fn POINT)"])
(defalias 'edebug-store-after-offset #[257 "\204
\211A\237\241\210\202 \303 \211AA\237 A@A\244\241\210 \244\nA\211@\211\207" [edebug-read-dotted-list edebug-current-offset edebug-offsets-stack nil] 5 "\n\n(fn POINT)"])
(defalias 'edebug-ignore-offset #[0 "\211AA\241\207" [edebug-current-offset] 2])
(defalias 'edebug-storing-offsets '(macro . #[385 "\300\301\302DBB\303BB\207" [unwind-protect progn edebug-store-before-offset ((edebug-store-after-offset (point)))] 6 "\n\n(fn POINT &rest BODY)"]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\207" [put edebug-storing-offsets edebug-form-spec (form body) function-put lisp-indent-function 1] 4)
(defconst edebug-read-alist '((symbol . edebug-read-symbol) (lparen . edebug-read-list) (string . edebug-read-string) (quote . edebug-read-quote) (backquote . edebug-read-backquote) (comma . edebug-read-comma) (lbracket . edebug-read-vector) (hash . edebug-read-function)))
(defalias 'edebug-read-storing-offsets #[257 "\302\303\216\304`!\210\305 \236A\206 \306!*\207" [edebug-read-dotted-list edebug-read-alist nil #[0 "\300`!\207" [edebug-store-after-offset] 2] edebug-store-before-offset edebug-next-token-class read] 3 "\n\n(fn STREAM)"])
(byte-code "\300\301\302\"\210\300\303\302\"\207" [defalias edebug-read-symbol read edebug-read-string] 3)
(defalias 'edebug-read-quote #[257 "\300u\210\301\216\302`S!\210)\303\304!D\207" [1 #[0 "\300`!\207" [edebug-store-after-offset] 2] edebug-store-before-offset quote edebug-read-storing-offsets] 4 "\n\n(fn STREAM)"])
(defalias 'edebug-read-backquote #[257 "\300u\210\301\216\302`S!\210)\303\304!D\207" [1 #[0 "\300`!\207" [edebug-store-after-offset] 2] edebug-store-before-offset \` edebug-read-storing-offsets] 4 "\n\n(fn STREAM)"])
(defalias 'edebug-read-comma #[257 "`\300u\210\301g\302=\203 \303\262\300u\210\202 g\304=\203 \305\262\300u\210\306\216\307!\210)\211\310!D\262\207" [1 \, 46 \,\. 64 \,@ #[0 "\300`!\207" [edebug-store-after-offset] 2] edebug-store-before-offset edebug-read-storing-offsets] 6 "\n\n(fn STREAM)"])
(defalias 'edebug-read-function #[257 "\300u\210g\301=\203 \300u\210\302\216\303`\304Z!\210)\305\306!D\207g\307>\203( \310u\210\311!\207\312\313!\207" [1 39 #[0 "\300`!\207" [edebug-store-after-offset] 2] edebug-store-before-offset 2 function edebug-read-storing-offsets (58 66 79 88 98 111 120 49 50 51 52 53 54 55 56 57 48) -1 read edebug-syntax-error "Bad char after #"] 4 "\n\n(fn STREAM)"])
(defalias 'edebug-read-list #[257 "\301u\210\302\303 \304>\204 \305!B\262\202 \211\237\262\303 \306=\203< \302\301u\210\305!\262\244\210\303 \307=\2048 \310\311!\210\211<\210\211\262\301u\210\207" [edebug-read-dotted-list 1 nil edebug-next-token-class (rparen dot) edebug-read-storing-offsets dot rparen edebug-syntax-error "Expected `)'"] 5 "\n\n(fn STREAM)"])
(defalias 'edebug-read-vector #[257 "\300u\210\301\302 \303=\204 \304!B\262\202 \305\306\237\"\262\300u\210\207" [1 nil edebug-next-token-class rbracket edebug-read-storing-offsets apply vector] 5 "\n\n(fn STREAM)"])
(defvar edebug-dotted-spec nil)
(defalias 'edebug-new-cursor #[514 "\300!\203\f \301\302\"\262B\207" [vectorp append nil] 5 "\n\n(fn EXPRESSIONS OFFSETS)"])
(defalias 'edebug-set-cursor #[771 "\240\210\241\210\207" [] 5 "\n\n(fn CURSOR EXPRESSIONS OFFSETS)"])
(put 'edebug-set-cursor 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'edebug-copy-cursor #[257 "\211@AB\207" [] 3 "\n\n(fn CURSOR)"])
(defalias 'edebug-cursor-expressions #[257 "\211@\207" [] 2 "\n\n(fn CURSOR)"])
(put 'edebug-cursor-expressions 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'edebug-cursor-offsets #[257 "\211A\207" [] 2 "\n\n(fn CURSOR)"])
(put 'edebug-cursor-offsets 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'edebug-empty-cursor #[257 "\211@?\207" [] 2 "\n\n(fn CURSOR)"])
(put 'edebug-empty-cursor 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'edebug-top-element #[257 "\211@@\207" [] 2 "\n\n(fn CURSOR)"])
(put 'edebug-top-element 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'edebug-top-element-required #[385 "\203 \301\302\"\210\211@?\262\203 \303\301#\210\211@@\207" [edebug-dotted-spec edebug-no-match "Dot expected." apply] 6 "\n\n(fn CURSOR &rest ERROR)"])
(defalias 'edebug-top-offset #[257 "\211A@\207" [] 2 "\n\n(fn CURSOR)"])
(put 'edebug-top-offset 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'edebug-move-cursor #[257 "\211\211@?\262\203 \300\301\"\210\211@A\240\210\211AA\241\210\207" [edebug-no-match "Not enough arguments."] 4 "\n\n(fn CURSOR)"])
(defalias 'edebug-before-offset #[257 "\211\211A\262\211:\203 \211@@\202 \211S\207" [] 3 "\n\n(fn CURSOR)"])
(defalias 'edebug-after-offset #[257 "\211\211A@\262\211:\203 \211A\262\202 \211\207" [] 3 "\n\n(fn CURSOR)"])
(defvar edebug-gate nil)
(defvar edebug-def-name nil)
(defvar edebug-old-def-name nil)
(defvar edebug-error-point nil)
(defvar edebug-best-error nil)
(defalias 'edebug-read-and-maybe-wrap-form #[0 "\306\307!\203 \211 \210\202 \310\311\"\210\210\306\211\211\211\211\211\211\211\312 \\\313\n\\ \3142: \315 \262\3060\211\203C \316\317\"\210\210. \211\207" [edebug-setup-hook max-lisp-eval-depth max-specpdl-size edebug-error-point edebug-best-error edebug-gate nil functionp mapc funcall 800 2000 no-match edebug-read-and-maybe-wrap-form1 apply edebug-syntax-error edebug-&rest edebug-&optional edebug-def-name edebug-top-window-data] 11])
(defalias 'edebug-read-and-maybe-wrap-form1 #[0 "\305\211\211\211\211\211\211\212\306 \307=\203N \310u\210\306 \311=\203N \312p!\2629\205) \313!\262<\2054 @\314=\262\205L A@\315=\205L \306 \311=\205L \312p!\262)\203\210 \204[ \f\203| \316\317p!C\nC\"\320\321!\322!S\323! ABC$@\262\202\245 \324\325\326 #\210\327 \202\245 \f\203\243 \316\317p!C\nC\"\320\321!\322!\305$\262\202\245 \327 +\207" [edebug-current-offset edebug-offsets-stack edebug-offsets edebug-all-defs edebug-all-forms nil edebug-next-token-class lparen 1 symbol read get-edebug-spec &define name edebug-new-cursor edebug-read-storing-offsets edebug-make-form-wrapper edebug-before-offset edebug-after-offset symbol-name put edebug point-marker edebug-read-sexp] 11])
(defalias 'edebug-interactive-p-name #[0 "\301\302\303\"!\207" [edebug-def-name intern format "edebug-%s-interactive-p"] 4])
#@50 Wrap the FORMS of a definition body.
(fn FORMS)
(defalias 'edebug-wrap-def-body #[257 "\203 \301\302 \303BC\304!E\207\304!\207" [edebug-def-interactive let edebug-interactive-p-name ((interactive-p)) edebug-make-enter-wrapper] 5 (#$ . 27326)])
(defalias 'edebug-make-enter-wrapper #[257 "\206 \206 \304\305!\306\307D\n\205 \310 \237B\311\312\313BBDF\207" [edebug-def-name edebug-old-def-name edebug-inside-func edebug-def-args cl-gensym "edebug-anon" edebug-enter quote list function lambda nil] 8 "\n\n(fn FORMS)"])
(defalias 'edebug-inc-offset #[257 " Z\nBT\207" [edebug-offset-index edebug-form-begin-marker edebug-offset-list] 4 "\n\n(fn OFFSET)"])
(defalias 'edebug-make-before-and-after-form #[771 "\300\301DF\207" [edebug-after edebug-before] 7 "\n\n(fn BEFORE-INDEX FORM AFTER-INDEX)"])
(defalias 'edebug-make-after-form #[514 "\300\301F\207" [edebug-after 0] 6 "\n\n(fn FORM AFTER-INDEX)"])
#@215 Return the unwrapped SEXP or return it as is if it is not wrapped.
The SEXP might be the result of wrapping a body, which is a list of
expressions; a `progn' form will be returned enclosing these forms.
(fn SEXP)
(defalias 'edebug-unwrap #[257 "\211:\203\" \211@\300=\203 \3018\207\211@\302=\203! \303\3018A@AA!\207\207\207" [edebug-after 3 edebug-enter macroexp-progn] 4 (#$ . 28257)])
#@51 Return the SEXP recursively unwrapped.
(fn SEXP)
(defalias 'edebug-unwrap* #[257 "\300!=\204 \211\262\300!\262\202 \211:\203 \301\302\"\202! \211\207" [edebug-unwrap mapcar edebug-unwrap*] 5 (#$ . 28654)])
(defalias 'edebug-defining-form #[1028 "\211\211@\262\211A\262A\240\210\241\210\266\300S$\207" [edebug-make-form-wrapper] 9 "\n\n(fn CURSOR FORM-BEGIN FORM-END SPECLIST)"])
(defalias 'edebug-make-form-wrapper #[1027 "\306\"\211\203 \211A@\202 \307 \310\223\310\311\310@\310\211\211\211 \2035 \312\"\202< \313\314 !C!\262\f\206I
\206I \315\316!\204a \f\307 \310\223E\266\203\262\202| \f\211\240\266A@\310\223\210\3178\310\223\266\320!\210\321\322\f\"\210\323 \237! \324\f!\210\325\f!\210 \204\251 \326p!\206\241 \327 \211\330!B \210\331\f\332\310 F#\210.\266\202)\207" [edebug-form-begin-marker edebug-inside-func edebug-def-interactive edebug-def-args edebug-def-name edebug-old-def-name edebug-get-form-data-entry make-marker nil 0 edebug-match edebug-make-enter-wrapper edebug-form cl-gensym "edebug-anon" 2 edebug-make-top-form-data-entry message "Edebug: %s" vconcat edebug-clear-frequency-count edebug-clear-coverage get-buffer-window selected-window window-start put edebug edebug-offset-index edebug-offset-list edebug-top-window-data] 15 "\n\n(fn CURSOR FORM-BEGIN FORM-END &optional SPECLIST)"])
(defalias 'edebug-clear-frequency-count #[257 "\301\302\303G\304\"#\207" [edebug-offset-list put edebug-freq-count make-vector 0] 7 "\n\n(fn NAME)"])
(defalias 'edebug-clear-coverage #[257 "\301\302\303G\304\"#\207" [edebug-offset-list put edebug-coverage make-vector unknown] 7 "\n\n(fn NAME)"])
(defalias 'edebug-form #[257 "\300\301\"\211A@\262:\203] @\302=\203 \202} @\2119\205$ \303!\304\":\203H @\305=\203H \306@\307 !\310!AB$\202X \311\312@!\313!\312\211A\262!#\266\203\202} 9\203| \314>\204n \315!\203r \202} \316\312A!\"\202} \317!\210\207" [edebug-top-element-required "Expected form" quote get-edebug-spec edebug-new-cursor &define edebug-defining-form edebug-after-offset symbol-name edebug-make-before-and-after-form edebug-inc-offset edebug-list-form (t nil) keywordp edebug-make-after-form edebug-move-cursor] 12 "\n\n(fn CURSOR)"])
(defalias 'edebug-forms #[257 "\300\301\"\207" [edebug-match (&rest form)] 4 "\n\n(fn CURSOR)"])
(put 'edebug-forms 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'edebug-sexps #[257 "\300\301\"\207" [edebug-match (&rest sexp)] 4 "\n\n(fn CURSOR)"])
(put 'edebug-sexps 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'edebug-list-form-args #[514 "\303!\211\203C \211:\203 \304\211\305\"*\202h \211\306=\203( \307\310\"\262\202h \211\311=\2038 \307\312\"\262\202h \2119\205h \211!\202h \313!\203a \n\203W \307\310\"\262\202h \307\312\"\262\202h \307\310\"\262\207" [edebug-error-point edebug-best-error edebug-eval-macro-args get-edebug-spec nil edebug-match-sublist t edebug-match (&rest form) 0 (&rest sexp) macrop] 7 "\n\n(fn HEAD CURSOR)"])
(put 'edebug-list-form-args 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'edebug-list-form #[257 "\306\307\"\310\311\211\211\211@\262\211A\262A\240\210\241\210\266\2119\203\263 \211\204. \311\202\321 \211\312=\203? \313\314!\210\315 \202\321 \211\314!\316!\211\203\207 \211:\203\\ \311\211 \317\"*\202\255 \211\310=\203l \320\321\"\262\202\255 \211\322=\203| \320\323\"\262\202\255 \2119\205\255 \211!\202\255 \324!\203\246 \203\234 \320\321\"\262\202\255 \320\323\"\262\202\255 \320\321\"\262\266\203B\202\321 \211:\203\316 \211@\325=\203\306 \320\326\"\202\321 \327\330\327#\202\321 \331\332!+\207" [edebug-&rest edebug-&optional edebug-gate edebug-def-interactive edebug-error-point edebug-best-error edebug-top-element-required "Expected elements" t nil interactive-p check-it edebug-move-cursor edebug-interactive-p-name get-edebug-spec edebug-match-sublist edebug-match (&rest form) 0 (&rest sexp) macrop \, (("," def-form) body) edebug-match-specs (lambda-expr body) edebug-syntax-error "Head of list form must be a symbol or lambda expression" edebug-eval-macro-args] 10 "\n\n(fn CURSOR)"])
(defvar edebug-after-dotted-spec nil)
(defvar edebug-matching-depth 0)
(defconst edebug-max-depth 150)
(defalias 'edebug-no-match #[385 "\206 \304! \206
\211\n\203\" \204\" \203 b\210\305\306\"\207\307\310\"\207" [edebug-error-point edebug-best-error edebug-gate edebug-&optional edebug-before-offset apply edebug-syntax-error throw no-match] 5 "\n\n(fn CURSOR &rest ARGS)"])
(defalias 'edebug-match #[514 "\305\211\211\211 \306\306#-\207" [edebug-gate edebug-error-point edebug-best-error edebug-&rest edebug-&optional nil edebug-match-specs] 7 "\n\n(fn CURSOR SPECS)"])
(defalias 'edebug-match-one-spec #[514 "\2119\203\n \300\"\207\301!\203 \302\303\304\"\"\207\211;\203\" \305\"\207\211<\205+ \306\"\207" [edebug-match-symbol vectorp edebug-match append nil edebug-match-string edebug-match-list] 7 "\n\n(fn CURSOR SPEC)"])
(defalias 'edebug-match-specs #[771 " V\203\f \303\304!\202 T\204 \305\202\257 :\204( \306\307C#)\202\257 \211@\262<\204e \n\204: \310\311\"\210\305\211@\262\211A\262C\240\210\241\210\266\307#@)\266\203\202\257 @\3059\205r \312!\313H\211\314=\203\204 \315!A\"\202\245 \211\316=\203\234 AA\262\315!A@\"\202\245 A\262\317\"#\244\266\203)\207" [edebug-matching-depth edebug-max-depth edebug-dotted-spec error "Too deep - perhaps infinite loop in spec?" nil t edebug-match-specs edebug-no-match "Dotted spec required." symbol-name 0 38 get-edebug-spec 58 edebug-match-one-spec] 11 "\n\n(fn CURSOR SPECS REMAINDER-HANDLER)"])
(byte-code "\300\211\203 \211@\301@\302A#\210A\266\202\202 \207" [((&optional . edebug-match-&optional) (&rest . edebug-match-&rest) (&or . edebug-match-&or) (form . edebug-match-form) (sexp . edebug-match-sexp) (body . edebug-match-body) (&define . edebug-match-&define) (name . edebug-match-name) (:name . edebug-match-colon-name) (arg . edebug-match-arg) (def-body . edebug-match-def-body) (def-form . edebug-match-def-form) (lambda-expr . edebug-match-lambda-expr) (¬ . edebug-match-¬) (&key . edebug-match-&key) (place . edebug-match-place) (gate . edebug-match-gate)) put edebug-form-spec] 6)
(defalias 'edebug-match-symbol #[514 "\300!\211\203 \211:\203 \301\"\202\\ \211!\202\\ \204# \302!\202\\ \303!\203X \304\305#\211<\203A \211@\306=\203A \301\307\"\202S !\204M \310\311#\210\312!\210\211C\262\202\\ \313\314\"\207" [get-edebug-spec edebug-match edebug-match-nil fboundp edebug-top-element-required "Expected" \, (("," def-form)) edebug-no-match "failed" edebug-move-cursor error "%s is not a form-spec or function"] 8 "\n\n(fn CURSOR SYMBOL)"])
(defalias 'edebug-match-sexp #[257 "\300\301\"\302!\210C\207" [edebug-top-element-required "Expected sexp" edebug-move-cursor] 4 "\n\n(fn CURSOR)"])
(defalias 'edebug-match-form #[257 "\300!C\207" [edebug-form] 3 "\n\n(fn CURSOR)"])
(defalias 'edebug-match-place 'edebug-match-form)
(defalias 'edebug-match-body #[257 "\211\300\301\"\207" [edebug-match (&rest form)] 5 "\n\n(fn CURSOR)"])
(put 'edebug-match-body 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'edebug-match-&optional #[514 "\300\300#\207" [edebug-&optional-wrapper] 6 "\n\n(fn CURSOR SPECS)"])
(defalias 'edebug-&optional-wrapper #[771 "\302\302\211@\262\211A\262\3032\" \304#\262\3020\204) \2029 \240\210\241\210\266\302*\207" [edebug-gate edebug-&optional nil no-match edebug-match-specs] 13 "\n\n(fn CURSOR SPECS REMAINDER-HANDLER)"])
(defalias 'edebug-&rest-wrapper #[771 "\204 \262\301#\207" [edebug-&rest edebug-&optional-wrapper] 7 "\n\n(fn CURSOR SPECS REMAINDER-HANDLER)"])
(defalias 'edebug-match-&rest #[514 "\211\303\211\304\304#+\207" [edebug-error-point edebug-best-error edebug-&rest nil edebug-&rest-wrapper] 6 "\n\n(fn CURSOR SPECS)"])
(defalias 'edebug-match-&or #[514 "\211\211@\262\211A\262\3032H \203? \3042) \305\303\306\211\211\307@\"+\"0\210A\262\240\210\241\210\266\202 \310\311\312$0\207" [edebug-error-point edebug-best-error edebug-gate matched no-match throw nil edebug-match-one-spec apply edebug-no-match "Expected one of"] 10 "\n\n(fn CURSOR SPECS)"])
(defalias 'edebug-match-¬ #[514 "\3012 \302\212\303\"\210*\3020\204 \304\305\"\210\302\207" [edebug-gate no-match nil edebug-match-&or edebug-no-match "Unexpected"] 5 "\n\n(fn CURSOR SPECS)"])
(put '&key 'edebug-form-spec 'edebug-match-&key)
(defalias 'edebug-match-&key #[514 "\300\301\302\303\"B\"\207" [edebug-match-&rest &or mapcar #[257 "\300\301\302@\"A@\"\207" [vector format ":%s"] 5 "\n\n(fn PAIR)"]] 8 "\n\n(fn CURSOR SPECS)"])
(defalias 'edebug-match-gate #[257 "\301\302\207" [edebug-gate t nil] 2 "\n\n(fn CURSOR)"])
(defalias 'edebug-match-list #[514 "\203 \302\303\303#)\302\207\211@\304\305#\306=\203C A@\2119\203: \211=\2040 \307\305#\210\310!\210\311\202> \312\313\"\262\202\224 \314=\203t \315!\203l \316\317\211A@\262A\"A\"\310!\210\320\314\"C\262\202\224 \307\305#\202\224 \211<\203\217 \316\317\211A@\262A\"\"C\310!\210\202\224 \307\305#\207" [edebug-dotted-spec edebug-gate nil edebug-match-specs edebug-top-element-required "Expected" quote edebug-no-match edebug-move-cursor t error "Bad spec: %s" vector vectorp edebug-match-sublist edebug-new-cursor apply] 9 "\n\n(fn CURSOR SPECS)"])
(defalias 'edebug-match-sublist #[514 "\302\303\303#\211@?\262\204# \203 \304\305 #\210\202# \305\306#\210)\207" [edebug-&optional edebug-best-error nil edebug-match-specs apply edebug-no-match "Failed matching"] 7 "\n\n(fn CURSOR SPECS)"])
(defalias 'edebug-match-string #[514 "\301\302#\303!=\204 \304\302#\202 \305\306!\210\211C\207" [edebug-gate edebug-top-element-required "Expected" intern edebug-no-match t edebug-move-cursor] 7 "\n\n(fn CURSOR SPEC)"])
(defalias 'edebug-match-nil #[257 "\211\211@?\262?\205 \300\301\"\207" [edebug-no-match "Unmatched argument(s)"] 4 "\n\n(fn CURSOR)"])
(defalias 'edebug-match-function #[257 "\300\301!\207" [error "Use function-form instead of function in edebug spec"] 3 "\n\n(fn CURSOR)"])
(defalias 'edebug-match-&define #[514 "\300\301!\211A\262\211:\203 \211A\262\202\n \211\262$\207" [edebug-make-form-wrapper edebug-before-offset] 7 "\n\n(fn CURSOR SPECS)"])
(defalias 'edebug-match-lambda-expr #[257 "\301\302\"\211A@\262:\205 @\2119\205 \303!\304\211:\203C \211@\305=\203C \306\307\"@\310!\311!AB$C\312!\210\202G \313\302\")\207" [edebug-inside-func edebug-top-element-required "Expected lambda expression" get-edebug-spec nil &define edebug-defining-form edebug-new-cursor edebug-after-offset symbol-name edebug-move-cursor edebug-no-match] 11 "\n\n(fn CURSOR)"])
(defalias 'edebug-match-name #[257 "\301\302\"\2119\204 \303\304\"\210\203 \305\306\307#!\202 \211\310!\210\211C\207" [edebug-def-name edebug-top-element-required "Expected name" edebug-no-match "Symbol expected for name of definition" intern format "%s@%s" edebug-move-cursor] 7 "\n\n(fn CURSOR)"])
(defalias 'edebug-match-colon-name #[514 "\203 \301\302\303#!\202 \211\304\207" [edebug-def-name intern format "%s@%s" nil] 7 "\n\n(fn CURSOR SPEC)"])
(defalias 'edebug-match-arg #[257 "\301\302\"\2119\203 \303!\203 \304\305#\210\306!\210\211B\211C\207" [edebug-def-args edebug-top-element-required "Expected arg" edebug-lambda-list-keywordp edebug-no-match "Bad argument:" edebug-move-cursor] 6 "\n\n(fn CURSOR)"])
(defalias 'edebug-match-def-form #[257 "\301\302\303!C!)C\207" [edebug-inside-func nil edebug-make-enter-wrapper edebug-form] 4 "\n\n(fn CURSOR)"])
(defalias 'edebug-match-def-body #[257 "\301\211\302\303\"\262\211\205 \304!C)\207" [edebug-inside-func t edebug-match (&rest form) edebug-wrap-def-body] 5 "\n\n(fn CURSOR)"])
#@86 Return non-nil if OBJECT is a symbol with an edebug-form-spec property.
(fn OBJECT)
(defalias 'edebug-spec-p #[257 "\2119\205 \211\300N\207" [edebug-form-spec] 3 (#$ . 40639)])
(byte-code "\300\301\302\303#\210\300\304\302\305#\210\300\306\302\307#\210\300\310\302\311#\210\300\312\302\313#\210\300\313\302\314#\210\300\315\302\316#\210\300\317\302\320#\210\300\321\302\322#\210\300\322\302\323#\210\300\324\302\325#\210\300\326\302\327#\210\300\330\302\331#\210\300\332\302\333#\210\300\334\302\335#\210\300\336\302\334#\210\300\337\302\340#\210\300\341\302\337#\210\300\342\302\343#\210\300\344\302\345#\210\300\346\302\347#\210\300\350\302\351#\210\352\353\346\"\210\300\353\302\354#\210\300\355\302\356#\210\300\357\302\360#\210\300\361\302\362#\210\300\363\302\362#\207" [put def-edebug-spec edebug-form-spec (&define :name edebug-spec name &or "nil" edebug-spec-p "t" "0" (&rest edebug-spec)) edebug-spec-list ((edebug-spec . [&or nil edebug-spec])) edebug-spec (&or (vector &rest edebug-spec) ("vector" &rest edebug-spec) ("quote" symbolp) edebug-spec-list stringp [edebug-lambda-list-keywordp &rest edebug-spec] [keywordp gate edebug-spec] edebug-spec-p symbolp) quote sexp defconst defvar (symbolp &optional form stringp) defun (&define name lambda-list [&optional stringp] [&optional ("interactive" interactive)] def-body) defmacro (&define name lambda-list [&optional stringp] [&optional ("declare" &rest sexp)] def-body) arglist lambda-list (([&rest arg] [&optional ["&optional" arg &rest arg]] &optional ["&rest" arg])) interactive (&optional &or stringp def-form) function-form (&or ([&or "quote" "function"] &or symbolp lambda-expr) form) function (&or symbolp lambda-expr) macro (&define "lambda" lambda-list def-body) let ((&rest &or (symbolp &optional form) symbolp) body) let* setq (&rest symbolp form) setq-default cond (&rest (&rest form)) condition-case (symbolp form &rest ([&or symbolp (&rest symbolp)] body)) \` (backquote-form) backquote-form (&or ([&or "," ",@"] &or ("quote" backquote-form) form) (backquote-form [&rest [¬ ","] backquote-form] . [&or nil backquote-form]) (vector &rest backquote-form) sexp) defalias edebug-\` (def-form) \, (&or ("quote" edebug-\`) def-form) \,@ (&define &or ("quote" edebug-\`) def-form) save-selected-window t save-current-buffer] 4)
(defvar edebug-active nil)
(defvar edebug-stack nil)
(defvar edebug-stack-depth -1)
(defvar edebug-offset-indices nil)
(defvar edebug-entered nil)
(defconst edebug-debugger 'edebug)
(defvar edebug-execution-mode 'step)
(defvar edebug-next-execution-mode nil)
#@701 Signal an error. Args are SIGNAL-NAME, and associated DATA.
A signal name is a symbol with an `error-conditions' property
that is a list of condition names.
A handler for any of those names will get to handle this signal.
The symbol `error' should always be one of them.
DATA should be a list. Its elements are printed as part of the error message.
If the signal is handled, DATA is made available to the handler.
See `condition-case'.
This is the Edebug replacement for the standard `signal'. It should
only be active while Edebug is. It checks `debug-on-error' to see
whether it should call the debugger. When execution is resumed, the
error is signaled again.
(fn SIGNAL-NAME SIGNAL-DATA)
(defalias 'edebug-signal #[514 "<\203 >\203 \302\303B\"\210\304\305\")\207" [debug-on-error signal-hook-function edebug error nil signal] 6 (#$ . 43208)])
(defalias 'edebug-enter #[771 " \204E \306\307\n\\\310 \\\f
\206 \311\216\312 \2066 \2066 \313 \314#.\n\202\222 \315N\211 !@ \"\316N \317N \320\"! #$B $\321%B %\322N\203\201 \323 \322N\324=\203\201 \325\322\313#\210&\203\216 \326#\202\220 \211 .)\207" [edebug-function edebug-entered max-lisp-eval-depth max-specpdl-size edebug-debugger debug-on-error t 100 200 #[0 "\300\207" [nil] 1] edebug-signal nil edebug-enter edebug edebug-freq-count edebug-coverage marker-buffer 0 edebug-on-entry step temp put edebug--enter-trace debug-on-quit edebug-on-error edebug-on-quit edebug-outside-debug-on-quit edebug-outside-debug-on-error debugger signal-hook-function edebug-next-execution-mode edebug-initial-mode edebug-execution-mode edebug-data edebug-def-mark edebug-buffer edebug-stack edebug-offset-indices edebug-trace] 12 "\n\n(fn FUNCTION ARGS BODY)"])
#@426 Return a cons cell describing the status of VAR's current binding.
The purpose of this function is so you can properly undo
subsequent changes to the same binding, by passing the status
cons cell to `edebug-restore-status'. The status cons cell
has the form (LOCUS . VALUE), where LOCUS can be a buffer
(for a buffer-local binding), a frame (for a frame-local binding),
or nil (if the default binding is current).
(fn VAR)
(defalias 'edebug-var-status #[257 "\300!JB\207" [variable-binding-locus] 3 (#$ . 44986)])
#@102 Reset VAR based on STATUS.
STATUS should be a list returned by `edebug-var-status'.
(fn VAR STATUS)
(defalias 'edebug-restore-status #[514 "\211@A\300!\203 \301!\205. rq\210L)\202. \302!\203+ \303BC\"\202. L\207" [bufferp buffer-live-p framep modify-frame-parameters] 8 (#$ . 45511)])
(defalias 'edebug--enter-trace #[771 "T\302\303\304\305#!\210\211 \211\306\304\307 #!\210*\207" [edebug-stack-depth edebug-result nil edebug-print-trace-before format "%s args: %s" edebug-print-trace-after "%s result: %s"] 9 "\n\n(fn FUNCTION ARGS BODY)"])
(put 'edebug-tracing 'edebug-form-spec '(form body))
#@120 Print MSG in *edebug-trace* before and after evaluating BODY.
The result of BODY is also printed.
(fn MSG &rest BODY)
(defalias 'edebug-tracing '(macro . #[385 "\300\301\302D\303\304\305\306BE\307\310\311 \312BBBDEF\207" [let ((edebug-stack-depth (1+ edebug-stack-depth)) edebug-result) edebug-print-trace-before prog1 setq edebug-result progn edebug-print-trace-after format "%s result: %s" (edebug-result)] 12 (#$ . 46135)]))
#@108 Function called to print trace info before expression evaluation.
MSG is printed after `::::{ '.
(fn MSG)
(defalias 'edebug-print-trace-before #[257 "\302\303\304 \305\"$\207" [edebug-trace-buffer edebug-stack-depth edebug-trace-display "%s{ %s" make-string 58] 7 (#$ . 46575)])
#@107 Function called to print trace info after expression evaluation.
MSG is printed after `::::} '.
(fn MSG)
(defalias 'edebug-print-trace-after #[257 "\302\303\304 \305\"$\207" [edebug-trace-buffer edebug-stack-depth edebug-trace-display "%s} %s" make-string 58] 7 (#$ . 46864)])
(defalias 'edebug-slow-before #[257 "\204! \240\210\n\nHTI\210 \304>\203 \305 \203! \306\307\310#\210\207" [edebug-active edebug-offset-indices edebug-freq-count edebug-execution-mode (Go-nonstop next) input-pending-p edebug-debugger before nil] 5 "\n\n(fn BEFORE-INDEX)"])
(defalias 'edebug-fast-before #[257 "\300\207" [nil] 2 "\n\n(fn BEFORE-INDEX)"])
(defalias 'edebug-slow-after #[771 "\203 \207 \240\210\n\nHTI\210 \203 \305\"\210\f\306=\203& \307 \204& \207\310\311#\207" [edebug-active edebug-offset-indices edebug-freq-count edebug-test-coverage edebug-execution-mode edebug--update-coverage Go-nonstop input-pending-p edebug-debugger after] 7 "\n\n(fn BEFORE-INDEX AFTER-INDEX VALUE)"])
(defalias 'edebug-fast-after #[771 "\207" [] 4 "\n\n(fn BEFORE-INDEX AFTER-INDEX VALUE)"])
(defalias 'edebug-run-slow #[0 "\300\301\302\"\210\300\303\304\"\207" [defalias edebug-before edebug-slow-before edebug-after edebug-slow-after] 3])
(defalias 'edebug-run-fast #[0 "\300\301\302\"\210\300\303\304\"\207" [defalias edebug-before edebug-fast-before edebug-after edebug-fast-after] 3])
(edebug-run-slow)
(defalias 'edebug--update-coverage #[514 "H\211\301=\206! \211\302=\203 I\202! =?\205! \301I\207" [edebug-coverage ok-coverage unknown] 6 "\n\n(fn AFTER-INDEX VALUE)"])
(defvar edebug-break-result nil)
(defvar edebug-global-break-result nil)
(defalias 'edebug-debugger #[771 "\203 \207 A@\n\236\211A@
\205% \3061# \307
!\2110\202% \210\310 \310 \206> \205> \f?\206> \307\f!\211\211\203U \311 8\203U \312 \n\" AAB\241\210\313>\203f \204f \314 \203l \315#\210-\207" [inhibit-redisplay edebug-data edebug-breakpoints edebug-break-data edebug-break-condition edebug-global-break-condition (error) edebug-eval nil 2 delq (go continue Continue-fast) input-pending-p edebug--display edebug-global-break-result edebug-global-break edebug-break edebug-break-result edebug-execution-mode] 8 "\n\n(fn OFFSET-INDEX ARG-MODE VALUE)"])
(defvar edebug-eval-list nil)
(defvar edebug-previous-result nil)
(defalias 'edebug-mark-marker 'mark-marker)
(defalias 'edebug--display #[771 "\212\300#)\207" [edebug--display-1] 7 "\n\n(fn VALUE OFFSET-INDEX ARG-MODE)"])
(defalias 'edebug--display-1 #[771 "\306!\204 \307 \210\310\311 \312\313 8H\\\312\314 8\315 p`\316 \312\211C\312\n\205) \317 \312C\312C\320\321! ? @ A\n B\f C D\322\323\324\325\326!\327\"\314$\216\312\211 E F\330\321\310\"\210\331G!\204r \332\333H\"\210\334=\203~ \335!\210I\203\210 \336I!J\203\222 \337 \240\210\340GB@\"\210B\315 \240\210\341!\210\342B@!\210Gq\210`\262\fCb\210\343=\203\310 g\344>\204\310 \332\345H\"\210KL L K\346 \210\347=\203\372 \350M\346 \210\351 \210@\352=\203\362 \353\354!\210\2021\355!\210\2021N\203-O\203\353\356PQ#\210\2021R\203 \353\357RS#\210\2021M\360=\2041\353\361!\210\2021\353\362!\210\334=\203LN\203IM\360=\204I\363T!\210\364 \210N\203tM\365=\203`\363T!\210\202\216M\360=\203n\363\323!\210\202\216\310\262\202\216M\366=\203\203\363T!\210\202\216M\367=\203\216\363\323!\210\370 \203\234\310\262\350M\371 \210\346 \210\322\323\372\325\326\n$\373\"\374$\216
\204\305M\375>\204\305\347=\203\312\376!\210+rGq\210 b.
\207" [edebug-def-mark edebug-data edebug-eval-list edebug-outside-d-c-i-n-s-w edebug-eval-buffer edebug-outside-windows marker-position debug t with-timeout-suspend nil 2 3 selected-window edebug-mark edebug-eval-result-list default-value cursor-in-non-selected-windows make-byte-code 0 " \203 \303 !\210\304\300!\210\305\306\n\"\207" vconcat vector [edebug-eval-buffer edebug-outside-d-c-i-n-s-w kill-buffer with-timeout-unsuspend set-default cursor-in-non-selected-windows] set-default buffer-name user-error "Buffer defining %s not found" after edebug-compute-previous-result edebug-current-windows edebug-get-displayed-buffer-points edebug-pop-to-buffer edebug-eval-display select-window before (40 35 96) "Source has changed - reevaluate definition of %s" edebug-overlay-arrow error step beep quit message "Quit" edebug-report-error "Global Break: %s => %s" "Break: %s => %s" Continue-fast "Break" "" sit-for edebug-previous-result continue trace Trace-fast input-pending-p edebug-stop "\306 \f=\203\f \307 \202 \310\f!\211\203
\240\210
\311!\241\210\210\302\310!\240\210\302\242\2036 \303\302\242\2054 \311\302\242!\240\210\203p \312!\210\203J \313\301\242!\210\302\242\203V \314\302\242\303\242\"\210
@\315!\203l \306 \f=\203l \314
A\316#\210\210\202z \315\300!\203z \317\300!\210\320!\203\205 q\210\f=\204\220 b\210\321\322 !\205\235 \322 \323\223\207" [edebug-buffer edebug-window-data window-buffer selected-window get-buffer-window window-start edebug-set-windows edebug-set-buffer-points set-window-start edebug-window-live-p no-force select-window buffer-name marker-buffer edebug-mark-marker nil edebug-trace-buffer edebug-save-windows edebug-outside-windows edebug-save-displayed-buffer-points edebug-outside-buffer edebug-outside-point edebug-outside-mark] 5 (step next) edebug--recursive-edit edebug-outside-mark edebug-outside-point edebug-outside-buffer edebug-window-data edebug-point edebug-active unread-command-events cursor-in-echo-area edebug-buffer edebug-function edebug-save-windows edebug-save-displayed-buffer-points overlay-arrow-position overlay-arrow-string edebug-execution-mode edebug-break edebug-global-break edebug-global-break-condition edebug-global-break-result edebug-break-condition edebug-break-result edebug-sit-for-seconds] 28 "\n\n(fn VALUE OFFSET-INDEX ARG-MODE)"])
(defvar edebug-number-of-recursions 0)
(defvar edebug-recursion-depth 0)
(defalias 'edebug--recursive-edit #[257 "rq\210\306 )\307 \310\211\211\211 \311\216\310\211\211\211\211\211\312\211\205) \310\211\2056 ! \" # $ % & '\313=\203g \211\314>\204g \315\316!\210\310(\317\320!\210\321\216\322 .\207" [edebug-outside-buffer edebug-inside-windows edebug-backtrace-buffer edebug-interactive-p edebug-entered edebug-recursion-depth match-data recursion-depth nil #[0 "\300\207" [nil] 1] t go (after error) message "Break" edebug-mode 1 #[0 "\305 \203\n \306 !\210\307\n!\210\310 !\203( q\210\f\311>\203$ \312 \210\313\314!\210\315\316!\207\317\320!\207" [signal-hook-function edebug-backtrace-buffer edebug-outside-match-data edebug-buffer edebug-execution-mode edebug-signal kill-buffer set-match-data buffer-name (go Go-nonstop) edebug-overlay-arrow sit-for 0 edebug-mode -1 get-buffer-create " bogus edebug buffer"] 2] recursive-edit edebug-outside-match-data last-command this-command edebug-continue-kbd-macro executing-kbd-macro edebug-outside-debug-on-error edebug-outside-debug-on-quit defining-kbd-macro debug-on-quit debug-on-error overriding-terminal-local-map overriding-local-map standard-input standard-output track-mouse last-nonmenu-event last-event-frame last-command-event last-input-event current-prefix-arg edebug-execution-mode signal-hook-function] 17 "\n\n(fn ARG-MODE)"])
#@50 Association list of arrows for each edebug mode.
(defconst edebug-arrow-alist '((Continue-fast . "=") (Trace-fast . "-") (continue . ">") (trace . "->") (step . "=>") (next . "=>") (go . "<>") (Go-nonstop . "..")) (#$ . 54197))
(defalias 'edebug-overlay-arrow #[0 "\304 \236A\305 \211p\223\207" [edebug-execution-mode edebug-arrow-alist overlay-arrow-string overlay-arrow-position line-beginning-position make-marker] 5])
#@174 Toggle the saving and restoring of all windows.
Also, each time you toggle it on, the inside and outside window
configurations become the same as the current configuration.
(defalias 'edebug-toggle-save-all-windows #[0 "?\211\203
\303!\211\304\305\203 \306\202 \307\"\207" [edebug-save-windows edebug-outside-windows edebug-inside-windows edebug-current-windows message "Window saving is %s for all windows." "on" "off"] 4 (#$ . 54631) nil])
(defalias 'edebug-changing-windows '(macro . #[128 "\300\301\302\303\304\305\"BBBB\207" [let ((window (selected-window))) (setq edebug-inside-windows (edebug-current-windows t)) (edebug-set-windows edebug-outside-windows) append ((setq edebug-outside-windows (edebug-current-windows edebug-save-windows)) (edebug-set-windows edebug-inside-windows))] 8 "\n\n(fn &rest BODY)"]))
#@182 Toggle the saving and restoring of the selected window.
Also, each time you toggle it on, the inside and outside window
configurations become the same as the current configuration.
(defalias 'edebug-toggle-save-selected-window #[0 "\303=\203\" \304 \305\303!\306\n!\210\307\310 \"\305!\306 !\266\202Q \304 >\203: \307\304 \n\236\n\"\307\304 \"\202Q \304 \305\303!\306\n!\210\211B\305!\306 !\266\311\312\304 >\203^ \313\202_ \314\304 #\207" [edebug-save-windows edebug-inside-windows edebug-outside-windows t selected-window edebug-current-windows edebug-set-windows delq edebug-window-list message "Window saving is %s for %s." "on" "off"] 4 (#$ . 55467) nil])
#@140 Toggle the saving and restoring of windows.
With prefix, toggle for just the selected window.
Otherwise, toggle for all windows.
(fn ARG)
(defalias 'edebug-toggle-save-windows #[257 "\211\203 \300 \207\301 \207" [edebug-toggle-save-selected-window edebug-toggle-save-all-windows] 2 (#$ . 56153) "P"])
#@61 Show the debug windows and where we stopped in the program.
(defalias 'edebug-where #[0 "\204 \303\304!\210\305 !\210\nb\207" [edebug-active edebug-buffer edebug-point error "Edebug is not active" edebug-pop-to-buffer] 2 (#$ . 56462) nil])
#@75 Change to the outside window configuration.
Use `edebug-where' to return.
(defalias 'edebug-view-outside #[0 "\204 \305\306!\210\307 !\310 !\210\fb\210\311\312\313\314!\"\207" [edebug-active edebug-save-windows edebug-inside-windows edebug-outside-windows edebug-outside-point error "Edebug is not active" edebug-current-windows edebug-set-windows message "Window configuration outside of Edebug. Return with %s" substitute-command-keys "\\<global-map>\\[edebug-where]"] 4 (#$ . 56710) nil])
#@167 Bounce the point in the outside current buffer.
If prefix argument ARG is supplied, sit for that many seconds
before returning. The default is one second.
(fn ARG)
(defalias 'edebug-bounce-point #[257 "\204 \305\306!\210\212\307 \310\311\312\313\314!\315\"\316$\216\317 !\210\nb\210\320\321p`\322\323 !\2030 \324\323 !\2021 \325$\210\326!\210\317 \f@\")\262)\207" [edebug-active edebug-outside-buffer edebug-outside-point edebug-buffer edebug-window-data error "Edebug is not active" current-window-configuration make-byte-code 0 "\301\300!\207" vconcat vector [set-window-configuration] 2 edebug-pop-to-buffer message "Current buffer: %s Point: %s Mark: %s" marker-buffer edebug-mark-marker marker-position "<not set>" sit-for] 8 (#$ . 57213) "p"])
(defalias 'edebug-find-stop-point #[0 "\303 \211\304N\211\203 \305!\203 \306\307\"\210\211\262\211@\310 8\212\311\312!\203* \313\314x\210`)\nZ\314\211G\262\315\262\211W\203L HV\203L \211T\262\2027 \211W\203` HX\203` B\202d \316\317\"+\207" [edebug-def-name edebug-data edebug-def-mark edebug-form-data-symbol edebug markerp error "%s is not instrumented for Edebug" 2 looking-at "[ ]" " " nil 0 message "Point is not on an expression in %s."] 8])
#@65 Move point to the next breakpoint, or first if none past point.
(defalias 'edebug-next-breakpoint #[0 "\304 \211\205t \211@\211A\305N\211@ A@\306 8\307 \204$ \310\311!\202q \211\2038 \211@@X\2038 \211A\262\202% \211\203A \211@\202C @\262\n@H\\b\210\310\312\3068\203Y \313\202Z \314A@\203l \315\316\317A@!\"\202m \314P\"\262,\266\203\207" [edebug-def-name edebug-data edebug-def-mark edebug-breakpoints edebug-find-stop-point edebug 2 nil message "No breakpoints in this function." "%s" "Temporary " "" format "Condition: %s" edebug-safe-prin1-to-string] 13 (#$ . 58448) nil])
#@251 Modify the breakpoint for the form at point or after it.
Set it if FLAG is non-nil, clear it otherwise. Then move to that point.
If CONDITION or TEMPORARY are non-nil, add those attributes to
the breakpoint.
(fn FLAG &optional CONDITION TEMPORARY)
(defalias 'edebug-modify-breakpoint #[769 "\304 \211\205i \211@\211A\305N\211@ A@\306 8\307 \236\262\310 \"\203K \311E B\312\"\203C \313\314#\210\202[ \313\315\"\210\202[ \211\203W \313\316\"\210\202[ \313\317!\210 A \240\210\nH\\b,\266\203\207" [edebug-def-name edebug-data edebug-def-mark edebug-breakpoints edebug-find-stop-point edebug 2 nil delq edebug-sort-alist < message "Breakpoint set in %s with condition: %s" "Breakpoint set in %s" "Breakpoint unset in %s" "No breakpoint here"] 12 (#$ . 59048)])
#@101 Set the breakpoint of nearest sexp.
With prefix argument, make it a temporary breakpoint.
(fn ARG)
(defalias 'edebug-set-breakpoint #[257 "\300\301\302#\207" [edebug-modify-breakpoint t nil] 5 (#$ . 59839) "P"])
#@39 Clear the breakpoint of nearest sexp.
(defalias 'edebug-unset-breakpoint #[0 "\300\301!\207" [edebug-modify-breakpoint nil] 2 (#$ . 60059) nil])
#@69 Set `edebug-global-break-condition' to EXPRESSION.
(fn EXPRESSION)
(defalias 'edebug-set-global-break-condition #[257 "\211\211\207" [edebug-global-break-condition] 3 (#$ . 60210) (byte-code "\205 \303\304\"\305\306 \307\n@\232\203 \310\202 \302%\262C\207" [edebug-global-break-condition read-expression-map read-expression-history format "%s" read-from-minibuffer "Global Condition: " t (read-expression-history . 1)] 8)])
(defalias 'edebug-set-mode #[771 "T\303 =\203 \304\305\"\210\306 \207\304\305\"\207" [edebug-recursion-depth edebug-execution-mode edebug-next-execution-mode recursion-depth message "%s" exit-recursive-edit] 6 "\n\n(fn MODE SHORTMSG MSG)"])
(defalias 'edebug-step-through-mode 'edebug-step-mode)
#@29 Proceed to next stop point.
(defalias 'edebug-step-mode #[0 "\300\301\302\303#\207" [edebug-set-mode step "" "Edebug will stop at next stop point."] 4 (#$ . 60955) nil])
#@37 Proceed to next `after' stop point.
(defalias 'edebug-next-mode #[0 "\300\301\302\303#\207" [edebug-set-mode next "" "Edebug will stop after next eval."] 4 (#$ . 61131) nil])
#@101 Go, evaluating until break.
With prefix ARG, set temporary break at current point and go.
(fn ARG)
(defalias 'edebug-go-mode #[257 "\211\203 \300\301!\210\302\303\304\305#\207" [edebug-set-breakpoint t edebug-set-mode go "Go..." "Edebug will go until break."] 5 (#$ . 61313) "P"])
#@95 Go, evaluating without debugging.
You can use `edebug-stop', or any editing command, to stop.
(defalias 'edebug-Go-nonstop-mode #[0 "\300\301\302\303#\207" [edebug-set-mode Go-nonstop "Go-Nonstop..." "Edebug will not stop at breaks."] 4 (#$ . 61602) nil])
#@75 Begin trace mode.
Pauses for `edebug-sit-for-seconds' at each stop point.
(defalias 'edebug-trace-mode #[0 "\300\301\302\303#\207" [edebug-set-mode trace "Tracing..." "Edebug will trace with pause."] 4 (#$ . 61864) nil])
#@94 Trace with no wait at each step.
Updates the display at each stop point, but does not pause.
(defalias 'edebug-Trace-fast-mode #[0 "\300\301\302\303#\207" [edebug-set-mode Trace-fast "Trace fast..." "Edebug will trace without pause."] 4 (#$ . 62091) nil])
#@79 Begin continue mode.
Pauses for `edebug-sit-for-seconds' at each break point.
(defalias 'edebug-continue-mode #[0 "\300\301\302\303#\207" [edebug-set-mode continue "Continue..." "Edebug will pause at breakpoints."] 4 (#$ . 62353) nil])
#@95 Trace with no wait at each step.
Updates the display at each break point, but does not pause.
(defalias 'edebug-Continue-fast-mode #[0 "\300\301\302\303#\207" [edebug-set-mode Continue-fast "Continue fast..." "Edebug will stop and go at breakpoints."] 4 (#$ . 62595) nil])
#@68 Proceed to first stop-point at or after current position of point.
(defalias 'edebug-goto-here #[0 "\300\301!\207" [edebug-go-mode t] 2 (#$ . 62874) nil])
#@85 Stop execution and do not continue.
Useful for exiting from trace or continue loop.
(defalias 'edebug-stop #[0 "\300\301!\207" [message "Stop"] 2 (#$ . 63035) nil])
#@139 Proceed from the current point to the end of the ARGth sexp ahead.
If there are not ARG sexps ahead, then do `edebug-step-out'.
(fn ARG)
(defalias 'edebug-forward-sexp #[257 "\3011 \302\303!\210\304\302!)0\207\210\305 \207" [parse-sexp-ignore-comments (error) t forward-sexp edebug-go-mode edebug-step-out] 3 (#$ . 63207) "p"])
#@204 Proceed from the current point to the end of the containing sexp.
If there is no containing sexp that is not the top level defun,
go to the end of the last sexp, or if that is the same point, then step.
(defalias 'edebug-step-out #[0 "\3011 \302\303\304!\210\212\303\304!\210)\305\302!)0\207\210`\306\307!\210`U\203' \310 \202* \305\302!\207" [parse-sexp-ignore-comments (error) t up-list 1 edebug-go-mode down-list -1 edebug-step-mode] 3 (#$ . 63546) nil])
(defalias 'edebug-instrument-function #[257 "\211\300N\301!\203 \302!\203 r\302!q\210\211b\210\303 \210)\202K \211:\203. \304\305\"\210\202K \306\307\"\211A\204; \310\311!\210r\211@q\210\211Ab\210\303 \210)\262\207" [edebug markerp marker-buffer edebug-eval-top-level-form message "%s is already instrumented." find-function-noselect t error "Could not find the definition in its file"] 5 "\n\n(fn FUNC)"])
#@263 Instrument the definition of the function or macro about to be called.
Do this when stopped before the form or it will be too late.
One side effect of using this command is that the next time the
function or macro is called, Edebug will be called there as well.
(defalias 'edebug-instrument-callee #[0 "\300\301!\204\n \302\303!\207\212\304\305!\210\300\301!\203 \306`!\211@\262\202\" \307p!)\310!\207" [looking-at "(" error "You must be before a list form" down-list 1 edebug-get-form-data-entry read edebug-instrument-function] 3 (#$ . 64432) nil])
#@208 Step into the definition of the function or macro about to be called.
This first does `edebug-instrument-callee' to ensure that it is
instrumented. Then it does `edebug-on-entry' and switches to `go' mode.
(defalias 'edebug-step-in #[0 "\300 \211\205 \301\302\"\210\303\304!\207" [edebug-instrument-callee edebug-on-entry temp edebug-go-mode nil] 4 (#$ . 64993) nil])
#@191 Cause Edebug to stop when FUNCTION is called.
With prefix argument, make this temporary so it is automatically
canceled the first time the function is entered.
(fn FUNCTION &optional FLAG)
(defalias 'edebug-on-entry #[513 "\300\301\203 \302\202\f \303#\207" [put edebug-on-entry temp t] 6 (#$ . 65371) "aEdebug on entry to: \nP"])
(defalias 'cancel-edebug-on-entry #[257 "\300\301\302#\207" [put edebug-on-entry nil] 5 "\n\n(fn FUNCTION)" "aEdebug on entry to: "])
#@122 Set mode to Go-nonstop, and exit to top-level.
This is useful for exiting even if `unwind-protect' code may be executed.
(defalias 'edebug-top-level-nonstop #[0 "\301\302 \207" [edebug-execution-mode Go-nonstop top-level] 1 (#$ . 65848) nil])
#@59 Association list between commands and the modes they set.
(defconst edebug-initial-mode-alist '((edebug-step-mode . step) (edebug-next-mode . next) (edebug-trace-mode . trace) (edebug-Trace-fast-mode . Trace-fast) (edebug-go-mode . go) (edebug-continue-mode . continue) (edebug-Continue-fast-mode . Continue-fast) (edebug-Go-nonstop-mode . Go-nonstop)) (#$ . 66098))
#@128 Set the initial execution mode of Edebug.
The mode is requested via the key that would be used to set the mode in
edebug-mode.
(defalias 'edebug-set-initial-mode #[0 "\303\304\305\306\307 \"@\n\310#\311H#!\312\n\" \236A\211\203' \211\313\314\"\202* \315\316!\207" [edebug-initial-mode edebug-initial-mode-alist edebug-mode-map read-key-sequence format "Change initial edebug mode from %s (%c) to (enter key): " where-is-internal rassq firstonly 0 lookup-key message "Edebug's initial mode is now: %s" error "Key must map to one of the mode changing commands"] 9 (#$ . 66472) nil])
#@112 Evaluate an expression list in the outside context.
Return the result of the last expression.
(fn &rest BODY)
(defalias 'edebug-outside-excursion '(macro . #[128 "\300\301\302\303\304\305\306\307\310\311\nBBBB\312BB\257\207" [save-excursion (if edebug-save-windows (progn (setq edebug-inside-windows (edebug-current-windows edebug-save-windows)) (edebug-set-windows edebug-outside-windows))) (set-buffer edebug-buffer) (set-match-data edebug-outside-match-data) (setq-default cursor-in-non-selected-windows edebug-outside-d-c-i-n-s-w) unwind-protect with-current-buffer edebug-outside-buffer (goto-char edebug-outside-point) (if (marker-buffer (edebug-mark-marker)) (set-marker (edebug-mark-marker) edebug-outside-mark)) ((if edebug-save-windows (edebug-set-windows edebug-inside-windows)) (setq edebug-outside-d-c-i-n-s-w (default-value 'cursor-in-non-selected-windows)) (setq-default cursor-in-non-selected-windows t))] 12 (#$ . 67067)]))
(put 'edebug-outside-excursion 'edebug-form-spec t)
(defalias 'edebug-eval #[257 "\300\301\302#\207" [backtrace-eval 0 edebug-after] 5 "\n\n(fn EXPR)"])
(defalias 'edebug-safe-eval #[257 "\3001 \301!0\207\302\303@\304NA@#\207" [(error) edebug-eval edebug-format "%s: %s" error-message] 6 "\n\n(fn EXPR)"])
(defalias 'edebug-report-error #[257 "\300\301@\302N\206 \303\304@\"\305\306A\307##\207" [message "%s: %s" error-message format "peculiar error (%s)" mapconcat #[257 "\300!\207" [prin1-to-string] 3 "\n\n(fn EDEBUG-ARG)"] ", "] 8 "\n\n(fn VALUE)"])
(defalias 'edebug-safe-prin1-to-string #[257 "\306\206 \n\206 \f\206
\307 \n\310!-\207" [edebug-print-length print-length edebug-print-level print-level edebug-print-circle print-circle t nil edebug-prin1-to-string print-readably print-escape-newlines] 6 "\n\n(fn VALUE)"])
(defalias 'edebug-compute-previous-result #[257 "\203 \302!\262\303\304!\305!Q\211\207" [edebug-unwrap-results edebug-previous-result edebug-unwrap* "Result: " edebug-safe-prin1-to-string eval-expression-print-format] 5 "\n\n(fn PREVIOUS-VALUE)"])
#@28 Print the previous result.
(defalias 'edebug-previous-result #[0 "\301\302\"\207" [edebug-previous-result message "%s"] 3 (#$ . 69123) nil])
(byte-code "\300\301\302\"\210\300\303\304\"\210\300\305\306\"\210\300\307\310\"\210\300\311\312\"\207" [defalias edebug-prin1 prin1 edebug-print print edebug-prin1-to-string prin1-to-string edebug-format format-message edebug-message message] 3)
#@134 Evaluate an expression in the outside environment.
If interactive, prompt for the expression.
Print result in minibuffer.
(fn EXPR)
(defalias 'edebug-eval-expression #[257 "\306\212\203 \307!\310\n!\210 q\210\311\f!\210\312\313
\"\210\314\216rq\210b\210\315\316 !\2033 \316 \317\223\210\320!B\321@!\322@!P+!\207" [edebug-save-windows edebug-inside-windows edebug-outside-windows edebug-buffer edebug-outside-match-data edebug-outside-d-c-i-n-s-w princ edebug-current-windows edebug-set-windows set-match-data set-default cursor-in-non-selected-windows #[0 "\203 \303 !\210\304\305!\306\305\307\"\207" [edebug-save-windows edebug-inside-windows edebug-outside-d-c-i-n-s-w edebug-set-windows default-value cursor-in-non-selected-windows set-default t] 3] marker-buffer edebug-mark-marker nil edebug-eval edebug-safe-prin1-to-string eval-expression-print-format edebug-outside-buffer edebug-outside-point edebug-outside-mark values] 5 (#$ . 69519) (byte-code "\301\302\303\304\305%C\207" [read-expression-map read-from-minibuffer "Eval: " nil t read-expression-history] 6)])
#@83 Evaluate sexp before point in the outside environment.
Print value in minibuffer.
(defalias 'edebug-eval-last-sexp #[0 "\300\301 !\207" [edebug-eval-expression edebug-last-sexp] 2 (#$ . 70621) nil])
#@109 Evaluate sexp before point in outside environment; insert value.
This prints the value into current buffer.
(defalias 'edebug-eval-print-last-sexp #[0 "\306 \212\203 \307!\310\n!\210 q\210\311\f!\210\312\313
\"\210\314\216rq\210b\210\315\316 !\2034 \316 \317\223\210\320\321!!+p \322\323!\210\322!\210\322\323!)\207" [edebug-save-windows edebug-inside-windows edebug-outside-windows edebug-buffer edebug-outside-match-data edebug-outside-d-c-i-n-s-w edebug-last-sexp edebug-current-windows edebug-set-windows set-match-data set-default cursor-in-non-selected-windows #[0 "\203 \303 !\210\304\305!\306\305\307\"\207" [edebug-save-windows edebug-inside-windows edebug-outside-d-c-i-n-s-w edebug-set-windows default-value cursor-in-non-selected-windows set-default t] 3] marker-buffer edebug-mark-marker nil edebug-safe-prin1-to-string edebug-safe-eval princ "\n" edebug-outside-buffer edebug-outside-point edebug-outside-mark standard-output] 4 (#$ . 70827) nil])
#@162 If non-nil, inhibit Edebug bindings on the C-x C-a key.
By default, loading the `edebug' library causes these bindings to
be installed in `emacs-lisp-mode-map'.
(defvar edebug-inhibit-emacs-lisp-mode-bindings nil (#$ . 71812))
(byte-code "\302\303\300\304#\210\305\211\203( \211@\303N\203! \300N\204! \306\300\303N#\210A\266\202\202 \210\307\303\300\310#\210\204Q \311 \312\313#\210\311 \314\315#\210\311 \316\317#\210\311 \320\321#\210\311 \322\323#\210\304\207" [edebug-inhibit-emacs-lisp-mode-bindings emacs-lisp-mode-map defvaralias gud-inhibit-global-bindings nil (saved-value saved-variable-comment) put make-obsolete-variable "24.3" define-key "" edebug-step-mode "" edebug-next-mode "" edebug-go-mode "\f" edebug-where "
" edebug-set-initial-mode] 7)
(defvar edebug-mode-map (byte-code "\301!\302\303\304#\210\302\305\306#\210\302\307\310#\210\302\311\312#\210\302\313\314#\210\302\315\316#\210\302\317\320#\210\302\321\322#\210\302\323\324#\210\302\325\326#\210\302\327\330#\210\302\331\332#\210\302\333\334#\210\302\335\336#\210\302\337\340#\210\302\341\342#\210\302\343\344#\210\302\345\346#\210\302\347\350#\210\302\351\352#\210\302\353\354#\210\302\355\356#\210\302\357\360#\210\302\361\362#\210\302\363\364#\210\302\365\366#\210\302\367\370#\210\302\371\372#\210\302\373\374#\210\302\375\372#\210\302\376\377#\210\302\201@ \201A #\210\302\201B \201C #\210\302\201D \201E #\210\302\201F \201G #\210\302\201H \304#\210\302\201I \306#\210\302\201J \310#\210\302\201K \346#\210\302\201L \350#\210\302\201M \201N #\210\302\201O \370#\210\211\207" [emacs-lisp-mode-map copy-keymap define-key " " edebug-step-mode "n" edebug-next-mode "g" edebug-go-mode "G" edebug-Go-nonstop-mode "t" edebug-trace-mode "T" edebug-Trace-fast-mode "c" edebug-continue-mode "C" edebug-Continue-fast-mode "f" edebug-forward-sexp "h" edebug-goto-here "I" edebug-instrument-callee "i" edebug-step-in "o" edebug-step-out "q" top-level "Q" edebug-top-level-nonstop "a" abort-recursive-edit "S" edebug-stop "b" edebug-set-breakpoint "u" edebug-unset-breakpoint "B" edebug-next-breakpoint "x" edebug-set-conditional-breakpoint "X" edebug-set-global-break-condition "r" edebug-previous-result "e" edebug-eval-expression "" edebug-eval-last-sexp "E" edebug-visit-eval-list "w" edebug-where "v" edebug-view-outside "p" edebug-bounce-point "P" "W" edebug-toggle-save-windows "?" edebug-help "d" edebug-backtrace "-" negative-argument "=" edebug-temp-display-freq-count "" "" "" " " "" "" #[0 "\300\301!\207" [edebug-set-breakpoint t] 2 nil nil] "\f"] 5))
#@67 Prefix key for global edebug commands, available from any buffer.
(defvar global-edebug-prefix "X" (#$ . 74427))
#@59 Global map of edebug commands, available from any buffer.
(defvar global-edebug-map (byte-code "\300 \301\302\303#\210\301\304\305#\210\301\306\307#\210\301\310\311#\210\301\312\313#\210\301\314\315#\210\301\316\317#\210\301\320\321#\210\301\322\323#\210\301\324\325#\210\301\326\327#\210\301\330\331#\210\301\332\333#\210\301\334\335#\210\301\336\337#\210\301\340\341#\210\301\342\343#\210\211\207" [make-sparse-keymap define-key " " edebug-step-mode "g" edebug-go-mode "G" edebug-Go-nonstop-mode "t" edebug-trace-mode "T" edebug-Trace-fast-mode "c" edebug-continue-mode "C" edebug-Continue-fast-mode "b" edebug-set-breakpoint "u" edebug-unset-breakpoint "x" edebug-set-conditional-breakpoint "X" edebug-set-global-break-condition "w" edebug-where "W" edebug-toggle-save-windows "q" top-level "Q" edebug-top-level-nonstop "a" abort-recursive-edit "=" edebug-display-freq-count] 5) (#$ . 74547))
(byte-code "\302!\210\303 \"\207" [global-edebug-prefix global-edebug-map global-unset-key global-set-key] 3)
#@25 Describe `edebug-mode'.
(defalias 'edebug-help #[0 "\300\301!\207" [describe-function edebug-mode] 2 (#$ . 75578) nil])
(defvar edebug--mode-saved-vars nil)
#@91 Non-nil if Edebug mode is enabled.
Use the command `edebug-mode' to change this variable.
(defvar edebug-mode nil (#$ . 75741))
(make-variable-buffer-local 'edebug-mode)
#@939 Mode for Emacs Lisp buffers while in Edebug.
In addition to all Emacs Lisp commands (except those that modify the
buffer) there are local and global key bindings to several Edebug
specific commands. E.g. `edebug-step-mode' is bound to \[edebug-step-mode]
in the Edebug buffer and \<global-map>\[edebug-step-mode] in any buffer.
Also see bindings for the eval list buffer *edebug* in `edebug-eval-mode'.
The edebug buffer commands:
\{edebug-mode-map}
Global commands prefixed by `global-edebug-prefix':
\{global-edebug-map}
Options:
`edebug-setup-hook'
`edebug-all-defs'
`edebug-all-forms'
`edebug-save-windows'
`edebug-save-displayed-buffer-points'
`edebug-initial-mode'
`edebug-trace'
`edebug-test-coverage'
`edebug-continue-kbd-macro'
`edebug-print-length'
`edebug-print-level'
`edebug-print-circle'
`edebug-on-error'
`edebug-on-quit'
`edebug-on-signal'
`edebug-unwrap-results'
`edebug-global-break-condition'
(fn &optional ARG)
(defalias 'edebug-mode #[256 "\302 \303=\203
?\202 \304!\305V\211\204? \2036 \211A\242\211:\203. \211@AL\210\2022 \306!\210\210\202 \307\310\311\312#\210\202s \313\211\203k \211@\211@A\211\314!\203Y \211JB\202Z \211 B\315!L\266A\266\202\202@ \210\316\310\311\312\211$\210\317\320\203} \321\202~ \322\"\210\323\324!\203\242 \302 \203\222 \211\302 \232\203\242 \325\326\327\203\235 \330\202\236 \331#\266\210\332 \210\207" [edebug-mode edebug--mode-saved-vars current-message toggle prefix-numeric-value 0 kill-local-variable remove-hook kill-buffer-hook edebug-kill-buffer t ((buffer-read-only . t)) local-variable-p make-local-variable add-hook run-hooks edebug-mode-hook edebug-mode-on-hook edebug-mode-off-hook called-interactively-p any " in current buffer" message "Edebug mode %sabled%s" "en" "dis" force-mode-line-update] 11 (#$ . 75918) (byte-code "\206 \301C\207" [current-prefix-arg toggle] 1)])
#@176 Hook run after entering or leaving `edebug-mode'.
No problems result if this variable is not bound.
`add-hook' automatically binds it. (This is true for all hook variables.)
(defvar edebug-mode-hook nil (#$ . 77796))
(byte-code "\301\302\303\304\211%\207" [edebug-mode-map add-minor-mode edebug-mode " *Debugging*" nil] 6)
#@79 Used on `kill-buffer-hook' when Edebug is operating in a buffer of Lisp code.
(defalias 'edebug-kill-buffer #[0 "\300\301\302\303#\207" [run-with-timer 0 nil top-level] 4 (#$ . 78127)])
#@53 Return a list of evaluations of `edebug-eval-list'.
(defalias 'edebug-eval-result-list #[0 "\303\304\305\306\n\"*\207" [edebug-trace edebug-execution-mode edebug-eval-list Go-nonstop nil mapcar edebug-safe-eval] 3 (#$ . 78319)])
(defalias 'edebug-eval-display-list #[257 "\303\304\305\306 \307Z\310\"\"q\210\311 \210\n\211\2038 \211@\312!\210\313 \210\312\211A\262\242!\210\313 \210\314!\210A\266\202\202 \210\315!)\207" [edebug-eval-buffer standard-output edebug-eval-list format ";%s\n" make-string window-width 2 45 erase-buffer prin1 terpri princ edebug-pop-to-buffer] 8 "\n\n(fn EVAL-RESULT-LIST)"])
(defalias 'edebug-create-eval-buffer #[0 "\205 \301!?\205 \302\303!\211q\210\304 \207" [edebug-eval-buffer buffer-name get-buffer-create "*edebug*" edebug-eval-mode] 2])
#@137 Display expressions and evaluations in EVAL-RESULT-LIST.
It modifies the context by popping up the eval display.
(fn EVAL-RESULT-LIST)
(defalias 'edebug-eval-display #[257 "\211\205\n \300 \210\301!\207" [edebug-create-eval-buffer edebug-eval-display-list] 3 (#$ . 79119)])
#@102 Redisplay eval list in outside environment.
May only be called from within `edebug--recursive-edit'.
(defalias 'edebug-eval-redisplay #[0 "\306 \210\212\203 \307!\310\n!\210 q\210\311\f!\210\312\313
\"\210\314\216rq\210b\210\315\316 !\2035 \316 \317\223\210\320\321 !+\207" [edebug-save-windows edebug-inside-windows edebug-outside-windows edebug-buffer edebug-outside-match-data edebug-outside-d-c-i-n-s-w edebug-create-eval-buffer edebug-current-windows edebug-set-windows set-match-data set-default cursor-in-non-selected-windows #[0 "\203 \303 !\210\304\305!\306\305\307\"\207" [edebug-save-windows edebug-inside-windows edebug-outside-d-c-i-n-s-w edebug-set-windows default-value cursor-in-non-selected-windows set-default t] 3] marker-buffer edebug-mark-marker nil edebug-eval-display-list edebug-eval-result-list edebug-outside-buffer edebug-outside-point edebug-outside-mark] 3 (#$ . 79402)])
#@50 Switch to the evaluation list buffer "*edebug*".
(defalias 'edebug-visit-eval-list #[0 "\301 \210\302!\207" [edebug-eval-buffer edebug-eval-redisplay edebug-pop-to-buffer] 2 (#$ . 80322) nil])
#@68 Replace the evaluation list with the sexps now in the eval buffer.
(defalias 'edebug-update-eval-list #[0 "`\301eb\210\302 \210m\204 \303\304!\210\305 B\262\306\307\301\310#\203< \304y\210\311\301w\210g\312U\204 m\204 \303\304!\210\305 B\262\202 \211\237\313 \210b\207" [edebug-eval-list nil edebug-skip-whitespace forward-sexp 1 edebug-last-sexp re-search-forward "^;" t " \n
" 59 edebug-eval-redisplay] 6 (#$ . 80522) nil])
#@44 Delete the item under point and redisplay.
(defalias 'edebug-delete-eval-item #[0 "\300\301\302\303#\203 \304y\210`\305\301\302\303#\210\306 \210`|\210\307 \207" [re-search-backward "^;" nil nofail 1 re-search-forward beginning-of-line edebug-update-eval-list] 5 (#$ . 80965) nil])
#@66 Keymap for Edebug Eval mode. Superset of Lisp Interaction mode.
(defvar edebug-eval-mode-map (byte-code "\301 \302\"\210\303\304\305#\210\303\306\307#\210\303\310\311#\210\303\312\313#\210\303\314\315#\210\211\207" [lisp-interaction-mode-map make-sparse-keymap set-keymap-parent define-key "" edebug-where "" edebug-delete-eval-item "" edebug-update-eval-list "" edebug-eval-last-sexp "\n" edebug-eval-print-last-sexp] 5) (#$ . 81254))
(put 'edebug-eval-mode 'mode-class 'special)
#@168 Hook run after entering Edebug Eval mode.
No problems result if this variable is not bound.
`add-hook' automatically binds it. (This is true for all hook variables.)
(defvar edebug-eval-mode-hook nil (#$ . 81758))
(byte-code "\300\301!\204\f \302\301\303\304#\210\300\207" [boundp edebug-eval-mode-map put definition-name edebug-eval-mode] 4)
(defvar edebug-eval-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204 \302\300\301\303\304!#\210\305\306!\204 \302\306\307\310#\210\300\207" [edebug-eval-mode-map variable-documentation put purecopy "Keymap for `edebug-eval-mode'." boundp edebug-eval-mode-syntax-table definition-name edebug-eval-mode] 5)
(defvar edebug-eval-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204 \302\300\301\303\304!#\210\302\305\306\307#\207" [edebug-eval-mode-syntax-table variable-documentation put purecopy "Syntax table for `edebug-eval-mode'." edebug-eval-mode-abbrev-table definition-name edebug-eval-mode] 5)
(defvar edebug-eval-mode-abbrev-table (progn (define-abbrev-table 'edebug-eval-mode-abbrev-table nil) edebug-eval-mode-abbrev-table))
(byte-code "\300\301N\204 \302\300\301\303\304!#\210\302\305\306\307#\207" [edebug-eval-mode-abbrev-table variable-documentation put purecopy "Abbrev table for `edebug-eval-mode'." edebug-eval-mode derived-mode-parent lisp-interaction-mode] 5)
#@607 Mode for evaluation list buffer while in Edebug.
In addition to all Interactive Emacs Lisp commands there are local and
global key bindings to several Edebug specific commands. E.g.
`edebug-step-mode' is bound to \[edebug-step-mode] in the Edebug
buffer and \<global-map>\[edebug-step-mode] in any buffer.
Eval list buffer commands:
\{edebug-eval-mode-map}
Global commands prefixed by `global-edebug-prefix':
\{global-edebug-map}
In addition to any hooks its parent mode `lisp-interaction-mode' might have run,
this mode runs the hook `edebug-eval-mode-hook', as the final step
during initialization.
(defalias 'edebug-eval-mode #[0 "\306\300!\210\307\310 \210\311\312\310\313N\203 \314\311\313\310\313N#\210\315 !\204' \316 \317 \"\210\320\f!\211\2035 \211\321 =\203; \322\f\323 \"\210\210\324
\325\"\204R
=\204R \326
\325C#\210\327 !\210\330\f!\210
)\331\332!\207" [delay-mode-hooks major-mode mode-name edebug-eval-mode-map edebug-eval-mode-syntax-table edebug-eval-mode-abbrev-table make-local-variable t lisp-interaction-mode edebug-eval-mode "Edebug Eval" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table run-mode-hooks edebug-eval-mode-hook local-abbrev-table] 5 (#$ . 83111) nil])
#@161 Replacement for `debug'.
If we are running an edebugged function, show where we last were.
Otherwise call `debug' normally.
(fn &optional ARG-MODE &rest ARGS)
(defalias 'edebug #[384 "\203. \306 =\203. \n@@\307\211\211\211? \f
\310#\210\311=?\205, \211-\207\312\313#\207" [edebug-entered edebug-recursion-depth edebug-offset-indices edebug-break edebug-global-break edebug-break-condition recursion-depth nil edebug--display error apply debug edebug-break-data edebug-breakpoints] 9 (#$ . 84488)])
#@58 Display a non-working backtrace. Better than nothing...
(defalias 'edebug-backtrace #[0 "\203\n \306!\204 \307\310! r\311\306!!q\210p\312 \210\313\211\314\211\314 \315 \210\316\317!\210+\211 \211\314\320\313 \321 \210q\210\314 eb\210`\262\322\323\313\314#\205{ \324 \210\325\326!\203k `\262\327y\210\211`|\210\202M \325\330!\203M \327y\210\211`|\210\202M *\266\203\331!\210)\207" [edebug-backtrace-buffer default-directory buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks buffer-name generate-new-buffer "*Backtrace*" get-buffer-create kill-all-local-variables nil t erase-buffer run-hooks temp-buffer-setup-hook 50 backtrace re-search-forward "^ (?edebug" beginning-of-line looking-at "^ (edebug-after" 1 "^ edebug" internal-temp-output-buffer-show inhibit-read-only standard-output print-length print-escape-newlines truncate-lines] 10 (#$ . 85009) nil])
#@226 In buffer BUF-NAME, display FMT and ARGS at the end and make it visible.
The buffer is created if it does not exist.
You must include newlines in FMT to break lines, but one newline is appended.
(fn BUF-NAME FMT &rest ARGS)
(defalias 'edebug-trace-display #[642 "p\301 \302!\303\304!\210\305\301 \262db\210\306\307#\310\261\210\311\312\313 Z!\210\314`\"\210db\210\315!\210\316!\210q\266\207" [truncate-lines selected-window get-buffer-create nil edebug-pop-to-buffer t apply edebug-format "\n" vertical-motion 1 window-height set-window-start bury-buffer select-window] 11 (#$ . 85930)])
#@94 Convenience call to `edebug-trace-display' using `edebug-trace-buffer'.
(fn FMT &rest ARGS)
(defalias 'edebug-trace #[385 "\301\302$\207" [edebug-trace-buffer apply edebug-trace-display] 7 (#$ . 86540)])
#@728 Display the frequency count data for each line of the current definition.
The frequency counts are inserted as comment lines after each line,
and you can undo all insertions with one `undo' command.
The counts are inserted starting under the `(' before an expression
or the `)' after an expression, or on the last char of a symbol.
The counts are only displayed when they differ from previous counts on
the same line.
If coverage is being tested, whenever all known results of an expression
are `eq', the char `=' will be appended after the count
for that expression. Note that this is always the case for an
expression only evaluated once.
To clear the frequency count and coverage data for a definition,
reinstrument it.
(defalias 'edebug-display-freq-count #[0 "\300 \211\301N\302N\303N\211@\3048\211GS\305\211\211\211\211\212\306X\205\304 H\\b\210\307 \210`Z\262\262\306S\211\262X\203K HX\2046 \310y\210`\262\262\311\262\312c\210T\211\262X\203\273 \nH\nH\212H\n\\b\210ig\313U\203\204 \306\202\205 \310Z)\314\306`ZZ]\315\"\306W\203\242 \316>\204\242 \317\202\243 \320U\203\256 \320\202\261 \321!\322\261\210\266\204\202Z \323c\210\262\202 )\207" [edebug-form-data-symbol edebug-freq-count edebug-coverage edebug 2 nil 0 beginning-of-line 1 -1 ";#" 40 make-string 32 (unknown ok-coverage) "=" "" int-to-string " " "\n"] 20 (#$ . 86755) nil])
#@111 Temporarily display the frequency count data for the current definition.
It is removed when you hit any char.
(defalias 'edebug-temp-display-freq-count #[0 "\302\303 \210\304 \210\305 \306 C\"\307 )\207" [inhibit-read-only unread-command-events t undo-boundary edebug-display-freq-count append read-event undo] 3 (#$ . 88166) nil])
(defalias 'edebug-toggle #[257 "\211J?L\210\300\301\211J#\207" [message "%s: %s"] 5 "\n\n(fn VARIABLE)"])
(require 'easymenu)
#@19 Menus for Edebug.
(defconst edebug-mode-menus '("Edebug" ["Stop" edebug-stop t] ["Step" edebug-step-mode t] ["Next" edebug-next-mode t] ["Trace" edebug-trace-mode t] ["Trace Fast" edebug-Trace-fast-mode t] ["Continue" edebug-continue-mode t] ["Continue Fast" edebug-Continue-fast-mode t] ["Go" edebug-go-mode t] ["Go Nonstop" edebug-Go-nonstop-mode t] "----" ["Help" edebug-help t] ["Abort" abort-recursive-edit t] ["Quit to Top Level" top-level t] ["Quit Nonstop" edebug-top-level-nonstop t] "----" ("Jumps" ["Forward Sexp" edebug-forward-sexp t] ["Step In" edebug-step-in t] ["Step Out" edebug-step-out t] ["Goto Here" edebug-goto-here t]) ("Breaks" ["Set Breakpoint" edebug-set-breakpoint t] ["Unset Breakpoint" edebug-unset-breakpoint t] ["Set Conditional Breakpoint" edebug-set-conditional-breakpoint t] ["Set Global Break Condition" edebug-set-global-break-condition t] ["Show Next Breakpoint" edebug-next-breakpoint t]) ("Views" ["Where am I?" edebug-where t] ["Bounce to Current Point" edebug-bounce-point t] ["View Outside Windows" edebug-view-outside t] ["Previous Result" edebug-previous-result t] ["Show Backtrace" edebug-backtrace t] ["Display Freq Count" edebug-display-freq-count t]) ("Eval" ["Expression" edebug-eval-expression t] ["Last Sexp" edebug-eval-last-sexp t] ["Visit Eval List" edebug-visit-eval-list t]) ("Options" ["Edebug All Defs" edebug-all-defs :style toggle :selected edebug-all-defs] ["Edebug All Forms" edebug-all-forms :style toggle :selected edebug-all-forms] "----" ["Tracing" (edebug-toggle 'edebug-trace) :style toggle :selected edebug-trace] ["Test Coverage" (edebug-toggle 'edebug-test-coverage) :style toggle :selected edebug-test-coverage] ["Save Windows" edebug-toggle-save-windows :style toggle :selected edebug-save-windows] ["Save Point" (edebug-toggle 'edebug-save-displayed-buffer-points) :style toggle :selected edebug-save-displayed-buffer-points])) (#$ . 88634))
(defalias 'edebug-window-live-p 'window-live-p)
(defalias 'edebug-mark #[0 "\300\301!\207" [mark t] 2])
#@172 Set a conditional breakpoint at nearest sexp.
The condition is evaluated in the outside context.
With prefix argument, make it a temporary breakpoint.
(fn ARG CONDITION)
(defalias 'edebug-set-conditional-breakpoint #[514 "\300\301#\207" [edebug-modify-breakpoint t] 6 (#$ . 90661) (byte-code "\306 \211\205< \211@\211A \307N\211A@\211 \236\211 A@\211 \205$ \310\311
\"\312\313\314@\232\2037 \315\2028 \316%-\266\202\262D\207" [current-prefix-arg edebug-def-name edebug-data edebug-breakpoints edebug-break-data edebug-break-condition edebug-find-stop-point edebug format "%s" read-from-minibuffer "Condition: " t (read-expression-history . 1) read-expression-history read-expression-map] 12)])
#@14 Edebug menus
(defvar edebug-menu nil (#$ . 91376))
(easy-menu-do-define 'edebug-menu edebug-mode-map "Edebug menus" edebug-mode-menus)
(defalias 'edebug--require-cl-read #[0 "\300\301!\207" [require edebug-cl-read] 2])
(byte-code "\300\301!\203 \302\303\304\"\210\202 \302\305\304\"\210\302\306\307\"\207" [featurep cl-read add-hook edebug-setup-hook edebug--require-cl-read cl-read-load-hooks called-interactively-p-functions edebug--called-interactively-skip] 3)
(defalias 'edebug--called-interactively-skip #[771 "A@\242\300=\205) A@A@\301=\205) \211A@\302=\205) \303\304\"A@\302=\203( \305\207\306\207" [lambda nil edebug-enter backtrace-frame called-interactively-p 2 1] 6 "\n\n(fn I FRAME1 FRAME2)"])
(edebug-install-read-eval-functions)
#@42 Unload the Edebug source level debugger.
(defalias 'edebug-unload-function #[0 "\203\f \301\302\216\303 \210)\304\305\306\"\210\304\307\310\"\210\311 \210\301\207" [edebug-active nil #[0 "\300\301\302\303#\207" [run-with-idle-timer 0 nil #[0 "\300\301!\207" [unload-feature edebug] 2]] 4] abort-recursive-edit remove-hook called-interactively-p-functions edebug--called-interactively-skip cl-read-load-hooks edebug--require-cl-read edebug-uninstall-read-eval-functions] 3 (#$ . 92131)])
(provide 'edebug)
Kontol Shell Bypass