;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:09:00 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/debug.el
;;; in Emacs version 24.3.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\302\303\304\305\306\307\310\311&\210\312\313\304\314\315\316\310\303\317\320&	\210\312\321\322\323\315\324\310\303\317\325&	\210\312\326\327\330\315\331\310\303\317\332&	\207" [require button custom-declare-group debugger nil "Debuggers and related commands for Emacs." :prefix "debugger-" :group debug custom-declare-variable debugger-mode-hook "Hooks run when `debugger-mode' is turned on." :type hook :version "20.3" debugger-batch-max-lines 40 "Maximum lines to show in debugger buffer in a noninteractive Emacs.\nWhen the debugger is entered and Emacs is running in batch mode,\nif the backtrace text has more than this many lines,\nthe middle is discarded, and just the beginning and end are displayed." integer "21.1" debugger-bury-or-kill 'bury "What to do with the debugger buffer when exiting `debug'.\nThe value affects the behavior of operations on any window\npreviously showing the debugger buffer.\n\n`nil' means that if its window is not deleted when exiting the\n  debugger, invoking `switch-to-prev-buffer' will usually show\n  the debugger buffer again.\n\n`append' means that if the window is not deleted, the debugger\n  buffer moves to the end of the window's previous buffers so\n  it's less likely that a future invocation of\n  `switch-to-prev-buffer' will switch to it.  Also, it moves the\n  buffer to the end of the frame's buffer list.\n\n`bury' means that if the window is not deleted, its buffer is\n  removed from the window's list of previous buffers.  Also, it\n  moves the buffer to the end of the frame's buffer list.  This\n  value provides the most reliable remedy to not have\n  `switch-to-prev-buffer' switch to the debugger buffer again\n  without killing the buffer.\n\n`kill' means to kill the debugger buffer.\n\nThe value used here is passed to `quit-restore-window'." (choice (const :tag "Keep alive" nil) (const :tag "Append" append) (const :tag "Bury" bury) (const :tag "Kill" kill)) "24.3"] 10)
#@53 List of functions currently set for debug on entry.
(defvar debug-function-list nil (#$ . 2530))
#@55 Non-nil means "single-step" after the debugger exits.
(defvar debugger-step-after-exit nil (#$ . 2633))
#@64 This is the value for the debugger to return, when it returns.
(defvar debugger-value nil (#$ . 2743))
#@68 This is the buffer that was current when the debugger was entered.
(defvar debugger-old-buffer nil (#$ . 2852))
#@54 This is the window last showing the debugger buffer.
(defvar debugger-previous-window nil (#$ . 2970))
#@57 The last recorded height of `debugger-previous-window'.
(defvar debugger-previous-window-height nil (#$ . 3079))
#@112 The contents of the previous backtrace (including text properties).
This is to optimize `debugger-make-xrefs'.
(defvar debugger-previous-backtrace nil (#$ . 3199))
#@56 Non-nil if we expect to get back in the debugger soon.
(defvar debugger-will-be-back nil (#$ . 3369))
#@48 Non-nil means that debug-on-entry is disabled.
(defvar inhibit-debug-on-entry nil (#$ . 3477))
#@178 Non-nil means that debug-on-entry is disabled.
This variable is used by `debugger-jump', `debugger-step-through',
and `debugger-reenable' to temporarily disable debug-on-entry.
(defvar debugger-jumping-flag nil (#$ . 3579))
#@352 Arguments with which the debugger was called.
It is a list expected to take the form (CAUSE . REST)
where CAUSE can be:
- debug: called for entry to a flagged function.
- t: called because of debug-on-next-call.
- lambda: same thing but via `funcall'.
- exit: called because of exit of a flagged function.
- error: called because of `debug-on-error'.
(defvar debugger-args nil (#$ . 3810))
(byte-code "\301\211\207" [debugger debug] 2)
#@359 Enter debugger.  \<debugger-mode-map>`\[debugger-continue]' returns from the debugger.
Arguments are mainly for use when this is called from the internals
of the evaluator.

You may call with no args, or you may pass nil as the first arg and
any other args you like.  In that case, the list of args after the
first will be printed into the backtrace buffer.
(defalias 'debug #[(&rest debugger-args) "\203	\207\n\204\306\307!\210\310\311\312!\205 r\311\312!q\210\313 )D\314\312!p\310\211\211\211\315 \f
*+,-./0123456\316 789:;<=>?@ABCDEFGHIJKLMNO\310\211*\310\211\317\211\310\211\211\211\211\211\211\211P\206\225\320 \321V\317\211\310\211\322 Q654P3210/.RS+-,\323\216\212T@\324=\203\342\325\326\317\"\210\327\326!\211UA@)\242\330=\203\342\325\331\317\"\210\332N\333V\205\357\334VBD\"\210\335 LVL=\203
W\203
\310\336\337\217\210\202
LV\340 \210\341T!\210\n\203S
\342ed\"XV\203F
eb\210\343X\245y\210`Ydb\210\343X\245XZy\210Y`|\210)\344c\210eb\210\306\345\313 \"\210\346\347!\210\306\350!\210\310\317Z5\306\350!\210\212\351 \210.GFE*D+C,B-A.@/?0>1=2<3;4:5986K[	.\207" [inhibit-redisplay debugger-value noninteractive major-mode load-read-function overriding-local-map message "Entering debugger..." nil get-buffer "*Backtrace*" buffer-string get-buffer-create match-data with-timeout-suspend t minibuffer-depth 0 current-window-configuration ((byte-code "\306!\203\307!	=\203\310!\203\311\f!\210\2024\306!\2034\307!	=\2034\312
\"\210q\210\313	!\203[r	q\210\314\315 \210\204O\316 \210\202ZA@c\210@ \210*\317!\210\320!\207" [debugger-window debugger-buffer debugger-previous-window-height debugger-will-be-back window-configuration debugger-bury-or-kill window-live-p window-buffer window-total-size set-window-configuration quit-restore-window buffer-live-p t erase-buffer fundamental-mode with-timeout-unsuspend set-match-data debugger-old-buffer inhibit-read-only debugger-previous-state debugger-with-timeout-suspend debugger-outer-match-data] 3)) debug backtrace-debug 3 backtrace-frame lambda 4 pop-to-buffer (display-buffer-reuse-window display-buffer-in-previous-window) previous-window selected-window (byte-code "\302	\303!Z\"\207" [debugger-window debugger-previous-window-height window-resize window-total-size] 5) ((error)) debugger-mode debugger-setup-buffer count-lines 2 "...\n" "%s" kill-emacs -1 "" recursive-edit overriding-terminal-local-map track-mouse last-command this-command unread-command-events unread-post-input-method-events last-input-event last-command-event last-nonmenu-event last-event-frame standard-input standard-output cursor-in-echo-area debugger-with-timeout-suspend debugger-outer-cursor-in-echo-area debugger-outer-inhibit-redisplay debugger-outer-standard-output debugger-outer-standard-input debugger-outer-last-event-frame debugger-outer-last-nonmenu-event debugger-outer-last-command-event debugger-outer-last-input-event debugger-outer-unread-post-input-method-events debugger-outer-unread-command-events debugger-outer-this-command debugger-outer-last-command debugger-outer-track-mouse debugger-outer-overriding-terminal-local-map debugger-outer-overriding-local-map debugger-outer-load-read-function debugger-outer-match-data executing-kbd-macro debugger-will-be-back debugger-step-after-exit debugger-window debugger-old-buffer debugger-buffer debugger-previous-state enable-recursive-minibuffers window-configuration inhibit-debug-on-entry inhibit-trace debugger-args x debugger-previous-window debugger-jumping-flag debugger-batch-max-lines middlestart buffer-read-only debug-on-next-call] 27 (#$ . 4254) nil])
#@103 Initialize the `*Backtrace*' buffer for entry to the debugger.
That buffer should be current already.
(defalias 'debugger-setup-buffer #[(debugger-args) "\306\307 \210\310\311!\210\311p\311\312\313\314 \210,eb\210`\315\316!\210%@\317=\203+\320\202,\321y\210`|\210\322c\210%@\211&\323>\203E\324c\210\202\252&\325=\203k\326c\210%A@'\327'p\"\210\330c\210\331\321!\210\332c\210\333 \210\202\252&\334=\203\203\335c\210\327%A@p\"\210\330c\210\202\252&\311=\203\220\336c\210\202\252\337c\210\327%@\306=\203\242%A\202\244%p\"\210\330c\210)\212())\203\330\340\341\306\311#\203\330\306\210\342\343r)@q\210`)\"c\210)\211A)@\210\202\260*\344 \207" [buffer-read-only buffer-undo-list print-length print-level print-escape-newlines standard-output nil erase-buffer set-buffer-multibyte t 8 50 backtrace search-forward "\n  debug(" debug 2 1 "Debugger entered" (lambda debug) "--entering a function:\n" exit "--returning value: " prin1 10 delete-char 32 beginning-of-line error "--Lisp error: " "--beginning evaluation of function call form:\n" ": " re-search-forward "^  eval-\\(buffer\\|region\\)(" format "  ; Reading at buffer position %d" debugger-make-xrefs debugger-args #1=#:val debugger-value eval-buffer-list tem] 5 (#$ . 7986)])
#@72 Attach cross-references to function names in the `*Backtrace*' buffer.
(defalias 'debugger-make-xrefs #[(&optional buffer) "r\206pq\210\212p\306ee\f\203{\307\211\306db\210\310\311!rq\210\312\216\fc\210
\203fo\204f`\313y\210`rq\210`\313y\210`)\314\307 \315p\n	&)!\204/\307\211\2043+	d|\210db\210\f\neZ\307Oc\210e	}\210+eb\210`\316\\b\210\317\320!\210m\204\306`!\317\321!\210`\"\322\323!\"\"!\211#\205\250\324#\325\"\211$\203\277!b\210\326\327!\210\330\331\332#$$\210,\333y\210\202~~\210+\334 \211*\207" [buffer new-end old-end inhibit-read-only debugger-previous-backtrace all-match t nil generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1=#:temp-buffer buffer-name kill-buffer] 2)) -1 zerop compare-buffer-substrings 2 skip-syntax-forward "^w_" "w_" intern-soft buffer-substring-no-properties symbol-file defun re-search-forward "\\(\\sw\\|\\s_\\)+" help-xref-button 0 help-function-def 1 buffer-string new-start old-start #1# case-fold-search beg end sym file] 9 (#$ . 9258) "b"])
#@126 Proceed, stepping through subexpressions of this expression.
Enter another debugger on next entry to eval, apply or funcall.
(defalias 'debugger-step-through #[nil "\303\211\303\304\305\306\"\210\307\310!\210\311 \207" [debugger-step-after-exit debugger-jumping-flag debugger-will-be-back t add-hook post-command-hook debugger-reenable message "Proceeding, will debug on next eval or call." exit-recursive-edit] 4 (#$ . 10327) nil])
#@56 Continue, evaluating this expression without stopping.
(defalias 'debugger-continue #[nil "\204\302\303!\210\304\305!\210\212eb\210\306\307\310\311#\203\311)\312 \207" [debugger-may-continue debugger-will-be-back error "Cannot continue" message "Continuing." re-search-forward "^\\* " nil t exit-recursive-edit] 4 (#$ . 10769) nil])
#@156 Continue, specifying value to return.
This is only useful when the value returned from the debugger
will be used, such as in a debug on exit from a frame.
(defalias 'debugger-return-value #[(val) "@\304>\203\305\306@\305=\203\307\202\310\"\210	\311\312\313\"\210\314\n!\210\212eb\210\315\316\317\313#\2030\313)\320 \207" [debugger-args val debugger-value debugger-will-be-back (t lambda error debug) error "Cannot return a value %s" "from an error" "at function entrance" princ "Returning " t prin1 re-search-forward "^\\* " nil exit-recursive-edit] 4 (#$ . 11115) "XReturn value (evaluated): "])
#@70 Continue to exit from this frame, with all debug-on-entry suspended.
(defalias 'debugger-jump #[nil "\302 \210\303\304\305\306\"\210\307\310!\210\303\311 \207" [debugger-jumping-flag debugger-will-be-back debugger-frame t add-hook post-command-hook debugger-reenable message "Continuing through this frame" exit-recursive-edit] 3 (#$ . 11729) nil])
#@142 Turn all debug-on-entry functions back on.
This function is put on `post-command-hook' by `debugger-jump' and
removes itself from that hook.
(defalias 'debugger-reenable #[nil "\301\302\303\304\"\207" [debugger-jumping-flag nil remove-hook post-command-hook debugger-reenable] 3 (#$ . 12087)])
#@70 Return number of frames in backtrace before the one point points at.
(defalias 'debugger-frame-number #[nil "\212\303 \210`\304\305!\211A@)\306=\204T\202\305T!\211A@)\307=\203,Teb\210\310\311!\203=\304\225b\210\312\313!\210\313y\210\314u\210g\315U\203P\312\313!\210\202T\312\314!\210\313y\210`	X\203l\310\316!\203f\313y\210T\202@+\207" [count opoint x beginning-of-line 0 backtrace-frame debug implement-debug-on-entry looking-at "Debugger entered--\\(Lisp error\\|returning value\\):" forward-sexp 1 2 40 " *;;;"] 3 (#$ . 12388)])
#@112 Request entry to debugger when this frame exits.
Applies to the frame whose line point is on in the backtrace.
(defalias 'debugger-frame #[nil "\212\301 \210\302\303!\203\304\305!\210)\301 \210\306\307 \310\"\210g\311U\203(\310\312\313!\210\314c\210)\301 \207" [inhibit-read-only beginning-of-line looking-at " *;;;\\|[a-z]" error "This line is not a function call" backtrace-debug debugger-frame-number t 32 delete-char 1 42] 3 (#$ . 12951) nil])
#@108 Do not enter debugger when this frame exits.
Applies to the frame whose line point is on in the backtrace.
(defalias 'debugger-frame-clear #[nil "\212\301 \210\302\303!\203\304\305!\210)\301 \210\306\307 \310\"\210g\311U\203(\312\313\314!\210\315c\210)\301 \207" [inhibit-read-only beginning-of-line looking-at " *;;;\\|[a-z]" error "This line is not a function call" backtrace-debug debugger-frame-number nil 42 t delete-char 1 32] 3 (#$ . 13410) nil])
#@35 Run BODY in original environment.
(defalias 'debugger-env-macro '(macro . #[(&rest body) "\301\302\303\304\305\306\307\310B\311BBFF\207" [body save-excursion (if (null (buffer-name debugger-old-buffer)) (setq debugger-old-buffer (current-buffer))) (set-buffer debugger-old-buffer) let ((load-read-function debugger-outer-load-read-function) (overriding-terminal-local-map debugger-outer-overriding-terminal-local-map) (overriding-local-map debugger-outer-overriding-local-map) (track-mouse debugger-outer-track-mouse) (last-command debugger-outer-last-command) (this-command debugger-outer-this-command) (unread-command-events debugger-outer-unread-command-events) (unread-post-input-method-events debugger-outer-unread-post-input-method-events) (last-input-event debugger-outer-last-input-event) (last-command-event debugger-outer-last-command-event) (last-nonmenu-event debugger-outer-last-nonmenu-event) (last-event-frame debugger-outer-last-event-frame) (standard-input debugger-outer-standard-input) (standard-output debugger-outer-standard-output) (inhibit-redisplay debugger-outer-inhibit-redisplay) (cursor-in-echo-area debugger-outer-cursor-in-echo-area)) (set-match-data debugger-outer-match-data) prog1 progn ((setq debugger-outer-match-data (match-data)) (setq debugger-outer-load-read-function load-read-function) (setq debugger-outer-overriding-terminal-local-map overriding-terminal-local-map) (setq debugger-outer-overriding-local-map overriding-local-map) (setq debugger-outer-track-mouse track-mouse) (setq debugger-outer-last-command last-command) (setq debugger-outer-this-command this-command) (setq debugger-outer-unread-command-events unread-command-events) (setq debugger-outer-unread-post-input-method-events unread-post-input-method-events) (setq debugger-outer-last-input-event last-input-event) (setq debugger-outer-last-command-event last-command-event) (setq debugger-outer-last-nonmenu-event last-nonmenu-event) (setq debugger-outer-last-event-frame last-event-frame) (setq debugger-outer-standard-input standard-input) (setq debugger-outer-standard-output standard-output) (setq debugger-outer-inhibit-redisplay inhibit-redisplay) (setq debugger-outer-cursor-in-echo-area cursor-in-echo-area))] 9 (#$ . 13874)]))
(put 'debugger-env-macro 'lisp-indent-function 0)
#@71 Eval an expression, in an environment like that outside the debugger.
(defalias 'debugger-eval-expression #[(exp) "\212\306!\204	pq\210	\n\f
\n\f
 !\"#$\307%!\210\310&!\311 %$#\"! \n\f
.\207" [debugger-old-buffer debugger-outer-load-read-function debugger-outer-overriding-terminal-local-map debugger-outer-overriding-local-map debugger-outer-track-mouse debugger-outer-last-command buffer-name set-match-data eval-expression match-data debugger-outer-this-command debugger-outer-unread-command-events debugger-outer-unread-post-input-method-events debugger-outer-last-input-event debugger-outer-last-command-event debugger-outer-last-nonmenu-event debugger-outer-last-event-frame debugger-outer-standard-input debugger-outer-standard-output debugger-outer-inhibit-redisplay debugger-outer-cursor-in-echo-area cursor-in-echo-area inhibit-redisplay standard-output standard-input last-event-frame last-nonmenu-event last-command-event last-input-event unread-post-input-method-events unread-command-events this-command last-command track-mouse overriding-local-map overriding-terminal-local-map load-read-function debugger-outer-match-data exp] 16 (#$ . 16176) (list (read-from-minibuffer "Eval: " nil read-expression-map t 'read-expression-history))])
(defvar debugger-mode-map (byte-code "\303 \304 \305	\n\"\210\306	!\210\307	\310\311#\210\307	\312\313#\210\307	\314\315#\210\307	\316\317#\210\307	\320\321#\210\307	\322\323#\210\307	\324\325#\210\307	\326\327#\210\307	\330\331#\210\307	\332\333#\210\307	\334\335#\210\307	\336\337#\210\307	\340\341#\210\307	\342\343#\210\307	\344\345#\210\307	\346\347B#\210\307\350\351#\210\307\352\353#\210\307\354\355#\210\307\356\357#\210\307\360\361#\210\307\362\363#\210\307\364\365#\210\307\366\367#\210\307\370\371#\210\307\372\373#\210\307\374\375#\210\307\376\377#\210\307\201@\201A#\210\307\201B\201C#\210\307\201D\201E#\210\307\201F\201G#\210	*\207" [menu-map map button-buffer-map make-keymap make-sparse-keymap set-keymap-parent suppress-keymap define-key "-" negative-argument "b" debugger-frame "c" debugger-continue "j" debugger-jump "r" debugger-return-value "u" debugger-frame-clear "d" debugger-step-through "l" debugger-list-functions "h" describe-mode "q" top-level "e" debugger-eval-expression " " next-line "R" debugger-record-expression "
" debug-help-follow [mouse-2] push-button [menu-bar debugger] "Debugger" [deb-top] (menu-item "Quit" top-level :help "Quit debugging and return to top level") [deb-s0] ("--") [deb-descr] (menu-item "Describe Debugger Mode" describe-mode :help "Display documentation for debugger-mode") [deb-hfol] (menu-item "Help Follow" debug-help-follow :help "Follow cross-reference") [deb-nxt] (menu-item "Next Line" next-line :help "Move cursor down") [deb-s1] ("--") [deb-lfunc] (menu-item "List debug on entry functions" debugger-list-functions :help "Display a list of all the functions now set to debug on entry") [deb-fclear] (menu-item "Cancel debug frame" debugger-frame-clear :help "Do not enter debugger when this frame exits") [deb-frame] (menu-item "Debug frame" debugger-frame :help "Request entry to debugger when this frame exits") [deb-s2] ("--") [deb-ret] (menu-item "Return value..." debugger-return-value :help "Continue, specifying value to return.") [deb-rec] (menu-item "Display and Record Expression" debugger-record-expression :help "Display a variable's value and record it in `*Backtrace-record*' buffer") [deb-eval] (menu-item "Eval Expression..." debugger-eval-expression :help "Eval an expression, in an environment like that outside the debugger") [deb-jump] (menu-item "Jump" debugger-jump :help "Continue to exit from this frame, with all debug-on-entry suspended") [deb-cont] (menu-item "Continue" debugger-continue :help "Continue, evaluating this expression without stopping") [deb-step] (menu-item "Step through" debugger-step-through :help "Proceed, stepping through subexpressions of this expression")] 5))
(put 'debugger-mode 'mode-class 'special)
#@522 Mode for backtrace buffers, selected in debugger.
\<debugger-mode-map>
A line starts with `*' if exiting that frame will call the debugger.
Type \[debugger-frame] or \[debugger-frame-clear] to set or remove the `*'.

When in debugger due to frame being exited,
use the \[debugger-return-value] command to override the value
being returned from that frame.

Use \[debug-on-entry] and \[cancel-debug-on-entry] to control
which functions will enter the debugger when called.

Complete list of commands:
\{debugger-mode-map}
(defalias 'debugger-mode #[nil "\305 \210\306\307\310\311!\210\312\f!\210\313\314!\207" [major-mode mode-name truncate-lines emacs-lisp-mode-syntax-table debugger-mode-map kill-all-local-variables debugger-mode "Debugger" t set-syntax-table use-local-map run-mode-hooks debugger-mode-hook] 2 (#$ . 20293)])
#@71 Buffer name for expression values, for \[debugger-record-expression].
(custom-declare-variable 'debugger-record-buffer "*Debugger-record*" '(#$ . 21131) :type 'string :group 'debugger :version "20.3")
#@74 Display a variable's value and record it in `*Backtrace-record*' buffer.
(defalias 'debugger-record-expression #[(exp) "\304!\211\305\306\307\"!\210\305\310!!\210\311 \210*r\312!q\210\313\314\315\316!\317\316!{\")\207" [debugger-record-buffer buffer standard-output exp get-buffer-create princ format "Debugger Eval (%s): " debugger-eval-expression terpri get-buffer message "%s" line-beginning-position 0 line-end-position] 6 (#$ . 21338) (list (read-from-minibuffer "Record Eval: " nil read-expression-map t 'read-expression-history))])
#@109 Follow cross-reference at POS, defaulting to point.

For the cross-reference format, see `help-make-xrefs'.
(defalias 'debug-help-follow #[(&optional pos) "\302\303!\210\204\n`\304!?\205:\305\212b\210\306\307!\210`\310\307!\210`{)!\311	!\2046\312	!\2046\313	!\2059\314	!)\207" [pos sym require help-mode push-button intern skip-syntax-backward "w_" skip-syntax-forward boundp fboundp facep help-xref-interned] 4 (#$ . 21890) "d"])
#@128 Conditionally call the debugger.
A call to this function is inserted by `debug-on-entry' to cause
functions to break on entry.
(defalias 'implement-debug-on-entry #[nil "\206	?\205\f\n\303!\207" [inhibit-debug-on-entry debugger-jumping-flag debugger debug] 2 (#$ . 22338)])
#@42 Return whether SYMBOL is a special form.
(defalias 'debugger-special-form-p #[(symbol) "\301!\205\302K!\205\303K!A\304=\207" [symbol fboundp subrp subr-arity unevalled] 2 (#$ . 22622)])
#@652 Request FUNCTION to invoke debugger each time it is called.

When called interactively, prompt for FUNCTION in the minibuffer.

This works by modifying the definition of FUNCTION.  If you tell the
debugger to continue, FUNCTION's execution proceeds.  If FUNCTION is a
normal function or a macro written in Lisp, you can also step through
its execution.  FUNCTION can also be a primitive that is not a special
form, in which case stepping is not possible.  Break-on-entry for
primitive functions only works when that function is called from Lisp.

Use \[cancel-debug-on-entry] to cancel the effect of this command.
Redefining FUNCTION also cancels it.
(defalias 'debug-on-entry #[(function) "\303!\203\304\305\"\210K9\204\306K!\203-\307\310\311K!\312\313KD\314BBFM\210\202WK\211\242)\315=\203>\316K\"\210K:\203SK@\317=\203WKA:\204W\320!\210K:\204b\304\321\"\210\322\323\"M\210\n>\204s\nB\207" [function object debug-function-list debugger-special-form-p error "Function %s is a special form" subrp lambda (&rest debug-on-entry-args) interactive-form apply quote (debug-on-entry-args) autoload autoload-do-load macro debug-convert-byte-code "Definition of %s is not a list" debug-on-entry-1 t] 8 (#$ . 22822) (let ((fn (function-called-at-point)) val) (if (debugger-special-form-p fn) (progn (setq fn nil))) (setq val (completing-read (if fn (format "Debug on entry to function (default %s): " fn) "Debug on entry to function: ") obarray #'(lambda (symbol) (and (fboundp symbol) (not (debugger-special-form-p symbol)))) t nil nil (symbol-name fn))) (list (if (equal val "") fn (intern val))))])
#@246 Undo effect of \[debug-on-entry] on FUNCTION.
If FUNCTION is nil, cancel debug-on-entry for all functions.
When called interactively, prompt for FUNCTION in the minibuffer.
To specify a nil argument interactively, exit with an empty minibuffer.
(defalias 'cancel-debug-on-entry #[(&optional function) "\203 \303\230\204 \304\305\"\305\306\307\217\210	M\210)\310\n\"\207\311\312!\210\313\314\n\"\207" [function defn debug-function-list "" debug-on-entry-1 nil (byte-code "A@\301\232\203\3028@\303=\203\3028A@A@\302\207" [defn (&rest debug-on-entry-args) 3 apply] 2) ((error)) delq message "Cancelling debug-on-entry for all functions" mapcar cancel-debug-on-entry] 3 (#$ . 24457) (list (let ((name (completing-read "Cancel debug on entry to function (default all functions): " (mapcar 'symbol-name debug-function-list) nil t))) (if name (progn (if (string= name "") nil (intern name))))))])
#@41 Return the argument list of DEFINITION.
(defalias 'debug-arglist #[(definition) "\301\302!\210\303\304\"\207" [definition require help-fns help-function-arglist preserve-names] 3 (#$ . 25371)])
(defalias 'debug-convert-byte-code #[(function) "K\211\242\302=\211\203	A\305	!\205f\306	!\307>\203#\310\202$\311	\312\307\312\313\"\"BBC	G\314V\203?\315	\314HD\fB	G\316V\203R	\316H\203R\317!\fB\320\321\fBBB*\n\203c\302	B	M*\207" [function defn macro args body byte-code-function-p debug-arglist &rest apply funcall remq &optional 5 interactive 4 documentation closure (t)] 8])
(defalias 'debug-on-entry-1 #[#'flag "K\211\211\242\305=\203\nA\n\242\306>\204\"\203u\307\310\"\210\202u\n@\311=\203,\nA\nA\211\211A@);\203E\n\211AA)\203E\nA\n\211A@)\242\312=\203T\nA\n\211A@)\313\232=\204u\n\203m\314\nAB\202s\n\211AA)\241\210	*\207" [function defn tail flag x macro (closure lambda) error "%s is not a user-defined Lisp function" closure interactive (implement-debug-on-entry) (implement-debug-on-entry)] 4])
#@64 Display a list of all the functions now set to debug on entry.
(defalias 'debugger-list-functions #[nil "\306\307!\210\310\311\312\313!\"\210r\314\315 !q\210p\316 \210	\317\211\320\211\320 \321 \210\322\323!\210+\211!\"r\"q\210#\204B\324\325!\202~\324\326!\210#\317$\211%\203s%@$\327`\330$!\210`\331\332\333$C&\210\334 \210%A\211%\204Q*\334 \210\324\335!\210\324\336!)\337!!\210+\207" [default-directory #1=#:old-dir buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks require help-mode help-setup-xref (debugger-list-functions) called-interactively-p interactive get-buffer-create help-buffer kill-all-local-variables nil t erase-buffer run-hooks temp-buffer-setup-hook princ "No debug-on-entry functions now\n" "Functions set to debug on entry:\n\n" make-text-button prin1 type help-function help-args terpri "Note: if you have redefined a function, then it may no longer\n" "be set to debug on entry, even if it is in the list." internal-temp-output-buffer-show inhibit-read-only #2=#:buf standard-output debug-function-list fun --dolist-tail--] 8 (#$ . 26430) nil])
(provide 'debug)