HOME

Mini Shell 1.0
DIR:/usr/share/emacs/26.1/lisp/emacs-lisp/
Current File : //usr/share/emacs/26.1/lisp/emacs-lisp/debug.elc
;ELC
;;; Compiled
;;; in Emacs version 26.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\314\315\316DD\317\320\321\310\303\322\323&	\210\312\324\314\315\325DD\326\320\327\310\303\322\330&	\210\312\331\314\315\332DD\333\320\334\322\335&\210\312\336\314\315\337DD\340\320\341\310\303\322\342&	\207" [require button custom-declare-group debugger nil "Debuggers and related commands for Emacs." :prefix "debugger-" :group debug custom-declare-variable debugger-mode-hook funcall function #[0 "\300\207" [nil] 1] "Hooks run when `debugger-mode' is turned on." :type hook :version "20.3" debugger-batch-max-lines #[0 "\300\207" [40] 1] "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-print-function #[0 "\300\207" [cl-prin1] 1] "Function used to print values in the debugger backtraces." (choice (const cl-prin1) (const prin1) function) "26.1" debugger-bury-or-kill #[0 "\300\207" [bury] 1] "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\nnil 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)
#@55 Non-nil means "single-step" after the debugger exits.
(defvar debugger-step-after-exit nil (#$ . 2704))
#@64 This is the value for the debugger to return, when it returns.
(defvar debugger-value nil (#$ . 2814))
#@68 This is the buffer that was current when the debugger was entered.
(defvar debugger-old-buffer nil (#$ . 2923))
#@54 This is the window last showing the debugger buffer.
(defvar debugger-previous-window nil (#$ . 3041))
#@57 The last recorded height of `debugger-previous-window'.
(defvar debugger-previous-window-height nil (#$ . 3150))
#@112 The contents of the previous backtrace (including text properties).
This is to optimize `debugger-make-xrefs'.
(defvar debugger-previous-backtrace nil (#$ . 3270))
#@56 Non-nil if we expect to get back in the debugger soon.
(defvar debugger-will-be-back nil (#$ . 3440))
#@50 Non-nil means that `debug-on-entry' is disabled.
(defvar inhibit-debug-on-entry nil (#$ . 3548))
#@180 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 (#$ . 3652))
#@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 (#$ . 3885))
(byte-code "\301\211\207" [debugger debug] 2)
#@376 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.

(fn &rest ARGS)
(defalias 'debug #[128 "\203	\207\n\204\306\307!\210\310\311\312!\205 r\311\312!q\210\313 )D\314\312!p\310C\310\211\211\315 \316 3456\n\310\2117\310\211\317\310\211\211\211\211\211\211\2118\206[\320 \321V\317\211\310\211\322 9:;8<=>	?\n@A\fB
CDEFG\323\321\324\325\326 	%\327\"\330$\216\2126@\331=\203\322\332\333\317\"\210\334\333!A@\242\335=\203\322\332\336\317\"\210\337\340\341H!\205\352\342\343H!!\205\352\344HBD\"\210\345 \240\210H\242=\203I\203#\3461\347\242J\350\242!Z\"0\202\210\202#\210\202#\242H\351 \210\3526!\210\n\203d\353ed\"KV\203Web\210\354K\245y\210`db\210\354K\245KZy\210\211`|\266\355c\210eb\210\306\356\313 \"\210\357\360!\210\306\361!\210\310\317L:\306\361!\210\212\362 \210.\2664M	.\207" [inhibit-redisplay debugger-value noninteractive major-mode debugger-outer-match-data executing-kbd-macro message "Entering debugger..." nil get-buffer "*Backtrace*" buffer-string get-buffer-create match-data with-timeout-suspend t minibuffer-depth 0 current-window-configuration make-byte-code "\306\302\242!\203\307\302\242!\301=\203\310\302\242!\203!\311\304!\210\202?\306\302\242!\203<\307\302\242!\301=\203<\312\302\242\"\210q\210\313\314\301!\203cr\301q\210\315\316 \210\300\204Y\317 \210\202b\300A@c\210\300@ \210*\320\303!\210\321!\207" vconcat vector [debugger-previous-window-height window-live-p window-buffer window-total-height set-window-configuration quit-restore-window nil buffer-live-p t erase-buffer fundamental-mode with-timeout-unsuspend set-match-data debugger-will-be-back debugger-bury-or-kill debugger-old-buffer debugger-previous-window inhibit-read-only debugger-outer-match-data] 3 debug backtrace-debug 4 backtrace-frame lambda 5 pop-to-buffer (display-buffer-reuse-window display-buffer-in-previous-window) window-live-p frame-visible-p window-frame previous-window selected-window (error) window-resize window-total-height debugger-mode debugger-setup-buffer count-lines 2 "...\n" "%s" kill-emacs -1 "" recursive-edit debugger-will-be-back debugger-step-after-exit debugger-old-buffer debugger-args overriding-terminal-local-map enable-recursive-minibuffers cursor-in-echo-area standard-output standard-input load-read-function overriding-local-map last-event-frame last-nonmenu-event last-command-event last-input-event unread-post-input-method-events unread-command-events inhibit-trace track-mouse this-command last-command debugger-previous-window debugger-jumping-flag debugger-previous-window-height debugger-batch-max-lines buffer-read-only debug-on-next-call] 41 (#$ . 4329) nil])
#@140 Format and insert the backtrace FRAMES at point.
Make functions into cross-reference buttons if DO-XREFS is non-nil.

(fn FRAMES DO-XREFS)
(defalias 'debugger-insert-backtrace #[514 "p\304\305!\210\211\205\247\211@\211@A\211@A\211@A\211@A\n\306\307\"\2030\310\2021\311c\210\205<\312\313\"`\203[\n\204[!\210\203T!\210\202f\314\315!\210\202fB!\210\211T\262\203~\316\211\317!G\\\320\321\322	D&\210\266\203\234\323>\203\234\324\325r\211A\262\242q\210`)\"c\210\326c\266
A\266\202\202	\262)\207" [eval-buffer-list standard-output debugger-stack-frame-as-list debugger-print-function require help-mode plist-get :debug-on-exit "* " "  " symbol-file defun princ "()" make-text-button symbol-name :type help-function-def help-args (eval-buffer eval-region) format "  ; Reading at buffer position %d" "\n"] 28 (#$ . 7390)])
#@114 Initialize the `*Backtrace*' buffer for entry to the debugger.
That buffer should be current already.

(fn ARGS)
(defalias 'debugger-setup-buffer #[257 "\306\307 \210\310\311!\210\311\312c\210\211@\313=\203\314\202\315\316\313!\233\311\211\317\320`C@\321\322>\203A\323c\210`S\240\210\2020\324=\203p\325c\210`\240\210A@+,+p\"\210\314@\233\211\326@\327\306#\240\266\330c\210\2020\331=\203\375A\211:\203\363\211@A\211:\203\317\211@A\211\332\333:\203\271@\211\334\267\202\260A\211:\203\340\211@\211\204\303A\211\204\270\335\336\"\202\276\337\340A\"\262\202\333A\211\204\325\335\341	#\262\202\331!\262\262\202\344!\262\202\264A\211:\203	\211A\211\204\335\342	#\202!\262\202
!\262\202\264A\211:\2032\211A\211\204)\335\343	#\202-!\262\2026!\262\202\264A\211:\203Y\211A\211\204P\335\344\"\202T!\262\202]!\262\202\264A\211:\203\247\211@\211\204\210A\211\204\335\345\n#\202\203!\262\202\242A\211\204\234\335\346	\f$\262\202\240!\262\262\202\253!\262\202\264!\262\202\275\211!\262\347\261\210\n`\240\210\330c\266\202\356\347c\210`\240\210,\f@\306=\203\346\fA\202\350\fp\"\210\330c\210\266\202\371\n\"\210\210\2020\337=\203\350c\210`\240\210,	A@p\"\210\330c\210\2020\311=\203*\351c\210`S\240\210\2020\211	\"\210\266\352\311\"\210\211\242b,\207" [buffer-read-only buffer-undo-list print-length print-level print-escape-control-characters print-escape-newlines nil erase-buffer set-buffer-multibyte t "Debugger entered" debug 3 1 backtrace-frames 8 50 #[514 "\301c\210\211`\240\210@\302=\203A\202p\"\210\303c\207" [debugger-print-function ": " nil 10] 5 "\n\n(fn ARGS POS)"] (debug lambda) "--entering a function:\n" exit "--returning value: " cl--set-getf :debug-on-exit 10 watchpoint "--" #[257 "\300\301A\"\207" [error #1="unrecognized watchpoint triggered %S"] 4 "\n\n(fn ARGS)"] #s(hash-table size 5 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (makunbound 157 defvaralias 233 let 274 unlet 315 set 354)) format "making %s void" error #1# "killing local value of %s in buffer %s" "aliasing %s to %s" "let-binding %s to %S" "ending let-binding of %s" "setting %s to %S" "setting %s in buffer %s to %S" ": " "--Lisp error: " "--beginning evaluation of function call form:\n" debugger-insert-backtrace debugger-value debugger-print-function] 29 (#$ . 8269)])
#@126 Proceed, stepping through subexpressions of this expression.
Enter another debugger on next entry to eval, apply or funcall.
(defalias 'debugger-step-through #[0 "\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 (#$ . 10755) nil])
#@56 Continue, evaluating this expression without stopping.
(defalias 'debugger-continue #[0 "\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 (#$ . 11195) nil])
#@166 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.

(fn VAL)
(defalias 'debugger-return-value #[257 "@\303>\203\304\305@\304=\203\306\202\307\"\210\211\310\311\312\"\210\313	!\210\212eb\210\314\315\316\312#\2030\312)\317 \207" [debugger-args 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] 5 (#$ . 11539) "XReturn value (evaluated): "])
#@70 Continue to exit from this frame, with all debug-on-entry suspended.
(defalias 'debugger-jump #[0 "\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 (#$ . 12159) 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 #[0 "\301\302\303\304\"\207" [debugger-jumping-flag nil remove-hook post-command-hook debugger-reenable] 3 (#$ . 12515)])
#@96 Return number of frames in backtrace before the one point points at.

(fn &optional SKIP-BASE)
(defalias 'debugger-frame-number #[256 "\212\300 \210\301\302!\203\303\304!\210`\305\2045\306!A@\307=\204%\211T\262\202\306T!A@\310=\2035\311\\\262eb\210\301\312!\203F\305\225b\210\313\314!\210\314y\210\311u\210\315 \203Z\316`\317\"b\210\202kg\320U\203g\313\314!\210\202k\313\311!\210\314y\210`X\203\204\301\321!\203}\314y\210\211T\262\202I\262)\207" [beginning-of-line looking-at " *;;;\\|[a-z]" error "This line is not a function call" 0 backtrace-frame debug debug--implement-debug-on-entry 2 "Debugger entered--\\(Lisp error\\|returning value\\):" forward-sexp 1 debugger--locals-visible-p next-single-char-property-change locals-visible 40 " *;;;"] 6 (#$ . 12814)])
#@112 Request entry to debugger when this frame exits.
Applies to the frame whose line point is on in the backtrace.
(defalias 'debugger-frame #[0 "\301\302 \303\"\210\304 \210g\305U\203\303\306\307!\210\310c\210)\304 \207" [inhibit-read-only backtrace-debug debugger-frame-number t beginning-of-line 32 delete-char 1 42] 3 (#$ . 13611) 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 #[0 "\301\302 \303\"\210\304 \210g\305U\203\306\307\310!\210\311c\210)\304 \207" [inhibit-read-only backtrace-debug debugger-frame-number nil beginning-of-line 42 t delete-char 1 32] 3 (#$ . 13958) nil])
#@52 Run BODY in original environment.

(fn &rest BODY)
(defalias 'debugger-env-macro '(macro . #[128 "\300\301\302\300B\303BBE\207" [progn (set-match-data debugger-outer-match-data) prog1 ((setq debugger-outer-match-data (match-data)))] 6 (#$ . 14310)]))
(byte-code "\300\301\302\303#\300\207" [function-put debugger-env-macro lisp-indent-function 0] 4)
#@86 Return the function name that marks the top of the backtrace.
See `backtrace-frame'.
(defalias 'debugger--backtrace-base #[0 "\300\301\302\"A@\303=\203
\303\207\302\207" [backtrace-frame 1 debug debug--implement-debug-on-entry] 3 (#$ . 14667)])
#@175 Eval an expression, in an environment like that outside the debugger.
The environment used is the one when entering the activation frame at point.

(fn EXP &optional NFRAME)
(defalias 'debugger-eval-expression #[513 "\211\206\3011\302\303!T0\202\210\304\305 \306!\210\307#\310\311\"\312!\211\203-\313\311\"\210\210\262\314 \207" [debugger-outer-match-data (error) debugger-frame-number skip-base 0 debugger--backtrace-base set-match-data backtrace-eval prin1 t eval-expression-print-format princ match-data] 10 (#$ . 14920) (byte-code "\300\301!C\207" [read--expression "Eval in stack frame: "] 2)])
#@61 Are the local variables of the current stack frame visible?
(defalias 'debugger--locals-visible-p #[0 "\212\300\301!\210\302`\303\")\207" [move-to-column 2 get-text-property locals-visible] 3 (#$ . 15542)])
#@58 Insert the local variables LOCALS at point.

(fn LOCALS)
(defalias 'debugger--insert-locals #[257 "\211\204\301c\207\302\211\211\205,\211@\211@A\303c\210\304p\"\210\305c\210\304p\"\266A\266\202\202\n\262)\207" [print-escape-newlines "\n    [no locals]" t "\n    " prin1 " = "] 8 (#$ . 15755)])
#@64 For the frame at point, insert locals and add text properties.
(defalias 'debugger--show-locals #[0 "\301\302!T\303 \304\"\305\212\306\307!\210`\310\210\311!\210\312`\313#\262*\207" [inhibit-read-only debugger-frame-number skip-base debugger--backtrace-base backtrace--locals t move-to-column 2 nil debugger--insert-locals add-text-properties (locals-visible t)] 8 (#$ . 16066)])
#@54 Delete local variables and remove the text property.
(defalias 'debugger--hide-locals #[0 "i\301\302!\210\303`\304\"\305\304\"\306\307\310#\210\211b\210\311\210`|\210\301!)\207" [inhibit-read-only move-to-column 2 next-single-char-property-change locals-visible previous-single-char-property-change t remove-text-properties (locals-visible) nil] 7 (#$ . 16459)])
#@58 Show or hide local variables of the current stack frame.
(defalias 'debugger-toggle-locals #[0 "\300 \203\301 \207\302 \207" [debugger--locals-visible-p debugger--hide-locals debugger--show-locals] 1 (#$ . 16835) nil])
(defvar debugger-mode-map (byte-code "\301 \302 \303\"\210\304!\210\305\306\307#\210\305\310\311#\210\305\312\313#\210\305\314\315#\210\305\316\317#\210\305\320\321#\210\305\322\323#\210\305\324\325#\210\305\326\327#\210\305\330\331#\210\305\332\333#\210\305\334\335#\210\305\336\337#\210\305\340\341#\210\305\342\343#\210\305\344\345#\210\305\346\347B#\210\305\350\351#\210\305\352\353#\210\305\354\355#\210\305\356\357#\210\305\360\361#\210\305\362\363#\210\305\364\365#\210\305\366\367#\210\305\370\371#\210\305\372\373#\210\305\374\375#\210\305\376\377#\210\305\201@\201A#\210\305\201B\201C#\210\305\201D\201E#\210\305\201F\201G#\210\207" [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 "v" debugger-toggle-locals " " 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")] 7))
(put 'debugger-mode 'mode-class 'special)
(defvar debugger-mode-hook nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [debugger-mode-hook variable-documentation put "Hook run after entering Debugger mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp debugger-mode-map definition-name debugger-mode] 4)
(defvar debugger-mode-map (make-sparse-keymap))
(byte-code "\301\302N\204\303\301\302\304\305!#\210\306\307!\204\303\307\310\311#\210\312\313 !\210\307\302N\204-\303\307\302\304\314!#\210\306\300!\204B\303\300\310\311#\210\315\316\300\317\"\210!\210\300\302N\204P\303\300\302\304\320!#\210\303\311\321\317#\207" [debugger-mode-abbrev-table debugger-mode-map variable-documentation put purecopy "Keymap for `debugger-mode'." boundp debugger-mode-syntax-table definition-name debugger-mode (lambda (#1=#:def-tmp-var) (defvar debugger-mode-syntax-table #1#)) make-syntax-table "Syntax table for `debugger-mode'." (lambda (#1#) (defvar debugger-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `debugger-mode'." derived-mode-parent] 5)
#@625 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}

This mode runs the hook `debugger-mode-hook', as the final or penultimate step
during initialization.
(defalias 'debugger-mode #[0 "\306\300!\210\307\310 \210\311\312\313!\210\314\f!\210
\307\314!\210\315\316\317\320\307$\210\313!\210)\321\322!\207" [delay-mode-hooks major-mode mode-name debugger-mode-map debugger-mode-syntax-table debugger-mode-abbrev-table make-local-variable t kill-all-local-variables debugger-mode "Debugger" use-local-map set-syntax-table add-hook kill-buffer-hook #[0 "\300 \301V\205	\302 \207" [recursion-depth 0 top-level] 2] nil run-mode-hooks debugger-mode-hook local-abbrev-table truncate-lines emacs-lisp-mode-syntax-table] 5 (#$ . 21001) nil])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313&	\207" [custom-declare-variable debugger-record-buffer funcall function #[0 "\300\207" [#1="*Debugger-record*"] 1 #1#] "Buffer name for expression values, for \\[debugger-record-expression]." :type string :group debugger :version "20.3"] 10)
#@84 Display a variable's value and record it in `*Backtrace-record*' buffer.

(fn EXP)
(defalias 'debugger-record-expression #[257 "\302!\211\303\304\305\"!\210\303\306!!\210\307 \210)\210r\310!q\210\311\312\313\314!\315\314!{\")\207" [debugger-record-buffer standard-output get-buffer-create princ format "Debugger Eval (%s): " debugger-eval-expression terpri get-buffer message "%s" line-beginning-position 0 line-end-position] 6 (#$ . 22523) (byte-code "\300\301!C\207" [read--expression "Record Eval: "] 2)])
#@129 Follow cross-reference at POS, defaulting to point.

For the cross-reference format, see `help-make-xrefs'.

(fn &optional POS)
(defalias 'debug-help-follow #[256 "\211\204`\262\300!?\2057\301\212b\210\302\303!\210`\304\303!\210`{)!\305!\2042\306!\2042\307!\2055\310!\262\207" [push-button intern skip-syntax-backward "w_" skip-syntax-forward boundp fboundp facep describe-symbol] 5 (#$ . 23044) "d"])
#@147 Conditionally call the debugger.
A call to this function is inserted by `debug-on-entry' to cause
functions to break on entry.

(fn &rest IGNORE)
(defalias 'debug--implement-debug-on-entry #[128 "\206	?\205\303\n\304!)\207" [inhibit-debug-on-entry debugger-jumping-flag debugger t debug] 3 (#$ . 23467)])
#@667 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.

(fn FUNCTION)
(defalias 'debug-on-entry #[257 "\300\301\302\303$\210\207" [advice-add :before debug--implement-debug-on-entry ((depth . -100))] 6 (#$ . 23785) (byte-code "\301 \302\303!\203\f\302\262\304\203\305\306\"\202\307\310\311\302\211\312	!&\262\211\313\232\2030\2023\314!C\207" [obarray function-called-at-point nil special-form-p completing-read format "Debug on entry to function (default %s): " "Debug on entry to function: " #[257 "\300!\205\n\301!?\207" [fboundp special-form-p] 3 "\n\n(fn SYMBOL)"] t symbol-name "" intern] 11)])
#@53 List of functions currently set for debug on entry.
(defalias 'debug--function-list #[0 "\300C\301\302\303\304\305\306!\307\"\310\311%!\210\211\242\207" [nil mapatoms make-byte-code 257 "\301\302\"\205
\300\300\242B\240\207" vconcat vector [advice-member-p debug--implement-debug-on-entry] 4 "\n\n(fn S)"] 8 (#$ . 25008)])
#@271 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.

(fn &optional FUNCTION)
(defalias 'cancel-debug-on-entry #[256 "\211\203\n\300\301\"\210\207\302\303!\210\304\305\306 \"\207" [advice-remove debug--implement-debug-on-entry message "Canceling debug-on-entry for all functions" mapcar cancel-debug-on-entry debug--function-list] 4 (#$ . 25343) (byte-code "\300\301\302\303\304 \"\305\306$\211\205\211\307\230?\205\310!\262C\207" [completing-read "Cancel debug on entry to function (default all functions): " mapcar symbol-name debug--function-list nil t "" intern] 5)])
#@64 Display a list of all the functions now set to debug on entry.
(defalias 'debugger-list-functions #[0 "\306\307!\210\310\311\312\313!\"\210r\314\315 !q\210p\316 \210\317\211\320\211\320\321 \210\322\323!\210+\211rq\210\324 \211\204?\325\326!\202f\325\327!\210\211\211\205d\211@\330`\331!\210`\332\333\334C&\210\335 \210A\266\202\202D\262\262)\336!\210)\207" [default-directory buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only 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 debug--function-list 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 internal-temp-output-buffer-show standard-output] 13 (#$ . 26121) nil])
#@120 Conditionally call the debugger.
This function is called when SYMBOL's value is modified.

(fn SYMBOL NEWVAL OP WHERE)
(defalias 'debug--implement-debug-watch #[1028 "\206	?\205\303\n\304%)\207" [inhibit-debug-on-entry debugger-jumping-flag debugger t watchpoint] 10 (#$ . 27060)])
#@684 Trigger a debugger invocation when VARIABLE is changed.

When called interactively, prompt for VARIABLE in the minibuffer.

This works by calling `add-variable-watch' on VARIABLE.  If you
quit from the debugger, this will abort the change (unless the
change is caused by the termination of a let-binding).

The watchpoint may be circumvented by C code that changes the
variable directly (i.e., not via `set').  Changing the value of
the variable (e.g., `setcar' on a list variable) will not trigger
watchpoint.

Use \[cancel-debug-on-variable-change] to cancel the effect of
this command.  Uninterning VARIABLE or making it an alias of
another symbol also cancels it.

(fn VARIABLE)
(defalias 'debug-on-variable-change #[257 "\300\301\"\207" [add-variable-watcher debug--implement-debug-watch] 4 (#$ . 27359) (byte-code "\301 \2119\205\211\302\303\203\304\305\"\202\306P\307\310\311\211\205%\312!&\211\313\232\2031\2024\314!C\207" [obarray variable-at-point completing-read "Debug when setting variable" format " (default %s): " ": " boundp t nil symbol-name "" intern] 11)])
(defalias 'debug-watch 'debug-on-variable-change)
#@51 List of variables currently set for debug on set.
(defalias 'debug--variable-list #[0 "\300C\301\302\303\304\305\306!\307\"\310\311%!\210\211\242\207" [nil mapatoms make-byte-code 257 "\301\302N>\205\300\300\242B\240\207" vconcat vector [debug--implement-debug-watch watchers] 4 "\n\n(fn S)"] 8 (#$ . 28511)])
#@291 Undo effect of \[debug-on-variable-change] on VARIABLE.
If VARIABLE is nil, cancel debug-on-variable-change for all variables.
When called interactively, prompt for VARIABLE in the minibuffer.
To specify a nil argument interactively, exit with an empty minibuffer.

(fn &optional VARIABLE)
(defalias 'cancel-debug-on-variable-change #[256 "\211\203	\300\301\"\207\302\303!\210\304\305\306 \"\207" [remove-variable-watcher debug--implement-debug-watch message "Canceling debug-watch for all variables" mapc cancel-debug-watch debug--variable-list] 4 (#$ . 28834) (byte-code "\300\301\302\303\304 \"\305\306$\211\205\211\307\230?\205\310!\262C\207" [completing-read "Cancel debug on set for variable (default all variables): " mapcar symbol-name debug--variable-list nil t "" intern] 5)])
(byte-code "\300\301\302\"\210\303\304!\207" [defalias cancel-debug-watch cancel-debug-on-variable-change provide debug] 3)