Gecko [ fernandoquevedodop.com ]

Name	Size	Permission
antlr-mode.elc	77.56 KB	-rw-r--r--
asm-mode.elc	7.42 KB	-rw-r--r--
autoconf.elc	4.55 KB	-rw-r--r--
bat-mode.elc	6.56 KB	-rw-r--r--
bug-reference.elc	7.3 KB	-rw-r--r--
cc-align.elc	39.52 KB	-rw-r--r--
cc-awk.elc	17.95 KB	-rw-r--r--
cc-bytecomp.elc	10.56 KB	-rw-r--r--
cc-cmds.elc	97.51 KB	-rw-r--r--
cc-defs.elc	66.37 KB	-rw-r--r--
cc-engine.elc	231.26 KB	-rw-r--r--
cc-fonts.elc	153.13 KB	-rw-r--r--
cc-guess.elc	13.35 KB	-rw-r--r--
cc-langs.elc	110.05 KB	-rw-r--r--
cc-menus.elc	8.05 KB	-rw-r--r--
cc-mode.elc	227.86 KB	-rw-r--r--
cc-styles.elc	16.66 KB	-rw-r--r--
cc-vars.elc	77.01 KB	-rw-r--r--
cfengine.elc	48.18 KB	-rw-r--r--
cmacexp.elc	6.2 KB	-rw-r--r--
compile.elc	92.53 KB	-rw-r--r--
cperl-mode.elc	212.98 KB	-rw-r--r--
cpp.elc	23.2 KB	-rw-r--r--
cwarn.elc	11.9 KB	-rw-r--r--
dcl-mode.elc	50.32 KB	-rw-r--r--
ebnf-abn.elc	6.95 KB	-rw-r--r--
ebnf-bnf.elc	8.02 KB	-rw-r--r--
ebnf-dtd.elc	13.53 KB	-rw-r--r--
ebnf-ebx.elc	8.12 KB	-rw-r--r--
ebnf-iso.elc	7.77 KB	-rw-r--r--
ebnf-otz.elc	8.47 KB	-rw-r--r--
ebnf-yac.elc	7.4 KB	-rw-r--r--
ebnf2ps.elc	121.12 KB	-rw-r--r--
ebrowse.elc	202.8 KB	-rw-r--r--
elisp-mode.elc	58.74 KB	-rw-r--r--
etags.elc	61.3 KB	-rw-r--r--
executable.elc	7.83 KB	-rw-r--r--
f90.elc	95.13 KB	-rw-r--r--
flymake-cc.elc	3.55 KB	-rw-r--r--
flymake-proc.elc	38.04 KB	-rw-r--r--
flymake.elc	63.5 KB	-rw-r--r--
fortran.elc	59.75 KB	-rw-r--r--
gdb-mi.elc	188.72 KB	-rw-r--r--
glasses.elc	10.37 KB	-rw-r--r--
grep.elc	40.95 KB	-rw-r--r--
gud.elc	98.55 KB	-rw-r--r--
hideif.elc	48.36 KB	-rw-r--r--
hideshow.elc	25.56 KB	-rw-r--r--
icon.elc	16.75 KB	-rw-r--r--
idlw-complete-structtag.elc	4.22 KB	-rw-r--r--
idlw-help.elc	35.91 KB	-rw-r--r--
idlw-shell.elc	129.89 KB	-rw-r--r--
idlw-toolbar.elc	27.44 KB	-rw-r--r--
idlwave.elc	250.95 KB	-rw-r--r--
inf-lisp.elc	21.06 KB	-rw-r--r--
js.elc	176.3 KB	-rw-r--r--
ld-script.elc	5.44 KB	-rw-r--r--
m4-mode.elc	6.34 KB	-rw-r--r--
make-mode.elc	62.21 KB	-rw-r--r--
meta-mode.elc	31.41 KB	-rw-r--r--
mixal-mode.elc	36.18 KB	-rw-r--r--
modula2.elc	30.37 KB	-rw-r--r--
octave.elc	63.2 KB	-rw-r--r--
opascal.elc	52.47 KB	-rw-r--r--
pascal.elc	39.22 KB	-rw-r--r--
perl-mode.elc	29.41 KB	-rw-r--r--
prog-mode.elc	15.82 KB	-rw-r--r--
project.elc	17.06 KB	-rw-r--r--
prolog.elc	85.47 KB	-rw-r--r--
ps-mode.elc	33 KB	-rw-r--r--
python.elc	178.17 KB	-rw-r--r--
ruby-mode.elc	63.86 KB	-rw-r--r--
scheme.elc	18.81 KB	-rw-r--r--
sh-script.elc	116.3 KB	-rw-r--r--
simula.elc	44.83 KB	-rw-r--r--
sql.elc	182.59 KB	-rw-r--r--
subword.elc	18.77 KB	-rw-r--r--
tcl.elc	40.14 KB	-rw-r--r--
vera-mode.elc	45.08 KB	-rw-r--r--
verilog-mode.elc	450.39 KB	-rw-r--r--
vhdl-mode.elc	528.7 KB	-rw-r--r--
which-func.elc	10.4 KB	-rw-r--r--
xref.elc	56.91 KB	-rw-r--r--
xscheme.elc	38 KB	-rw-r--r--

Code Editor : gdb-mi.elc

;ELC���
;;; Compiled
;;; in Emacs version 27.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\300\303!\210\300\304!\207" [require gud json bindat cl-lib] 2)
(defvar gdb-memory-address "main")
#@44 Last successfully accessed memory address.
(defvar gdb-memory-last-address nil (#$ . 545))
#@56 Address of next memory page for program memory buffer.
(defvar gdb-memory-next-page nil (#$ . 642))
#@60 Address of previous memory page for program memory buffer.
(defvar gdb-memory-prev-page nil (#$ . 748))
#@350 Main current thread.

Invalidation triggers use this variable to query GDB for
information on the specified thread by wrapping GDB/MI commands
in `gdb-current-context-command'.

This variable may be updated implicitly by GDB via `gdb-stopped'
or explicitly by `gdb-select-thread'.

Only `gdb-setq-thread-number' should be used to change this
value.
(defvar gdb-thread-number nil (#$ . 859))
#@291 Selected frame level for main current thread.

Updated according to the following rules:

When a thread is selected or current thread stops, set to "0".

When current thread goes running (and possibly exits eventually),
set to nil.

May be manually changed by user with `gdb-select-frame'.
(defvar gdb-frame-number nil (#$ . 1257))
#@41 Identity of frame for watch expression.
(defvar gdb-frame-address nil (#$ . 1595))
#@52 Name of selected function for main current thread.
(defvar gdb-selected-frame nil (#$ . 1684))
#@48 Name of selected file for main current thread.
(defvar gdb-selected-file nil (#$ . 1785))
#@50 Number of selected line for main current thread.
(defvar gdb-selected-line nil (#$ . 1881))
#@238 Associative list of threads provided by "-thread-info" MI command.

Keys are thread numbers (in strings) and values are structures as
returned from -thread-info by `gdb-json-partial-output'.  Updated in
`gdb-thread-list-handler-custom'.
(defvar gdb-threads-list nil (#$ . 1980))
#@122 Number of currently running threads.

If nil, no information is available.

Updated in `gdb-thread-list-handler-custom'.
(defvar gdb-running-threads-count nil (#$ . 2266))
#@77 Number of currently stopped threads.

See also `gdb-running-threads-count'.
(defvar gdb-stopped-threads-count nil (#$ . 2444))
#@272 Associative list of breakpoints provided by "-break-list" MI command.

Keys are breakpoint numbers (in string) and values are structures
as returned from "-break-list" by `gdb-json-partial-output'
("body" field is used). Updated in
`gdb-breakpoints-list-handler-custom'.
(defvar gdb-breakpoints-list nil (#$ . 2578))
(defvar gdb-current-language nil)
#@228 List of variables in watch window.
Each element has the form
  (VARNUM EXPRESSION NUMCHILD TYPE VALUE STATUS HAS_MORE FP)
where STATUS is nil (`unchanged'), `changed' or `out-of-scope', FP the frame
address for root variables.
(defvar gdb-var-list nil (#$ . 2936))
#@50 Source file from which program execution begins.
(defvar gdb-main-file nil (#$ . 3207))
(defvar gdb-stack-position nil)
(defvar gdb-thread-position nil)
(defvar gdb-disassembly-position nil)
#@92 Alist of breakpoint numbers and full filenames.
Only used for files that Emacs can't find.
(defvar gdb-location-alist nil (#$ . 3404))
#@79 GUD tooltips display variable values when t, and macro definitions otherwise.
(defvar gdb-active-process nil (#$ . 3545))
(defvar gdb-error "Non-nil when GDB is reporting an error.")
#@74 Non-nil if GDB knows that the inferior includes preprocessor macro info.
(defvar gdb-macro-info nil (#$ . 3734))
#@25 List of register names.
(defvar gdb-register-names nil (#$ . 3853))
#@45 List of changed register numbers (strings).
(defvar gdb-changed-registers nil (#$ . 3927))
(defvar gdb-buffer-fringe-width nil)
(defvar gdb-last-command nil)
(defvar gdb-prompt-name nil)
(defvar gdb-token-number 0)
#@64 List of gdb-handler keeping track of all pending GDB commands.
(defvar gdb-handler-list nil (#$ . 4148))
#@50 List of source files for the current executable.
(defvar gdb-source-file-list nil (#$ . 4259))
(defvar gdb-first-done-or-error t)
(defvar gdb-source-window nil)
(defvar gdb-inferior-status nil)
(defvar gdb-continuation nil)
(defvar gdb-supports-non-stop nil)
#@129 Message to be shown in GUD console.

This variable is updated in `gdb-done-or-error' and returned by
`gud-gdbmi-marker-filter'.
(defvar gdb-filter-output nil (#$ . 4525))
#@147 Indicates whether current GDB session is using non-stop mode.

It is initialized to `gdb-non-stop-setting' at the beginning of
every GDB session.
(defvar gdb-non-stop nil (#$ . 4703))
#@49 One of the symbols bound in `gdb-buffer-rules'.
(defvar gdb-buffer-type nil (#$ . 4893))
(make-variable-buffer-local 'gdb-buffer-type)
#@429 The disposition of the output of the current gdb command.
Possible values are these symbols:

`user' -- gdb output should be copied to the GUD buffer
              for the user to see.

`emacs' -- output should be collected in the partial-output-buffer
	       for subsequent processing by a command.  This is the
	       disposition of output generated by commands that
	       gdb mode sends to gdb on its own behalf.
(defvar gdb-output-sink nil (#$ . 5035))
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313&	\207" [custom-declare-variable gdb-discard-unordered-replies funcall function #[0 "\300\207" [t] 1] "Non-nil means discard any out-of-order GDB replies.\nThis protects against lost GDB replies, assuming that GDB always\nreplies in the same order as Emacs sends commands.  When receiving a\nreply with a given token-number, assume any pending messages with a\nlower token-number are out-of-order." :type boolean :group gud :version "24.4"] 10)
#@70 compiler-macro for inlining `gdb-handler-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'gdb-handler-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block gdb-handler-p (and (memq (type-of cl-x) cl-struct-gdb-handler-tags) t)) nil] 9 (#$ . 6017)])
(put 'gdb-handler-p 'compiler-macro 'gdb-handler-p--cmacro)
#@13

(fn CL-X)
(defalias 'gdb-handler-p #[257 "\301!>\205	�\302\207" [cl-struct-gdb-handler-tags type-of t] 3 (#$ . 6357)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put gdb-handler-p side-effect-free error-free put gdb-handler cl-deftype-satisfies] 5)
#@81 compiler-macro for inlining `gdb-handler-token-number'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'gdb-handler-token-number--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block gdb-handler-token-number (progn (or (gdb-handler-p cl-x) (signal 'wrong-type-argument (list 'gdb-handler cl-x))) (aref cl-x 1))) nil] 9 (#$ . 6635)])
(put 'gdb-handler-token-number 'compiler-macro 'gdb-handler-token-number--cmacro)
#@69 Access slot "token-number" of `gdb-handler' struct CL-X.

(fn CL-X)
(defalias 'gdb-handler-token-number #[257 "\301!>\204�\302\303\304D\"\210\211\305H\207" [cl-struct-gdb-handler-tags type-of signal wrong-type-argument gdb-handler 1] 5 (#$ . 7076)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put gdb-handler-token-number side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" gdb-handler-token-number] 5 "\n\n(fn CL-DO CL-X)"]] 5)
#@77 compiler-macro for inlining `gdb-handler-function'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'gdb-handler-function--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block gdb-handler-function (progn (or (gdb-handler-p cl-x) (signal 'wrong-type-argument (list 'gdb-handler cl-x))) (aref cl-x 2))) nil] 9 (#$ . 7576)])
(put 'gdb-handler-function 'compiler-macro 'gdb-handler-function--cmacro)
#@65 Access slot "function" of `gdb-handler' struct CL-X.

(fn CL-X)
(defalias 'gdb-handler-function #[257 "\301!>\204�\302\303\304D\"\210\211\305H\207" [cl-struct-gdb-handler-tags type-of signal wrong-type-argument gdb-handler 2] 5 (#$ . 7997)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put gdb-handler-function side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" gdb-handler-function] 5 "\n\n(fn CL-DO CL-X)"]] 5)
#@84 compiler-macro for inlining `gdb-handler-pending-trigger'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'gdb-handler-pending-trigger--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block gdb-handler-pending-trigger (progn (or (gdb-handler-p cl-x) (signal 'wrong-type-argument (list 'gdb-handler cl-x))) (aref cl-x 3))) nil] 9 (#$ . 8481)])
(put 'gdb-handler-pending-trigger 'compiler-macro 'gdb-handler-pending-trigger--cmacro)
#@72 Access slot "pending-trigger" of `gdb-handler' struct CL-X.

(fn CL-X)
(defalias 'gdb-handler-pending-trigger #[257 "\301!>\204�\302\303\304D\"\210\211\305H\207" [cl-struct-gdb-handler-tags type-of signal wrong-type-argument gdb-handler 3] 5 (#$ . 8937)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put gdb-handler-pending-trigger side-effect-free t defalias copy-gdb-handler copy-sequence] 4)
#@117 compiler-macro for inlining `make-gdb-handler'.

(fn CL-WHOLE &cl-quote &key TOKEN-NUMBER FUNCTION PENDING-TRIGGER)
(defalias 'make-gdb-handler--cmacro #[385 "\300\301\"A@\300\302\"A@\300\303\"A@\211\203=�\211@\304>\203&�\211AA\262\202�\305>A@\2034�\306\262\202�\307\310@\"\210\202�\210\311\312\313\306\306&\207" [plist-member :token-number :function :pending-trigger (:token-number :function :pending-trigger :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:token-number :function :pending-trigger)" cl--defsubst-expand (token-number function pending-trigger) (cl-block make-gdb-handler (record 'gdb-handler token-number function pending-trigger))] 14 (#$ . 9358)])
(put 'make-gdb-handler 'compiler-macro 'make-gdb-handler--cmacro)
#@97 Constructor for objects of type `gdb-handler'.

(fn &key TOKEN-NUMBER FUNCTION PENDING-TRIGGER)
(defalias 'make-gdb-handler #[128 "\300\301\"A@\300\302\"A@\300\303\"A@\211\203=�\211@\304>\203&�\211AA\262\202�\305>A@\2034�\306\262\202�\307\310@\"\210\202�\210\311\312$\207" [plist-member :token-number :function :pending-trigger (:token-number :function :pending-trigger :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:token-number :function :pending-trigger)" record gdb-handler] 9 (#$ . 10149)])
(byte-code "\300\301\302\303#\304\305\306\307\310\311\312\313\305\303&	\207" [function-put make-gdb-handler side-effect-free t cl-struct-define gdb-handler "Data required to handle the reply of a command sent to GDB." cl-structure-object record nil ((cl-tag-slot) (token-number nil :read-only t) (function nil :read-only t) (pending-trigger nil)) cl-struct-gdb-handler-tags] 11)
#@448 Insert a new GDB command handler in `gdb-handler-list'.
Handlers are used to keep track of the commands sent to GDB
and to handle the replies received.
Upon reception of a reply prefixed with TOKEN-NUMBER,
invoke the callback HANDLER-FUNCTION.
If PENDING-TRIGGER is specified, no new GDB commands will be
sent with this same PENDING-TRIGGER until a reply is received
for this handler.

(fn TOKEN-NUMBER HANDLER-FUNCTION &optional PENDING-TRIGGER)
(defalias 'gdb-add-handler #[770 "\301\302$B\211\207" [gdb-handler-list record gdb-handler] 8 (#$ . 11079)])
#@205 Remove the handler TOKEN-NUMBER from `gdb-handler-list'.
Additionally, if `gdb-discard-unordered-replies' is non-nil,
discard all handlers having a token number less than TOKEN-NUMBER.

(fn TOKEN-NUMBER)
(defalias 'gdb-delete-handler #[257 "\203�\302\303\304\305\306\307!\310\"\311\312%	\"\211\207\302\303\304\313\306\307!\314\"\315\316%	\"\211\207" [gdb-discard-unordered-replies gdb-handler-list cl-delete-if make-byte-code 257 "\302!	>\204�\303\304\305D\"\210\211\306H\300W\203-�\307\310\302!	>\204(�\303\304\305D\"\210\306H\"\210\302!	>\204<�\303\304\305D\"\210\211\306H\300X\207" vconcat vector [cl-struct-gdb-handler-tags type-of signal wrong-type-argument gdb-handler 1 message "WARNING! Discarding GDB handler with token #%d\n"] 7 "Discard any HANDLER with a token number `<=' than TOKEN-NUMBER.\n\n(fn HANDLER)" "\302!	>\204�\303\304\305D\"\210\211\306H\300=\207" [cl-struct-gdb-handler-tags type-of signal wrong-type-argument gdb-handler 1] 5 "Discard any HANDLER with a token number `eq' to TOKEN-NUMBER.\n\n(fn HANDLER)"] 8 (#$ . 11647)])
#@91 Return the function callback registered with the handler TOKEN-NUMBER.

(fn TOKEN-NUMBER)
(defalias 'gdb-get-handler-function #[257 "\302\303\304\305\306\307!\310\"\311\312%\"\313!	>\204�\314\315\316D\"\210\211\317H\207" [gdb-handler-list cl-struct-gdb-handler-tags cl-find-if make-byte-code 257 "\302!	>\204�\303\304\305D\"\210\211\306H\300=\207" vconcat vector [cl-struct-gdb-handler-tags type-of signal wrong-type-argument gdb-handler 1] 5 "\n\n(fn HANDLER)" type-of signal wrong-type-argument gdb-handler 2] 8 (#$ . 12723)])
#@100 Return non-nil if a command handler is pending with trigger PENDING-TRIGGER.

(fn PENDING-TRIGGER)
(defalias 'gdb-pending-handler-p #[257 "\301\302\303\304\305\306!\307\"\310\311%\"\207" [gdb-handler-list cl-find-if make-byte-code 257 "\302!	>\204�\303\304\305D\"\210\211\306H\300=\207" vconcat vector [cl-struct-gdb-handler-tags type-of signal wrong-type-argument gdb-handler 3] 5 "\n\n(fn HANDLER)"] 8 (#$ . 13268)])
#@212 Handle the GDB reply TOKEN-NUMBER.
This invokes the handler registered with this token number
in `gdb-handler-list' and clears all pending handlers invalidated
by the reception of this reply.

(fn TOKEN-NUMBER)
(defalias 'gdb-handle-reply #[257 "\300!\211\205�\3011�\211 0\202�\302\303!!\262\210\304!\207" [gdb-get-handler-function (error) message error-message-string gdb-delete-handler] 6 (#$ . 13700)])
#@286 Remove all pending triggers from gdb-handler-list.
The handlers are left in gdb-handler-list so that replies received
from GDB could still be handled.  However, removing the pending triggers
allows Emacs to send new commands even if replies of previous commands
were not yet received.
(defalias 'gdb-remove-all-pending-triggers #[0 "\211\205$�\211@\302!	>\204�\303\304\305D\"\210\211\211\306\307I\266A\266\202\202�\207" [gdb-handler-list cl-struct-gdb-handler-tags type-of signal wrong-type-argument gdb-handler 3 nil] 6 (#$ . 14120)])
#@178 Wait for all pending GDB commands to finish and evaluate BODY.

This function checks every 0.5 seconds if there are any pending
triggers in `gdb-handler-list'.

(fn &rest BODY)
(defalias 'gdb-wait-for-pending '(macro . #[128 "\300\301\302\303\304\302\305\306\307	B\310\nBFEDF\207" [run-with-timer 0.5 nil quote lambda if (not (cl-find-if (lambda (handler) (gdb-handler-pending-trigger handler)) gdb-handler-list)) progn gdb-wait-for-pending] 12 (#$ . 14670)]))
#@158 Register new PUBLISHER's SUBSCRIBER.

SUBSCRIBER must be a pair, where cdr is a function of one
argument (see `gdb-emit-signal').

(fn PUBLISHER SUBSCRIBER)
(defalias 'gdb-add-subscriber '(macro . #[514 "\300\301D\302BBB\207" [add-to-list quote (t)] 6 (#$ . 15140)]))
#@66 Unregister SUBSCRIBER from PUBLISHER.

(fn PUBLISHER SUBSCRIBER)
(defalias 'gdb-delete-subscriber '(macro . #[514 "\300\301EE\207" [setq delete] 7 (#$ . 15416)]))
#@18

(fn PUBLISHER)
(defalias 'gdb-get-subscribers #[257 "\207" [] 2 (#$ . 15588)])
#@101 Call cdr for each subscriber of PUBLISHER with SIGNAL as argument.

(fn PUBLISHER &optional SIGNAL)
(defalias 'gdb-emit-signal #[513 "\300!\211\205�\211@\211A!\210A\266\202\202�\207" [gdb-get-subscribers] 6 (#$ . 15676)])
#@157 Used to invalidate GDB buffers by emitting a signal in `gdb-update'.
Must be a list of pairs with cars being buffers and cdr's being
valid signal handlers.
(defvar gdb-buf-publisher nil (#$ . 15910))
(byte-code "\300\301\302\303\304\305\306\307\310\311&	\210\300\312\302\313\304\301\310\311&\210\300\314\302\315\304\301\310\311&\210\316\317\320\321\322DD\323\304\301\324\325\310\326&	\210\316\327\320\321\330DD\331\324\332\304\312\310\333&	\210\316\334\320\321\335DD\336\324\332\304\312\310\311&	\210\316\337\320\321\340DD\341\324\342\304\312\310\311\306\343&\210\316\344\320\321\345DD\346\324\347\304\301\310\311\306\350&\210\316\351\320\321\352DD\353\324\332\304\312\310\311&	\210\316\354\320\321\355DD\356\324\332\304\314\310\311&	\210\316\357\320\321\360DD\361\324\332\304\314\310\311&	\210\316\362\320\321\363DD\364\324\332\304\314\310\311&	\210\316\365\320\321\366DD\367\324\332\304\314\310\311&	\210\316\370\320\321\371DD\372\324\332\304\314\310\311&	\210\316\373\320\321\374DD\375\324\332\304\314\310\311&	\210\316\376\320\321\377DD\201@�\324\332\304\314\310\311&	\207" [custom-declare-group gdb nil "GDB graphical interface." :group tools :link (info-link "(emacs)GDB Graphical Interface") :version "23.2" gdb-non-stop "GDB non-stop debugging settings." gdb-buffers "GDB buffers." custom-declare-variable gdb-debug-log-max funcall function #[0 "\300\207" [128] 1] "Maximum size of `gdb-debug-log'.  If nil, size is unlimited." :type (choice (integer :tag "Number of elements") (const :tag "Unlimited" nil)) "22.1" gdb-non-stop-setting #[0 "\301=?\207" [system-type windows-nt] 2] "If non-nil, GDB sessions are expected to support the non-stop mode.\nWhen in the non-stop mode, stopped threads can be examined while\nother threads continue to execute.\n\nIf this is non-nil, GDB will be sent the \"set non-stop 1\" command,\nand if that results in an error, the non-stop setting will be\nturned off automatically.\n\nOn MS-Windows, this is off by default, because MS-Windows targets\ndon't support the non-stop mode.\n\nGDB session needs to be restarted for this setting to take effect." boolean "26.1" gdb-gud-control-all-threads #[0 "\300\207" [t] 1] "When non-nil, GUD execution commands affect all threads when\nin non-stop mode.  Otherwise, only current thread is affected." gdb-switch-reasons #[0 "\300\207" [t] 1] "List of stop reasons for which Emacs should switch thread.\nWhen t, switch to stopped thread no matter what the reason was.\nWhen nil, never switch to stopped thread automatically.\n\nThis setting is used in non-stop mode only.  In all-stop mode,\nEmacs always switches to the thread which caused the stop." (choice (const :tag "All reasons" t) (set :tag "Selection of reasons..." (const :tag "A breakpoint was reached." "breakpoint-hit") (const :tag "A watchpoint was triggered." "watchpoint-trigger") (const :tag "A read watchpoint was triggered." "read-watchpoint-trigger") (const :tag "An access watchpoint was triggered." "access-watchpoint-trigger") (const :tag "Function finished execution." "function-finished") (const :tag "Location reached." "location-reached") (const :tag "Watchpoint has gone out of scope" "watchpoint-scope") (const :tag "End of stepping range reached." "end-stepping-range") (const :tag "Signal received (like interruption)." "signal-received")) (const :tag "None" nil)) (info-link "(gdb)GDB/MI Async Records") gdb-stopped-functions #[0 "\300\207" [nil] 1] "List of functions called whenever GDB stops.\n\nEach function takes one argument, a parsed MI response, which\ncontains fields of corresponding MI *stopped async record:\n\n    ((stopped-threads . \"all\")\n     (thread-id . \"1\")\n     (frame (line . \"38\")\n            (fullname . \"/home/sphinx/projects/gsoc/server.c\")\n            (file . \"server.c\")\n            (args ((value . \"0x804b038\")\n                   (name . \"arg\")))\n            (func . \"hello\")\n            (addr . \"0x0804869e\"))\n     (reason . \"end-stepping-range\"))\n\nNote that \"reason\" is only present in non-stop debugging mode.\n\n`bindat-get-field' may be used to access the fields of response.\n\nEach function is called after the new current thread was selected\nand GDB buffers were updated in `gdb-stopped'." (repeat function) (info-link "(gdb)GDB/MI Async Records") gdb-switch-when-another-stopped #[0 "\300\207" [t] 1] "When nil, don't switch to stopped thread if some other\nstopped thread is already selected." gdb-stack-buffer-locations #[0 "\300\207" [t] 1] "Show file information or library names in stack buffers." gdb-stack-buffer-addresses #[0 "\300\207" [nil] 1] "Show frame addresses in stack buffers." gdb-thread-buffer-verbose-names #[0 "\300\207" [t] 1] "Show long thread names in threads buffer." gdb-thread-buffer-arguments #[0 "\300\207" [t] 1] "Show function arguments in threads buffer." gdb-thread-buffer-locations #[0 "\300\207" [t] 1] "Show file information or library names in threads buffer." gdb-thread-buffer-addresses #[0 "\300\207" [nil] 1] "Show addresses for thread frames in threads buffer." gdb-show-threads-by-default #[0 "\300\207" [nil] 1] "Show threads list buffer instead of breakpoints list by default."] 12)
#@196 List of commands sent to and replies received from GDB.
Most recent commands are listed first.  This list stores only the last
`gdb-debug-log-max' values.  This variable is used to debug GDB-MI.
(defvar gdb-debug-log nil (#$ . 21090))
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313\314\315\316\317&
\207" [custom-declare-variable gdb-enable-debug funcall function #[0 "\300\207" [nil] 1] "Non-nil if Gdb-Enable-Debug mode is enabled.\nSee the `gdb-enable-debug' command\nfor a description of this minor mode." :set custom-set-minor-mode :initialize custom-initialize-default :group gdb :type boolean :version "22.1"] 14)
#@640 Toggle logging of transaction between Emacs and Gdb.
The log is stored in `gdb-debug-log' as an alist with elements
whose cons is send, send-item or recv and whose cdr is the string
being transferred.  This list may grow up to a size of
`gdb-debug-log-max' after which the oldest element (at the end of
the list) is deleted every time a new one is added (at the front).

If called interactively, enable Gdb-Enable-Debug mode if ARG is
positive, and disable it if ARG is zero or negative.  If called from
Lisp, also enable the mode if ARG is omitted or nil, and toggle it if
ARG is `toggle'; disable the mode otherwise.

(fn &optional ARG)
(defalias 'gdb-enable-debug #[256 "\300 \301\302\303=\203�\304\302!?\202�\305!\306V\"\210\307\310\304\302!\203$�\311\202%�\312\"\210\313\314!\203O�\315\302!\210\300 \203=�\211\300 \232\203O�\316\317\320\304\302!\203J�\321\202K�\322#\266\210\323 \210\304\302!\207" [current-message set-default gdb-enable-debug toggle default-value prefix-numeric-value 0 run-hooks gdb-enable-debug-hook gdb-enable-debug-on-hook gdb-enable-debug-off-hook called-interactively-p any customize-mark-as-set "" message "Gdb-Enable-Debug mode %sabled%s" "en" "dis" force-mode-line-update] 7 (#$ . 21734) (byte-code "\206�\301C\207" [current-prefix-arg toggle] 1)])
(defvar gdb-enable-debug-hook nil)
(byte-code "\301\302N\204\f�\303\301\302\304#\210\305\306\307\310\300!\205�\307\211%\210\311\312\313\314\315DD\316\317\320\321\322\323\324&	\210\311\325\313\314\326DD\327\317\320\321\322\323\324&	\210\311\330\313\314\331DD\332\317\333\321\322\323\334&	\210\311\335\313\314\336DD\337\317\333\321\322\323\324&	\207" [gdb-enable-debug-map gdb-enable-debug-hook variable-documentation put "Hook run after entering or leaving `gdb-enable-debug'.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" add-minor-mode gdb-enable-debug nil boundp custom-declare-variable gdb-cpp-define-alist-program funcall function #[0 "\300\207" [#1="gcc -E -dM -"] 1 #1#] "Shell command for generating a list of defined macros in a source file.\nThis list is used to display the #define directive associated\nwith an identifier as a tooltip.  It works in a debug session with\nGDB, when `gud-tooltip-mode' is t.\n\nSet `gdb-cpp-define-alist-flags' for any include paths or\npredefined macros." :type string :group gdb :version "22.1" gdb-cpp-define-alist-flags #[0 "\300\207" [#2=""] 1 #2#] "Preprocessor flags for `gdb-cpp-define-alist-program'." gdb-create-source-file-list #[0 "\300\207" [t] 1] "Non-nil means create a list of files from which the executable was built.\nSet this to nil if the GUD buffer displays \"initializing...\" in the mode\nline for a long time when starting, possibly because your executable was\nbuilt from a large number of files.  This allows quicker initialization\nbut means that these files are not automatically enabled for debugging,\ne.g., you won't be able to click in the fringe to set a breakpoint until\nexecution has already stopped there." boolean "23.1" gdb-show-main #[0 "\300\207" [nil] 1] "Non-nil means display source file containing the main routine at startup.\nAlso display the main routine in the disassembly buffer if present."] 10)
#@75 When non-nil, print the messages sent/received from GDB/MI in *Messages*.
(defvar gdbmi-debug-mode nil (#$ . 25003))
#@15

(fn STATUS)
(defalias 'gdb-force-mode-line-update #[257 "\211\205�\302!\205�r\211q\210\303\304\305\306!!#\307 )\207" [gud-comint-buffer mode-line-process buffer-name format ":%s [%s]" process-status get-buffer-process force-mode-line-update] 7 (#$ . 25126)])
#@28 Switch to non-stop/A mode.
(defalias 'gdb-control-all-threads #[0 "\301\302 \210\303\304!\207" [gdb-gud-control-all-threads t force-mode-line-update message "Now in non-stop/A mode."] 2 (#$ . 25400) nil])
#@28 Switch to non-stop/T mode.
(defalias 'gdb-control-current-thread #[0 "\301\302 \210\303\304!\207" [gdb-gud-control-all-threads nil force-mode-line-update message "Now in non-stop/T mode."] 2 (#$ . 25612) nil])
(defalias 'gdb-find-watch-expression #[0 "\301`!\302Z8\211@\303\304\305\"\210\306\307\310\"\"\303\211\311\307\302\"\312\313#A@\262@\262\211\211\203]�\211@\306\"\262\304\314\3158\"\203J�\316\317Q\202M�\320PP\262\320Q\262A\266\202\202+�\210\266\204\207" [gdb-var-list line-number-at-pos 2 nil string-match "\$var[0-9]+\$\\.\$.*\$" assoc match-string 1 split-string "\\." t ".*\\[[0-9]+\\]$" 3 "[" "]" "."] 14])
#@308 When `gdb-non-stop' is t, add --thread option to COMMAND if
`gdb-gud-control-all-threads' is nil and --all option otherwise.
If NOALL is t, always add --thread option no matter what
`gdb-gud-control-all-threads' value is.

When `gdb-non-stop' is nil, return COMMAND unchanged.

(fn COMMAND &optional NOALL)
(defalias 'gdb-gud-context-command #[513 "\203�	\203�\211\204�\n\203�\303P\207\304!\207\207" [gdb-non-stop gdb-gud-control-all-threads gdb-supports-non-stop " --all " gdb-current-context-command] 4 (#$ . 26268)])
#@227 `gud-call' wrapper which adds --thread/--all options between
CMD1 and CMD2.  NOALL is the same as in `gdb-gud-context-command'.

NOARG must be t when this macro is used outside `gud-def'.

(fn CMD1 &optional CMD2 NOALL NOARG)
(defalias 'gdb-gud-context-call '(macro . #[1025 "\300\301\302E\303F?\205�\304E\207" [gud-call concat gdb-gud-context-command " " arg] 9 (#$ . 26803)]))
#@27

(fn FILTER PROC STRING)
(defalias 'gdb--check-interpreter #[771 "\211G\301U?\205?�\302\303!\304\"\211\303!=\204�\305\"\210\266\211\301H\306>\204;�\307\310!\210\311\312\313#\314Q\266\202\315\300!\210\316\"\207" [gud-marker-filter 0 advice--remove-function process-filter gdb--check-interpreter set-process-filter (94 126 64 38 42 61) "Error: you did not specify -i=mi on GDB's command line!" message propertize font-lock-face error "\n" make-local-variable gud-gdb-marker-filter] 8 (#$ . 27195)])
(defvar gdb-control-level 0)
#@2990 Run gdb passing it COMMAND-LINE as arguments.

If COMMAND-LINE names a program FILE to debug, gdb will run in
a buffer named *gud-FILE*, and the directory containing FILE
becomes the initial working directory and source-file directory
for your debugger.
If COMMAND-LINE requests that gdb attaches to a process PID, gdb
will run in *gud-PID*, otherwise it will run in *gud*; in these
cases the initial working directory is the default-directory of
the buffer in which this command was invoked.

COMMAND-LINE should include "-i=mi" to use gdb's MI text interface.
Note that the old "--annotate" option is no longer supported.

If option `gdb-many-windows' is nil (the default value) then gdb just
pops up the GUD buffer unless `gdb-show-main' is t.  In this case
it starts with two windows: one displaying the GUD buffer and the
other with the source file with the main routine of the inferior.

If option `gdb-many-windows' is t, regardless of the value of
`gdb-show-main', the layout below will appear.  Keybindings are
shown in some of the buffers.

Watch expressions appear in the speedbar/slowbar.

The following commands help control operation :

`gdb-many-windows'    - Toggle the number of windows gdb uses.
`gdb-restore-windows' - To restore the window layout.

See Info node `(emacs)GDB Graphical Interface' for a more
detailed description of this mode.

(fn COMMAND-LINE)
(defalias 'gdb #[257 "\203\"�\306!\203\"�\307!\203\"�rq\210	)\310=\203\"�\311 \210\312\313!\210\314\315\316#\210\307!\317\320\321\322\323\324\325!\326\"\327$\321\330\331\324\325!\332\"\333\334%B\262\335\315$\266\336\301!\210\337\336\302!\210\322\340\341\f!\203\342\343\344!\206t�
\345=\203s�\346\202t�\347!\343\350!\351\352\342\353!\342\354!\230?\205\206�\355\"\211\203\345�\211@\356\342!\211\262!\203\336�\357\360!r\211q\210\321\322\361\324\325!\362\"\327$\216\363!\210\364\365\315\366#\203\334�\367\370!\371\230\203\314�\342\367\327!\372!\"\262\202\257�\367\370!\373\230\203\257�\367\327!\262\202\257�*\210A\266\202\202\207�\210\211;\203\374!\211\262\250\203\211\322V\203\336\375!\210\211=;\203\336\376!\210>\377\366!\266\201E�\201F�\201G�\"\210\201H�\201I�\201F�\"\210\201J�\324@\201K�\"\201F�\"\210\201E�\201L�\201M�\"\210\201H�\201N�\201L�\"\210\201J�\324@\201O�\"\201L�\"\210\201E�\201P�\201Q�\"\210\201H�\201R�\201P�\"\210\201J�\324@\201S�\"\201P�\"\210\201E�\201T�\201U�\"\210\201H�\201V�\201T�\"\210\201J�\324@\201W�\"\201T�\"\210\201E�\201X�\201Y�\"\210\201H�\201Z�\201X�\"\210\201J�\324@\201[�\"\201X�\"\210\201E�\201\\�\201]�\"\210\201E�\201^�\201_�\"\210\201H�\201`�\201^�\"\210\201J�\324@\201a�\"\201^�\"\210\201E�\201b�\201c�\"\210\201H�\201d�\201b�\"\210\201J�\324@\201e�\"\201b�\"\210\201E�\201f�\201g�\"\210\201H�\201h�\201f�\"\210\201J�\324@\201i�\"\201f�\"\210\201E�\201j�\201k�\"\210\201E�\201l�\201m�\"\210\201H�\201n�\201l�\"\210\201J�\324@\201o�\"\201l�\"\210\201E�\201p�\201q�\"\210\201H�\201r�\201p�\"\210\201J�\324@\201s�\"\201p�\"\210\201E�\201t�\201u�\"\210\201E�\201v�\201w�\"\210\201H�\201x�\201v�\"\210\201J�\324@\201y�\"\201v�\"\210\201E�\201z�\201{�\"\210\201H�\201|�\201z�\"\210\201J�\324@\201}�\"\201z�\"\210\201E�\201~�\201�\"\210\201H�\201\200�\201~�\"\210\201J�\324@\201\201�\"\201~�\"\210\201E�\201\202�\201\203�\"\210\201E�\201\204�\201\205�\"\210\201\206�A\201\207�\201\210�#\210\201\206�A\201\211�\201\210�#\210\201\206�A\201\212�\201\213�#\210\201\206�A\201\214�\201\215�#\210\201\206�A\201\216�\201\217�#\210\201\206�A\201\220�\201\217�#\210\201\206�A\201\221�\201\217�#\210\201\206�A\201\222�\201\217�#\210\201\206�A\201\223�\201\224�#\210\201\206�A\201\225�\201\224�#\210\201\206�A\201\226�\201\224�#\210\201\206�A\201\227�\201\224�#\210\336\201B�!\210\201\230�B\201\231�\201\232�\201\233�\315\201\234�$\210\201H�\201e�\201\235�\"\210\201H�\201\236�\201\237�\"\210\366C\315D\201\240� \210\201\241�\201\242�!\207" [gud-comint-buffer gud-minor-mode gdb-control-level comint-input-sender comint-input-ring system-type buffer-name get-buffer-process gdba gdb-restore-windows error "Multiple debugging requires restarting in text command mode" gud-common-init nil gud-gdbmi-marker-filter advice--add-function :around make-byte-code 0 "\301\300!\207" vconcat vector [process-filter] 2 257 "\301\300\"\207" [set-process-filter] 4 "\n\n(fn GV--VAL)" gdb--check-interpreter make-local-variable gdbmi gdb-send ring-empty-p expand-file-name getenv "GDBHISTFILE" ms-dos "_gdb_history" ".gdb_history" "HISTSIZE" append ("~/.gdbinit") "." "~" (".gdbinit") file-readable-p generate-new-buffer " *temp*" "\301\300!\205	�\302\300!\207" [buffer-name kill-buffer] insert-file-contents re-search-forward "^ *set history \$filename\\|size\$  *\$.*\$" t match-string 1 "filename" file-name-directory "size" string-to-number comint-input-ring-size comint-input-ring-file-name comint-read-input-ring gud-key-prefix gud-minor-mode-map gud-gdb-completion-function gdb-first-prompt gud-running defalias gud-tbreak #[257 "?\205	�\301\302\"\207" [gud-running gud-call "tbreak %f:%l"] 4 "Set temporary breakpoint at current line.\n\n(fn ARG)" #1="p"] local-set-key "" global-set-key "" gud-jump #[257 "?\205
�\301\302\"\210\301\303!\207" [gud-running gud-call "tbreak %f:%l" "jump %f:%l"] 4 "Set execution address to current line.\n\n(fn ARG)" #1#] "\n" "\n" gud-up #[257 "?\205	�\301\302\"\207" [gud-running gud-call "up %p"] 4 "Up N stack frames (numeric arg).\n\n(fn ARG)" #1#] "<" "<" gud-down #[257 "?\205	�\301\302\"\207" [gud-running gud-call "down %p"] 4 "Down N stack frames (numeric arg).\n\n(fn ARG)" #1#] ">" ">" gud-print #[257 "?\205	�\301\302\"\207" [gud-running gud-call "print %e"] 4 "Evaluate C expression at point.\n\n(fn ARG)" #1#] "" "" gud-pstar #[257 "?\205	�\301\302\"\207" [gud-running gud-call "print* %e"] 4 "Evaluate C dereferenced pointer expression at point.\n\n(fn ARG)" #1#] gud-step #[257 "?\205�\301\302\303\304\"\305P\"\207" [gud-running gud-call gdb-gud-context-command "-exec-step" t " %p"] 5 "Step one source line with display.\n\n(fn ARG)" #1#] "" "" gud-stepi #[257 "?\205�\301\302\303\304\"\305P\"\207" [gud-running gud-call gdb-gud-context-command "-exec-step-instruction" t " %p"] 5 "Step one instruction with display.\n\n(fn ARG)" #1#] "	" "	" gud-next #[257 "?\205�\301\302\303\304\"\305P\"\207" [gud-running gud-call gdb-gud-context-command "-exec-next" t " %p"] 5 "Step one line (skip functions).\n\n(fn ARG)" #1#] "" "" gud-nexti #[257 "?\205�\301\302\303\304\"\305P\"\207" [gud-running gud-call gdb-gud-context-command "-exec-next-instruction" t " %p"] 5 "Step one instruction (skip functions).\n\n(fn ARG)" #1#] gud-cont #[257 "?\205�\301\302\303\304\"\305P\"\207" [gud-running gud-call gdb-gud-context-command "-exec-continue" nil " "] 5 "Continue with display.\n\n(fn ARG)" #1#] "" "" gud-finish #[257 "?\205�\301\302\303\304\"\305P\"\207" [gud-running gud-call gdb-gud-context-command "-exec-finish" t " "] 5 "Finish executing current function.\n\n(fn ARG)" #1#] "" "" gud-run #[257 "?\205	�\301\302\"\207" [gud-running gud-call "-exec-run"] 4 "Run the program.\n\n(fn ARG)" #1#] gud-break #[257 "?\205�\302\303	\"\204�\304\305\"\207\212\306 \210\307u\210\304\310\")\207" [gud-running mode-name string-match "Disassembly" gud-call "break %f:%l" beginning-of-line 2 "break *%a"] 4 "Set breakpoint at current line or address.\n\n(fn ARG)" #1#] "" "" gud-remove #[257 "?\205�\302\303	\"\204�\304\305\"\207\212\306 \210\307u\210\304\310\")\207" [gud-running mode-name string-match "Disassembly" gud-call "clear %f:%l" beginning-of-line 2 "clear *%a"] 4 "Remove breakpoint at current line or address.\n\n(fn ARG)" #1#] "" "" gud-until #[257 "?\205�\302\303	\"\204�\304\305\"\207\212\306 \210\307u\210\304\310\")\207" [gud-running mode-name string-match "Disassembly" gud-call "-exec-until %f:%l" beginning-of-line 2 "-exec-until *%a"] 4 "Continue to current line or address.\n\n(fn ARG)" #1#] "" "" gud-go #[257 "?\205�\302	\203�\303\304!\202�\305\"\207" [gud-running gdb-active-process gud-call gdb-gud-context-command "-exec-continue" "-exec-run"] 4 "Start or continue execution.\n\n(fn ARG)" #1#] gud-pp #[257 "?\205�\301\302\303\304\305 \"\306=\203�\307 \202�\310P\"\207" [gud-running gud-call "pp " buffer-local-value major-mode window-buffer speedbar-mode gdb-find-watch-expression "%e"] 6 "Print the Emacs s-expression.\n\n(fn ARG)" #1#] define-key [left-margin mouse-1] gdb-mouse-set-clear-breakpoint [left-fringe mouse-1] [left-margin C-mouse-1] gdb-mouse-toggle-breakpoint-margin [left-fringe C-mouse-1] gdb-mouse-toggle-breakpoint-fringe [left-margin drag-mouse-1] gdb-mouse-until [left-fringe drag-mouse-1] [left-margin mouse-3] [left-fringe mouse-3] [left-margin C-drag-mouse-1] gdb-mouse-jump [left-fringe C-drag-mouse-1] [left-fringe C-mouse-3] [left-margin C-mouse-3] gud-gdbmi-completions add-hook completion-at-point-functions gud-gdb-completion-at-point local completion-at-point [remap comint-delchar-or-maybe-eof] gdb-delchar-or-quit gdb-update run-hooks gdb-mode-hook] 12 (#$ . 27744) (byte-code "\300\301!C\207" [gud-query-cmdline gdb] 2)])
(defalias 'gdb-init-1 #[0 "\306\211\306\211\307\306\211'\306(\310)\306\211*+\311,\312 @-\306\211./\306\21101\306\21123\306\2114567\313 \210\3148\315\316\317\3209#!\210\321\322!\210\323 \210\324\325\326!!\210:\327=\203l�\330\331\332\"\210\330\333\332\"\210\330\334\332\"\2107\203{�\330\335\336\"\210\330\337\332\"\210\330\340\332\"\210;\203\217�\330\341\342\"\210\330\343\344\"\210\330\345\346\"\207" [gdb-selected-frame gdb-frame-number gdb-thread-number gdb-var-list gdb-output-sink gdb-location-alist nil user 0 t window-fringes gdbmi-bnf-init gdbmi gdb-force-mode-line-update propertize "initializing..." face gdb-get-buffer-create gdb-inferior-io gdb-clear-inferior-io gdb-inferior-io--init-proc get-process "gdb-inferior" windows-nt gdb-input "-gdb-set new-console off" ignore "-gdb-set interactive-mode on" "-gdb-set height 0" "-gdb-set non-stop 1" gdb-non-stop-handler "-enable-pretty-printing" "-enable-frame-filters" "-file-list-exec-source-files" gdb-get-source-file-list "-file-list-exec-source-file" gdb-get-source-file "-gdb-show prompt" gdb-get-prompt gdb-source-file-list gdb-last-command gdb-token-number gdb-handler-list gdb-prompt-name gdb-first-done-or-error gdb-buffer-fringe-width gdb-debug-log gdb-source-window gdb-inferior-status gdb-continuation gdb-buf-publisher gdb-threads-list gdb-breakpoints-list gdb-register-names gdb-non-stop-setting gdb-non-stop gdb-buffer-type font-lock-variable-name-face system-type gdb-create-source-file-list] 6])
(defalias 'gdb-non-stop-handler #[0 "eb\210\302\303\304\305#\203�\306\307!\210\304\211\211\207\305\310\311\312\"\210\310\313\314\"\207" [gdb-non-stop gdb-supports-non-stop re-search-forward "No symbol" nil t message "This version of GDB doesn't support non-stop mode.  Turning it off." gdb-input "-gdb-set target-async 1" ignore "-list-target-features" gdb-check-target-async] 5])
(defalias 'gdb-check-target-async #[0 "eb\210\301\302\303\304#?\205�\305\306!\210\303\307\310\311\"\207" [gdb-non-stop re-search-forward "async" nil t message "Target doesn't support non-stop mode.  Turning it off." gdb-input "-gdb-set non-stop 0" ignore] 4])
#@168 Delete ARG characters or send a quit command to GDB.
Send a quit only if point is at the end of the buffer, there is
no input, and GDB is waiting for input.

(fn ARG)
(defalias 'gdb-delchar-or-quit #[257 "p=\203\f�	\304=\204�\305\306!\210\307!m\203A�\310!\203A�\n\204A�`\311\312!!U\203A�\313V\2037�\314!\202D�\315c\210\316\317\211\"\202D�\320!\207" [gud-comint-buffer gud-minor-mode gud-running gdb-control-level gdbmi error "Not in a GDB-MI buffer" get-buffer-process process-live-p marker-position process-mark 0 process-send-eof "quit" comint-send-input t delete-char] 6 (#$ . 40676) "p"])
#@47 Alist of #define directives for GUD tooltips.
(defvar gdb-define-alist nil (#$ . 41283))
#@57 Create an alist of #define directives for GUD tooltips.
(defalias 'gdb-create-define-alist #[0 "\306 \307\310!\311\216rq\210\211\203-�\312!\203-�\313	!\204-�\314\n\315\316D\316\317\320\fQ&\210*rq\210\321 +\322\323\315#\316\211\211\205Y�\211@\322\324\"A@\262B
BA\266\202\202>�\262\207" [standard-output default-directory shell-file-name gdb-cpp-define-alist-program gdb-cpp-define-alist-flags gdb-define-alist buffer-file-name generate-new-buffer " *string-output*" #[0 "\301!\207" [standard-output kill-buffer] 2] file-exists-p file-remote-p call-process t nil "-c" " " buffer-string split-string "\n" "[( ]"] 10 (#$ . 41378)])
(defconst gdb--string-regexp "\"\$?:[^\\\"]\\|\\\\.\$*\"")
#@13

(fn EXPR)
(defalias 'gdb-tooltip-print #[257 "r\302\303!q\210eb\210\304\305\306Q\307\310#\203(�\311\312\313\314\315!!Q	\206$�\316 ?\"\202>�\304\317\307\310#\205>�\311\313\314\315!!	\206=�\316 ?\")\207" [gdb--string-regexp gud-tooltip-echo-area gdb-get-buffer gdb-partial-output-buffer re-search-forward ".*value=\$" "\$" nil t tooltip-show " = " read match-string 1 display-graphic-p "msg=\$\".+\"\$$"] 7 (#$ . 42093)])
#@13

(fn EXPR)
(defalias 'gdb-tooltip-print-1 #[257 "r\300\301!q\210eb\210\302\303\304\305#\205$�\306\307!?\205$�\310\311\312Q\313\304\314DE\")\207" [gdb-get-buffer gdb-partial-output-buffer search-forward "expands to: " nil t looking-at "\\S-+.*(.*).*" gdb-input "-data-evaluate-expression \"" "\"" lambda gdb-tooltip-print] 7 (#$ . 42527)])
(defalias 'gdb-init-buffer #[0 "\304\300!\210\305\304\302!\210	\205�\304\306!\210\307 \210\310\311\307\312\313$\207" [gud-minor-mode gud-tool-bar-map tool-bar-map gud-tooltip-mode make-local-variable gdbmi gdb-define-alist gdb-create-define-alist add-hook after-save-hook nil t] 5])
#@54

(fn ARROW-POSITION START-POSN END-POSN &rest BODY)
(defalias 'gdb--if-arrow '(macro . #[899 "\300\301!\302\303\304	DDC\302\305\306\307DDE\310\311\312\305E\305\313D\314DEEBBEEEE\207" [make-symbol "buffer" if let marker-buffer equal window-buffer posn-window with-current-buffer when or posn-point marker-position] 20 (#$ . 43162)]))
(byte-code "\300\301\302\303#\300\207" [function-put gdb--if-arrow lisp-indent-function 3] 4)
#@225 Continue running until a source line past the current line.
The destination source line can be selected either by clicking
with mouse-3 on the fringe/margin or dragging the arrow
with mouse-1 (default bindings).

(fn EVENT)
(defalias 'gdb-mouse-until #[257 "\302!\303!\203=�\304!\211\305\211@\262!\232\203<�r\211q\210\232\204-�\306!\307!\232\203;�\310\306!!\311\312\313!P!\266)\210	\205z�\304	!\211\305\211@\262!\232\205x�r\211q\210\232\204d�\306!\307	!\232\205w�\212eb\210\310\306!!Sy\210\314u\210\311\315!))\262\207" [gud-overlay-arrow-position gdb-disassembly-position event-start event-end marker-buffer window-buffer posn-point marker-position line-number-at-pos gud-call "until " number-to-string 2 "until *%a"] 9 (#$ . 43616) "e"])
#@308 Set execution address/line.
The destination source line can be selected either by clicking with C-mouse-3
on the fringe/margin or dragging the arrow with C-mouse-1 (default bindings).
Unlike `gdb-mouse-until' the destination address can be before the current
line, and no execution takes place.

(fn EVENT)
(defalias 'gdb-mouse-jump #[257 "\302!\303!\203E�\304!\211\305\211@\262!\232\203D�r\211q\210\232\204-�\306!\307!\232\203C�\310\306!!\311\312\313!P!\210\311\314\313!P!\266)\210	\205\206�\304	!\211\305\211@\262!\232\205\204�r\211q\210\232\204l�\306!\307	!\232\205\203�\212eb\210\310\306!!Sy\210\315u\210\311\316!\210\311\317!))\262\207" [gud-overlay-arrow-position gdb-disassembly-position event-start event-end marker-buffer window-buffer posn-point marker-position line-number-at-pos gud-call "tbreak " number-to-string "jump " 2 "tbreak *%a" "jump *%a"] 9 (#$ . 44382) "e"])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313&	\210\300\314\302\303\315DD\316\306\317\310\311\312\313&	\210\300\320\302\303\321DD\322\306\307\310\311\312\323&	\210\300\324\302\303\325DD\326\327\330\331\332\310\311\306\307\312\313&
\207" [custom-declare-variable gdb-show-changed-values funcall function #[0 "\300\207" [t] 1] "If non-nil change the face of out of scope variables and changed values.\nOut of scope variables are suppressed with `shadow' face.\nChanged values are highlighted with the face `font-lock-warning-face'.\nUsed by Speedbar." :type boolean :group gdb :version "22.1" gdb-max-children #[0 "\300\207" [40] 1] "Maximum number of children before expansion requires confirmation.\nUsed by Speedbar." integer gdb-delete-out-of-scope #[0 "\300\207" [t] 1] "If non-nil delete watch expressions automatically when they go out of scope." "22.2" gdb-speedbar-auto-raise #[0 "\300\207" [nil] 1] "Non-nil if Gdb-Speedbar-Auto-Raise mode is enabled.\nSee the `gdb-speedbar-auto-raise' command\nfor a description of this minor mode." :set custom-set-minor-mode :initialize custom-initialize-default] 14)
#@347 Minor mode to automatically raise the speedbar for watch expressions.

If called interactively, enable Gdb-Speedbar-Auto-Raise mode if ARG is
positive, and disable it if ARG is zero or negative.  If called from
Lisp, also enable the mode if ARG is omitted or nil, and toggle it if
ARG is `toggle'; disable the mode otherwise.

(fn &optional ARG)
(defalias 'gdb-speedbar-auto-raise #[256 "\300 \301\302\303=\203�\304\302!?\202�\305!\306V\"\210\307\310\304\302!\203$�\311\202%�\312\"\210\313\314!\203O�\315\302!\210\300 \203=�\211\300 \232\203O�\316\317\320\304\302!\203J�\321\202K�\322#\266\210\323 \210\304\302!\207" [current-message set-default gdb-speedbar-auto-raise toggle default-value prefix-numeric-value 0 run-hooks gdb-speedbar-auto-raise-hook gdb-speedbar-auto-raise-on-hook gdb-speedbar-auto-raise-off-hook called-interactively-p any customize-mark-as-set "" message "Gdb-Speedbar-Auto-Raise mode %sabled%s" "en" "dis" force-mode-line-update] 7 (#$ . 46423) (byte-code "\206�\301C\207" [current-prefix-arg toggle] 1)])
(defvar gdb-speedbar-auto-raise-hook nil)
(byte-code "\304\305N\204\f�\306\304\305\307#\210\310\311\312\313\300!\205�\312\211%\210\314\315\316\317\320DD\321\322\323\324\325\326\327&	\210\330	\331\332#\210\330\n\333\334\"\332#\207" [gdb-speedbar-auto-raise-map gud-minor-mode-map global-map gud-key-prefix gdb-speedbar-auto-raise-hook variable-documentation put "Hook run after entering or leaving `gdb-speedbar-auto-raise'.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" add-minor-mode gdb-speedbar-auto-raise nil boundp custom-declare-variable gdb-use-colon-colon-notation funcall function #[0 "\300\207" [nil] 1] "If non-nil use FUN::VAR format to display variables in the speedbar." :type boolean :group gdb :version "22.1" define-key "" gud-watch vconcat ""] 10)
#@120 Watch expression at point.
With arg, enter name of variable to be watched in the minibuffer.

(fn &optional ARG EVENT)
(defalias 'gud-watch #[512 "\303\304\"\211\305=\203h�\203�\306\307!!\210\310\311!\210\312 r\313\314\315\316\317!\320\"\321$\216\2032�\322\323\324\"\202M�	\203B�\n\203B�\325 \326 {\202M�\327\330!\205I�\331\332`!P\333\314G\334$\210\335\336P\337\334\340DE\"\262*\262\202k�\341\342!\207" [gud-comint-buffer transient-mark-mode mark-active buffer-local-value gud-minor-mode gdbmi posn-set-point event-end require tooltip internal--before-save-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-save-selected-window] 2 completing-read "Name of variable: " gud-gdb-complete-command region-beginning region-end derived-mode-p gdb-registers-mode "$" tooltip-identifier-from-point set-text-properties nil gdb-input "-var-create - * " lambda gdb-var-create-handler message "gud-watch is a no-op in this mode."] 11 (#$ . 48322) (list current-prefix-arg last-input-event)])
#@13

(fn EXPR)
(defalias 'gdb-var-create-handler #[257 "\306 \307\310\"\204R�\307\311\"\312\230\203%�	\203%�\n\203%�\n\313Q\211\262\202&�\307\314\"\307\315\"\307\316\"\317\307\320\"\257\211\fB\321\322!\210
\323\230?\205M�\324\323!\262\202V�\325\326\"\207" [gdb-current-language gdb-use-colon-colon-notation gdb-selected-frame gdb-frame-address gdb-var-list speedbar-initial-expansion-list-name gdb-json-partial-output bindat-get-field msg name "c" "::" numchild type value nil has_more speedbar 1 "GUD" speedbar-change-initial-expansion-list message-box "No symbol \"%s\" in current context."] 11 (#$ . 49350)])
(defalias 'gdb-speedbar-update #[0 "\301\300!\205�\302!\205�\303\304\305\306#\207" [speedbar-frame boundp frame-live-p gdb-input "-environment-pwd" gdb-speedbar-timer-fn gdb-speedbar-update] 4])
(defalias 'gdb-speedbar-timer-fn #[0 "\203�\302	!\210\303 \207" [gdb-speedbar-auto-raise speedbar-frame raise-frame speedbar-timer-fn] 2])
#@23

(fn VARNUM CHANGED)
(defalias 'gdb-var-evaluate-expression-handler #[514 "eb\210\302\303\304Q\305\306#\210\307	\"\211\203(�\203�\310\233\311\240\210\312\233\313\314\315!!\240\210\210\316 \207" [gdb--string-regexp gdb-var-list re-search-forward ".*value=\$" "\$" nil t assoc 5 changed 4 read match-string 1 gdb-speedbar-update] 7 (#$ . 50320)])
#@15

(fn VARNUM)
(defalias 'gdb-var-list-children #[257 "\300\301P\302\"\210\300\303P\304\305\306DE\"\207" [gdb-input "-var-update " ignore "-var-list-children --all-values " lambda nil gdb-var-list-children-handler] 7 (#$ . 50680)])
#@15

(fn VARNUM)
(defalias 'gdb-var-list-children-handler #[257 "\301\302\303\304!!\302\305\"\3062~�\211\203x�\211@@\230\203l�\211AA\302\307\"\240\210\211B\262\211\203h�\211@\302\310\"\302\311\"\302\307\"\302\312\"\302\313\"\301\302\314\"\257\315@\"\203Z�\316\306\301\"\210\211B\262\210A\266\202\202+�\210\202q�\211B\262A\266\202\202�\210\237\2110\266\317 \207" [gdb-var-list nil bindat-get-field gdb-json-partial-output "child" children child-already-watched numchild name exp type value has_more assoc throw gdb-speedbar-update] 17 (#$ . 50920)])
#@78 Set the output format for a variable displayed in the speedbar.

(fn FORMAT)
(defalias 'gdb-var-set-format #[257 "\301e`\"\302Z8\211@\303\304\305R\306\"\210\307 \207" [gdb-var-list count-lines 2 gdb-input "-var-set-format " " " ignore gdb-var-update] 8 (#$ . 51501)])
#@19

(fn VAR VARNUM)
(defalias 'gdb-var-delete-1 #[514 "\301\302P\303\"\210\304\"\211\211\205*�\211@\305@\306P@\"\203#�\304\"A\266\202\202
�\207" [gdb-var-list gdb-input "-var-delete " ignore delq string-match "\\."] 8 (#$ . 51779)])
#@53 Delete watch expression at point from the speedbar.
(defalias 'gdb-var-delete #[0 "\301 \302\303\"\210\304e`\"\305Z8\211@\302\306@\"\203�\307\310!\202#�\311\"\266\202\207" [gdb-var-list speedbar-line-text string-match "\$\\S-+\$" count-lines 2 "\\." message-box "Can only delete a root expression" gdb-var-delete-1] 6 (#$ . 52026) nil])
#@77 Delete children of variable object at point from the speedbar.

(fn VARNUM)
(defalias 'gdb-var-delete-children #[257 "\300\301P\302\"\207" [gdb-input "-var-delete -c " ignore] 4 (#$ . 52377)])
#@81 Assign a value to a variable displayed in the speedbar.

(fn TEXT TOKEN INDENT)
(defalias 'gdb-edit-value #[771 "\301e`\"\302Z8\211@\303\304!\305\306\307R\310\311\312DE\"\207" [gdb-var-list count-lines 2 read-string "New value: " gdb-input "-var-assign " " " lambda nil gdb-edit-value-handler] 12 (#$ . 52577)])
(defconst gdb-error-regexp "\\^error,msg=\$\".+\"\$")
#@14

(fn VALUE)
(defalias 'gdb-edit-value-handler #[257 "eb\210\301\302\303#\205�\304\305\"\207" [gdb-error-regexp re-search-forward nil t message-box "Invalid number or expression (%s)"] 5 (#$ . 52955)])
(defalias 'gdb-var-update #[0 "\300\301\302\303#\207" [gdb-input "-var-update --all-values *" gdb-var-update-handler gdb-var-update] 4])
(defalias 'gdb-var-update-handler #[0 "\302\303 \304\"\211\203�\211@\305\233\306\240\210A\266\202\202�\210\211\203\211\211@\302\307\"\310\"\302\311\"\203\231�\302\312\"\302\313\"\314\230\203V�	\203M�\315\"\210\202\227�\305\233\316\240\210\202\227�\317\230\203\213�\320\233\240\210\211\203l�\211\321\230\203\227�\204\227�\3228\321\230\203\227�\323\233\302\324\"\240\210\305\233\325\240\210\202\227�\326\230\203\227�\315\"\210\266\306\211\302\327\"\203\200\211A\262\n\242\262\203}@\230\203l\330!\330\3228!AA\240\210B\262V\203&\211\331\211W\203\357�\211
\211A\262\242B\262\210\211T\262\202\324�\266\211\203\"\211@\302\307\"\302\332\"\302\333\"\302\334\"\302\324\"\325\302\313\"\257\211B\262\210A\266\202\202\362�\210\202gW\203g\331\211W\203I\211
\211A\262\242B\262\210\211T\262\202.\266\211Z\331\211W\203e\211
\211A\262\266\211T\262\202O\266\266\202qB\262\211A\262\n\242\262\202\255�\237\266A\266\202\202�\266\335 \207" [gdb-var-list gdb-delete-out-of-scope bindat-get-field gdb-json-partial-output changelist 5 nil name assoc new_num_children in_scope has_more "false" gdb-var-delete-1 out-of-scope "true" 6 "0" 2 4 value changed "invalid" new_children string-to-number 0 exp numchild type gdb-speedbar-update] 23])
#@200 Expand the node the user clicked on.
TEXT is the text of the button we clicked on, a + or - item.
TOKEN is data related to this node.
INDENT is the current indentation depth.

(fn TEXT TOKEN INDENT)
(defalias 'gdb-speedbar-expand-node #[771 "\302\303\"\203,�\304\"\211A@\3058\306!	X\204#�\307\310\311#!\203'�\312!\210\266\202d�\302\313\"\203`�\211\203P�\211@\302\314P@\"\203I�\315\"A\266\202\2024�\210\316!\210\317\320!\210\321!\210\202d�\322\323!\210\324 \207" [gdb-var-list gdb-max-children string-match "\\+" assoc 2 string-to-number y-or-n-p format "%s has %s children. Continue? " gdb-var-list-children "-" "\\." delq gdb-var-delete-children speedbar-change-expand-button-char 43 speedbar-delete-subblock error "Ooops...  not sure what to do" speedbar-center-buffer-smartly] 11 (#$ . 54635)])
(defalias 'gdb-get-target-string #[0 "rq\210	)\207" [gud-comint-buffer gud-target-name] 1])
(defvar gdb-buffer-rules nil)
#@20

(fn RULES-ENTRY)
(defalias 'gdb-rules-name-maker #[257 "\211A@\207" [] 2 (#$ . 55581)])
#@20

(fn RULES-ENTRY)
(defalias 'gdb-rules-buffer-mode #[257 "\3008\207" [2] 3 (#$ . 55677)])
#@20

(fn RULES-ENTRY)
(defalias 'gdb-rules-update-trigger #[257 "\3008\207" [3] 3 (#$ . 55775)])
#@89 Rename current buffer according to name-maker associated with
it in `gdb-buffer-rules'.
(defalias 'gdb-update-buffer-name #[0 "\302\303	\"!\211\205�\304 !\207" [gdb-buffer-type gdb-buffer-rules gdb-rules-name-maker assoc rename-buffer] 4 (#$ . 55876)])
#@55 Get `gdb-buffer-rules' entry for current buffer type.
(defalias 'gdb-current-buffer-rules #[0 "\302	\"\207" [gdb-buffer-type gdb-buffer-rules assoc] 3 (#$ . 56138)])
#@131 Get thread object of current buffer from `gdb-threads-list'.

When current buffer is not bound to any thread, return main
thread.
(defalias 'gdb-current-buffer-thread #[0 "\302	\"A\207" [gdb-thread-number gdb-threads-list assoc] 3 (#$ . 56312)])
#@62 Get current stack frame object for thread of current buffer.
(defalias 'gdb-current-buffer-frame #[0 "\300\301 \302\"\207" [bindat-get-field gdb-current-buffer-thread frame] 3 (#$ . 56565)])
#@57 Get value of `gdb-buffer-type' for BUFFER.

(fn BUFFER)
(defalias 'gdb-buffer-type #[257 "r\211q\210)\207" [gdb-buffer-type] 2 (#$ . 56762)])
#@83 Return t if current GDB buffer shows main selected thread and
is not bound to it.
(defalias 'gdb-buffer-shows-main-thread-p #[0 "\300\301!?\207" [local-variable-p gdb-thread-number] 2 (#$ . 56911)])
#@190 Get a specific GDB buffer.

In that buffer, `gdb-buffer-type' must be equal to BUFFER-TYPE
and `gdb-thread-number' (if provided) must be equal to THREAD.

(fn BUFFER-TYPE &optional THREAD)
(defalias 'gdb-get-buffer #[513 "\30221�\303 \211\203-�\211@r\211q\210=\203%�\203 �	\232\203%�\304\302\"\210)A\266\202\202�\305\2620\207" [gdb-buffer-type gdb-thread-number found buffer-list throw nil] 7 (#$ . 57117)])
#@475 Create a new GDB buffer of the type specified by BUFFER-TYPE.
The buffer-type should be one of the cars in `gdb-buffer-rules'.

If THREAD is non-nil, it is assigned to `gdb-thread-number'
buffer-local variable of the new buffer.

Buffer mode and name are selected according to buffer type.

If buffer has trigger associated with it in `gdb-buffer-rules',
this trigger is subscribed to `gdb-buf-publisher' and called with
'update argument.

(fn BUFFER-TYPE &optional THREAD)
(defalias 'gdb-get-buffer-create #[513 "\306\"\206l�\307\"\310\311!r\211q\210\312!\313!\203� \210\203+�\314\302!\210\314\304!\210\315\304\"\314\316!\210
\317\320! !\210\211\203f�p\321p\"B\211\235\203Y�\210\202a�\322C\"\210\211\323!\210p\266\202)\266\202\207" [gdb-buffer-rules gdb-buffer-type gdb-thread-number gud-comint-buffer gud-minor-mode gud-tool-bar-map gdb-get-buffer assoc generate-new-buffer "limbo" gdb-rules-buffer-mode gdb-rules-update-trigger make-local-variable buffer-local-value tool-bar-map rename-buffer gdb-rules-name-maker gdb-bind-function-to-buffer append start gdb-buf-publisher] 10 (#$ . 57540)])
#@73 Return a function which will evaluate EXPR in BUFFER.

(fn EXPR BUFFER)
(defalias 'gdb-bind-function-to-buffer #[514 "\300\301\302\303\304D\305BBEE\207" [lambda (&rest args) with-current-buffer apply quote (args)] 9 (#$ . 58671)])
#@51

(fn NAME BUFFER &optional DOC SPLIT-HORIZONTAL)
(defalias 'def-gdb-preempt-display-buffer '(macro . #[1026 "\300\301\205�\302\303\304	\305BBE\257\207" [defun (&optional thread) (message "%s" thread) gdb-preempt-existing-or-display-buffer gdb-get-buffer-create (thread)] 13 (#$ . 58911)]))
#@32

(fn BUFFER-TYPE &rest RULES)
(defalias 'gdb-set-buffer-rules #[385 "\301\"\211\203�\211\241\202�BB\211\207" [gdb-buffer-rules assoc] 5 (#$ . 59216)])
#@57 Generic mode to derive all other GDB buffer modes from.
(defalias 'gdb-parent-mode #[0 "\301 \210\302\303 \210\304\305\306\307\302$\207" [buffer-read-only kill-all-local-variables t buffer-disable-undo add-hook kill-buffer-hook #[0 "\301\302 !\211\205�\303p\304p\"B\"\211\207" [gdb-buf-publisher gdb-rules-update-trigger gdb-current-buffer-rules delete gdb-bind-function-to-buffer] 6] nil] 5 (#$ . 59383)])
(gdb-set-buffer-rules 'gdb-partial-output-buffer 'gdb-partial-output-name)
(defalias 'gdb-partial-output-name #[0 "\300\301 \302Q\207" [" *partial-output-" gdb-get-target-string "*"] 3])
(gdb-set-buffer-rules 'gdb-inferior-io 'gdb-inferior-io-name 'gdb-inferior-io-mode)
(defalias 'gdb-inferior-io-name #[0 "\300\301 \302Q\207" ["*input/output of " gdb-get-target-string "*"] 3])
#@54 Display IO of debugged program in a separate window.
(defalias 'gdb-display-io-buffer #[0 "\300\301\302!!\207" [gdb-display-buffer gdb-get-buffer-create gdb-inferior-io] 3 (#$ . 60181) nil])
#@13

(fn PROC)
(defalias 'gdb-inferior-io--init-proc #[257 "\300\301\"\210\302\303\"\210\304\305\"\206�\306!\211?\206�\211\307\230?\205&�\310\311P\312\"\207" [set-process-filter gdb-inferior-filter set-process-sentinel gdb-inferior-io-sentinel process-get remote-tty process-tty-name "" gdb-input "-inferior-tty-set " ignore] 5 (#$ . 60378)])
#@17

(fn PROC STR)
(defalias 'gdb-inferior-io-sentinel #[514 "\301!\302=\205(�\303!\304\305!!\205&�\306!\205&�\307\310\311\211\211%\210\312\305!!\262\207" [gud-comint-buffer process-status failed process-buffer process-live-p get-buffer-process buffer-live-p comint-exec "gdb-inferior" nil gdb-inferior-io--init-proc] 9 (#$ . 60731)])
(byte-code "\301\302\303\304\305DD\306\307\310\311\312\313\314\315&\207" [display-buffer--action-custom-type custom-declare-variable gdb-display-buffer-other-frame-action funcall function #[0 "\300\207" [((display-buffer-reuse-window display-buffer-pop-up-frame) (reusable-frames . visible) (inhibit-same-window . t) (pop-up-frame-parameters (height . 14) (width . 80) (unsplittable . t) (tool-bar-lines) (menu-bar-lines) (minibuffer)))] 1] "`display-buffer' action for displaying GDB utility frames." :group gdb :type :risky t :version "24.3"] 12)
#@50 Display IO of debugged program in another frame.
(defalias 'gdb-frame-io-buffer #[0 "\301\302\303!\"\207" [gdb-display-buffer-other-frame-action display-buffer gdb-get-buffer-create gdb-inferior-io] 3 (#$ . 61627) nil])
(defvar gdb-inferior-io-mode-map (byte-code "\300 \301\302\303#\210\301\304\305#\210\301\306\307#\210\301\310\311#\210\301\312\311#\210\211\207" [make-sparse-keymap define-key "" gdb-io-interrupt "" gdb-io-stop "" gdb-io-quit "" gdb-io-eof ""] 5))
(defvar gdb-inferior-io-mode-hook nil)
(byte-code "\300\301N\204\f�\302\300\301\303#\210\304\305!\204�\302\305\306\307#\210\300\207" [gdb-inferior-io-mode-hook variable-documentation put "Hook run after entering Inferior I/O mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp gdb-inferior-io-mode-map definition-name gdb-inferior-io-mode] 4)
(defvar gdb-inferior-io-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204�\302\300\301\303\304!#\210\302\305\306\307#\207" [gdb-inferior-io-mode-map variable-documentation put purecopy "Keymap for `gdb-inferior-io-mode'." gdb-inferior-io-mode derived-mode-parent comint-mode] 5)
#@243 Major mode for gdb inferior-io.

In addition to any hooks its parent mode `comint-mode' might have run,
this mode runs the hook `gdb-inferior-io-mode-hook', as the final or penultimate step
during initialization.

\{gdb-inferior-io-mode-map}
(defalias 'gdb-inferior-io-mode #[0 "\304\300!\210\305\306 \210\307\310\306\311N\203�\312\307\311\306\311N#\210\313!\204'�\314\315 \"\210\316!\210\317\320p\321#\210)\322\323!\207" [delay-mode-hooks major-mode mode-name gdb-inferior-io-mode-map make-local-variable t comint-mode gdb-inferior-io-mode "Inferior I/O" mode-class put keymap-parent set-keymap-parent current-local-map use-local-map make-comint-in-buffer "gdb-inferior" nil run-mode-hooks gdb-inferior-io-mode-hook] 5 (#$ . 62837) nil])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313&	\207" [custom-declare-variable gdb-display-io-nopopup funcall function #[0 "\300\207" [nil] 1] "When non-nil, and the `gdb-inferior-io' buffer is buried, don't pop it up." :type boolean :group gdb :version "25.1"] 10)
#@20

(fn PROC STRING)
(defalias 'gdb-inferior-filter #[514 "\211\301\230\204!�\302\203�\303\304!\211\262\203�\305!\203 �\306\307\304!!\210\210r\307\304!q\210\310\")\207" [gdb-display-io-nopopup "" nil gdb-get-buffer gdb-inferior-io get-buffer-window gdb-display-buffer gdb-get-buffer-create comint-output-filter] 6 (#$ . 63871)])
#@39 Interrupt the program being debugged.
(defalias 'gdb-io-interrupt #[0 "\302\303!	\"\207" [gud-comint-buffer comint-ptyp interrupt-process get-buffer-process] 3 (#$ . 64211) nil])
#@49 Send quit signal to the program being debugged.
(defalias 'gdb-io-quit #[0 "\302\303!	\"\207" [gud-comint-buffer comint-ptyp quit-process get-buffer-process] 3 (#$ . 64397) nil])
#@34 Stop the program being debugged.
(defalias 'gdb-io-stop #[0 "\302\303!	\"\207" [gud-comint-buffer comint-ptyp stop-process get-buffer-process] 3 (#$ . 64583) nil])
#@49 Send end-of-file to the program being debugged.
(defalias 'gdb-io-eof #[0 "\301\302!!\207" [gud-comint-buffer process-send-eof get-buffer-process] 3 (#$ . 64754) nil])
(defalias 'gdb-clear-inferior-io #[0 "r\300\301!q\210\302 )\207" [gdb-get-buffer-create gdb-inferior-io erase-buffer] 2])
#@36 XPM data used for breakpoint icon.
(defconst breakpoint-xpm-data "/* XPM */\nstatic char *magick[] = {\n/* columns rows colors chars-per-pixel */\n\"10 10 2 1\",\n\"  c red\",\n\"+ c None\",\n/* pixels */\n\"+++    +++\",\n\"++      ++\",\n\"+        +\",\n\"          \",\n\"          \",\n\"          \",\n\"          \",\n\"+        +\",\n\"++      ++\",\n\"+++    +++\",\n};" (#$ . 65051))
#@44 PBM data used for enabled breakpoint icon.
(defconst breakpoint-enabled-pbm-data "P1\n10 10\",\n0 0 0 0 1 1 1 1 0 0 0 0\n0 0 0 1 1 1 1 1 1 0 0 0\n0 0 1 1 1 1 1 1 1 1 0 0\n0 1 1 1 1 1 1 1 1 1 1 0\n0 1 1 1 1 1 1 1 1 1 1 0\n0 1 1 1 1 1 1 1 1 1 1 0\n0 1 1 1 1 1 1 1 1 1 1 0\n0 0 1 1 1 1 1 1 1 1 0 0\n0 0 0 1 1 1 1 1 1 0 0 0\n0 0 0 0 1 1 1 1 0 0 0 0" (#$ . 65451))
#@45 PBM data used for disabled breakpoint icon.
(defconst breakpoint-disabled-pbm-data "P1\n10 10\",\n0 0 1 0 1 0 1 0 0 0\n0 1 0 1 0 1 0 1 0 0\n1 0 1 0 1 0 1 0 1 0\n0 1 0 1 0 1 0 1 0 1\n1 0 1 0 1 0 1 0 1 0\n0 1 0 1 0 1 0 1 0 1\n1 0 1 0 1 0 1 0 1 0\n0 1 0 1 0 1 0 1 0 1\n0 0 1 0 1 0 1 0 1 0\n0 0 0 1 0 1 0 1 0 0" (#$ . 65817))
#@48 Icon for enabled breakpoint in display margin.
(defvar breakpoint-enabled-icon nil (#$ . 66145))
#@49 Icon for disabled breakpoint in display margin.
(defvar breakpoint-disabled-icon nil (#$ . 66248))
(byte-code "\300\301\302\"\210\300\303\304\"\210\305\306\307\310\311\312%\210\305\313\314\315\311\312%\207" [define-fringe-bitmap breakpoint "<~\377\377\377\377~<" hollow-right-triangle "\340\220\210\204\204\210\220\340" custom-declare-face breakpoint-enabled ((t :foreground "red1" :weight bold)) "Face for enabled breakpoint icon in fringe." :group gdb breakpoint-disabled ((((class color) (min-colors 88)) :foreground "grey70") (((class color) (min-colors 8) (background light)) :foreground "black") (((class color) (min-colors 8) (background dark)) :foreground "white") (((type tty) (class mono)) :inverse-video t) (t :background "gray")) "Face for disabled breakpoint icon in fringe."] 6)
#@65 Regexp that matches Python and Guile commands supported by GDB.
(defvar gdb-python-guile-commands-regexp "python\\|python-interactive\\|pi\\|guile\\|guile-repl\\|gr" (#$ . 67047))
#@191 Regexp matching GDB commands that enter a recursive reading loop.
As long as GDB is in the recursive reading loop, it does not expect
commands to be prefixed by "-interpreter-exec console".
(defvar gdb-control-commands-regexp (concat "^\$comm\\(a\\(n\\(ds?\$?\\)?\\)?\\|if\\|while\\|def\$i\\(ne?\$?\\)?\\|doc\$u\\(m\\(e\\(nt?\$?\\)?\\)?\\)?\\|" gdb-python-guile-commands-regexp "\\|while-stepping\\|stepp\$i\\(ng?\$?\\)?\\|ws\\|actions\\)\$[[:blank:]]+\\([^[:blank:]]*\$\\)?$") (#$ . 67234))
#@15

(fn STRING)
(defalias 'gdb-strip-string-backslash #[257 "\300\301\302#\207" [replace-regexp-in-string "\\\\$" ""] 5 (#$ . 67742)])
#@49 A comint send filter for gdb.

(fn PROC STRING)
(defalias 'gdb-send #[514 "rq\210\306\307ed\310#\210*\n\311U\2037�\211\312\230\204.�\203'�\313!\314Q\2027�\313!\2027�\f\2035�\f\262\315\204r�\316\317\"\204H�\n\311V\203r�\306\320\321P\"\210\316\322\323=\203^�\324\202_�\325\326Q\"\203\300�\n\311V\203\300�\nS\202\300�\316\327\"\203\203�\313!\314Q\202\300�\306\330\331P!\321Q\203\232�\332BB\320\"\266\316\322\323=\203\255�\324\202\256�\325\326Q\"\203\276�\n\311V\203\276�\nS\315\316 \"\211\205\315�\333\334\"\316!\"\205\351�\211\203\345�\203\345�G\311U\205\351�\nT\211\207" [gud-comint-buffer inhibit-read-only gdb-control-level gdb-continuation gdb-last-command gdb-first-done-or-error t remove-text-properties (face nil) 0 "" gdb-strip-string-backslash " " nil string-match "^-" process-send-string "\n" "^\$" windows-nt "" "" "\\|,q\\|,quit\\|end\$$" "\\\\$" "-interpreter-exec console " gdb-mi-quote mi-send match-string 3 system-type gdb-enable-debug gdb-debug-log gdb-control-commands-regexp gdb-python-guile-commands-regexp] 7 (#$ . 67882)])
#@182 Return STRING quoted properly as an MI argument.
The string is enclosed in double quotes.
All embedded quotes, newlines, and backslashes are preceded with a backslash.

(fn STRING)
(defalias 'gdb-mi-quote #[257 "\300\301\302#\262\300\303\304\305\211%\262\306\306Q\207" [replace-regexp-in-string "\$[\"\\]\$" "\\\\\\&" "\n" "\\n" t "\""] 7 (#$ . 68988)])
#@340 Send COMMAND to GDB via the MI interface.
Run the function HANDLER-FUNCTION, with no arguments, once the command is
complete.  Do not send COMMAND to GDB if TRIGGER-NAME is non-nil and
Emacs is still waiting for a reply from another command previously
sent with the same TRIGGER-NAME.

(fn COMMAND HANDLER-FUNCTION &optional TRIGGER-NAME)
(defalias 'gdb-input #[770 "\211\203�\305!?\2057�T\306!P\262	\203 �\307E\nB\310#\210\203/�\311\312\"\210\313\314\f!\315P\"\207" [gdb-token-number gdb-enable-debug gdb-debug-log gdbmi-debug-mode gud-comint-buffer gdb-pending-handler-p number-to-string send-item gdb-add-handler message "gdb-input: %s" process-send-string get-buffer-process "\n"] 7 (#$ . 69356)])
#@56 Add --thread to gdb COMMAND when needed.

(fn COMMAND)
(defalias 'gdb-current-context-command #[257 "\203
�	\203
�\211\302Q\207\207" [gdb-thread-number gdb-supports-non-stop " --thread "] 4 (#$ . 70080)])
#@126 Add thread information and asterisks to string NAME.

If `gdb-thread-number' is nil, just wrap NAME in asterisks.

(fn NAME)
(defalias 'gdb-current-context-buffer-name #[257 "\301\302\300!\203�\303\304\"\202�\305\301R\207" [gdb-thread-number "*" local-variable-p format " (bound to thread %s)" ""] 6 (#$ . 70294)])
#@79 Add thread information to MODE which is to be used as `mode-name'.

(fn MODE)
(defalias 'gdb-current-context-mode-name #[257 "\211\203\f�\301\302\"\202
�\303P\207" [gdb-thread-number format " [thread %s]" ""] 5 (#$ . 70619)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\207" [custom-declare-variable gud-gdb-command-name funcall function #[0 "\300\207" [#1="gdb -i=mi"] 1 #1#] "Default command to execute an executable under the GDB debugger." :type string :group gdb] 8)
(defalias 'gdb-resync #[0 "\302\303\304 \207" [gud-running gdb-output-sink nil user gdb-remove-all-pending-triggers] 1])
#@135 Update buffers showing status of debug session.
If NO-PROC is non-nil, do not try to contact the GDB process.

(fn &optional NO-PROC)
(defalias 'gdb-update #[256 "\203�\305\306\307\310	#!\210\311 \210\312\211\204�\313 \210\314\315!\210\314\316!\210\317 \210\211\204,�\320\n\321\"\210\322\303!\205O�\323!\205O�\f\211\203L�\211@\324\233\312\240\210A\266\202\2029�\210\325 \207" [gdb-first-prompt font-lock-variable-name-face gdb-buf-publisher speedbar-frame gdb-var-list gdb-force-mode-line-update propertize "initializing..." face gdb-init-1 nil gdb-get-main-selected-frame gdb-get-buffer-create gdb-threads-buffer gdb-breakpoints-buffer gdb-get-changed-registers gdb-emit-signal update boundp frame-live-p 5 gdb-var-update] 6 (#$ . 71236)])
#@235 Set `gdb-thread-number' to NUMBER.
Only this function must be used to change `gdb-thread-number'
value to NUMBER, because `gud-running' and `gdb-frame-number'
need to be updated appropriately when current thread changes.

(fn NUMBER)
(defalias 'gdb-setq-thread-number #[257 "\211\302\230\204�\211\302\303 \207" [gdb-thread-number gdb-frame-number "0" gdb-update-gud-running] 3 (#$ . 71991)])
#@460 Set `gud-running' according to the state of current thread.

`gdb-frame-number' is set to 0 if current thread is now stopped.

Note that when `gdb-gud-control-all-threads' is t, `gud-running'
cannot be reliably used to determine whether or not execution
control buttons should be shown in menu or toolbar.  Use
`gdb-running-threads-count' and `gdb-stopped-threads-count'
instead.

For all-stop mode, thread information is unavailable while target
is running.
(defalias 'gdb-update-gud-running #[0 "\302\303 \304\"\305\230\303 \205�=?\205�\306\211\207" [gud-running gdb-frame-number bindat-get-field gdb-current-buffer-thread state "running" "0"] 4 (#$ . 72393)])
#@60 Return t if "Run/continue" should be shown on the toolbar.
(defalias 'gdb-show-run-p #[0 "?\206�	\203
�\n\204�?\206�	\205�\f\305V\207" [gdb-active-process gdb-gud-control-all-threads gdb-non-stop gud-running gdb-stopped-threads-count 0] 2 (#$ . 73069)])
#@52 Return t if "Stop" should be shown on the toolbar.
(defalias 'gdb-show-stop-p #[0 "\203�	\204\f�\n\206�\205�??\205�\304V\207" [gdb-gud-control-all-threads gdb-non-stop gud-running gdb-running-threads-count 0] 2 (#$ . 73335)])
#@15

(fn BUFFER)
(defalias 'gdb-display-source-buffer #[257 "\205\n�\302\303@!!\211\206�	\205�\304	!\205�	\211\203$�\211\305\"\210\207" [gud-last-last-frame gdb-source-window get-buffer-window gud-find-file window-live-p set-window-buffer] 6 (#$ . 73575)])
#@157 Return non-nil if string STR starts with MATCH, else returns nil.
OFFSET is the position in STR at which the comparison takes place.

(fn STR OFFSET MATCH)
(defalias 'gdbmi-start-with #[771 "\211GGZ\211Y\205�\300\211\\#\230\207" [substring] 11 (#$ . 73844)])
#@166 Return non-nil if STR and MATCH are equal up to the end of either strings.
OFFSET is the position in STR at which the comparison takes place.

(fn STR OFFSET MATCH)
(defalias 'gdbmi-same-start #[771 "GZG^\211\300V\205�\301\211\\#\301\300#\230\207" [0 substring] 11 (#$ . 74121)])
#@87 Return non-nil if CHARACTER is a numerical character between 0 and 9.

(fn CHARACTER)
(defalias 'gdbmi-is-number #[257 "\211\300Y\205	�\211\301X\207" [48 57] 3 (#$ . 74420)])
#@224 Current GDB/MI output parser state.
The parser is placed in a different state when an incomplete data steam is
received from GDB.
This variable will preserve the state required to resume the parsing
when more data arrives.
(defvar gdbmi-bnf-state 'gdbmi-bnf-output (#$ . 74602))
(make-variable-buffer-local 'gdbmi-bnf-state)
#@247 Offset in `gud-marker-acc' at which the parser is reading.
This offset is used to be able to parse the GDB/MI message
in-place, without the need of copying the string in a temporary buffer
or discarding parsed tokens by substringing the message.
(defvar gdbmi-bnf-offset 0 (#$ . 74934))
(make-variable-buffer-local 'gdbmi-bnf-offset)
#@39 Initialize the GDB/MI message parser.
(defalias 'gdbmi-bnf-init #[0 "\303\304\305\211\207" [gdbmi-bnf-state gdbmi-bnf-offset gud-marker-acc gdbmi-bnf-output 0 ""] 2 (#$ . 75274)])
#@135 Implementation of the following GDB/MI output grammar rule:

output ==>
       ( out-of-band-record )* [ result-record ] gdb-prompt
(defalias 'gdbmi-bnf-output #[0 "\300 \210\301 \204�\302 \210\303 \207" [gdbmi-bnf-skip-unrecognized gdbmi-bnf-out-of-band-record gdbmi-bnf-result-record gdbmi-bnf-gdb-prompt] 1 (#$ . 75464)])
#@167 Skip characters until is encounters the beginning of a valid record.
Used as a protection mechanism in case something goes wrong when parsing
a GDB/MI reply message.
(defalias 'gdbmi-bnf-skip-unrecognized #[0 "G	\303W\203�\304H!\203�T\262\202�W\205P�H\305>?\205P�\306	#?\205P�\307\310	#\205P�\311\312\"\312\225\n\203I�\313\314\"\210\315!\210\316\262\207" [gud-marker-acc gdbmi-bnf-offset gdbmi-debug-mode "(gdb) \n" gdbmi-is-number (94 42 43 61 126 64 38) gdbmi-same-start string-match "\$[^^*+=~@&]+\$" match-string 0 message "gdbmi-bnf-skip-unrecognized: %s" gdb-shell t] 7 (#$ . 75799)])
#@124 Implementation of the following GDB/MI output grammar rule:
  gdb-prompt ==>
       `(gdb)' nl

nl ==>
       CR | CR-LF
(defalias 'gdbmi-bnf-gdb-prompt #[0 "\303\304	#\205�\n\203�\305\306\"\210\307!\210	G\\\310\207" [gud-marker-acc gdbmi-bnf-offset gdbmi-debug-mode "(gdb) \n" gdbmi-start-with message "gdbmi-bnf-gdb-prompt: %s" gdb-gdb t] 5 (#$ . 76421)])
#@179 Implementation of the following GDB/MI output grammar rule:

result-record ==>
       [ token ] `^' result-class ( `,' result )* nl

token ==>
       any sequence of digits.
(defalias 'gdbmi-bnf-result-record #[0 "\300 \207" [gdbmi-bnf-result-and-async-record-impl] 1 (#$ . 76796)])
#@123 Implementation of the following GDB/MI output grammar rule:

out-of-band-record ==>
       async-record | stream-record
(defalias 'gdbmi-bnf-out-of-band-record #[0 "\300 \206�\301 \207" [gdbmi-bnf-async-record gdbmi-bnf-stream-record] 1 (#$ . 77090)])
#@390 Implementation of the following GDB/MI output grammar rules:

async-record ==>
       exec-async-output | status-async-output | notify-async-output

exec-async-output ==>
       [ token ] `*' async-output

status-async-output ==>
       [ token ] `+' async-output

notify-async-output ==>
       [ token ] `=' async-output

async-output ==>
       async-class ( `,' result )* nl
(defalias 'gdbmi-bnf-async-record #[0 "\300 \207" [gdbmi-bnf-result-and-async-record-impl] 1 (#$ . 77352)])
#@287 Implement the following GDB/MI output grammar rule:
  stream-record ==>
       console-stream-output | target-stream-output | log-stream-output

console-stream-output ==>
       `~' c-string

target-stream-output ==>
       `@' c-string

log-stream-output ==>
       `&' c-string
(defalias 'gdbmi-bnf-stream-record #[0 "	GW\205X�	H\304\235\205X�\305\306\n\307Q	#\205X�\310\311	\"\310\312	\"\313\225\2031�\314\315\310\313	\"\"\210\316\230\203>�\317!\210\202U�\320\230\203K�\321!\210\202U�\322\230\203U�\323!\210\324\266\202\207" [gdbmi-bnf-offset gud-marker-acc gdb--string-regexp gdbmi-debug-mode (126 64 38) string-match "\$[~@&]\$\$" "\$\n" match-string 1 2 0 message "gdbmi-bnf-stream-record: %s" "~" gdbmi-bnf-console-stream-output "@" gdbmi-bnf-target-stream-output "&" gdbmi-bnf-log-stream-output t] 7 (#$ . 77856)])
#@82 Handler for the console-stream-output GDB/MI output grammar rule.

(fn C-STRING)
(defalias 'gdbmi-bnf-console-stream-output #[257 "\301!\210\302\211\207" [gdb-first-done-or-error gdb-console t] 3 (#$ . 78706)])
#@81 Handler for the target-stream-output GDB/MI output grammar rule.

(fn C-STRING)
(defalias 'gdbmi-bnf-target-stream-output #[257 "\300\207" ["Handler for the target-stream-output GDB/MI output grammar rule."] 2 (#$ . 78925)])
#@78 Handler for the log-stream-output GDB/MI output grammar rule.

(fn C-STRING)
(defalias 'gdbmi-bnf-log-stream-output #[257 "\300!\301\230?\205\f�\302!\207" [read "No registers.\n" gdb-internals] 3 (#$ . 79156)])
#@693 Alist of alists, mapping the type and class of message to a handler function.
Handler functions are all flagged as either `progressive' or `atomic'.
`progressive' handlers are capable of parsing incomplete messages.
They can be called several time with new data chunk as they arrive from GDB.
`progressive' handlers must have an extra argument that is set to a non-nil
value when the message is complete.

Implement the following GDB/MI output grammar rule:
  result-class ==>
       `done' | `running' | `connected' | `error' | `exit'

async-class ==>
       `stopped' | others (where others will be added depending on the needs
                           --this is still in development).
(defconst gdbmi-bnf-result-state-configs '(("^" ("done" gdb-done . progressive) ("error" gdb-error . progressive) ("running" gdb-starting . atomic)) ("*" ("stopped" gdb-stopped . atomic) ("running" gdb-running . atomic)) ("+") ("=" ("thread-created" gdb-thread-created . atomic) ("thread-selected" gdb-thread-selected . atomic) ("thread-existed" gdb-ignored-notification . atomic) ('default gdb-ignored-notification . atomic))) (#$ . 79376))
#@335 Common implementation of the result-record and async-record rule.
Both rules share the same syntax.  Those records may be very large in size.
For that reason, the "result" part of the  record is parsed by
`gdbmi-bnf-incomplete-record-result', which will keep
receiving characters as they arrive from GDB until the record is complete.
(defalias 'gdbmi-bnf-result-and-async-record-impl #[0 "G	\211W\203�\305H!\203�\211T\262\202�\211W\205\253�H\306\235\205\253�\307\310	#\205\253�\311\312\"\311\313\"\311\314\"\311\315\"\316\230\317\211C\320\225\n\203R�\321\322\311\320\"\"\210\323\"A\262\211\323\"A\240\210\211\242\204n�\211\323\324\"A\240\210\203\226�\211\242\203\250�\211\242A\325=\203\213�\211\242@\326#\210\202\250�\211\242@\326\"\210\202\250�\327\320\330\331\332\n\"\333\"\314$\211 \210\334\266\206\207" [gud-marker-acc gdbmi-bnf-offset gdbmi-debug-mode gdbmi-bnf-result-state-configs gdbmi-bnf-state gdbmi-is-number (42 43 61 94) string-match "\$[0-9]*\$\$[*+=^]\$\$.+?\$\$[,\n]\$" match-string 1 2 3 4 "\n" nil 0 message "gdbmi-bnf-result-record: %s" assoc default progressive "" make-byte-code "\302\300\301\242\"\207" vconcat vector [gdbmi-bnf-incomplete-record-result] t] 16 (#$ . 80517)])
#@244 State of the parser used to progressively parse a result-record or async-record
rule from an incomplete data stream.  The parser will stay in this state until
the end of the current result or async record is reached.

(fn TOKEN CLASS-COMMAND)
(defalias 'gdbmi-bnf-incomplete-record-result #[514 "	GW\205v�\304\305	#A\306=??\307\n\203\"�\310\311\312	#\"\210\204*�\203>�\312	#\262G\\\203>�T\203D�\313\203b�\203W�@#\210\202b�\203b�@\"\210\204s�\n\203n�\310\314!\210\315\316\307\"\210\266\204\207" [gdbmi-bnf-offset gud-marker-acc gdbmi-debug-mode gdbmi-bnf-state string-match "\n" progressive nil message "gdbmi-bnf-incomplete-record-result: %s" substring gdbmi-bnf-output "gdbmi-bnf-incomplete-record-result, aborting: incomplete stream" throw gdbmi-incomplete-stream] 12 (#$ . 81764)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313&	\207" [custom-declare-variable gdb-mi-decode-strings funcall function #[0 "\300\207" [nil] 1] "When non-nil, decode octal escapes in GDB output into non-ASCII text.\n\nIf the value is a coding-system, use that coding-system to decode\nthe bytes reconstructed from octal escapes.  Any other non-nil value\nmeans to decode using the coding-system set for the GDB process.\n\nWarning: setting this non-nil might mangle strings reported by GDB\nthat have literal substrings which match the \\nnn octal escape\npatterns, where nnn is an octal number between 200 and 377.  So\nwe only recommend to set this variable non-nil if the program you\nare debugging really reports non-ASCII text, or some of its source\nfile names include non-ASCII characters." :type (choice (const :tag "Don't decode" nil) (const :tag "Decode using default coding-system" t) (coding-system :tag "Decode using this coding-system")) :group gdb :version "25.1"] 10)
#@76 Decode octal escapes in MI output STRING into multibyte text.

(fn STRING)
(defalias 'gdb-mi-decode #[257 "\302!\203\n�\202�r\303\304!q\210	)\305\306!r\211q\210\307\310\311\312\313!\314\"\315$\216\316\317!\210\320p\"\210eb\210\321\322\317\323#\203B�\324\325\317\211#\210\2021�eb\210\326\327p!\"*\262\207" [gdb-mi-decode-strings buffer-file-coding-system coding-system-p gdb-get-buffer-create gdb-partial-output-buffer generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205	�\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 set-buffer-multibyte nil prin1 re-search-forward "\\\\\$\\\\[2-3][0-7][0-7]\$" t replace-match "\\1" decode-coding-string read] 9 (#$ . 83588)])
#@36 Filter GDB/MI output.

(fn STRING)
(defalias 'gud-gdbmi-marker-filter #[257 "\203	�\306!\262	\203%�\307B\nB\203%�\nGV\203%�S\n\233\310\241\210\fP\311\fG\3122B�W\205A� \205A�\2021�0\266\313U\204T�\314\f\"\313\203e�\fG\313V\203e�\315\316\f\"\210
\207" [gdb-mi-decode-strings gdb-enable-debug gdb-debug-log gdb-debug-log-max gud-marker-acc gdb-filter-output gdb-mi-decode recv nil "" gdbmi-incomplete-stream 0 substring message "gud-gdbmi-marker-filter, unparsed string: %s" gdbmi-bnf-offset gdbmi-bnf-state gdbmi-debug-mode] 4 (#$ . 84287)])
#@21

(fn OUTPUT-FIELD)
(defalias 'gdb-gdb #[257 "\300\207" [nil] 2 (#$ . 84859)])
#@21

(fn OUTPUT-FIELD)
(defalias 'gdb-shell #[257 "\211P\211\207" [gdb-filter-output] 3 (#$ . 84944)])
#@27

(fn TOKEN OUTPUT-FIELD)
(defalias 'gdb-ignored-notification #[514 "\300\207" [nil] 3 (#$ . 85052)])
#@27

(fn TOKEN OUTPUT-FIELD)
(defalias 'gdb-thread-created #[514 "\300\207" [nil] 3 (#$ . 85160)])
#@138 Handle =thread-exited async record.
Unset `gdb-thread-number' if current thread exited and update threads list.

(fn TOKEN OUTPUT-FIELD)
(defalias 'gdb-thread-exited #[514 "\301\302!\303\"\230\203�\304\305!\210\306\307\305\310#\207" [gdb-thread-number bindat-get-field gdb-json-string id gdb-setq-thread-number nil run-with-timer 0.5 (lambda nil (if (not (cl-find-if (lambda (handler) (gdb-handler-pending-trigger handler)) gdb-handler-list)) (progn . #1=((gdb-emit-signal gdb-buf-publisher 'update-threads))) (gdb-wait-for-pending . #1#)))] 7 (#$ . 85263)])
#@110 Handler for =thread-selected MI output record.

Sets `gdb-thread-number' to new id.

(fn TOKEN OUTPUT-FIELD)
(defalias 'gdb-thread-selected #[514 "\300!\301\302\"\303!\210\304\305\306\307#\207" [gdb-json-string bindat-get-field id gdb-setq-thread-number run-with-timer 0.5 nil (lambda nil (if (not (cl-find-if (lambda (handler) (gdb-handler-pending-trigger handler)) gdb-handler-list)) (progn . #1=((gdb-update))) (gdb-wait-for-pending . #1#)))] 8 (#$ . 85833)])
#@27

(fn TOKEN OUTPUT-FIELD)
(defalias 'gdb-running #[514 "\306\307!\310\"\211\311\230\204�\211\230\203�\312\210\313\314\315\n\316#!\210\f\204%�\317\317\211\207" [gdb-thread-number gdb-frame-number gdb-inferior-status font-lock-type-face gdb-non-stop gud-running bindat-get-field gdb-json-string thread-id "all" nil "running" gdb-force-mode-line-update propertize face t gdb-active-process] 7 (#$ . 86305)])
#@28

(fn OUTPUT-FIELD RESULT)
(defalias 'gdb-starting #[514 "\304\305\306\307	#!\210\310\211\211\207" [gdb-inferior-status font-lock-type-face gdb-active-process gud-running "running" gdb-force-mode-line-update propertize face t] 8 (#$ . 86726)])
#@124 Given the contents of *stopped MI async record, select new
current thread and update GDB buffers.

(fn TOKEN OUTPUT-FIELD)
(defalias 'gdb-stopped #[514 "\306!\307\310\"\307\311\"\307\312\"\307\313\"\204$�\314\315	\205 �\316PP\317\"\210\206)�\320\321\322\n\323#!\210\324\230\203:�\325\203Q�\211\203Q�\326\327
\"\204Q�
\330\331#P%\203\213�&\204e�\307\332 \333\"\334\230\204\213�%\335=\204s�%\235\203\206�'\230\204\213�\336\337\"\210\340!\210\202\213�\336\341\"\210(\203\225�
)P(\204\237�*\203\245�\342 \210\325(\343\344\"\207" [gdb-register-names gdb-supports-non-stop gdb-inferior-status font-lock-warning-face gdb-active-process gdb-filter-output gdb-json-string bindat-get-field reason thread-id return-value gdb-result-var gdb-input "-data-list-register-names" " --thread " gdb-register-names-handler "unknown" gdb-force-mode-line-update propertize face "exited-normally" nil string-match "^Value returned is " format "Value returned is %s = %s\n" gdb-current-buffer-thread state "stopped" t message "Switched to thread %s" gdb-setq-thread-number "Thread %s stopped" gdb-update run-hook-with-args gdb-stopped-functions gdb-switch-reasons gdb-switch-when-another-stopped gdb-thread-number gdb-first-done-or-error gdb-prompt-name gdb-non-stop] 12 (#$ . 86981)])
#@21

(fn OUTPUT-FIELD)
(defalias 'gdb-internals #[257 "\302\303\230\203\f�\304\202�\305!\306\307G\310	%\210\211\262\"\211\207" [gdb-filter-output font-lock-warning-face gdb-concat-output "\"\\n\"" "" read put-text-property 0 face] 10 (#$ . 88283)])
#@21

(fn OUTPUT-FIELD)
(defalias 'gdb-console #[257 "\301\302!\"\211\207" [gdb-filter-output gdb-concat-output read] 5 (#$ . 88543)])
#@46

(fn TOKEN-NUMBER OUTPUT-FIELD IS-COMPLETE)
(defalias 'gdb-done #[771 "\300\301$\207" [gdb-done-or-error done] 8 (#$ . 88683)])
#@46

(fn TOKEN-NUMBER OUTPUT-FIELD IS-COMPLETE)
(defalias 'gdb-error #[771 "\300\301$\207" [gdb-done-or-error error] 8 (#$ . 88821)])
#@51

(fn TOKEN-NUMBER TYPE OUTPUT-FIELD IS-COMPLETE)
(defalias 'gdb-done-or-error #[1028 "\306\230\203!�\307\310\262\311=\203#�\312\313\314\315\316\"!\"\210\310\262\202#�\317\320	!\211?\2060�\321!\322>\203N�\n\203N�\204H�\204H�\211\204H�\f
P\323!\210\310\324\f\"\307\203k�\203k�r\325\326!q\210\327\330!!\210)\205q�\331 \207" [gdb-output-sink gud-comint-buffer gdb-first-done-or-error gud-running gdb-filter-output gdb-prompt-name "" user nil error message "%s" read substring 4 emacs get-buffer-process process-status (exit signal) gdb-update gdb-concat-output gdb-get-buffer-create gdb-partial-output-buffer gdb-handle-reply string-to-number gdb-clear-partial-output] 10 (#$ . 88961)])
#@19

(fn SO-FAR NEW)
(defalias 'gdb-concat-output #[514 "\301\267\202�P\207\302!\210\207\303\207" [gdb-output-sink #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (user 6 emacs 10)) gdb-append-to-partial-output nil] 4 (#$ . 89673)])
#@15

(fn STRING)
(defalias 'gdb-append-to-partial-output #[257 "r\300\301!q\210db\210\211c)\207" [gdb-get-buffer-create gdb-partial-output-buffer] 3 (#$ . 89952)])
(defalias 'gdb-clear-partial-output #[0 "r\300\301!q\210\302 )\207" [gdb-get-buffer-create gdb-partial-output-buffer erase-buffer] 2])
#@748 Prepare GDB/MI output in current buffer for parsing with `json-read'.

Field names are wrapped in double quotes and equal signs are
replaced with semicolons.

If FIX-KEY is non-nil, strip all "FIX-KEY=" occurrences from
partial output.  This is used to get rid of useless keys in lists
in MI messages, e.g.: [key=.., key=..].  -stack-list-frames and
-break-info are examples of MI commands which issue such
responses.

If FIX-LIST is non-nil, "FIX-LIST={..}" is replaced with
"FIX-LIST=[..]" prior to parsing.  This is used to fix broken
-break-info output when it contains breakpoint script field
incompatible with GDB/MI output syntax.

If `default-directory' is remote, full file names are adapted accordingly.

(fn &optional FIX-KEY FIX-LIST)
(defalias 'gdb-jsonify-buffer #[512 "\212\301!\211\203 �eb\210\302\303\304\305#\203 �\306\307P\304\211\211\310%\210\202�\210eb\210\203@�\212\302\311\312Q\304\305#\203?�\306\313\304\211\211\310%\210\202)�)\211\203t�\212\302\314P\304\305#\203s�`\315Zb\316 \210`S\212b\210\317\310!\210\320c\210\211b\210\317\310!\210\321c\210)\266\202E�)eb\210\322c\210\323\302\304\305#\203\234�\306\324\304\211#\210\304f\325=\203\226�\316 \210\202{�\304u\210\202{�\210db\210\326c)\207" [default-directory file-remote-p re-search-forward "[\\[,]fullname=\"\$.+\$\"" nil t replace-match "\\1" 1 "[\\[,]\$" "=\$" "" "={\"" 2 forward-sexp delete-char "[" "]" "{" "\$[[:alnum:]_-]+\$=" "\"\\1\":" 34 "}"] 9 (#$ . 90255)])
#@157 Prepare and parse GDB/MI output in current buffer with `json-read'.

FIX-KEY and FIX-LIST work as in `gdb-jsonify-buffer'.

(fn &optional FIX-KEY FIX-LIST)
(defalias 'gdb-json-read-buffer #[512 "\301\"\210\212eb\210\302\303 *\207" [json-array-type gdb-jsonify-buffer list json-read] 5 (#$ . 91722)])
#@164 Prepare and parse STRING containing GDB/MI output with `json-read'.

FIX-KEY and FIX-LIST work as in `gdb-jsonify-buffer'.

(fn STRING &optional FIX-KEY FIX-LIST)
(defalias 'gdb-json-string #[769 "\300\301!r\211q\210\302\303\304\305\306!\307\"\310$\216c\210\311\"*\207" [generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205	�\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 gdb-json-read-buffer] 10 (#$ . 92032)])
#@150 Prepare and parse gdb-partial-output-buffer with `json-read'.

FIX-KEY and FIX-KEY work as in `gdb-jsonify-buffer'.

(fn &optional FIX-KEY FIX-LIST)
(defalias 'gdb-json-partial-output #[512 "r\300\301!q\210\302\")\207" [gdb-get-buffer-create gdb-partial-output-buffer gdb-json-read-buffer] 5 (#$ . 92475)])
#@63 Return a pair of LINE beginning and end positions.

(fn LINE)
(defalias 'gdb-line-posns #[257 "\211\300 ZT\301!\302!B\207" [line-number-at-pos line-beginning-position line-end-position] 5 (#$ . 92790)])
#@167 Set VARIABLE marker to point at beginning of LINE.

If current window has no fringes, inverse colors on LINE.

Return position where LINE begins.

(fn LINE VARIABLE)
(defalias 'gdb-mark-line '(macro . #[514 "\300\301\302\303DD\304B\305\306BB\307BBBD\207" [save-excursion let* posns gdb-line-posns ((start-posn (car posns)) (end-posn (cdr posns))) set-marker ((copy-marker start-posn)) ((when (not (> (car (window-fringes)) 0)) (put-text-property start-posn end-posn 'font-lock-face '(:inverse-video t))) start-posn)] 8 (#$ . 93002)]))
#@23

(fn STRING PADDING)
(defalias 'gdb-pad-string #[514 "\300\301\302!\303Q\"\207" [format "%" number-to-string "s"] 6 (#$ . 93545)])
#@68 compiler-macro for inlining `gdb-table-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'gdb-table-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block gdb-table-p (and (memq (type-of cl-x) cl-struct-gdb-table-tags) t)) nil] 9 (#$ . 93685)])
(put 'gdb-table-p 'compiler-macro 'gdb-table-p--cmacro)
#@13

(fn CL-X)
(defalias 'gdb-table-p #[257 "\301!>\205	�\302\207" [cl-struct-gdb-table-tags type-of t] 3 (#$ . 94014)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put gdb-table-p side-effect-free error-free put gdb-table cl-deftype-satisfies] 5)
#@79 compiler-macro for inlining `gdb-table-column-sizes'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'gdb-table-column-sizes--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block gdb-table-column-sizes (progn (or (gdb-table-p cl-x) (signal 'wrong-type-argument (list 'gdb-table cl-x))) (aref cl-x 1))) nil] 9 (#$ . 94285)])
(put 'gdb-table-column-sizes 'compiler-macro 'gdb-table-column-sizes--cmacro)
#@67 Access slot "column-sizes" of `gdb-table' struct CL-X.

(fn CL-X)
(defalias 'gdb-table-column-sizes #[257 "\301!>\204�\302\303\304D\"\210\211\305H\207" [cl-struct-gdb-table-tags type-of signal wrong-type-argument gdb-table 1] 5 (#$ . 94713)])
(byte-code "\300\301\302\303#\300\207" [function-put gdb-table-column-sizes side-effect-free t] 4)
#@71 compiler-macro for inlining `gdb-table-rows'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'gdb-table-rows--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block gdb-table-rows (progn (or (gdb-table-p cl-x) (signal 'wrong-type-argument (list 'gdb-table cl-x))) (aref cl-x 2))) nil] 9 (#$ . 95065)])
(put 'gdb-table-rows 'compiler-macro 'gdb-table-rows--cmacro)
#@59 Access slot "rows" of `gdb-table' struct CL-X.

(fn CL-X)
(defalias 'gdb-table-rows #[257 "\301!>\204�\302\303\304D\"\210\211\305H\207" [cl-struct-gdb-table-tags type-of signal wrong-type-argument gdb-table 2] 5 (#$ . 95453)])
(byte-code "\300\301\302\303#\300\207" [function-put gdb-table-rows side-effect-free t] 4)
#@81 compiler-macro for inlining `gdb-table-row-properties'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'gdb-table-row-properties--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block gdb-table-row-properties (progn (or (gdb-table-p cl-x) (signal 'wrong-type-argument (list 'gdb-table cl-x))) (aref cl-x 3))) nil] 9 (#$ . 95781)])
(put 'gdb-table-row-properties 'compiler-macro 'gdb-table-row-properties--cmacro)
#@69 Access slot "row-properties" of `gdb-table' struct CL-X.

(fn CL-X)
(defalias 'gdb-table-row-properties #[257 "\301!>\204�\302\303\304D\"\210\211\305H\207" [cl-struct-gdb-table-tags type-of signal wrong-type-argument gdb-table 3] 5 (#$ . 96219)])
(byte-code "\300\301\302\303#\300\207" [function-put gdb-table-row-properties side-effect-free t] 4)
#@78 compiler-macro for inlining `gdb-table-right-align'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'gdb-table-right-align--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block gdb-table-right-align (progn (or (gdb-table-p cl-x) (signal 'wrong-type-argument (list 'gdb-table cl-x))) (aref cl-x 4))) nil] 9 (#$ . 96577)])
(put 'gdb-table-right-align 'compiler-macro 'gdb-table-right-align--cmacro)
#@66 Access slot "right-align" of `gdb-table' struct CL-X.

(fn CL-X)
(defalias 'gdb-table-right-align #[257 "\301!>\204�\302\303\304D\"\210\211\305H\207" [cl-struct-gdb-table-tags type-of signal wrong-type-argument gdb-table 4] 5 (#$ . 97000)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put gdb-table-right-align side-effect-free t defalias copy-gdb-table copy-sequence] 4)
#@122 compiler-macro for inlining `make-gdb-table'.

(fn CL-WHOLE &cl-quote &key COLUMN-SIZES ROWS ROW-PROPERTIES RIGHT-ALIGN)
(defalias 'make-gdb-table--cmacro #[385 "\300\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\211\203D�\211@\305>\203,�\211AA\262\202�\306>A@\203;�\307\262\202�\310\311@\"\210\202�\210\312\313\314\307	\307				&	\207" [plist-member :column-sizes :rows :row-properties :right-align (:column-sizes :rows :row-properties :right-align :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:column-sizes :rows :row-properties :right-align)" cl--defsubst-expand (column-sizes rows row-properties right-align) (cl-block make-gdb-table (record 'gdb-table column-sizes rows row-properties right-align))] 16 (#$ . 97398)])
(put 'make-gdb-table 'compiler-macro 'make-gdb-table--cmacro)
#@102 Constructor for objects of type `gdb-table'.

(fn &key COLUMN-SIZES ROWS ROW-PROPERTIES RIGHT-ALIGN)
(defalias 'make-gdb-table #[128 "\300\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\211\203D�\211@\305>\203,�\211AA\262\202�\306>A@\203;�\307\262\202�\310\311@\"\210\202�\210\312\313%\207" [plist-member :column-sizes :rows :row-properties :right-align (:column-sizes :rows :row-properties :right-align :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:column-sizes :rows :row-properties :right-align)" record gdb-table] 11 (#$ . 98240)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-gdb-table side-effect-free t cl-struct-define gdb-table nil cl-structure-object record ((cl-tag-slot) (column-sizes nil) (rows nil) (row-properties nil) (right-align nil)) cl-struct-gdb-table-tags] 11)
#@185 Add ROW of string to TABLE and recalculate column sizes.

When non-nil, PROPERTIES will be added to the whole row when
calling `gdb-table-string'.

(fn TABLE ROW &optional PROPERTIES)
(defalias 'gdb-table-add-row #[770 "\301!>\204�\302\303\304D\"\210\305H\301!>\204\"�\302\303\304D\"\210\306H\301!>\2045�\302\303\304D\"\210\307H\301!>\204I�\302\303\304D\"\210\310H\204n�\301!>\204a�\302\303\304	D\"\210\211\307\311	G\312\"I\266\301!>\204�\302\303\304	D\"\210\211\305\313\nC\"I\266\301!>\204\236�\302\303\304	D\"\210\211\306\313	C\"I\266\301!>\204\275�\302\303\304	D\"\210\211\307\314\315\316\317\320\321	!\322\"\323\324%\301\f!>\204\340�\302\303\304D\"\210\307H#I\266\301!>\204\373�\302\303\304	D\"\210\310H?\205\325\301!>\204\302\303\304\nD\"\210\307H!\312\240\207" [cl-struct-gdb-table-tags type-of signal wrong-type-argument gdb-table 2 3 1 4 make-list 0 append cl-mapcar make-byte-code 514 "\301!\302\206	�\303!]\300\203�\211\202�\211[\207" vconcat vector [abs string-width ""] 5 "\n\n(fn X S)" last] 17 (#$ . 99130)])
#@85 Return TABLE as a string with columns separated with SEP.

(fn TABLE &optional SEP)
(defalias 'gdb-table-string #[513 "\301!>\204�\302\303\304D\"\210\305H\306\307\310\311\312\313\314\315		\"\316\"\317\320%\301!>\2045�\302\303\304	D\"\210\321H\301!>\204J�\302\303\304\nD\"\210\322H#\323#\207" [cl-struct-gdb-table-tags type-of signal wrong-type-argument gdb-table 1 mapconcat identity cl-mapcar make-byte-code 514 "\302\303\304\305\306\307\301#\300##\207" vconcat vector [apply propertize mapconcat identity cl-mapcar #[514 "\300\"\207" [gdb-pad-string] 5 "\n\n(fn S X)"]] 10 "\n\n(fn ROW PROPERTIES)" 2 3 "\n"] 13 (#$ . 100246)])
#@71 Return a list of FIELDS values from STRUCT.

(fn STRUCT &rest FIELDS)
(defalias 'gdb-get-many-fields #[385 "\300\211\203�\211@\301\"B\262A\266\202\202�\210\211\237\207" [nil bindat-get-field] 8 (#$ . 100906)])
#@943 Define a trigger TRIGGER-NAME which sends GDB-COMMAND and sets
HANDLER-NAME as its handler.  HANDLER-NAME is bound to current
buffer with `gdb-bind-function-to-buffer'.

If SIGNAL-LIST is non-nil, GDB-COMMAND is sent only when the
defined trigger is called with an argument from SIGNAL-LIST.  It's
not recommended to define triggers with empty SIGNAL-LIST.
Normally triggers should respond at least to the `update' signal.

Normally the trigger defined by this command must be called from
the buffer where HANDLER-NAME must work.  This should be done so
that buffer-local thread number may be used in GDB-COMMAND (by
calling `gdb-current-context-command').
`gdb-bind-function-to-buffer' is used to achieve this, see
`gdb-get-buffer-create'.

Triggers defined by this command are meant to be used as a
trigger argument when describing buffer types with
`gdb-set-buffer-rules'.

(fn TRIGGER-NAME GDB-COMMAND HANDLER-NAME &optional SIGNAL-LIST)
(defalias 'def-gdb-auto-update-trigger '(macro . #[1027 "\300\301\302\303\304D\305\306EE\307\310\311\nD\312BB\313\314\311DEFEF\207" [defun (&optional signal) when or not memq signal gdb-input gdb-bind-function-to-buffer quote ((current-buffer)) cons (current-buffer)] 16 (#$ . 101131)]))
#@334 Define a handler HANDLER-NAME calling CUSTOM-DEFUN.

Handlers are normally called from the buffers they put output in.

Erase current buffer and evaluate CUSTOM-DEFUN.
Then call `gdb-update-buffer-name'.

If NOPRESERVE is non-nil, window point is not restored after CUSTOM-DEFUN.

(fn HANDLER-NAME CUSTOM-DEFUN &optional NOPRESERVE)
(defalias 'def-gdb-auto-update-handler '(macro . #[770 "\300\301\302\303?\205�\304B\305C\306?\205�\307BBBBBF\207" [defun nil let* (inhibit-read-only t) ((window (get-buffer-window (current-buffer) 0)) (start (window-start window)) (p (window-point window))) (erase-buffer) (gdb-update-buffer-name) ((set-window-start window start) (set-window-point window p))] 12 (#$ . 102378)]))
#@290 Define trigger and handler.

TRIGGER-NAME trigger is defined to send GDB-COMMAND.
See `def-gdb-auto-update-trigger'.

HANDLER-NAME handler uses customization of CUSTOM-DEFUN.
See `def-gdb-auto-update-handler'.

(fn TRIGGER-NAME GDB-COMMAND HANDLER-NAME CUSTOM-DEFUN &optional SIGNAL-LIST)
(defalias 'def-gdb-trigger-and-handler '(macro . #[1284 "\300\301\257\302EE\207" [progn def-gdb-auto-update-trigger def-gdb-auto-update-handler] 11 (#$ . 103107)]))
#@25

(fn &optional SIGNAL)
(defalias 'gdb-invalidate-breakpoints #[256 "\211\300>\205�\301\302\303\304p\"p\305B#\207" [(start update) gdb-input "-break-list" gdb-bind-function-to-buffer gdb-breakpoints-list-handler gdb-invalidate-breakpoints] 6 (#$ . 103577)])
(defalias 'gdb-breakpoints-list-handler #[0 "\301\302p\303\"\304!\305!\306 \210\307 \210\310 \210\311\"\210\312\")\207" [inhibit-read-only t get-buffer-window 0 window-start window-point erase-buffer gdb-breakpoints-list-handler-custom gdb-update-buffer-name set-window-start set-window-point] 6])
(gdb-set-buffer-rules 'gdb-breakpoints-buffer 'gdb-breakpoints-buffer-name 'gdb-breakpoints-mode 'gdb-invalidate-breakpoints)
(defalias 'gdb-breakpoints-list-handler-custom #[0 "\302\303\304\305\"\306\307#\310\311\312\211\211\211%\312\313\314\"\210\211\203\300�\211@\302\315\"B\211\235\203.�\210\2022�\211B\210\302\316\"\302\317\"\302\320\"\302\321\"\313\302\315\"\206P�\322\302	\323\"\206Y�\322\302\n\324\"\211\325\230\203h�\326\202i�\327\262\302\330\"\302\f\331\"\206y�\322\203\216�\332\333\n\"\203\216�\302
\334\"\202\250�\n\206\250�\206\250�\335\336\206\240�\337\340	#\341!Q\257\342\343	D\205\265�\344\"#\266A\266\202\202�\210\345\346\"c\210\347 \207" [gdb-breakpoints-list font-lock-function-name-face bindat-get-field gdb-json-partial-output "bkpt" "script" BreakpointTable body record gdb-table nil gdb-table-add-row ("Num" "Type" "Disp" "Enb" "Addr" "Hits" "What") number at pending func type "" disp enabled "y" #("y" 0 1 (font-lock-face font-lock-warning-face)) #("n" 0 1 (font-lock-face font-lock-comment-face)) addr times string-match ".*watchpoint" what "in " propertize "unknown" font-lock-face gdb-frame-location append gdb-breakpoint (help-echo "mouse-2, RET: visit breakpoint" mouse-face highlight) gdb-table-string " " gdb-place-breakpoints] 21])
(defalias 'gdb-place-breakpoints #[0 "\303 \211\203'�\211@r\211q\210\304=\203�\305\306\307 \"\204�\310ed\"\210)A\266\202\202�\210	\211\205\244�\211@\211A\311\312\"\211\203\233�\311\313\"\311\314\"\311\315\"\203O�\316!\204V�\317\n\"A\262\203`�\320\230\203\203�\311\321\"\211\262\203\231�\322\323\324Q\325\"\210\322\326\327\330\331	FE\"\210\202\231�r\332\333\"q\210\334 \210\335\336\230\337!#\210)\266\266A\266\202\202)�\207" [gud-minor-mode gdb-breakpoints-list gdb-location-alist buffer-list gdbmi string-match "\\` ?\\*.+\\*\\'" buffer-name gdb-remove-breakpoint-icons bindat-get-field line fullname enabled number file-exists-p assoc "File not found" file gdb-input "list " ":1" ignore "-file-list-exec-source-file" lambda nil gdb-get-location find-file-noselect nowarn gdb-init-buffer gdb-put-breakpoint-icon "y" string-to-number] 15])
(defconst gdb-source-file-regexp (concat "fullname=\$" gdb--string-regexp "\$"))
#@120 Find the directory containing the relevant source file.
Put in buffer and place breakpoint icon.

(fn BPTNO LINE FLAG)
(defalias 'gdb-get-location #[771 "eb\210\3022P�\303\304\305#\203�\306\307B	\"\210\202:�\310\311!B	B\312 \210\313	\"\2045�\307B	B\314\315!\210\316\302\304\"\210r\317\310\311!!q\210\320 \210\321\322=\323!#)0\207" [gdb-source-file-regexp gdb-location-alist file-not-found re-search-forward nil t delete "File not found" match-string 1 gdb-resync assoc message-box "Cannot find source file for breakpoint location.\nAdd directory to search path for source files using the GDB command, dir." throw find-file-noselect gdb-init-buffer gdb-put-breakpoint-icon 121 string-to-number] 8 (#$ . 106408)])
(add-hook 'find-file-hook 'gdb-find-file-hook)
#@88 Set up buffer for debugging if file is part of the source code
of the current session.
(defalias 'gdb-find-file-hook #[0 "\303!\205\"�\205\"�\304\305\"\306=\205\"�	\n\235\205\"�r\307	!q\210\310 )\207" [gud-comint-buffer buffer-file-name gdb-source-file-list buffer-name buffer-local-value gud-minor-mode gdbmi find-buffer-visiting gdb-init-buffer] 3 (#$ . 107184)])
#@129 Set/clear breakpoint in left fringe/margin at mouse click.
If not in a source or disassembly buffer just set point.

(fn EVENT)
(defalias 'gdb-mouse-set-clear-breakpoint #[257 "\300!\210\301!\302\211@\262!r\303\304\305\306\307!\310\"\311$\216\312@\313\"\210\314 \204,�\315\316!\203b�\317!\247\203b�\212\317!b\210\211\3208\262\206F�\321!\262\204V�\322\317!!@\323=\203]�\324\325!\210\202a�\326\325!\210)\327!*\262\207" [mouse-minibuffer-check event-end internal--before-with-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-with-selected-window] 2 select-window norecord buffer-file-name derived-mode-p gdb-disassembly-mode posn-point 7 posn-string fringe-bitmaps-at-pos breakpoint gud-remove nil gud-break posn-set-point] 9 (#$ . 107560) "e"])
#@72 Enable/disable breakpoint in left margin with mouse click.

(fn EVENT)
(defalias 'gdb-mouse-toggle-breakpoint-margin #[257 "\300!\210\301!\302!\247\205c�\303\211@\262!r\304\305\306\307\310!\311\"\312$\216\313@\314\"\210\212\302!b\210\211\3158\262\206;�\316!\262\205`�\317\320\305\321\316!@#\320\305\322\316!@#\203Z�\323\202[�\324P\262!+\262\207" [mouse-minibuffer-check event-end posn-point internal--before-with-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-with-selected-window] 2 select-window norecord 7 posn-string gud-basic-call get-text-property gdb-bptno gdb-enabled "-break-disable " "-break-enable "] 10 (#$ . 108357) "e"])
#@72 Enable/disable breakpoint in left fringe with mouse click.

(fn EVENT)
(defalias 'gdb-mouse-toggle-breakpoint-fringe #[257 "\300!\210\301!\302!\303\247\205o�\304\211@\262!r\305\306\307\310\311!\312\"\313$\216\314@\315\"\210r\316 q\210b\210\317\211\"\211\203P�\211@\320\321\"\203I�\320\322\"\262A\266\202\2026�\210;\205l�\323\324\306\325#\203c�\326\202d�\327\324\306\330#P!+\262\207" [mouse-minibuffer-check event-end posn-point nil internal--before-with-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-with-selected-window] 2 select-window norecord window-buffer overlays-in overlay-get put-break before-string gud-basic-call get-text-property gdb-enabled "-break-disable " "-break-enable " gdb-bptno] 11 (#$ . 109052) "e"])
(defalias 'gdb-breakpoints-buffer-name #[0 "\300\301 \302Q\207" ["*breakpoints of " gdb-get-target-string "*"] 3])
#@49 Display GDB breakpoints.

(fn &optional THREAD)
(defalias 'gdb-display-breakpoints-buffer #[256 "\300\301\302\"!\207" [gdb-display-buffer gdb-get-buffer-create gdb-breakpoints-buffer] 5 (#$ . 109950) nil])
#@66 Display GDB breakpoints in another frame.

(fn &optional THREAD)
(defalias 'gdb-frame-breakpoints-buffer #[256 "\301\302\303\"\"\207" [gdb-display-buffer-other-frame-action display-buffer gdb-get-buffer-create gdb-breakpoints-buffer] 5 (#$ . 110163) nil])
(defvar gdb-breakpoints-mode-map (byte-code "\300 \300\301!\302\303\304#\210\302\305\306#\210\302\307\310#\210\302\311\312#\210\313!\210\302\314\301B#\210\302\315\316#\210\302\317\320#\210\302\321\322#\210\302\323\324#\210\302\325\326#\210\302\327\324#\210\302\330\331#\210\207" [make-sparse-keymap "Breakpoints" define-key [quit] ("Quit" . gdb-delete-frame-or-window) [goto] ("Goto" . gdb-goto-breakpoint) [delete] ("Delete" . gdb-delete-breakpoint) [toggle] ("Toggle" . gdb-toggle-breakpoint) suppress-keymap [menu-bar breakpoints] " " gdb-toggle-breakpoint "D" gdb-delete-breakpoint "q" gdb-delete-frame-or-window "
" gdb-goto-breakpoint "	" #[0 "\300\301\302!\303\"\207" [gdb-set-window-buffer gdb-get-buffer-create gdb-threads-buffer t] 3 nil nil] [mouse-2] [follow-link] mouse-face] 7))
#@73 Delete frame if there is only one window.  Otherwise delete the window.
(defalias 'gdb-delete-frame-or-window #[0 "\300 \203�\301 \207\302 \207" [one-window-p delete-frame delete-window] 1 (#$ . 111235) nil])
#@205 Return a keymap with single entry for mouse key MOUSE on the header line.
MOUSE is defined to run function FUNCTION with no args in the buffer
corresponding to the mode line clicked.

(fn MOUSE FUNCTION)
(defalias 'gdb-make-header-line-mouse-map #[514 "\300 \301\302\303\"#\210\301\302\303\304\"\305#\210\211\207" [make-sparse-keymap define-key vector header-line down-mouse-1 ignore] 8 (#$ . 111452)])
#@46

(fn NAME BUFFER HELP-ECHO MOUSE-FACE FACE)
(defalias 'gdb-propertize-header '(macro . #[1285 "\300\301\302\303D\304\303D\305\306\307\310\311\312\313\314\315\316\303DD\317BBEFE\257\n\207" [propertize 'help-echo 'mouse-face quote 'face 'local-map gdb-make-header-line-mouse-map 'mouse-1 lambda (event) (interactive "e") save-selected-window (select-window (posn-window (event-start event))) gdb-set-window-buffer gdb-get-buffer-create (t)] 25 (#$ . 111866)]))
(defalias 'gdb-threads-buffer-name #[0 "\300\301 \302Q\207" ["*threads of " gdb-get-target-string "*"] 3])
#@45 Display GDB threads.

(fn &optional THREAD)
(defalias 'gdb-display-threads-buffer #[256 "\300\301\302\"!\207" [gdb-display-buffer gdb-get-buffer-create gdb-threads-buffer] 5 (#$ . 112447) nil])
#@62 Display GDB threads in another frame.

(fn &optional THREAD)
(defalias 'gdb-frame-threads-buffer #[256 "\301\302\303\"\"\207" [gdb-display-buffer-other-frame-action display-buffer gdb-get-buffer-create gdb-threads-buffer] 5 (#$ . 112648) nil])
#@25

(fn &optional SIGNAL)
(defalias 'gdb-invalidate-threads #[256 "\211\300>\205�\301\302\303!\304\305p\"p\306B#\207" [(start update update-threads) gdb-input gdb-current-context-command "-thread-info" gdb-bind-function-to-buffer gdb-thread-list-handler gdb-invalidate-threads] 6 (#$ . 112900)])
(defalias 'gdb-thread-list-handler #[0 "\301\302p\303\"\304!\305!\306 \210\307 \210\310 \210\311\"\210\312\")\207" [inhibit-read-only t get-buffer-window 0 window-start window-point erase-buffer gdb-thread-list-handler-custom gdb-update-buffer-name set-window-start set-window-point] 6])
(gdb-set-buffer-rules 'gdb-threads-buffer 'gdb-threads-buffer-name 'gdb-threads-mode 'gdb-invalidate-threads)
#@48 Font lock keywords used in `gdb-threads-mode'.
(defvar gdb-threads-font-lock-keywords '(("in \$[^ ]+\$" (1 font-lock-function-name-face)) (" \$stopped\$" (1 font-lock-warning-face)) (" \$running\$" (1 font-lock-string-face)) ("\$\\(\\sw\\|[_.]\$+\\)=" (1 font-lock-variable-name-face))) (#$ . 113606))
(defvar gdb-threads-mode-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\303#\210\301\335\336#\210\211\207" [make-sparse-keymap define-key "
" gdb-select-thread "f" gdb-display-stack-for-thread "F" gdb-frame-stack-for-thread "l" gdb-display-locals-for-thread "L" gdb-frame-locals-for-thread "r" gdb-display-registers-for-thread "R" gdb-frame-registers-for-thread "d" gdb-display-disassembly-for-thread "D" gdb-frame-disassembly-for-thread "i" gdb-interrupt-thread "c" gdb-continue-thread "s" gdb-step-thread "	" #[0 "\300\301\302!\303\"\207" [gdb-set-window-buffer gdb-get-buffer-create gdb-breakpoints-buffer t] 3 nil nil] [mouse-2] [follow-link] mouse-face] 5))
(defvar gdb-threads-header (byte-code "\300\301\302\303\304\305\306\307\310\311\312\313\"&	\314\300\315\302\316\304\316\306\317\310\311\312\320\"&	E\207" [propertize "Breakpoints" help-echo "mouse-1: select" mouse-face mode-line-highlight face mode-line-inactive local-map gdb-make-header-line-mouse-map mouse-1 #[257 "\300 r\301\302\303\304\305!\306\"\307$\216\310\311!\211@\262!\210\312\313\314!\315\"*\207" [internal--before-save-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-save-selected-window] 2 select-window event-start gdb-set-window-buffer gdb-get-buffer-create gdb-breakpoints-buffer t] 8 "\n\n(fn EVENT)" #1="e"] " " "Threads" nil mode-line #[257 "\300 r\301\302\303\304\305!\306\"\307$\216\310\311!\211@\262!\210\312\313\314!\315\"*\207" [internal--before-save-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-save-selected-window] 2 select-window event-start gdb-set-window-buffer gdb-get-buffer-create gdb-threads-buffer t] 8 "\n\n(fn EVENT)" #1#]] 14))
(defvar gdb-threads-mode-hook nil)
(byte-code "\300\301N\204\f�\302\300\301\303#\210\304\305!\204�\302\305\306\307#\210\300\207" [gdb-threads-mode-hook variable-documentation put "Hook run after entering Threads mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp gdb-threads-mode-map definition-name gdb-threads-mode] 4)
(defvar gdb-threads-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\322#\207" [gdb-threads-mode-abbrev-table gdb-threads-mode-map variable-documentation put purecopy "Keymap for `gdb-threads-mode'." boundp gdb-threads-mode-syntax-table definition-name gdb-threads-mode (lambda (#1=#:def-tmp-var) (defvar gdb-threads-mode-syntax-table #1#)) make-syntax-table "Syntax table for `gdb-threads-mode'." (lambda (#1#) (defvar gdb-threads-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `gdb-threads-mode'." derived-mode-parent gdb-parent-mode] 5)
#@235 Major mode for GDB threads.

In addition to any hooks its parent mode `gdb-parent-mode' might have run,
this mode runs the hook `gdb-threads-mode-hook', as the final or penultimate step
during initialization.

\{gdb-threads-mode-map}
(defalias 'gdb-threads-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
\325!C#\210\327!\210\330\f!\210
!\331 \332\333\334\"\210\"#\306\335!\210\336)\337\340!\207" [delay-mode-hooks major-mode mode-name gdb-threads-mode-map gdb-threads-mode-syntax-table gdb-threads-mode-abbrev-table make-local-variable t gdb-parent-mode gdb-threads-mode "Threads" 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 make-marker add-to-list overlay-arrow-variable-list gdb-thread-position font-lock-defaults (gdb-threads-font-lock-keywords) run-mode-hooks gdb-threads-mode-hook local-abbrev-table gdb-threads-header header-line-format] 5 (#$ . 117063) nil])
(defalias 'gdb-thread-list-handler-custom #[0 "\306\307 \310\"\311\312\313\211\211\211%\313\211\314\211\313\211\223\210\315!\211\203\317�\211@\306\316\"\317\232\306\320\"B\211\235\2038�\210\202<�\211B\210\211\203G�	T\202J�\nT\321\306\320\"\f\203]�\306\322\"\323P\202^�\324\306\316\"\204\254�\325\306\326\327#
\203\205�\330\306\n\326\331#\332\333\334#\262\335Q\202\206�\3240\203\225�\336\306\326\"!\202\226�\3241\203\246�\337\306\f\326\340#P\202\247�\324\260\202\255�\324QD\341\342\343\344\345\257#\2662\306\320\"\230\203\310�G\262A\266\202\202�\210\346\323\"c\210\211\203\373�\212\347!\211@A\350!\313\223\210\351 @\314V\204\370�\352\353\354$\210\266)\266\355 \210\3563\357\"\207" [gdb-threads-list gdb-running-threads-count gdb-stopped-threads-count gdb-thread-position gdb-thread-buffer-verbose-names gdb-thread-buffer-arguments bindat-get-field gdb-json-partial-output threads record gdb-table nil 0 reverse state "running" id gdb-table-add-row target-id " " "" " in " frame func " (" args mapconcat #[257 "\300\301\302\303\304\305##\207" [apply format "%s=%s" gdb-get-many-fields name value] 8 "\n\n(fn ARG)"] "," ")" gdb-frame-location " at " addr gdb-thread mouse-face highlight help-echo "mouse-2, RET: select thread" gdb-table-string gdb-line-posns copy-marker window-fringes put-text-property font-lock-face (:inverse-video t) gdb-update-gud-running gdb-emit-signal update-disassembly gdb-thread-buffer-locations gdb-thread-buffer-addresses gdb-thread-number gdb-buf-publisher] 21])
#@277 Define a NAME command which will act upon thread on the current line.

CUSTOM-DEFUN may use locally bound `thread' variable, which will
be the value of `gdb-thread' property of the current line.
If `gdb-thread' is nil, error is signaled.

(fn NAME CUSTOM-DEFUN &optional DOC)
(defalias 'def-gdb-thread-buffer-command '(macro . #[770 "\300\301\205�\302\303\304\305\306\307\310\311
\312BBBEE\257\207" [defun (&optional event) (interactive (list last-input-event)) (if event (posn-set-point (event-end event))) save-excursion (beginning-of-line) let ((thread (get-text-property (point) 'gdb-thread))) if thread ((error "Not recognized as thread line"))] 17 (#$ . 119812)]))
#@125 Define a NAME which will call BUFFER-COMMAND with id of thread
on the current line.

(fn NAME BUFFER-COMMAND &optional DOC)
(defalias 'def-gdb-thread-buffer-simple-command '(macro . #[770 "\300\301BF\207" [def-gdb-thread-buffer-command ((bindat-get-field thread 'id))] 7 (#$ . 120496)]))
#@76 Select the thread at current line of threads buffer.

(fn &optional EVENT)
(defalias 'gdb-select-thread #[256 "\211\203\n�\300\301!!\210\212\302 \210\303`\304\"\211\203,�\305\306\"\307!\210\310\311P\312\"\210\313 \262\202/�\314\315!\262)\207" [posn-set-point event-end beginning-of-line get-text-property gdb-thread bindat-get-field id gdb-setq-thread-number gdb-input "-thread-select " ignore gdb-update error "Not recognized as thread line"] 6 (#$ . 120793) (list last-input-event)])
#@76 Display stack buffer for the thread at current line.

(fn &optional EVENT)
(defalias 'gdb-display-stack-for-thread #[256 "\211\203\n�\300\301!!\210\212\302 \210\303`\304\"\211\203�\305\306\307\"!\202\"�\310\311!\262)\207" [posn-set-point event-end beginning-of-line get-text-property gdb-thread gdb-preemptively-display-stack-buffer bindat-get-field id error "Not recognized as thread line"] 6 (#$ . 121291) (list last-input-event)])
#@77 Display locals buffer for the thread at current line.

(fn &optional EVENT)
(defalias 'gdb-display-locals-for-thread #[256 "\211\203\n�\300\301!!\210\212\302 \210\303`\304\"\211\203�\305\306\307\"!\202\"�\310\311!\262)\207" [posn-set-point event-end beginning-of-line get-text-property gdb-thread gdb-preemptively-display-locals-buffer bindat-get-field id error "Not recognized as thread line"] 6 (#$ . 121735) (list last-input-event)])
#@80 Display registers buffer for the thread at current line.

(fn &optional EVENT)
(defalias 'gdb-display-registers-for-thread #[256 "\211\203\n�\300\301!!\210\212\302 \210\303`\304\"\211\203�\305\306\307\"!\202\"�\310\311!\262)\207" [posn-set-point event-end beginning-of-line get-text-property gdb-thread gdb-preemptively-display-registers-buffer bindat-get-field id error "Not recognized as thread line"] 6 (#$ . 122182) (list last-input-event)])
#@82 Display disassembly buffer for the thread at current line.

(fn &optional EVENT)
(defalias 'gdb-display-disassembly-for-thread #[256 "\211\203\n�\300\301!!\210\212\302 \210\303`\304\"\211\203�\305\306\307\"!\202\"�\310\311!\262)\207" [posn-set-point event-end beginning-of-line get-text-property gdb-thread gdb-preemptively-display-disassembly-buffer bindat-get-field id error "Not recognized as thread line"] 6 (#$ . 122638) (list last-input-event)])
#@91 Display another frame with stack buffer for thread at current line.

(fn &optional EVENT)
(defalias 'gdb-frame-stack-for-thread #[256 "\211\203\n�\300\301!!\210\212\302 \210\303`\304\"\211\203�\305\306\307\"!\202\"�\310\311!\262)\207" [posn-set-point event-end beginning-of-line get-text-property gdb-thread gdb-frame-stack-buffer bindat-get-field id error "Not recognized as thread line"] 6 (#$ . 123100) (list last-input-event)])
#@92 Display another frame with locals buffer for thread at current line.

(fn &optional EVENT)
(defalias 'gdb-frame-locals-for-thread #[256 "\211\203\n�\300\301!!\210\212\302 \210\303`\304\"\211\203�\305\306\307\"!\202\"�\310\311!\262)\207" [posn-set-point event-end beginning-of-line get-text-property gdb-thread gdb-frame-locals-buffer bindat-get-field id error "Not recognized as thread line"] 6 (#$ . 123542) (list last-input-event)])
#@99 Display another frame with registers buffer for the thread at current line.

(fn &optional EVENT)
(defalias 'gdb-frame-registers-for-thread #[256 "\211\203\n�\300\301!!\210\212\302 \210\303`\304\"\211\203�\305\306\307\"!\202\"�\310\311!\262)\207" [posn-set-point event-end beginning-of-line get-text-property gdb-thread gdb-frame-registers-buffer bindat-get-field id error "Not recognized as thread line"] 6 (#$ . 123987) (list last-input-event)])
#@101 Display another frame with disassembly buffer for the thread at current line.

(fn &optional EVENT)
(defalias 'gdb-frame-disassembly-for-thread #[256 "\211\203\n�\300\301!!\210\212\302 \210\303`\304\"\211\203�\305\306\307\"!\202\"�\310\311!\262)\207" [posn-set-point event-end beginning-of-line get-text-property gdb-thread gdb-frame-disassembly-buffer bindat-get-field id error "Not recognized as thread line"] 6 (#$ . 124446) (list last-input-event)])
#@159 Define a NAME which will execute GUD-COMMAND with
`gdb-thread-number' locally bound to id of thread on the current
line.

(fn NAME GUD-COMMAND &optional DOC)
(defalias 'def-gdb-thread-buffer-gud-command '(macro . #[770 "\300\301\302\303\304\305\306	DDE\307BBBF\207" [def-gdb-thread-buffer-command if gdb-non-stop let ((gdb-thread-number (bindat-get-field thread 'id)) (gdb-gud-control-all-threads nil)) call-interactively function ((error "Available in non-stop mode only, customize `gdb-non-stop-setting'"))] 12 (#$ . 124911)]))
#@57 Interrupt thread at current line.

(fn &optional EVENT)
(defalias 'gdb-interrupt-thread #[256 "\211\203\n�\303\304!!\210\212\305 \210\306`\307\"\211\203.�\203(�\310\311\"\312\313\314!*\2021�\315\316!\2021�\315\317!\262)\207" [gdb-non-stop gdb-gud-control-all-threads gdb-thread-number posn-set-point event-end beginning-of-line get-text-property gdb-thread bindat-get-field id nil call-interactively gud-stop-subjob error "Available in non-stop mode only, customize `gdb-non-stop-setting'" "Not recognized as thread line"] 5 (#$ . 125450) (list last-input-event)])
#@56 Continue thread at current line.

(fn &optional EVENT)
(defalias 'gdb-continue-thread #[256 "\211\203\n�\303\304!!\210\212\305 \210\306`\307\"\211\203.�\203(�\310\311\"\312\313\314!*\2021�\315\316!\2021�\315\317!\262)\207" [gdb-non-stop gdb-gud-control-all-threads gdb-thread-number posn-set-point event-end beginning-of-line get-text-property gdb-thread bindat-get-field id nil call-interactively gud-cont error "Available in non-stop mode only, customize `gdb-non-stop-setting'" "Not recognized as thread line"] 5 (#$ . 126027) (list last-input-event)])
#@52 Step thread at current line.

(fn &optional EVENT)
(defalias 'gdb-step-thread #[256 "\211\203\n�\303\304!!\210\212\305 \210\306`\307\"\211\203.�\203(�\310\311\"\312\313\314!*\2021�\315\316!\2021�\315\317!\262)\207" [gdb-non-stop gdb-gud-control-all-threads gdb-thread-number posn-set-point event-end beginning-of-line get-text-property gdb-thread bindat-get-field id nil call-interactively gud-step error "Available in non-stop mode only, customize `gdb-non-stop-setting'" "Not recognized as thread line"] 5 (#$ . 126595) (list last-input-event)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313&	\210\300\314\302\303\315DD\316\306\307\310\311\312\313&	\210\300\317\302\303\320DD\321\306\322\310\311\312\323&	\210\300\324\302\303\325DD\326\306\327\310\311\312\313&	\207" [custom-declare-variable gdb-memory-rows funcall function #[0 "\300\207" [8] 1] "Number of data rows in memory window." :type integer :group gud :version "23.2" gdb-memory-columns #[0 "\300\207" [4] 1] "Number of data columns in memory window." gdb-memory-format #[0 "\300\207" [#1="x"] 1 #1#] "Display format of data items in memory window." (choice (const :tag "Hexadecimal" "x") (const :tag "Signed decimal" "d") (const :tag "Unsigned decimal" "u") (const :tag "Octal" "o") (const :tag "Binary" "t")) "22.1" gdb-memory-unit #[0 "\300\207" [4] 1] "Unit size of data items in memory window." (choice (const :tag "Byte" 1) (const :tag "Halfword" 2) (const :tag "Word" 4) (const :tag "Giant word" 8))] 10)
#@25

(fn &optional SIGNAL)
(defalias 'gdb-invalidate-memory #[256 "\211\305>\205�\306\307\310	\n\f&\311\312p\"p\313B#\207" [gdb-memory-address gdb-memory-format gdb-memory-unit gdb-memory-rows gdb-memory-columns (start update) gdb-input format "-data-read-memory %s %s %d %d %d" gdb-bind-function-to-buffer gdb-read-memory-handler gdb-invalidate-memory] 9 (#$ . 128098)])
(defalias 'gdb-read-memory-handler #[0 "\301\302p\303\"\304!\305!\306 \210\307 \210\310 \210\311\"\210\312\")\207" [inhibit-read-only t get-buffer-window 0 window-start window-point erase-buffer gdb-read-memory-custom gdb-update-buffer-name set-window-start set-window-point] 6])
(gdb-set-buffer-rules 'gdb-memory-buffer 'gdb-memory-buffer-name 'gdb-memory-mode 'gdb-invalidate-memory)
#@170 Return length of string with memory unit of SIZE in FORMAT.

SIZE is in bytes, as in `gdb-memory-unit'.  FORMAT is a string as
in `gdb-memory-format'.

(fn SIZE FORMAT)
(defalias 'gdb-memory-column-width #[514 "\300\301\"A\211\2038�\302\303\304\305\306_\"\"!\307\230\203!�\310\\\2023�\311\230\204-�\312\230\2032�\211T\2023�\211\262\202;�\313\314!\207" [assoc (("x" . 16) ("d" . 10) ("u" . 10) ("o" . 8) ("t" . 2)) ceiling log expt 2.0 8 "x" 2 "d" "o" error "Unknown format"] 9 (#$ . 128871)])
(defalias 'gdb-read-memory-custom #[0 "\306 \307\310\"\211\204\\�\307\311\"\307\312\"\307\313\"\307\314\"\211\211\205U�\211@\307\312\"\315Pc\210\307\316\"\211\203J�\211@\317\320\321\f
\"\\\"c\210A\266\202\2022�\210\322 \210A\266\202\202 �\262\262\202f�\323\324!\210\325!)\207" [gdb-memory-address gdb-memory-next-page gdb-memory-prev-page gdb-memory-last-address gdb-memory-unit gdb-memory-format gdb-json-partial-output bindat-get-field msg memory addr next-page prev-page ":" data gdb-pad-string 2 gdb-memory-column-width newline gdb-invalidate-memory update error] 13])
(defvar gdb-memory-mode-map (byte-code "\300 \301\302\"\210\303\304\305#\210\303\306\307#\210\303\310\311#\210\303\312\313#\210\303\314\315#\210\303\316\317#\210\303\320\321#\210\303\322\323#\210\303\324\325#\210\303\326\327#\210\303\330\331#\210\303\332\333#\210\303\334\335#\210\303\336\337#\210\303\340\341#\210\211\207" [make-sparse-keymap suppress-keymap t define-key "q" kill-current-buffer "n" gdb-memory-show-next-page "p" gdb-memory-show-previous-page "a" gdb-memory-set-address "t" gdb-memory-format-binary "o" gdb-memory-format-octal "u" gdb-memory-format-unsigned "d" gdb-memory-format-signed "x" gdb-memory-format-hexadecimal "b" gdb-memory-unit-byte "h" gdb-memory-unit-halfword "w" gdb-memory-unit-word "g" gdb-memory-unit-giant "R" gdb-memory-set-rows "C" gdb-memory-set-columns] 5))
#@70 Handle a click on address field in memory buffer header.

(fn EVENT)
(defalias 'gdb-memory-set-address-event #[257 "\300 r\301\302\303\304\305!\306\"\307$\216\310\311!\211@\262!\210\312 *\207" [internal--before-save-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-save-selected-window] 2 select-window event-start gdb-memory-set-address] 8 (#$ . 130788) "e"])
#@31 Set the start memory address.
(defalias 'gdb-memory-set-address #[0 "\301\302!\303\304!\207" [gdb-memory-address read-from-minibuffer "Memory address: " gdb-invalidate-memory update] 2 (#$ . 131190) nil])
#@113 Define a function NAME which reads new VAR value from minibuffer.

(fn NAME VARIABLE ECHO-STRING &optional DOC)
(defalias 'def-gdb-set-positive-number '(macro . #[1027 "\300\301\205�\302\303\304\305\306\307DD\310B\311\312\313\314\315D\316BB\317BBBBEE\257\207" [defun (event) (interactive "e") save-selected-window (select-window (posn-window (event-start event))) let* arg read-from-minibuffer ((count (string-to-number arg))) if (<= count 0) (error "Positive number only") customize-set-variable quote (count) ((gdb-invalidate-memory 'update))] 19 (#$ . 131403)]))
#@59 Set the number of data rows in memory window.

(fn EVENT)
(defalias 'gdb-memory-set-rows #[257 "\300 r\301\302\303\304\305!\306\"\307$\216\310\311!\211@\262!\210\312\313!\314!\211\302X\203+�\315\316!\2023�\317\320\"\210\321\322!\266\202*\207" [internal--before-save-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-save-selected-window] 2 select-window event-start read-from-minibuffer "Rows: " string-to-number error "Positive number only" customize-set-variable gdb-memory-rows gdb-invalidate-memory update] 8 (#$ . 131984) "e"])
#@62 Set the number of data columns in memory window.

(fn EVENT)
(defalias 'gdb-memory-set-columns #[257 "\300 r\301\302\303\304\305!\306\"\307$\216\310\311!\211@\262!\210\312\313!\314!\211\302X\203+�\315\316!\2023�\317\320\"\210\321\322!\266\202*\207" [internal--before-save-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-save-selected-window] 2 select-window event-start read-from-minibuffer "Columns: " string-to-number error "Positive number only" customize-set-variable gdb-memory-columns gdb-invalidate-memory update] 8 (#$ . 132559) "e"])
#@127 Define a function NAME to switch memory buffer to use FORMAT.

DOC is an optional documentation string.

(fn NAME FORMAT DOC)
(defalias 'def-gdb-memory-format '(macro . #[771 "\300\301\205�\302\303\304E\305BBBBBB\207" [defun nil (interactive) customize-set-variable 'gdb-memory-format ((gdb-invalidate-memory 'update))] 11 (#$ . 133147)]))
#@35 Set the display format to binary.
(defalias 'gdb-memory-format-binary #[0 "\300\301\302\"\210\303\304!\207" [customize-set-variable gdb-memory-format "t" gdb-invalidate-memory update] 3 (#$ . 133499) nil])
#@34 Set the display format to octal.
(defalias 'gdb-memory-format-octal #[0 "\300\301\302\"\210\303\304!\207" [customize-set-variable gdb-memory-format "o" gdb-invalidate-memory update] 3 (#$ . 133711) nil])
#@45 Set the display format to unsigned decimal.
(defalias 'gdb-memory-format-unsigned #[0 "\300\301\302\"\210\303\304!\207" [customize-set-variable gdb-memory-format "u" gdb-invalidate-memory update] 3 (#$ . 133921) nil])
#@36 Set the display format to decimal.
(defalias 'gdb-memory-format-signed #[0 "\300\301\302\"\210\303\304!\207" [customize-set-variable gdb-memory-format "d" gdb-invalidate-memory update] 3 (#$ . 134145) nil])
#@40 Set the display format to hexadecimal.
(defalias 'gdb-memory-format-hexadecimal #[0 "\300\301\302\"\210\303\304!\207" [customize-set-variable gdb-memory-format "x" gdb-invalidate-memory update] 3 (#$ . 134358) nil])
#@45 Keymap to select format in the header line.
(defvar gdb-memory-format-map (byte-code "\300 \301\302\303#\210\211\207" [make-sparse-keymap define-key [header-line down-mouse-3] gdb-memory-format-menu-1] 5) (#$ . 134580))
#@45 Menu of display formats in the header line.
(defvar gdb-memory-format-menu (byte-code "\300\301!\302\303\304#\210\302\305\306#\210\302\307\310#\210\302\311\312#\210\302\313\314#\210\211\207" [make-sparse-keymap "Format" define-key [binary] (menu-item "Binary" gdb-memory-format-binary :button (:radio equal gdb-memory-format "t")) [octal] (menu-item "Octal" gdb-memory-format-octal :button (:radio equal gdb-memory-format "o")) [unsigned] (menu-item "Unsigned Decimal" gdb-memory-format-unsigned :button (:radio equal gdb-memory-format "u")) [signed] (menu-item "Signed Decimal" gdb-memory-format-signed :button (:radio equal gdb-memory-format "d")) [hexadecimal] (menu-item "Hexadecimal" gdb-memory-format-hexadecimal :button (:radio equal gdb-memory-format "x"))] 5) (#$ . 134807))
#@14

(fn EVENT)
(defalias 'gdb-memory-format-menu #[257 "\301\"\207" [gdb-memory-format-menu x-popup-menu] 4 (#$ . 135602) "@e"])
#@14

(fn EVENT)
(defalias 'gdb-memory-format-menu-1 #[257 "\301 r\302\303\304\305\306!\307\"\310$\216\311\312!\211@\262!\210\300!\211\205'�\313\306@!\"\211\205.�\314!\266\202*\207" [gdb-memory-format-menu internal--before-save-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-save-selected-window] 2 select-window event-start lookup-key call-interactively] 8 (#$ . 135737) "e"])
#@132 Define a function NAME to switch memory unit size to UNIT-SIZE.

DOC is an optional documentation string.

(fn NAME UNIT-SIZE DOC)
(defalias 'def-gdb-memory-unit '(macro . #[771 "\300\301\205�\302\303\304E\305BBBBBB\207" [defun nil (interactive) customize-set-variable 'gdb-memory-unit ((gdb-invalidate-memory 'update))] 11 (#$ . 136159)]))
#@49 Set the unit size to giant words (eight bytes).
(defalias 'gdb-memory-unit-giant #[0 "\300\301\302\"\210\303\304!\207" [customize-set-variable gdb-memory-unit 8 gdb-invalidate-memory update] 3 (#$ . 136512) nil])
#@42 Set the unit size to words (four bytes).
(defalias 'gdb-memory-unit-word #[0 "\300\301\302\"\210\303\304!\207" [customize-set-variable gdb-memory-unit 4 gdb-invalidate-memory update] 3 (#$ . 136731) nil])
#@45 Set the unit size to halfwords (two bytes).
(defalias 'gdb-memory-unit-halfword #[0 "\300\301\302\"\210\303\304!\207" [customize-set-variable gdb-memory-unit 2 gdb-invalidate-memory update] 3 (#$ . 136942) nil])
#@29 Set the unit size to bytes.
(defalias 'gdb-memory-unit-byte #[0 "\300\301\302\"\210\303\304!\207" [customize-set-variable gdb-memory-unit 1 gdb-invalidate-memory update] 3 (#$ . 137160) nil])
#@237 Define a function NAME which show new address in memory buffer.

The defined function switches Memory buffer to show address
stored in ADDRESS-VAR variable.

DOC is an optional documentation string.

(fn NAME ADDRESS-VAR &optional DOC)
(defalias 'def-gdb-memory-show-page '(macro . #[770 "\300\205�\301\302\303DC\304BB\257\207" [defun (interactive) let gdb-memory-address ((gdb-invalidate-memory))] 10 (#$ . 137359)]))
(defalias 'gdb-memory-show-previous-page #[0 "\302 )\207" [gdb-memory-prev-page gdb-memory-address gdb-invalidate-memory] 1 nil nil])
(defalias 'gdb-memory-show-next-page #[0 "\302 )\207" [gdb-memory-next-page gdb-memory-address gdb-invalidate-memory] 1 nil nil])
#@44 Keymap to select units in the header line.
(defvar gdb-memory-unit-map (byte-code "\300 \301\302\303#\210\211\207" [make-sparse-keymap define-key [header-line down-mouse-3] gdb-memory-unit-menu-1] 5) (#$ . 138059))
#@35 Menu of units in the header line.
(defvar gdb-memory-unit-menu (byte-code "\300\301!\302\303\304#\210\302\305\306#\210\302\307\310#\210\302\311\312#\210\211\207" [make-sparse-keymap "Unit" define-key [giantwords] (menu-item "Giant words" gdb-memory-unit-giant :button (:radio equal gdb-memory-unit 8)) [words] (menu-item "Words" gdb-memory-unit-word :button (:radio equal gdb-memory-unit 4)) [halfwords] (menu-item "Halfwords" gdb-memory-unit-halfword :button (:radio equal gdb-memory-unit 2)) [bytes] (menu-item "Bytes" gdb-memory-unit-byte :button (:radio equal gdb-memory-unit 1))] 5) (#$ . 138281))
#@14

(fn EVENT)
(defalias 'gdb-memory-unit-menu #[257 "\301\"\207" [gdb-memory-unit-menu x-popup-menu] 4 (#$ . 138894) "@e"])
#@14

(fn EVENT)
(defalias 'gdb-memory-unit-menu-1 #[257 "\301 r\302\303\304\305\306!\307\"\310$\216\311\312!\211@\262!\210\300!\211\205'�\313\306@!\"\211\205.�\314!\266\202*\207" [gdb-memory-unit-menu internal--before-save-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-save-selected-window] 2 select-window event-start lookup-key call-interactively] 8 (#$ . 139025) "e"])
#@47 Font lock keywords used in `gdb-memory-mode'.
(defvar gdb-memory-font-lock-keywords '(("<\$\\(\\sw\\|[_.]\$+\\)\$\\+[0-9]+\$?>" (1 font-lock-function-name-face))) (#$ . 139442))
#@40 Header line used in `gdb-memory-mode'.
(defvar gdb-memory-header '(:eval (concat "Start address[" (propertize "-" 'face font-lock-warning-face 'help-echo "mouse-1: decrement address" 'mouse-face 'mode-line-highlight 'local-map (gdb-make-header-line-mouse-map 'mouse-1 #'gdb-memory-show-previous-page)) "|" (propertize "+" 'face font-lock-warning-face 'help-echo "mouse-1: increment address" 'mouse-face 'mode-line-highlight 'local-map (gdb-make-header-line-mouse-map 'mouse-1 #'gdb-memory-show-next-page)) "]: " (propertize gdb-memory-address 'face font-lock-warning-face 'help-echo "mouse-1: set start address" 'mouse-face 'mode-line-highlight 'local-map (gdb-make-header-line-mouse-map 'mouse-1 #'gdb-memory-set-address-event)) "  Rows: " (propertize (number-to-string gdb-memory-rows) 'face font-lock-warning-face 'help-echo "mouse-1: set number of columns" 'mouse-face 'mode-line-highlight 'local-map (gdb-make-header-line-mouse-map 'mouse-1 #'gdb-memory-set-rows)) "  Columns: " (propertize (number-to-string gdb-memory-columns) 'face font-lock-warning-face 'help-echo "mouse-1: set number of columns" 'mouse-face 'mode-line-highlight 'local-map (gdb-make-header-line-mouse-map 'mouse-1 #'gdb-memory-set-columns)) "  Display Format: " (propertize gdb-memory-format 'face font-lock-warning-face 'help-echo "mouse-3: select display format" 'mouse-face 'mode-line-highlight 'local-map gdb-memory-format-map) "  Unit Size: " (propertize (number-to-string gdb-memory-unit) 'face font-lock-warning-face 'help-echo "mouse-3: select unit size" 'mouse-face 'mode-line-highlight 'local-map gdb-memory-unit-map))) (#$ . 139630))
(defvar gdb-memory-mode-hook nil)
(byte-code "\300\301N\204\f�\302\300\301\303#\210\304\305!\204�\302\305\306\307#\210\300\207" [gdb-memory-mode-hook variable-documentation put "Hook run after entering Memory mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp gdb-memory-mode-map definition-name gdb-memory-mode] 4)
(defvar gdb-memory-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\322#\207" [gdb-memory-mode-abbrev-table gdb-memory-mode-map variable-documentation put purecopy "Keymap for `gdb-memory-mode'." boundp gdb-memory-mode-syntax-table definition-name gdb-memory-mode (lambda (#1=#:def-tmp-var) (defvar gdb-memory-mode-syntax-table #1#)) make-syntax-table "Syntax table for `gdb-memory-mode'." (lambda (#1#) (defvar gdb-memory-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `gdb-memory-mode'." derived-mode-parent gdb-parent-mode] 5)
#@238 Major mode for examining memory.

In addition to any hooks its parent mode `gdb-parent-mode' might have run,
this mode runs the hook `gdb-memory-mode-hook', as the final or penultimate step
during initialization.

\{gdb-memory-mode-map}
(defalias 'gdb-memory-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
\306\331!\210\332)\333\334!\207" [delay-mode-hooks major-mode mode-name gdb-memory-mode-map gdb-memory-mode-syntax-table gdb-memory-mode-abbrev-table make-local-variable t gdb-parent-mode gdb-memory-mode "Memory" 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 font-lock-defaults (gdb-memory-font-lock-keywords) run-mode-hooks gdb-memory-mode-hook local-abbrev-table gdb-memory-header header-line-format] 5 (#$ . 142460) nil])
(defalias 'gdb-memory-buffer-name #[0 "\300\301 \302Q\207" ["*memory of " gdb-get-target-string "*"] 3])
#@53 Display GDB memory contents.

(fn &optional THREAD)
(defalias 'gdb-display-memory-buffer #[256 "\300\301\302\"!\207" [gdb-display-buffer gdb-get-buffer-create gdb-memory-buffer] 5 (#$ . 143667) nil])
#@43 Display memory contents in another frame.
(defalias 'gdb-frame-memory-buffer #[0 "\301\302\303!\"\207" [gdb-display-buffer-other-frame-action display-buffer gdb-get-buffer-create gdb-memory-buffer] 3 (#$ . 143874) nil])
(defalias 'gdb-disassembly-buffer-name #[0 "\300\301\302 P!\207" [gdb-current-context-buffer-name "disassembly of " gdb-get-target-string] 3])
#@61 Display GDB disassembly information.

(fn &optional THREAD)
(defalias 'gdb-display-disassembly-buffer #[256 "\300\301\302\"!\207" [gdb-display-buffer gdb-get-buffer-create gdb-disassembly-buffer] 5 (#$ . 144244) nil])
#@25

(fn &optional THREAD)
(defalias 'gdb-preemptively-display-disassembly-buffer #[256 "\300\301\"\210\302\303\304\"\305\"\207" [message "%s" gdb-preempt-existing-or-display-buffer gdb-get-buffer-create gdb-disassembly-buffer nil] 5 (#$ . 144469)])
#@78 Display GDB disassembly information in another frame.

(fn &optional THREAD)
(defalias 'gdb-frame-disassembly-buffer #[256 "\301\302\303\"\"\207" [gdb-display-buffer-other-frame-action display-buffer gdb-get-buffer-create gdb-disassembly-buffer] 5 (#$ . 144724) nil])
#@25

(fn &optional SIGNAL)
(defalias 'gdb-invalidate-disassembly #[256 "\211\300>\205(�\301\302 \303\304\"\303\305\"\203�\306\307#\202�\310\266\203\311\312p\"p\313B#\207" [(start update-disassembly) gdb-input gdb-current-buffer-frame bindat-get-field fullname line format "-data-disassemble -f %s -l %s -n -1 -- 0" "-data-disassemble -s $pc -e \"$pc + 150\" -- 0" gdb-bind-function-to-buffer gdb-disassembly-handler gdb-invalidate-disassembly] 9 (#$ . 145000)])
(defalias 'gdb-disassembly-handler #[0 "\301\302 \210\303 \210\304 )\207" [inhibit-read-only t erase-buffer gdb-disassembly-handler-custom gdb-update-buffer-name] 1])
(gdb-set-buffer-rules 'gdb-disassembly-buffer 'gdb-disassembly-buffer-name 'gdb-disassembly-mode 'gdb-invalidate-disassembly)
#@52 Font lock keywords used in `gdb-disassembly-mode'.
(defvar gdb-disassembly-font-lock-keywords '(("<\$\\(\\sw\\|[_.]\$+\\)\$\\+[0-9]+\$?>" (1 font-lock-function-name-face)) ("^0x[0-9a-f]+ \$<\\(\\(\\sw\\|[_.]\$+\\)\\+[0-9]+>\\)?:[ 	]+\$\\sw+\$" (4 font-lock-keyword-face)) ("%\\sw+" . font-lock-variable-name-face) ("^\$Dump of assembler code for function\$ \$.+\$:" (1 font-lock-comment-face) (2 font-lock-function-name-face)) ("^\$End of assembler dump\\.\$" . font-lock-comment-face)) (#$ . 145766))
(defvar gdb-disassembly-mode-map (byte-code "\300 \301!\210\302\303\304#\210\211\207" [make-sparse-keymap suppress-keymap define-key "q" kill-current-buffer] 5))
(defvar gdb-disassembly-mode-hook nil)
(byte-code "\300\301N\204\f�\302\300\301\303#\210\304\305!\204�\302\305\306\307#\210\300\207" [gdb-disassembly-mode-hook variable-documentation put "Hook run after entering Disassembly mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp gdb-disassembly-mode-map definition-name gdb-disassembly-mode] 4)
(defvar gdb-disassembly-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\322#\207" [gdb-disassembly-mode-abbrev-table gdb-disassembly-mode-map variable-documentation put purecopy "Keymap for `gdb-disassembly-mode'." boundp gdb-disassembly-mode-syntax-table definition-name gdb-disassembly-mode (lambda (#1=#:def-tmp-var) (defvar gdb-disassembly-mode-syntax-table #1#)) make-syntax-table "Syntax table for `gdb-disassembly-mode'." (lambda (#1#) (defvar gdb-disassembly-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `gdb-disassembly-mode'." derived-mode-parent gdb-parent-mode] 5)
#@259 Major mode for GDB disassembly information.

In addition to any hooks its parent mode `gdb-parent-mode' might have run,
this mode runs the hook `gdb-disassembly-mode-hook', as the final or penultimate step
during initialization.

\{gdb-disassembly-mode-map}
(defalias 'gdb-disassembly-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
\325!C#\210\327!\210\330\f!\210
!\331\332\333\"\210\307\"\306\333!\210\334 \306\335!\210\336)\337\340!\207" [delay-mode-hooks major-mode mode-name gdb-disassembly-mode-map gdb-disassembly-mode-syntax-table gdb-disassembly-mode-abbrev-table make-local-variable t gdb-parent-mode gdb-disassembly-mode "Disassembly" 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 add-to-list overlay-arrow-variable-list gdb-disassembly-position make-marker font-lock-defaults (gdb-disassembly-font-lock-keywords) run-mode-hooks gdb-disassembly-mode-hook local-abbrev-table fringes-outside-margins] 5 (#$ . 147728) nil])
(defalias 'gdb-disassembly-handler-custom #[0 "\305\306 \307\"\305\310 \311\"\312\313\314\211\211\211%\314\211\203l�\211@\315\305\316\"\305\317\"\305\320\"\2033�\321\322#\2024�\323\266\202\305\324\"E\"\210\305\316\"\230\203e�\325!>\204V�\326\327\313D\"\210\330HG\262	\331\230?\205d�\332A\266\202\202�\210\333\334\"c\210\335 \210\211\203\245�\336p\337\"\340\212\341!\211@A\342!\314\223\210\343 @\337V\204\236�\344\345\346$\210\266\203)\"\266\347\350\305\310 \351\"P!\211\207" [cl-struct-gdb-table-tags gdb-frame-number fringe-indicator-alist gdb-disassembly-position mode-name bindat-get-field gdb-json-partial-output asm_insns gdb-current-buffer-frame addr record gdb-table nil gdb-table-add-row address func-name offset format "<%s+%s>:" "" inst type-of signal wrong-type-argument 2 "0" ((overlay-arrow . hollow-right-triangle)) gdb-table-string " " gdb-disassembly-place-breakpoints get-buffer-window 0 set-window-point gdb-line-posns copy-marker window-fringes put-text-property font-lock-face (:inverse-video t) gdb-current-context-mode-name "Disassembly: " func] 15])
(defalias 'gdb-disassembly-place-breakpoints #[0 "\301ed\"\210\211\2059�\211@\211A\302\303\"\302\304\"\302\305\"\212eb\210\306\307P\310\311#\203/�\312\313\230\"\210)\266A\266\202\202�\207" [gdb-breakpoints-list gdb-remove-breakpoint-icons bindat-get-field number enabled addr re-search-forward "^" nil t gdb-put-breakpoint-icon "y"] 10])
(defvar gdb-breakpoints-header (byte-code "\300\301\302\303\304\303\305\306\307\310\311\312\"&	\313\300\314\302\315\304\316\305\317\307\310\311\320\"&	E\207" [propertize "Breakpoints" help-echo nil mouse-face face mode-line local-map gdb-make-header-line-mouse-map mouse-1 #[257 "\300 r\301\302\303\304\305!\306\"\307$\216\310\311!\211@\262!\210\312\313\314!\315\"*\207" [internal--before-save-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-save-selected-window] 2 select-window event-start gdb-set-window-buffer gdb-get-buffer-create gdb-breakpoints-buffer t] 8 "\n\n(fn EVENT)" #1="e"] " " "Threads" "mouse-1: select" mode-line-highlight mode-line-inactive #[257 "\300 r\301\302\303\304\305!\306\"\307$\216\310\311!\211@\262!\210\312\313\314!\315\"*\207" [internal--before-save-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-save-selected-window] 2 select-window event-start gdb-set-window-buffer gdb-get-buffer-create gdb-threads-buffer t] 8 "\n\n(fn EVENT)" #1#]] 14))
(defvar gdb-breakpoints-mode-hook nil)
(byte-code "\300\301N\204\f�\302\300\301\303#\210\304\305!\204�\302\305\306\307#\210\300\207" [gdb-breakpoints-mode-hook variable-documentation put "Hook run after entering Breakpoints mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp gdb-breakpoints-mode-map definition-name gdb-breakpoints-mode] 4)
(defvar gdb-breakpoints-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\322#\207" [gdb-breakpoints-mode-abbrev-table gdb-breakpoints-mode-map variable-documentation put purecopy "Keymap for `gdb-breakpoints-mode'." boundp gdb-breakpoints-mode-syntax-table definition-name gdb-breakpoints-mode (lambda (#1=#:def-tmp-var) (defvar gdb-breakpoints-mode-syntax-table #1#)) make-syntax-table "Syntax table for `gdb-breakpoints-mode'." (lambda (#1#) (defvar gdb-breakpoints-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `gdb-breakpoints-mode'." derived-mode-parent gdb-parent-mode] 5)
#@247 Major mode for gdb breakpoints.

In addition to any hooks its parent mode `gdb-parent-mode' might have run,
this mode runs the hook `gdb-breakpoints-mode-hook', as the final or penultimate step
during initialization.

\{gdb-breakpoints-mode-map}
(defalias 'gdb-breakpoints-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 gdb-breakpoints-mode-map gdb-breakpoints-mode-syntax-table gdb-breakpoints-mode-abbrev-table make-local-variable t gdb-parent-mode gdb-breakpoints-mode "Breakpoints" 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 gdb-breakpoints-mode-hook local-abbrev-table gdb-breakpoints-header header-line-format] 5 (#$ . 152771) nil])
#@66 Enable/disable breakpoint at current line of breakpoints buffer.
(defalias 'gdb-toggle-breakpoint #[0 "\212\300 \210\301`\302\"\211\203$�\303\304\305\"\306\232\203�\307\202�\310\304\311\"P!\202'�\312\313!\262)\207" [beginning-of-line get-text-property gdb-breakpoint gud-basic-call bindat-get-field enabled "y" "-break-disable " "-break-enable " number error "Not recognized as break/watchpoint line"] 6 (#$ . 153852) nil])
#@62 Delete the breakpoint at current line of breakpoints buffer.
(defalias 'gdb-delete-breakpoint #[0 "\212\300 \210\301`\302\"\211\203�\303\304\305\306\"P!\202�\307\310!\262)\207" [beginning-of-line get-text-property gdb-breakpoint gud-basic-call "-break-delete " bindat-get-field number error "Not recognized as break/watchpoint line"] 6 (#$ . 154287) nil])
#@95 Go to the location of breakpoint at current line of breakpoints buffer.

(fn &optional EVENT)
(defalias 'gdb-goto-breakpoint #[256 "\211\203\n�\303\304!!\210\305!\211\203&�\306 r\307\310\311\312\313!\314\"\315$\216\316!\210*\210\210\212\317 \210\320`\321\"\211\203\206�\322\323\"\322\324\"\322\325\"\306 r\307\310\311\312\313!\326\"\315$\216\327\330!\203Y�\202^�\331	\"A!\332!\206h�\333!\211rq\210eb\210\334!Sy\210\335`\")\266\202*\262\266\203\202\211�\336\337!\262)\207" [gud-comint-buffer gdb-location-alist gdb-source-window posn-set-point event-end get-buffer-window internal--before-save-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-save-selected-window] 2 select-window beginning-of-line get-text-property gdb-breakpoint bindat-get-field number fullname line [internal--after-save-selected-window] find-file-noselect file-exists-p assoc gdb-display-source-buffer display-buffer string-to-number set-window-point error "Not recognized as break/watchpoint line"] 12 (#$ . 154653) (list last-input-event)])
#@25

(fn &optional SIGNAL)
(defalias 'gdb-invalidate-frames #[256 "\211\300>\205�\301\302\303!\304\305p\"p\306B#\207" [(start update) gdb-input gdb-current-context-command "-stack-list-frames" gdb-bind-function-to-buffer gdb-stack-list-frames-handler gdb-invalidate-frames] 6 (#$ . 155724)])
(defalias 'gdb-stack-list-frames-handler #[0 "\301\302p\303\"\304!\305!\306 \210\307 \210\310 \210\311\"\210\312\")\207" [inhibit-read-only t get-buffer-window 0 window-start window-point erase-buffer gdb-stack-list-frames-custom gdb-update-buffer-name set-window-start set-window-point] 6])
(gdb-set-buffer-rules 'gdb-stack-buffer 'gdb-stack-buffer-name 'gdb-frames-mode 'gdb-invalidate-frames)
#@142 Return " of file:line" or " of library" for structure FRAME.

FRAME must have either "file" and "line" members or "from"
member.

(fn FRAME)
(defalias 'gdb-frame-location #[257 "\300\301\"\300\302\"\300\303\"\203�\203�\304Q\206�\211\211\203&�\305P\202'�\306\262\207" [bindat-get-field file line from ":" " of " ""] 7 (#$ . 156424)])
(defalias 'gdb-stack-list-frames-custom #[0 "\305\306\307!\310\"\311\312\313\211\211\211%\313\211\223\210\211\203S�\211@\314\305\315\"\316\305\317\"	\203/�\320!\2020�\321\n\203>�\322\305\323\"P\202?�\321QE\324\325\326\327\330\257#\210A\266\202\202�\210\331\332\"c\266\203\210�\333 \203\210�\212\334\335!T!\211@A\336!\313\223\210\337 @\340V\204\205�\341\342\343$\210\266)\344\345!\211\207" [gdb-stack-position gdb-stack-buffer-locations gdb-stack-buffer-addresses gdb-frame-number mode-name bindat-get-field gdb-json-partial-output "frame" stack record gdb-table nil gdb-table-add-row level "in" func gdb-frame-location "" " at " addr mouse-face highlight help-echo "mouse-2, RET: Select frame" gdb-frame gdb-table-string " " gdb-buffer-shows-main-thread-p gdb-line-posns string-to-number copy-marker window-fringes 0 put-text-property font-lock-face (:inverse-video t) gdb-current-context-mode-name "Frames"] 14])
(defalias 'gdb-stack-buffer-name #[0 "\300\301\302 P!\207" [gdb-current-context-buffer-name "stack frames of " gdb-get-target-string] 3])
#@65 Display GDB backtrace for current stack.

(fn &optional THREAD)
(defalias 'gdb-display-stack-buffer #[256 "\300\301\302\"!\207" [gdb-display-buffer gdb-get-buffer-create gdb-stack-buffer] 5 (#$ . 157852) nil])
#@25

(fn &optional THREAD)
(defalias 'gdb-preemptively-display-stack-buffer #[256 "\300\301\"\210\302\303\304\"\305\"\207" [message "%s" gdb-preempt-existing-or-display-buffer gdb-get-buffer-create gdb-stack-buffer t] 5 (#$ . 158069)])
#@82 Display GDB backtrace for current stack in another frame.

(fn &optional THREAD)
(defalias 'gdb-frame-stack-buffer #[256 "\301\302\303\"\"\207" [gdb-display-buffer-other-frame-action display-buffer gdb-get-buffer-create gdb-stack-buffer] 5 (#$ . 158310) nil])
(defvar gdb-frames-mode-map (byte-code "\300 \301!\210\302\303\304#\210\302\305\306#\210\302\307\306#\210\302\310\311#\210\211\207" [make-sparse-keymap suppress-keymap define-key "q" kill-current-buffer "
" gdb-select-frame [mouse-2] [follow-link] mouse-face] 5))
#@47 Font lock keywords used in `gdb-frames-mode'.
(defvar gdb-frames-font-lock-keywords '(("in \$[^ ]+\$" (1 font-lock-function-name-face))) (#$ . 158847))
(defvar gdb-frames-mode-hook nil)
(byte-code "\300\301N\204\f�\302\300\301\303#\210\304\305!\204�\302\305\306\307#\210\300\207" [gdb-frames-mode-hook variable-documentation put "Hook run after entering Frames mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp gdb-frames-mode-map definition-name gdb-frames-mode] 4)
(defvar gdb-frames-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\322#\207" [gdb-frames-mode-abbrev-table gdb-frames-mode-map variable-documentation put purecopy "Keymap for `gdb-frames-mode'." boundp gdb-frames-mode-syntax-table definition-name gdb-frames-mode (lambda (#1=#:def-tmp-var) (defvar gdb-frames-mode-syntax-table #1#)) make-syntax-table "Syntax table for `gdb-frames-mode'." (lambda (#1#) (defvar gdb-frames-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `gdb-frames-mode'." derived-mode-parent gdb-parent-mode] 5)
#@236 Major mode for gdb call stack.

In addition to any hooks its parent mode `gdb-parent-mode' might have run,
this mode runs the hook `gdb-frames-mode-hook', as the final or penultimate step
during initialization.

\{gdb-frames-mode-map}
(defalias 'gdb-frames-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
\325!C#\210\327!\210\330\f!\210
!\331 \332\333\334\"\210\307\"\306\335!\210\336)\337\340!\207" [delay-mode-hooks major-mode mode-name gdb-frames-mode-map gdb-frames-mode-syntax-table gdb-frames-mode-abbrev-table make-local-variable t gdb-parent-mode gdb-frames-mode "Frames" 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 make-marker add-to-list overlay-arrow-variable-list gdb-stack-position font-lock-defaults (gdb-frames-font-lock-keywords) run-mode-hooks gdb-frames-mode-hook local-abbrev-table truncate-lines] 5 (#$ . 160208) nil])
#@73 Select the frame and display the relevant source.

(fn &optional EVENT)
(defalias 'gdb-select-frame #[256 "\211\203\n�\301\302!!\210\303`\304\"\211\2031�\305 \203+�\306\307\"\211\310\311P\312\"\210\313 \262\2024�\314\315!\2024�\314\316!\207" [gdb-frame-number posn-set-point event-end get-text-property gdb-frame gdb-buffer-shows-main-thread-p bindat-get-field level gdb-input "-stack-select-frame " ignore gdb-update error "Could not select frame for non-current thread" "Not recognized as frame line"] 6 (#$ . 161385) (list last-input-event)])
#@25

(fn &optional SIGNAL)
(defalias 'gdb-invalidate-locals #[256 "\211\300>\205�\301\302\303!\304P\305\306p\"p\307B#\207" [(start update) gdb-input gdb-current-context-command "-stack-list-locals" " --simple-values" gdb-bind-function-to-buffer gdb-locals-handler gdb-invalidate-locals] 6 (#$ . 161942)])
(defalias 'gdb-locals-handler #[0 "\301\302p\303\"\304!\305!\306 \210\307 \210\310 \210\311\"\210\312\")\207" [inhibit-read-only t get-buffer-window 0 window-start window-point erase-buffer gdb-locals-handler-custom gdb-update-buffer-name set-window-start set-window-point] 6])
(gdb-set-buffer-rules 'gdb-locals-buffer 'gdb-locals-buffer-name 'gdb-locals-mode 'gdb-invalidate-locals)
#@74 Keymap to create watch expression of a complex data type local variable.
(defvar gdb-locals-watch-map (byte-code "\300 \301!\210\302\303\304#\210\302\305\304#\210\211\207" [make-sparse-keymap suppress-keymap define-key "
" gud-watch [mouse-2]] 5) (#$ . 162642))
#@60 Keymap to edit value of a simple data type local variable.
(defvar gdb-edit-locals-map-1 (byte-code "\300 \301!\210\302\303\304#\210\302\305\304#\210\211\207" [make-sparse-keymap suppress-keymap define-key "
" gdb-edit-locals-value [mouse-2]] 5) (#$ . 162913))
#@84 Assign a value to a variable displayed in the locals buffer.

(fn &optional EVENT)
(defalias 'gdb-edit-locals-value #[256 "\212\211\203�\300\301!!\210\302 \210\303\304`\305\"\306\"\307\310\311\"!\312\313\314R!\266\202)\207" [posn-set-point event-end beginning-of-line bindat-get-field get-text-property gdb-local-variable name read-string format "New value (%s): " gud-basic-call "-gdb-set variable " " = "] 8 (#$ . 163183) (list last-input-event)])
(defalias 'gdb-locals-handler-custom #[0 "\305\306 \307\"\310\311\312\211\211\211%\211\203q�\211@\305\313\"\305\314\"\305\315\"\204&�\316\262\2031�\317\320\"\203D�\321\322G\323\324\325\326\327\257$\210\202S�\321\322G\323\324\325\330\327	\257$\210\331\332\333\n#\332\333#E\334D#\266A\266\202\202
�\210\335\336\"c\210\337\340\305\341 \342\"P!\211\207" [gdb-locals-watch-map gdb-edit-locals-map-1 font-lock-type-face font-lock-variable-name-face mode-name bindat-get-field gdb-json-partial-output locals record gdb-table nil name value type "<complex data type>" string-match "0x" add-text-properties 0 mouse-face highlight help-echo "mouse-2: create watch expression" local-map "mouse-2: edit value" gdb-table-add-row propertize font-lock-face gdb-local-variable gdb-table-string " " gdb-current-context-mode-name "Locals: " gdb-current-buffer-frame func] 16])
(defvar gdb-locals-header (byte-code "\300\301\302\303\304\303\305\306\307\310\311\312\"&	\313\300\314\302\315\304\316\305\317\307\310\311\320\"&	E\207" [propertize "Locals" help-echo nil mouse-face face mode-line local-map gdb-make-header-line-mouse-map mouse-1 #[257 "\300 r\301\302\303\304\305!\306\"\307$\216\310\311!\211@\262!\210\312\313\314!\315\"*\207" [internal--before-save-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-save-selected-window] 2 select-window event-start gdb-set-window-buffer gdb-get-buffer-create gdb-locals-buffer t] 8 "\n\n(fn EVENT)" #1="e"] " " "Registers" "mouse-1: select" mode-line-highlight mode-line-inactive #[257 "\300 r\301\302\303\304\305!\306\"\307$\216\310\311!\211@\262!\210\312\313\314!\315\"*\207" [internal--before-save-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-save-selected-window] 2 select-window event-start gdb-set-window-buffer gdb-get-buffer-create gdb-registers-buffer t] 8 "\n\n(fn EVENT)" #1#]] 14))
(defvar gdb-locals-mode-map (byte-code "\300 \301!\210\302\303\304#\210\302\305\306#\210\211\207" [make-sparse-keymap suppress-keymap define-key "q" kill-current-buffer "	" #[0 "\301\302\303\"\304\"\207" [gdb-thread-number gdb-set-window-buffer gdb-get-buffer-create gdb-registers-buffer t] 4 nil nil]] 5))
(defvar gdb-locals-mode-hook nil)
(byte-code "\300\301N\204\f�\302\300\301\303#\210\304\305!\204�\302\305\306\307#\210\300\207" [gdb-locals-mode-hook variable-documentation put "Hook run after entering Locals mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp gdb-locals-mode-map definition-name gdb-locals-mode] 4)
(defvar gdb-locals-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\322#\207" [gdb-locals-mode-abbrev-table gdb-locals-mode-map variable-documentation put purecopy "Keymap for `gdb-locals-mode'." boundp gdb-locals-mode-syntax-table definition-name gdb-locals-mode (lambda (#1=#:def-tmp-var) (defvar gdb-locals-mode-syntax-table #1#)) make-syntax-table "Syntax table for `gdb-locals-mode'." (lambda (#1#) (defvar gdb-locals-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `gdb-locals-mode'." derived-mode-parent gdb-parent-mode] 5)
#@232 Major mode for gdb locals.

In addition to any hooks its parent mode `gdb-parent-mode' might have run,
this mode runs the hook `gdb-locals-mode-hook', as the final or penultimate step
during initialization.

\{gdb-locals-mode-map}
(defalias 'gdb-locals-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 gdb-locals-mode-map gdb-locals-mode-syntax-table gdb-locals-mode-abbrev-table make-local-variable t gdb-parent-mode gdb-locals-mode "Locals" 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 gdb-locals-mode-hook local-abbrev-table gdb-locals-header header-line-format] 5 (#$ . 167080) nil])
(defalias 'gdb-locals-buffer-name #[0 "\300\301\302 P!\207" [gdb-current-context-buffer-name "locals of " gdb-get-target-string] 3])
#@74 Display the local variables of current GDB stack.

(fn &optional THREAD)
(defalias 'gdb-display-locals-buffer #[256 "\300\301\302\"!\207" [gdb-display-buffer gdb-get-buffer-create gdb-locals-buffer] 5 (#$ . 168239) nil])
#@25

(fn &optional THREAD)
(defalias 'gdb-preemptively-display-locals-buffer #[256 "\300\301\"\210\302\303\304\"\305\"\207" [message "%s" gdb-preempt-existing-or-display-buffer gdb-get-buffer-create gdb-locals-buffer t] 5 (#$ . 168467)])
#@95 Display the local variables of the current GDB stack in another frame.

(fn &optional THREAD)
(defalias 'gdb-frame-locals-buffer #[256 "\301\302\303\"\"\207" [gdb-display-buffer-other-frame-action display-buffer gdb-get-buffer-create gdb-locals-buffer] 5 (#$ . 168710) nil])
#@25

(fn &optional SIGNAL)
(defalias 'gdb-invalidate-registers #[256 "\211\300>\205�\301\302\303!\304P\305\306p\"p\307B#\207" [(start update) gdb-input gdb-current-context-command "-data-list-register-values" " x" gdb-bind-function-to-buffer gdb-registers-handler gdb-invalidate-registers] 6 (#$ . 168993)])
(defalias 'gdb-registers-handler #[0 "\301\302p\303\"\304!\305!\306 \210\307 \210\310 \210\311\"\210\312\")\207" [inhibit-read-only t get-buffer-window 0 window-start window-point erase-buffer gdb-registers-handler-custom gdb-update-buffer-name set-window-start set-window-point] 6])
(gdb-set-buffer-rules 'gdb-registers-buffer 'gdb-registers-buffer-name 'gdb-registers-mode 'gdb-invalidate-registers)
(defalias 'gdb-registers-handler-custom #[0 "\205\\�\305\306 \307\"\310\311\312\211\211\211%\211\203O�\211@\305\313\"\305\314\"\315!8\316\317\320	#\n\235\203:�\317\320#\202;�D\321\322\323\324\325\257#\266A\266\202\202�\210\326\327\"c\266\330\331!\211\207" [gdb-register-names font-lock-variable-name-face gdb-changed-registers font-lock-warning-face mode-name bindat-get-field gdb-json-partial-output register-values record gdb-table nil number value string-to-number gdb-table-add-row propertize font-lock-face mouse-face highlight help-echo "mouse-2: edit value" gdb-register-name gdb-table-string " " gdb-current-context-mode-name "Registers"] 16])
#@87 Assign a value to a register displayed in the registers buffer.

(fn &optional EVENT)
(defalias 'gdb-edit-register-value #[256 "\212\211\203�\300\301!!\210\302 \210\303\304`\305\"!\306\307\310\"!\311\312\313R!\266\202)\207" [posn-set-point event-end beginning-of-line bindat-get-field get-text-property gdb-register-name read-string format "New value (%s): " gud-basic-call "-gdb-set variable $" " = "] 8 (#$ . 170388) (list last-input-event)])
(defvar gdb-registers-mode-map (byte-code "\300 \301!\210\302\303\304#\210\302\305\304#\210\302\306\307#\210\302\310\311#\210\211\207" [make-sparse-keymap suppress-keymap define-key "
" gdb-edit-register-value [mouse-2] "q" kill-current-buffer "	" #[0 "\301\302\303\"\304\"\207" [gdb-thread-number gdb-set-window-buffer gdb-get-buffer-create gdb-locals-buffer t] 4 nil nil]] 5))
(defvar gdb-registers-header (byte-code "\300\301\302\303\304\305\306\307\310\311\312\313\"&	\314\300\315\302\316\304\316\306\317\310\311\312\320\"&	E\207" [propertize "Locals" help-echo "mouse-1: select" mouse-face mode-line-highlight face mode-line-inactive local-map gdb-make-header-line-mouse-map mouse-1 #[257 "\300 r\301\302\303\304\305!\306\"\307$\216\310\311!\211@\262!\210\312\313\314!\315\"*\207" [internal--before-save-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-save-selected-window] 2 select-window event-start gdb-set-window-buffer gdb-get-buffer-create gdb-locals-buffer t] 8 "\n\n(fn EVENT)" #1="e"] " " "Registers" nil mode-line #[257 "\300 r\301\302\303\304\305!\306\"\307$\216\310\311!\211@\262!\210\312\313\314!\315\"*\207" [internal--before-save-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-save-selected-window] 2 select-window event-start gdb-set-window-buffer gdb-get-buffer-create gdb-registers-buffer t] 8 "\n\n(fn EVENT)" #1#]] 14))
(defvar gdb-registers-mode-hook nil)
(byte-code "\300\301N\204\f�\302\300\301\303#\210\304\305!\204�\302\305\306\307#\210\300\207" [gdb-registers-mode-hook variable-documentation put "Hook run after entering Registers mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp gdb-registers-mode-map definition-name gdb-registers-mode] 4)
(defvar gdb-registers-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\322#\207" [gdb-registers-mode-abbrev-table gdb-registers-mode-map variable-documentation put purecopy "Keymap for `gdb-registers-mode'." boundp gdb-registers-mode-syntax-table definition-name gdb-registers-mode (lambda (#1=#:def-tmp-var) (defvar gdb-registers-mode-syntax-table #1#)) make-syntax-table "Syntax table for `gdb-registers-mode'." (lambda (#1#) (defvar gdb-registers-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `gdb-registers-mode'." derived-mode-parent gdb-parent-mode] 5)
#@241 Major mode for gdb registers.

In addition to any hooks its parent mode `gdb-parent-mode' might have run,
this mode runs the hook `gdb-registers-mode-hook', as the final or penultimate step
during initialization.

\{gdb-registers-mode-map}
(defalias 'gdb-registers-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 gdb-registers-mode-map gdb-registers-mode-syntax-table gdb-registers-mode-abbrev-table make-local-variable t gdb-parent-mode gdb-registers-mode "Registers" 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 gdb-registers-mode-hook local-abbrev-table gdb-registers-header header-line-format] 5 (#$ . 173514) nil])
(defalias 'gdb-registers-buffer-name #[0 "\300\301\302 P!\207" [gdb-current-context-buffer-name "registers of " gdb-get-target-string] 3])
#@55 Display GDB register contents.

(fn &optional THREAD)
(defalias 'gdb-display-registers-buffer #[256 "\300\301\302\"!\207" [gdb-display-buffer gdb-get-buffer-create gdb-registers-buffer] 5 (#$ . 174712) nil])
#@25

(fn &optional THREAD)
(defalias 'gdb-preemptively-display-registers-buffer #[256 "\300\301\"\210\302\303\304\"\305\"\207" [message "%s" gdb-preempt-existing-or-display-buffer gdb-get-buffer-create gdb-registers-buffer t] 5 (#$ . 174927)])
#@72 Display GDB register contents in another frame.

(fn &optional THREAD)
(defalias 'gdb-frame-registers-buffer #[256 "\301\302\303\"\"\207" [gdb-display-buffer-other-frame-action display-buffer gdb-get-buffer-create gdb-registers-buffer] 5 (#$ . 175176) nil])
(defalias 'gdb-get-changed-registers #[0 "\300\301!\205�\302\303\304\305#\207" [gdb-get-buffer gdb-registers-buffer gdb-input "-data-list-changed-registers" gdb-changed-registers-handler gdb-get-changed-registers] 4])
(defalias 'gdb-changed-registers-handler #[0 "\301\302\303 \304\"\211\205�\211@\211BA\266\202\202�\207" [gdb-changed-registers nil bindat-get-field gdb-json-partial-output changed-registers] 4])
(defalias 'gdb-register-names-handler #[0 "\301\302\303 \304\"\211\203�\211@\211BA\266\202\202�\210\305!\211\207" [gdb-register-names nil bindat-get-field gdb-json-partial-output register-names reverse] 4])
#@136 Create list of source files for current GDB session.
If buffers already exist for any of these files, `gud-minor-mode'
is set in them.
(defalias 'gdb-get-source-file-list #[0 "eb\210\303\304\305#\203�\306\307\310!!	B\202�\311 \211\2053�\211@r\211q\210\n	\235\203+�\312 \210)A\266\202\202�\207" [gdb-source-file-regexp gdb-source-file-list buffer-file-name re-search-forward nil t read match-string 1 buffer-list gdb-init-buffer] 4 (#$ . 176078)])
#@91 Trigger for `gdb-frame-handler' which uses main current thread.
Called from `gdb-update'.
(defalias 'gdb-get-main-selected-frame #[0 "\300\301\302!\303\304#\207" [gdb-input gdb-current-context-command "-stack-info-frame" gdb-frame-handler gdb-get-main-selected-frame] 4 (#$ . 176537)])
#@90 Set `gdb-selected-frame' and `gdb-selected-file' to show
overlay arrow in source buffer.
(defalias 'gdb-frame-handler #[0 "\306\307 \310\"\211\205c�\306\311\"\306\312\"\306\313\"\306\314\"\306\315\"\211\205(�\316!	\2038�\f\2038�	\fB\317 \210\210\205c�\320!\321!\205a�rq\210\n\322\230?\205V�\323\324 \211\325\223)\266\202\207" [gdb-selected-frame gdb-selected-file gdb-frame-number gdb-frame-address gdb-selected-line gud-last-frame bindat-get-field gdb-json-partial-output frame func fullname level addr line string-to-number gud-display-frame marker-buffer marker-position "0" ((overlay-arrow . hollow-right-triangle)) make-marker nil gud-overlay-arrow-position fringe-indicator-alist] 7 (#$ . 176829)])
(defconst gdb-prompt-name-regexp (concat "value=\$" gdb--string-regexp "\$"))
#@30 Find prompt for GDB session.
(defalias 'gdb-get-prompt #[0 "eb\210\303\304	\303\305#\210\306\307\310!!\nP\211\207" [gdb-prompt-name gdb-prompt-name-regexp gdb-filter-output nil re-search-forward t read match-string 1] 4 (#$ . 177645)])
#@60 Show buffer BUF, and make that window dedicated.

(fn BUF)
(defalias 'gdb-display-buffer #[257 "\300!\301\302\"\210\211\207" [display-buffer set-window-dedicated-p t] 5 (#$ . 177891)])
#@314 Find window displaying a buffer with the same
`gdb-buffer-type' as BUF and show BUF there.  If no such window
exists, just call `gdb-display-buffer' for BUF.  If the window
found is already dedicated, split window according to
SPLIT-HORIZONTAL and show BUF in the new window.

(fn BUF &optional SPLIT-HORIZONTAL)
(defalias 'gdb-preempt-existing-or-display-buffer #[513 "\203N�\300!?\205Q�\301!\302\303\304\305\306\307!\310\"\311\312%!\211\203(�\313\"\202M�\302\303\304\314\306\307!\315\"\311\312%!\211\203H�\313\316\317#\"\202K�\320!\262\207\321\322!\207" [get-buffer-window gdb-buffer-type get-window-with-predicate make-byte-code 257 "\300\301\302!!=\205�\303!?\207" vconcat vector [gdb-buffer-type window-buffer window-dedicated-p] 5 "\n\n(fn W)" set-window-buffer "\300\301\302!!=\207" [gdb-buffer-type window-buffer] split-window nil gdb-display-buffer error "Null buffer"] 11 (#$ . 178085)])
(byte-code "\302\303!\304\305\306\303\307BBB#\210\304\310\311#\210\304\312\313#\210\304\314\315#\210\304\316\317#\210\304\320\321#\210\304\322\323#\210\304\324\325#\210\304\326\327#\210\304\330\331#\266\302\332!\304\333\306\332\334BBB#\210\304\335\336#\210\304\337\340#\210\304\341\342#\210\304\343\344#\210\304\345\346#\210\304\347\350#\210\304\351\352#\210\304\353\354#\210\304\355\356#\266\302\357!\304\360\361#\210\304\362\363#\210\304\364\365#\210\304\366\367#\210\304\370\371#\210\304\372\373#\210\304\374\375#\210\304\376\377#\210\304\201@�\201A�\201B�\201C�\"\210\201D�#\210\304\201E�\306\357\201F�BBB#\266\201G�	\201H�\201I�\201J�$\210\201G�	\201K�\201L�\201M�$\207" [gud-menu-map gud-tool-bar-map make-sparse-keymap "GDB-Windows" define-key [displays] menu-item (:visible (eq gud-minor-mode 'gdbmi)) [gdb] ("Gdb" . gdb-display-gdb-buffer) [threads] ("Threads" . gdb-display-threads-buffer) [memory] ("Memory" . gdb-display-memory-buffer) [disassembly] ("Disassembly" . gdb-display-disassembly-buffer) [registers] ("Registers" . gdb-display-registers-buffer) [inferior] ("IO" . gdb-display-io-buffer) [locals] ("Locals" . gdb-display-locals-buffer) [frames] ("Stack" . gdb-display-stack-buffer) [breakpoints] ("Breakpoints" . gdb-display-breakpoints-buffer) "GDB-Frames" [frames] (:visible (eq gud-minor-mode 'gdbmi)) [gdb] ("Gdb" . gdb-frame-gdb-buffer) [threads] ("Threads" . gdb-frame-threads-buffer) [memory] ("Memory" . gdb-frame-memory-buffer) [disassembly] ("Disassembly" . gdb-frame-disassembly-buffer) [registers] ("Registers" . gdb-frame-registers-buffer) [inferior] ("IO" . gdb-frame-io-buffer) [locals] ("Locals" . gdb-frame-locals-buffer) [frames] ("Stack" . gdb-frame-stack-buffer) [breakpoints] ("Breakpoints" . gdb-frame-breakpoints-buffer) "GDB-MI" [gdb-customize] (menu-item "Customize" (lambda nil (interactive) (customize-group 'gdb)) :help "Customize Gdb Graphical Mode options.") [gdb-many-windows] (menu-item "Display Other Windows" gdb-many-windows :help "Toggle display of locals, stack and breakpoint information" :button (:toggle . gdb-many-windows)) [gdb-restore-windows] (menu-item "Restore Window Layout" gdb-restore-windows :help "Restore standard layout for debug session.") [sep1] (menu-item "--") [all-threads] (menu-item "GUD controls all threads" (lambda nil (interactive) (setq gdb-gud-control-all-threads t)) :help "GUD start/stop commands apply to all threads" :button (:radio . gdb-gud-control-all-threads)) [current-thread] (menu-item "GUD controls current thread" (lambda nil (interactive) (setq gdb-gud-control-all-threads nil)) :help "GUD start/stop commands apply to current thread only" :button (:radio not gdb-gud-control-all-threads)) [sep2] (menu-item "--") [gdb-customize-reasons] (menu-item "Customize switching..." (lambda nil (interactive) (customize-option 'gdb-switch-reasons))) [gdb-switch-when-another-stopped] defalias gdb-toggle-switch-when-another-stopped #[256 "\300\301!\210\301\302N\206�\303\301\304N\206�\305\301\301!?\"\266\202\203&�\306\307\310\"\210\202+�\306\307\311\"\210\211\2052�\312\301!\207" [custom-load-symbol gdb-switch-when-another-stopped custom-set set-default custom-get default-value message "GDB thread switching %s" "enabled globally" "disabled globally" customize-mark-as-set] 7 "Toggle whether to switch to stopped thread.\nIn an interactive call, record this option as a candidate for saving\nby \"Save Options\" in Custom buffers.\n\n(fn &optional INTERACTIVELY)" "p"] (menu-item "Automatically switch to stopped thread" gdb-toggle-switch-when-another-stopped :help "Switch to stopped thread" :button (:toggle and (default-boundp 'gdb-switch-when-another-stopped) (default-value 'gdb-switch-when-another-stopped))) [mi] (:visible (eq gud-minor-mode 'gdbmi)) define-key-after [all-threads] (menu-item "Switch to non-stop/A mode" gdb-control-all-threads :image (find-image '((:type xpm :file "gud/thread.xpm"))) :visible (and (eq gud-minor-mode 'gdbmi) gdb-non-stop (not gdb-gud-control-all-threads))) run [current-thread] (menu-item "Switch to non-stop/T mode" gdb-control-current-thread :image (find-image '((:type xpm :file "gud/all.xpm"))) :visible (and (eq gud-minor-mode 'gdbmi) gdb-non-stop gdb-gud-control-all-threads)) all-threads] 8)
#@38 Display GUD buffer in another frame.
(defalias 'gdb-frame-gdb-buffer #[0 "\301!\207" [gud-comint-buffer display-buffer-other-frame] 2 (#$ . 183287) nil])
#@21 Display GUD buffer.
(defalias 'gdb-display-gdb-buffer #[0 "\301\302\303#\207" [gud-comint-buffer pop-to-buffer nil 0] 4 (#$ . 183448) nil])
#@192 Set buffer of selected window to NAME and dedicate window.

When IGNORE-DEDICATED is non-nil, buffer is set even if selected
window is dedicated.

(fn NAME &optional IGNORE-DEDICATED WINDOW)
(defalias 'gdb-set-window-buffer #[769 "\211\204�\300 \262\203�\301\302\"\210\303\304!\"\210\301\305\"\207" [selected-window set-window-dedicated-p nil set-window-buffer get-buffer t] 7 (#$ . 183596)])
#@58 Layout the window pattern for option `gdb-many-windows'.
(defalias 'gdb-setup-windows #[0 "\305\306!\210\305\307!\210\305\310!\210\311\312 \313\"\210\314!\210\315 \210\312 \316\313\317 \320_\321\245\"\316\313\317 \320\245\"\322 \323\324 \313#\210\325!\210\326	\203E�\327	@!\202Q�\n\203O�\327\n!\202Q�\330 \"\210\312 \322 \323\305\331!\313#\266\325!\210\323\332 !\210\322 \323\f\203v�\333 \202x�\334 \313#\266\325!\207" [gud-comint-buffer gud-last-last-frame gdb-main-file gdb-source-window gdb-show-threads-by-default gdb-get-buffer-create gdb-locals-buffer gdb-stack-buffer gdb-breakpoints-buffer set-window-dedicated-p selected-window nil switch-to-buffer delete-other-windows split-window window-height 3 4 split-window-right gdb-set-window-buffer gdb-locals-buffer-name select-window set-window-buffer gud-find-file list-buffers-noselect gdb-inferior-io gdb-stack-buffer-name gdb-threads-buffer-name gdb-breakpoints-buffer-name] 9 (#$ . 184003)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313\314\315\316\317&
\207" [custom-declare-variable gdb-many-windows funcall function #[0 "\300\207" [nil] 1] "Non-nil if Gdb-Many-Windows mode is enabled.\nSee the `gdb-many-windows' command\nfor a description of this minor mode.\nSetting this variable directly does not take effect;\neither customize it (see the info node `Easy Customization')\nor call the function `gdb-many-windows'." :set custom-set-minor-mode :initialize custom-initialize-default :group gdb :type boolean :version "22.1"] 14)
#@537 If nil just pop up the GUD buffer unless `gdb-show-main' is t.
In this case it starts with two windows: one displaying the GUD
buffer and the other with the source file with the main routine
of the debugged program.  Non-nil means display the layout shown for
`gdb'.

If called interactively, enable Gdb-Many-Windows mode if ARG is
positive, and disable it if ARG is zero or negative.  If called from
Lisp, also enable the mode if ARG is omitted or nil, and toggle it if
ARG is `toggle'; disable the mode otherwise.

(fn &optional ARG)
(defalias 'gdb-many-windows #[256 "\301 \302\303\304=\203�\305\303!?\202�\306!\307V\"\210\2031�\310!\2031�\3111,�\312 0\2020�\210\2021�\210\313\314\305\303!\203=�\315\202>�\316\"\210\317\320!\203h�\321\303!\210\301 \203V�\211\301 \232\203h�\322\323\324\305\303!\203c�\325\202d�\326#\266\210\327 \210\305\303!\207" [gud-comint-buffer current-message set-default gdb-many-windows toggle default-value prefix-numeric-value 0 buffer-name (error) gdb-restore-windows run-hooks gdb-many-windows-hook gdb-many-windows-on-hook gdb-many-windows-off-hook called-interactively-p any customize-mark-as-set "" message "Gdb-Many-Windows mode %sabled%s" "en" "dis" force-mode-line-update] 7 (#$ . 185532) (byte-code "\206�\301C\207" [current-prefix-arg toggle] 1)])
(defvar gdb-many-windows-hook nil)
(byte-code "\301\302N\204\f�\303\301\302\304#\210\305\306\307\310\300!\205�\307\211%\207" [gdb-many-windows-map gdb-many-windows-hook variable-documentation put "Hook run after entering or leaving `gdb-many-windows'.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" add-minor-mode gdb-many-windows nil boundp] 6)
#@123 Restore the basic arrangement of windows used by gdb.
This arrangement depends on the value of option `gdb-many-windows'.
(defalias 'gdb-restore-windows #[0 "\306!\210\307 \210	\203�\310 \207\n\204�\205/�\311 \312\n\203%�\313\n@!\202(�\313\f!\"\210\211\211\262\207" [gud-comint-buffer gdb-many-windows gud-last-last-frame gdb-show-main gdb-main-file gdb-source-window switch-to-buffer delete-other-windows gdb-setup-windows split-window set-window-buffer gud-find-file] 5 (#$ . 187265) nil])
#@103 Exit a debugging session cleanly.
Kills the gdb buffers, and resets variables and the source buffers.
(defalias 'gdb-reset #[0 "\306\307!\211\203�\310!\210\210\311 \211\203K�\211@\211=\204D�r\211q\210	\312=\203C�\313\314\315 \"\2033�\316\317!\210\202C�\320ed\321#\210\317\322\323!\210\322\324!\210)A\266\202\202�\210\317\325\302\"\326\317\325\305\"\317\325\327\"\330\331!\203m�\332 \210\317\211\333\334\335\321#\207" [gud-comint-buffer gud-minor-mode gdb-disassembly-position overlay-arrow-variable-list fringe-indicator-alist gdb-stack-position get-process "gdb-inferior" delete-process buffer-list gdbmi string-match "\\` ?\\*.+\\*\\'" buffer-name kill-buffer nil gdb-remove-breakpoint-icons t kill-local-variable tool-bar-map gdb-define-alist delq ((overlay-arrow . right-triangle)) gdb-thread-position boundp speedbar-frame speedbar-timer-fn remove-hook after-save-hook gdb-create-define-alist gud-running gdb-active-process] 7 (#$ . 187771)])
#@97 Find the source file where the program starts and display it with related
buffers, if required.
(defalias 'gdb-get-source-file #[0 "eb\210\305\306\307#\203�\310\311\312!!\n\203�\313 \210\202-�\314\315!\210\203-�	\203-�\316\317	!!\210\320\321\322\323\f#!\207" [gdb-source-file-regexp gdb-main-file gdb-many-windows gdb-show-main font-lock-variable-name-face re-search-forward nil t read match-string 1 gdb-setup-windows gdb-get-buffer-create gdb-breakpoints-buffer display-buffer gud-find-file gdb-force-mode-line-update propertize "ready" face] 5 (#$ . 188746)])
#@265 Put string PUTSTRING in front of POS in the current buffer.
PUTSTRING is displayed by putting an overlay into the current buffer with a
`before-string' string that has a `display' property whose value is
PUTSTRING.

(fn PUTSTRING POS &optional DPROP &rest SPROPS)
(defalias 'gdb-put-string #[898 "\300\301\302\"p\303!\262\304\211#\206�\305\306DD\307\310\301\311%\210\2030�\312\310\301$\210\313\314\315#\210\313\316#\266\202\207" [make-string 1 120 copy-sequence make-overlay margin left-margin put-text-property 0 display add-text-properties overlay-put put-break t before-string] 14 (#$ . 189321)])
#@210 Remove strings between START and END in BUFFER.
Remove only strings that were put in BUFFER with calls to `gdb-put-string'.
BUFFER nil or omitted means use the current buffer.

(fn START END &optional BUFFER)
(defalias 'gdb-remove-strings #[770 "\211\204�p\262\300\"\211\205#�\211@\301\302\"\203�\303!\210A\266\202\202�\207" [overlays-in overlay-get put-break delete-overlay] 8 (#$ . 189949)])
#@37

(fn ENABLED BPTNO &optional LINE)
(defalias 'gdb-put-breakpoint-icon #[770 "\306\206�\307 !\211@SAT\203�\310\202�\311\312p\313\"\314\313\315\316$\210\2036�\314\313\315\317\n\320BB$\210\202B�\314\313\315\317\n\321BB$\210\322\"\210\323 \203\334�\206\\�\211\203[�\324!@\206\\�	\325Y\203}�\326\327T\330\331\f\203p�\332\202q�\333E\317\334&\202\n\335W\203\221�r\335\211\203\220�\336\n#\210)\337\203\266�\f\206\324�\340\341\342\343
\344BBBB\341\345\343,\346BBBBD!\211\202\324�-\206\324�\340\341\342\343
\347BBBB\341\345\343.\350BBBBD!\211-T\351$\202\n\335W\203\365�r\335\312p\313\"\211\203\363�\336\n#\210\210)\326\352\353\203\332\202\333#T\"\207" [left-fringe-width gdb-buffer-fringe-width left-margin-width right-margin-width breakpoint-enabled-icon breakpoint-xpm-data gdb-line-posns line-number-at-pos "B" "b" get-buffer-window 0 add-text-properties 1 (help-echo "mouse-1: clear bkpt, mouse-3: enable/disable bkpt") gdb-bptno (gdb-enabled t) (gdb-enabled nil) gdb-remove-breakpoint-icons display-images-p window-fringes 8 gdb-put-string nil left-fringe breakpoint breakpoint-enabled breakpoint-disabled gdb-enabled 2 set-window-margins put-image find-image :type xpm :data (:ascent 100 :pointer hand) pbm (:ascent 100 :pointer hand) (:conversion disabled :ascent 100 :pointer hand) (:ascent 100 :pointer hand) left-margin propertize face breakpoint-enabled-pbm-data breakpoint-disabled-icon breakpoint-disabled-pbm-data] 16 (#$ . 190358)])
#@42

(fn START END &optional REMOVE-MARGIN)
(defalias 'gdb-remove-breakpoint-icons #[770 "\302\"\210\303 \203�\304\"\210\211\205$�\305\306p\305\"\211\205\"�\307	#\262\207" [left-margin-width right-margin-width gdb-remove-strings display-images-p remove-images 0 get-buffer-window set-window-margins] 8 (#$ . 191854)])
#@161 Completion table for GDB/MI commands.
COMMAND is the prefix for which we seek completion.
CONTEXT is the text before COMMAND on the line.

(fn CONTEXT COMMAND)
(defalias 'gud-gdbmi-completions #[514 "\306\307G\307\310r\311\312!q\210\313\314Q\315\"\210\f\203&�\316\317
!!\210\202�)\320	!-\207" [gud-marker-filter gud-gdb-fetched-lines gud-gdb-fetch-lines-break gud-gdb-fetch-lines-string gud-gdb-fetch-lines-in-progress gud-comint-buffer t nil gud-gdbmi-fetch-lines-filter gdb-get-buffer gdb-partial-output-buffer gdb-input "complete " #[0 "\301\211\207" [gud-gdb-fetch-lines-in-progress nil] 2] accept-process-output get-buffer-process gud-gdb-completions-1] 7 (#$ . 192185)])
#@66 Custom filter function for `gud-gdbmi-completions'.

(fn STRING)
(defalias 'gud-gdbmi-fetch-lines-filter #[257 "\303!P\262\304\305\"\203!�\306	\307\224#\nB\306\307\225\"\262\202�\310\207" [gud-gdb-fetch-lines-string gud-gdb-fetch-lines-break gud-gdb-fetched-lines gud-gdbmi-marker-filter string-match "\n" substring 0 ""] 5 (#$ . 192878)])
(provide 'gdb-mi)

${this.title}

Code Editor : gdb-mi.elc