%PDF-
%PDF-
Mini Shell
Mini Shell
;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; 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 "\301\302!\210\303\304\305\306\307\310\307\311&\210\312\300\313\314\315DD\316\317\320\307\304&\210\321\322\323\"\324\"\207" [gud-key-prefix require comint custom-declare-group gud nil "The \"Grand Unified Debugger\" interface.\nSupported debuggers include gdb, sdb, dbx, xdb, perldb,\npdb (Python), and jdb." :group processes tools custom-declare-variable funcall function #[0 "\300\207" [#1=""] 1 #1#] "Prefix of all GUD commands valid in C buffers." :type key-sequence global-set-key vconcat "\f" gud-refresh] 8)
(defvar gud-marker-filter nil)
(put 'gud-marker-filter 'permanent-local t)
(defvar gud-find-file nil)
(put 'gud-find-file 'permanent-local t)
#@19
(fn &rest ARGS)
(defalias 'gud-marker-filter #[128 "\301\"\207" [gud-marker-filter apply] 4 (#$ . 1081)])
(defvar gud-minor-mode nil)
(put 'gud-minor-mode 'permanent-local t)
(defvar gud-comint-buffer nil)
(defvar gud-keep-buffer nil)
#@242 Return the symbol used for SYM in MINOR-MODE.
MINOR-MODE defaults to `gud-minor-mode'.
The symbol returned is `gud-<MINOR-MODE>-<SYM>'.
If SOFT is non-nil, returns nil if the symbol doesn't already exist.
(fn SYM &optional SOFT MINOR-MODE)
(defalias 'gud-symbol #[769 "\211\204\f \204\f \301\302!\210\203 \303\202 \304\305\306\206 #!\207" [gud-minor-mode error "Gud internal error" intern-soft intern format "gud-%s-%s"] 8 (#$ . 1327)])
#@87 Return the value of `gud-symbol' SYM. Default to nil.
(fn SYM &optional MINOR-MODE)
(defalias 'gud-val #[513 "\300\301#\302!\205
\211J\207" [gud-symbol t boundp] 6 (#$ . 1780)])
#@82 Non-nil if debugged program is running.
Used to gray out relevant toolbar icons.
(defvar gud-running nil (#$ . 1970))
#@66 The apparent name of the program being debugged in a gud buffer.
(defvar gud-target-name "--unknown--" (#$ . 2094))
#@33 Go to relevant Emacs info node.
(defalias 'gud-goto-info #[0 "\301=\203\n \302\303!\207\302\304!\207" [gud-minor-mode gdbmi info-other-window "(emacs)GDB Graphical Interface" "(emacs)Debuggers"] 2 (#$ . 2216) nil])
(defalias 'gud-tool-bar-item-visible-no-fringe #[0 "\301\302\303 \"\304=\206 \301\302\303 \"\305=\206 \306=\205 \307 @\310V?\207" [gud-minor-mode buffer-local-value major-mode window-buffer speedbar-mode gdb-memory-mode gdbmi window-fringes 0] 3])
(defalias 'gud-stop-subjob #[0 "rq\210 \303\230\203 \304 \202% \n\305\267\202# \306\307!\202% \306\310\311!!\202% \312 )\207" [gud-comint-buffer gud-target-name gud-minor-mode "emacs" comint-stop-subjob #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (jdb 21 gdbmi 27)) gud-call "suspend" gdb-gud-context-command "-exec-interrupt" comint-interrupt-subjob] 3 nil nil])
#@22 Menu for `gud-mode'.
(defconst gud-menu-map (byte-code "\301\302\303\304\300!\205\n \305\306D$\207" [gud-menu-map easy-mmode-define-keymap (([help] "Info (debugger)" . gud-goto-info) ([tooltips] menu-item "Show GUD tooltips" gud-tooltip-mode :enable (and (not emacs-basic-display) (display-graphic-p) (fboundp 'x-show-tip)) :visible (memq gud-minor-mode '(gdbmi guiler dbx sdb xdb pdb)) :button (:toggle . gud-tooltip-mode)) ([refresh] "Refresh" . gud-refresh) ([run] menu-item "Run" gud-run :enable (not gud-running) :visible (or (memq gud-minor-mode '(gdb dbx jdb)) (and (eq gud-minor-mode 'gdbmi) (or (not (gdb-show-run-p)) (bound-and-true-p gdb-active-process))))) ([go] menu-item (if (bound-and-true-p gdb-active-process) "Continue" "Run") gud-go :visible (and (eq gud-minor-mode 'gdbmi) (gdb-show-run-p))) ([stop] menu-item "Stop" gud-stop-subjob :visible (or (not (memq gud-minor-mode '(gdbmi pdb))) (and (eq gud-minor-mode 'gdbmi) (gdb-show-stop-p)))) ([until] menu-item "Continue to selection" gud-until :enable (not gud-running) :visible (and (memq gud-minor-mode '(gdbmi gdb perldb)) (gud-tool-bar-item-visible-no-fringe))) ([remove] menu-item "Remove Breakpoint" gud-remove :enable (not gud-running) :visible (gud-tool-bar-item-visible-no-fringe)) ([tbreak] menu-item "Temporary Breakpoint" gud-tbreak :enable (not gud-running) :visible (memq gud-minor-mode '(gdbmi gdb sdb xdb))) ([break] menu-item "Set Breakpoint" gud-break :enable (not gud-running) :visible (gud-tool-bar-item-visible-no-fringe)) ([up] menu-item "Up Stack" gud-up :enable (not gud-running) :visible (memq gud-minor-mode '(gdbmi gdb guiler dbx xdb jdb pdb))) ([down] menu-item "Down Stack" gud-down :enable (not gud-running) :visible (memq gud-minor-mode '(gdbmi gdb guiler dbx xdb jdb pdb))) ([pp] menu-item "Print S-expression" gud-pp :enable (and (not gud-running) (bound-and-true-p gdb-active-process)) :visible (and (string-equal (buffer-local-value 'gud-target-name gud-comint-buffer) "emacs") (eq gud-minor-mode 'gdbmi))) ([print*] menu-item (if (eq gud-minor-mode 'jdb) "Dump object" "Print Dereference") gud-pstar :enable (not gud-running) :visible (memq gud-minor-mode '(gdbmi gdb jdb))) ([print] menu-item "Print Expression" gud-print :enable (not gud-running)) ([watch] menu-item "Watch Expression" gud-watch :enable (not gud-running) :visible (eq gud-minor-mode 'gdbmi)) ([finish] menu-item "Finish Function" gud-finish :enable (not gud-running) :visible (memq gud-minor-mode '(gdbmi gdb guiler xdb jdb pdb))) ([stepi] menu-item "Step Instruction" gud-stepi :enable (not gud-running) :visible (memq gud-minor-mode '(gdbmi gdb dbx))) ([nexti] menu-item "Next Instruction" gud-nexti :enable (not gud-running) :visible (memq gud-minor-mode '(gdbmi gdb dbx))) ([step] menu-item "Step Line" gud-step :enable (not gud-running)) ([next] menu-item "Next Line" gud-next :enable (not gud-running)) ([cont] menu-item "Continue" gud-cont :enable (not gud-running) :visible (not (eq gud-minor-mode 'gdbmi)))) nil boundp :name "Gud"] 6) (#$ . 3097))
#@28 Map used in visited files.
(defconst gud-minor-mode-map (byte-code "\303\304\305\306BBC ?\205\206 \307\310\311\312\313#\314BB\315\310\316\312\313#\317BB\320\310\321\312\313#\322BB\323\310\324\312\313#\325BB\326\310\327\312\313#\330BB\331\332\310\333\312\313#\334BBB\335\332\310\336\312\313#\337BBB\340\332\310\341\312\313#\342BBB\343\332\310\344\312\313#\345BBB\346\332\310\347\312\313#\350BBB\351\310\352\312\313#\353BB\354BBBBBBBBBBB\"\355\356\302!\205\217 \n\355$\207" [gud-menu-map window-system gud-minor-mode-map easy-mmode-define-keymap append [menu-bar debug] "Gud" [menu-bar down] propertize "down" face font-lock-doc-face gud-down [menu-bar up] "up" gud-up [menu-bar finish] "finish" gud-finish [menu-bar step] "step" gud-step [menu-bar next] "next" gud-next [menu-bar until] menu-item "until" (gud-until :visible (memq gud-minor-mode '(gdbmi gdb perldb))) [menu-bar cont] "cont" (gud-cont :visible (not (eq gud-minor-mode 'gdbmi))) [menu-bar run] "run" (gud-run :visible (memq gud-minor-mode '(gdbmi gdb dbx jdb))) [menu-bar go] " go " (gud-go :visible (and (eq gud-minor-mode 'gdbmi) (gdb-show-run-p))) [menu-bar stop] "stop" (gud-stop-subjob :visible (or (and (eq gud-minor-mode 'gdbmi) (gdb-show-stop-p)) (not (eq gud-minor-mode 'gdbmi)))) [menu-bar print] "print" gud-print (([menu-bar tools] . undefined) ([menu-bar buffer] . undefined) ([menu-bar options] . undefined) ([menu-bar edit] . undefined) ([menu-bar file] . undefined)) nil boundp] 18) (#$ . 6135))
(byte-code "\302\236 \203 \241\210\202 \302B\211\262B\210\207" [minor-mode-map-alist gud-minor-mode-map gud-minor-mode] 4)
#@20 `gud-mode' keymap.
(defvar gud-mode-map (make-sparse-keymap) (#$ . 7751))
(defvar gud-tool-bar-map (byte-code "\301 \302\211\203 \211@\303@A$\210A\266\202\202 \262\207" [gud-minor-mode-map make-sparse-keymap ((gud-break . "gud/break") (gud-remove . "gud/remove") (gud-print . "gud/print") (gud-pstar . "gud/pstar") (gud-pp . "gud/pp") (gud-watch . "gud/watch") (gud-run . "gud/run") (gud-go . "gud/go") (gud-stop-subjob . "gud/stop") (gud-cont . "gud/cont") (gud-until . "gud/until") (gud-next . "gud/next") (gud-step . "gud/step") (gud-finish . "gud/finish") (gud-nexti . "gud/nexti") (gud-stepi . "gud/stepi") (gud-up . "gud/up") (gud-down . "gud/down") (gud-goto-info . "info")) tool-bar-local-item-from-menu] 8))
#@128 Transform a relative file name to an absolute file name.
Uses `gud-<MINOR-MODE>-directories' to find the source files.
(fn F)
(defalias 'gud-file-name #[257 "\301!\206 \302P\262\303!\203 \304!\207\305\306!\307\2036 \304@\"\303!\203. \211\262\307\262\210A\262\202 \207" [default-directory file-remote-p "" file-exists-p expand-file-name gud-val directories nil] 6 (#$ . 8484)])
#@13
(fn FILE)
(defalias 'gud-find-file #[257 "\306\307\"\203 \310\311\312\211$\262\202 \206 \313!\211;\203+ \314!\205) \315\316\"\262\211\205g r\211q\210\317\300!\210\320\303!\203E \317\303!\210\n\f\203a \321=\203a \317\305!\210
\204Z \322 \210\323\324\322\325\312$\210\317\326!\210)\211\207" [gud-minor-mode gud-find-file gud-tool-bar-map tool-bar-map gud-tooltip-mode gdb-define-alist string-match "//+" replace-match "/" t gud-file-name file-readable-p find-file-noselect nowarn make-local-variable boundp gdbmi gdb-create-define-alist add-hook after-save-hook nil gud-keep-buffer] 8 (#$ . 8884)])
#@1051 Define FUNC to be a command sending CMD and bound to KEY, with
optional doc string DOC. Certain %-escapes in the string arguments
are interpreted specially if present. These are:
%f -- Name (without directory) of current source file.
%F -- Name (without directory or extension) of current source file.
%d -- Directory of current source file.
%l -- Number of current source line.
%e -- Text of the C lvalue or function-call expression surrounding point.
%a -- Text of the hexadecimal address surrounding point.
%p -- Prefix argument to the command (if any) as a number.
%c -- Fully qualified class name derived from the expression
surrounding point (jdb only).
The `current' source file is the file of the current buffer (if
we're in a C file) or the source file current at the last break or
step (if we're in the GUD buffer).
The `current' line is that of the current buffer (if we're in a
source file) or the source line number at the last break or step (if
we're in the GUD buffer).
(fn FUNC CMD KEY &optional DOC)
(defalias 'gud-def '(macro . #[1027 "\300\301\302D\303\304\305\205 C\306\307\310\f;\203# \311
\312BB\202% \fED\"BBE\2058 \313\314P\302DE\205G \315\316\317E\302 DEF\207" [progn defalias quote lambda (arg) append (interactive "p") if (not gud-running) gud-call (arg) local-set-key "" global-set-key vconcat gud-key-prefix] 17 (#$ . 9507)]))
(defvar gud-last-frame nil)
(defvar gud-last-last-frame nil)
#@126 Description of the currently displayed GUD stack.
The value t means that there is no stack, and we are in display-file mode.
(defvar gud-last-speedbar-stackframe nil (#$ . 10983))
#@47 Keymap used when in the buffers display mode.
(defvar gud-speedbar-key-map nil (#$ . 11169))
#@56 Display the data type of the watch expression element.
(defalias 'gud-speedbar-item-info #[0 "\301`!\302Z8\3038\203 \304\305\3038\3068#\202 \304\307\3068\"\207" [gdb-var-list line-number-at-pos 2 7 dframe-message "%s: %s" 3 "%s"] 6 (#$ . 11268)])
#@62 Install those variables used by speedbar to enhance gud/gdb.
(defalias 'gud-install-speedbar-variables #[0 "\204+ \302 \303\304\305#\210\303\306\305#\210\303\307\305#\210\303\310\311#\210\303\312\313#\210\303\314\315#\210\316\317!\210\320 \235\2037 \207\320 B\211\207" [gud-speedbar-key-map speedbar-mode-functions-list speedbar-make-specialized-keymap define-key "j" speedbar-edit-line "e" "
" " " speedbar-toggle-line-expansion "D" gdb-var-delete "p" gud-pp speedbar-add-expansion-list ("GUD" gud-speedbar-menu-items gud-speedbar-key-map gud-expansion-speedbar-buttons) ("GUD" (speedbar-item-info . gud-speedbar-item-info) (speedbar-line-directory . ignore))] 4 (#$ . 11528)])
#@53 Additional menu items to add to the speedbar frame.
(defvar gud-speedbar-menu-items '(["Jump to stack frame" speedbar-edit-line :visible (not (eq (buffer-local-value 'gud-minor-mode gud-comint-buffer) 'gdbmi))] ["Edit value" speedbar-edit-line :visible (eq (buffer-local-value 'gud-minor-mode gud-comint-buffer) 'gdbmi)] ["Delete expression" gdb-var-delete :visible (eq (buffer-local-value 'gud-minor-mode gud-comint-buffer) 'gdbmi)] ["Auto raise frame" gdb-speedbar-auto-raise :style toggle :selected gdb-speedbar-auto-raise :visible (eq (buffer-local-value 'gud-minor-mode gud-comint-buffer) 'gdbmi)] ("Output Format" :visible (eq (buffer-local-value 'gud-minor-mode gud-comint-buffer) 'gdbmi) ["Binary" (gdb-var-set-format "binary") t] ["Natural" (gdb-var-set-format "natural") t] ["Hexadecimal" (gdb-var-set-format "hexadecimal") t])) (#$ . 12223))
(byte-code "\300\301!\203\f \302 \210\202 \303\304\302\"\210\300\207" [featurep speedbar gud-install-speedbar-variables add-hook speedbar-load-hook] 3)
#@138 Wrapper for call to `speedbar-add-expansion-list'.
DIRECTORY and ZERO are not used, but are required by the caller.
(fn DIRECTORY ZERO)
(defalias 'gud-expansion-speedbar-buttons #[514 "\301!\207" [gud-comint-buffer gud-speedbar-buttons] 4 (#$ . 13236)])
#@227 Create a speedbar display based on the current state of GUD.
If the GUD BUFFER is not running a supported debugger, then turn
off the specialized speedbar mode. BUFFER is not used, but is
required by the caller.
(fn BUFFER)
(defalias 'gud-speedbar-buttons #[257 "\205\306!\205r\211q\210 )\307p\310\"\311!\312!\313=\203\215\314 \210\315c\210\n\316\203\210\316\310\211@\211@A@\3178\203B \3178\202C \320\3218\3228\3238\324\310G\325 %\210\324\310G\325\f%\210\326\327\n#\203y T\262 \310\224T\262\202b \310=\203\203 \316\262 \211\203\215 \211\330\230\203\345 \3318\330\232\204\246 \3318\332\232\203\345 \326\333\"\203\345 \334\335\336\316\211 \337 Q\206\272 \340=?\205\277 \341\316
\203\334 \206\335 \342\267\202\330 \343\202\335 \344\202\335 \345\202\335 \345& \210\202\340=\203\356 \344\262 A@\203 \326\327P
A@@\"\203 \346\262\n\202\f\347\262\n\326\350\"\203X\334\335 \351 \337\n\337 \260\206-\340=?\2052\341\316
\203O\206P \352\267\202K\343\202P\344\202P\345\202P\345& \210\202\334\335 \351 \337\nQ\316\211\204q \203y
\203y\344\202z\345& \210\266\nA\262\202( \266\202 \212eb\210\353\354!)\203\240=>\232\204 \355=\203\254\356!\202\261\357!\210\316\314 \210\211\204\276\360c\210\202\301\361c\210\211\211\203\211@\211A@\362\261\210\211G\331U\203\344\363@\364\316\211\211\345&\210\202\374\363@\365\366\n\367>\203\364\370\202\367\371\372!\345&\210A\266\202\202\302\266=>\373\"\210\374\"\266\204\207" [gud-comint-buffer gud-minor-mode gdb-var-list font-lock-variable-name-face font-lock-type-face gdb-show-changed-values buffer-name get-buffer-window 0 window-start window-point gdbmi erase-buffer "Watch Expressions:\n" nil 3 " " 4 5 6 put-text-property face string-match "\\." "0" 2 "1" "char \\*$" speedbar-make-tag-line bracket 63 " " out-of-scope gdb-edit-value #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (changed 208 out-of-scope 212)) font-lock-warning-face shadow t 45 43 "\\*$\\|\\*&$" gdb-speedbar-expand-node #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (changed 323 out-of-scope 327)) looking-at "Current Stack:" gdb gud-gdb-get-stackframe speedbar-remove-localized-speedbar-support "No Stack frames\n" "Current Stack:\n" ":\n" speedbar-insert-button speedbar-directory-face speedbar-file-face speedbar-highlight-face (gdbmi gdb) gud-gdb-goto-stackframe error "Should never be here" set-window-start set-window-point gud-last-last-frame gud-last-speedbar-stackframe] 27 (#$ . 13499)])
(defvar gud-gdb-history nil)
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\207" [custom-declare-variable gud-gud-gdb-command-name funcall function #[0 "\300\207" [#1="gdb --fullname"] 1 #1#] "Default command to run an executable under GDB in text command mode.\nThe option \"--fullname\" must be included in this value." :type string :group gud] 8)
(defvar gud-gdb-marker-regexp "\\(.:?[^:\n]*\\):\\([0-9]*\\):.*\n")
(defvar gud-marker-acc "")
(make-variable-buffer-local 'gud-marker-acc)
#@15
(fn STRING)
(defalias 'gud-gdb-marker-filter #[257 "P\303\304 \"\203+ \305\306\"\307\305\310\"!B\211\311\312\211\224#P\262\311\312\225\"\202 \304\313\"\203E \211\311\312\211\224#P\262\311\312\225\"\202+ \304\314\"\203_ \211\311\312\211\224#P\262\311\312\224\"\202f \211P\262\303\211\207" [gud-marker-acc gud-gdb-marker-regexp gud-last-frame "" string-match match-string 1 string-to-number 2 substring 0 "\n\\(.*\\)\n" "\\(\n\\)?\\(.*\\)?\\'"] 7 (#$ . 16621)])
#@57 Keymap for minibuffer prompting of gud startup command.
(defconst gud-minibuffer-local-map (byte-code "\302\303\304\305\300!\205\n \306 D$\207" [gud-minibuffer-local-map minibuffer-local-map easy-mmode-define-keymap ((" " . comint-dynamic-complete-filename)) nil boundp :inherit] 6) (#$ . 17117))
#@34
(fn MINOR-MODE &optional INIT)
(defalias 'gud-query-cmdline #[513 "\302\303\304#\305\306\"\307!\204 \304L\210\310\311\312\"J\242\206^ \206' \313!\314\206] \304\315!\211\203X \211@\316!\203Q \317!\204Q \203N \320\"\203Q \211\262A\266\202\2021 \262\262Q \304%\207" [default-directory gud-minibuffer-local-map gud-symbol history nil gud-val command-name boundp read-from-minibuffer format "Run %s (like this): " symbol-name " " directory-files file-executable-p file-directory-p file-newer-than-file-p] 14 (#$ . 17421)])
(defvar gdb-first-prompt t)
#@75 Non-nil means this is text that has been saved for later in `gud-filter'.
(defvar gud-filter-pending-text nil (#$ . 18001))
#@213 Completion function for GDB commands.
It receives two arguments: COMMAND, the prefix for which we seek
completion; and CONTEXT, the text before COMMAND on the line.
It should return a list of completion strings.
(defvar gud-gdb-completion-function nil (#$ . 18132))
#@512 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.
(fn COMMAND-LINE)
(defalias 'gud-gdb #[257 "\203\" \306!\203\" \307!\203\" rq\210 )\310=\203\" \311 \210\312\313!\210\314\315\316#\210\317\301!\210\320\321\322\323\"\210\324\325\322\"\210\326\327\n\330\"\322\"\210\321\331\332\"\210\324\333\331\"\210\326\327\n\334\"\331\"\210\321\335\336\"\210\324\337\335\"\210\326\327\n\340\"\335\"\210\321\341\342\"\210\324\343\341\"\210\326\327\n\344\"\341\"\210\321\345\346\"\210\324\347\345\"\210\326\327\n\350\"\345\"\210\321\351\352\"\210\324\353\351\"\210\326\327\n\354\"\351\"\210\321\355\356\"\210\321\357\360\"\210\324\361\357\"\210\326\327\n\362\"\357\"\210\321\363\364\"\210\324\365\363\"\210\326\327\n\366\"\363\"\210\321\367\370\"\210\324\371\367\"\210\326\327\n\372\"\367\"\210\321\373\374\"\210\324\375\373\"\210\326\327\n\376\"\373\"\210\321\377\201C \"\210\324\201D \377\"\210\326\327\n\201E \"\377\"\210\321\201F \201G \"\210\324\201H \201F \"\210\326\327\n\201I \"\201F \"\210\321\201J \201K \"\210\321\201L \201M \"\210\324\201N \201L \"\210\326\327\n\201O \"\201L \"\210\321\201P \201Q \"\210\324\201R \201P \"\210\326\327\n\201S \"\201P \"\210\321\201T \201U \"\210\201V \201W \201X \315\201Y $\210\317\303!\210\201Z \324\350\201[ \"\210\201\\ \211\201] @\315\211AB\201^ \201_ !\207" [gud-comint-buffer gud-minor-mode gud-key-prefix gud-gdb-completion-function comint-prompt-regexp paragraph-start buffer-name get-buffer-process gdbmi gdb-restore-windows error "Multiple debugging requires restarting in text command mode" gud-common-init nil gud-gdb-marker-filter make-local-variable gdb defalias gud-break #[257 "?\205 \301\302\"\207" [gud-running gud-call "break %f:%l"] 4 "Set breakpoint at current line.\n\n(fn ARG)" #1="p"] local-set-key "" global-set-key vconcat "" 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#] "" "" gud-remove #[257 "?\205 \301\302\"\207" [gud-running gud-call "clear %f:%l"] 4 "Remove breakpoint at current line\n\n(fn ARG)" #1#] "" "" gud-step #[257 "?\205 \301\302\"\207" [gud-running gud-call "step %p"] 4 "Step one source line with display.\n\n(fn ARG)" #1#] "" "" gud-stepi #[257 "?\205 \301\302\"\207" [gud-running gud-call "stepi %p"] 4 "Step one instruction with display.\n\n(fn ARG)" #1#] " " " " gud-next #[257 "?\205 \301\302\"\207" [gud-running gud-call "next %p"] 4 "Step one line (skip functions).\n\n(fn ARG)" #1#] "" "" gud-nexti #[257 "?\205 \301\302\"\207" [gud-running gud-call "nexti %p"] 4 "Step one instruction (skip functions).\n\n(fn ARG)" #1#] gud-cont #[257 "?\205 \301\302\"\207" [gud-running gud-call "cont"] 4 "Continue with display.\n\n(fn ARG)" #1#] "" "" gud-finish #[257 "?\205 \301\302\"\207" [gud-running gud-call "finish"] 4 "Finish executing current function.\n\n(fn ARG)" #1#] "" "" 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 gdb-first-prompt gud-running gud-filter-pending-text #[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-pv #[257 "?\205 \301\302\"\207" [gud-running gud-call "pv %e"] 4 "Print the value of the lisp variable.\n\n(fn ARG)" #1#] "" "" gud-until #[257 "?\205 \301\302\"\207" [gud-running gud-call "until %l"] 4 "Continue to current line.\n\n(fn ARG)" #1#] "" "" gud-run #[257 "?\205 \301\302\"\207" [gud-running gud-call "run"] 4 "Run the program.\n\n(fn ARG)" #1#] add-hook completion-at-point-functions gud-gdb-completion-at-point local gud-gdb-completions completion-at-point "^(.*gdb[+]?) *" t run-hooks gud-gdb-mode-hook] 7 (#$ . 18405) (byte-code "\300\301!C\207" [gud-query-cmdline gud-gdb] 2)])
#@158 Completion table for GDB commands.
COMMAND is the prefix for which we seek completion.
CONTEXT is the text before COMMAND on the line.
(fn CONTEXT COMMAND)
(defalias 'gud-gdb-completions #[514 "\300\301QpG#\211\203 \302\303@\"\203 \304\305!\210\306!\207" [gud-gdb-run-command-fetch-lines "complete " string-match "^Undefined command: \"complete\"" error "This version of GDB doesn't support the `complete' command" gud-gdb-completions-1] 6 (#$ . 23171)])
#@22
(fn COMPLETE-LIST)
(defalias 'gud-gdb-completions-1 #[257 "\300\301\"\262\211A\211\203* @@\230\203 A\211\262\241\210\202 \211\262\211A\262\202 \266\211G\302U\203[ \211@\303\211\304\305#\203J \211T\262\303\225\262\2027 \306\307\"\302U\203Y \310PC\262\266\207" [sort string-lessp 1 0 string-match "\\([^'\\]\\|\\\\'\\)*'" mod 2 "'"] 8 (#$ . 23640)])
#@59 Return the data to complete the GDB command before point.
(defalias 'gud-gdb-completion-at-point #[0 "`\212\301\302 x\210`)\303\304\"\305\306\302 {\"!E\207" [gud-gdb-completion-function "^ " comint-line-beginning-position copy-marker t completion-table-dynamic apply-partially] 9 (#$ . 24018)])
#@172 Filter used to read the list of lines output by a command.
STRING is the output to filter.
It is passed through `gud-gdb-marker-filter' before we look at it.
(fn STRING)
(defalias 'gud-gdb-fetch-lines-filter #[257 "\305!\262P\262\306\307\"\203$ \310 \311\224#\nB\310\311\225\"\262\202\n \306 \"\203. \312\207\211\313\207" [gud-gdb-fetch-lines-string gud-gdb-fetch-lines-break gud-gdb-fetched-lines comint-prompt-regexp gud-gdb-fetch-lines-in-progress gud-gdb-marker-filter string-match "\n" substring 0 nil ""] 5 (#$ . 24325)])
#@83 Goto the stackframe described by TEXT, TOKEN, and INDENT.
(fn TEXT TOKEN INDENT)
(defalias 'gud-gdb-goto-stackframe #[771 "\300 r\301\302\303\304\305!\306\"\307$\216\310 \210\311\312A@P!\210\313\314!\210\315 *\207" [internal--before-save-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-save-selected-window] 2 dframe-select-attached-frame gud-basic-call "server frame " sit-for 1 dframe-maybee-jump-to-attached-frame] 10 (#$ . 24873)])
#@40 Stack frames we are fetching from GDB.
(defvar gud-gdb-fetched-stack-frame nil (#$ . 25351))
#@73 Extract the current stack frame out of the GUD GDB BUFFER.
(fn BUFFER)
(defalias 'gud-gdb-get-stackframe #[257 "\300\301\302\"\211@\205 \303\304@\"?\205\201 \211\211\203~ \211@\300\211\303\305\"\204J \303\306\"\204J \303\307\"\203u \211@@@A@\310\311\"\310\312\"F\240\210\202u \310\311\"\262\310\312\"\262\303\307\"\203m \310\311\"\310\312\"F\202p DB\262\266A\266\202\202 \210\237\207" [nil gud-gdb-run-command-fetch-lines "server backtrace" string-match "No stack" "^#\\([0-9]+\\) +[0-9a-fx]+ in \\([:0-9a-zA-Z_]+\\) (" "^#\\([0-9]+\\) +\\([:0-9a-zA-Z_]+\\) (" "at \\([-0-9a-zA-Z_/.]+\\):\\([0-9]+\\)$" match-string 1 2] 14 (#$ . 25450)])
#@233 Run COMMAND, and return the list of lines it outputs.
BUFFER is the current buffer which may be the GUD buffer in which to run.
SKIP is the number of chars to skip on each line, it defaults to 0.
(fn COMMAND BUFFER &optional SKIP)
(defalias 'gud-gdb-run-command-fetch-lines #[770 "rq\210=\205 \212db\210\306y\210\307 !)??\205> \310\311\211\206\" \306\312 \313!\210\203; \314\315!!\210\202-
\237-)\207" [gud-comint-buffer comint-prompt-regexp gud-marker-filter gud-gdb-fetch-lines-break gud-gdb-fetch-lines-string gud-gdb-fetched-lines 0 looking-at t nil gud-gdb-fetch-lines-filter gud-basic-call accept-process-output get-buffer-process gud-gdb-fetch-lines-in-progress] 8 (#$ . 26130)])
(defvar gud-sdb-history nil)
#@69 If nil, we're on a System V Release 4 and don't need the tags hack.
(defvar gud-sdb-needs-tags (byte-code "\300\301!?\207" [file-exists-p "/var"] 2) (#$ . 26868))
(defvar gud-sdb-lastfile nil)
#@15
(fn STRING)
(defalias 'gud-sdb-marker-filter #[257 "\203\n P\202 \211\303\304\305#\203% \306\307\"\310\306\311\"!B\211\202l \304\312#\203? \306\313\"\211\310\306\307\"!B\211\202l \304\314#\203P \306\313\"\211\202l \n\203i \304\315#\203i \n\310\306\316\"!B\211\202l \303\211\203v \317\225\262\202
\304\320#\203\205 \317\225\262\202v \321\206\214 \317\"\210\207" [gud-marker-acc gud-last-frame gud-sdb-lastfile nil string-match "\\(^\\|\n\\)\\*?\\(0x\\w* in \\)?\\([^:\n]*\\):\\([0-9]*\\):.*\n" match-string 3 string-to-number 4 "^\\(BREAKPOINT\\|STEPPED\\) process [0-9]+ function [^ ]+ in \\(.+\\)\n\\([0-9]+\\):" 2 "^\\(BREAKPOINT\\|STEPPED\\) process [0-9]+ function [^ ]+ in \\(.+\\)\n" "^\\([0-9]+\\):" 1 0 "\n" substring] 8 (#$ . 27067)])
#@10
(fn F)
(defalias 'gud-sdb-find-file #[257 "\203 \301!\207\302!\207" [gud-sdb-needs-tags find-tag-noselect find-file-noselect] 3 (#$ . 27852)])
#@179 Run sdb on program FILE in buffer *gud-FILE*.
The directory containing FILE becomes the initial working directory
and source-file directory for your debugger.
(fn COMMAND-LINE)
(defalias 'sdb #[257 "\203 \306\307!\210\203! \310\301!\203 ;\203 \311 !\204! \312\313!\210\314\315\316\317$\210\320\302!\210\321\322\323\324\"\210\325\326\323\"\210\327\330 \331\"\323\"\210\322\332\333\"\210\325\334\332\"\210\327\330 \335\"\332\"\210\322\336\337\"\210\325\340\336\"\210\327\330 \341\"\336\"\210\322\342\343\"\210\325\344\342\"\210\327\330 \345\"\342\"\210\322\346\347\"\210\325\350\346\"\210\327\330 \351\"\346\"\210\322\352\353\"\210\325\354\352\"\210\327\330 \355\"\352\"\210\322\356\357\"\210\325\360\356\"\210\327\330 \361\"\356\"\210\322\362\363\"\210\325\364\362\"\210\327\330 \365\"\362\"\210\366\211\367\370!\207" [gud-sdb-needs-tags tags-file-name gud-minor-mode gud-key-prefix comint-prompt-regexp paragraph-start require etags boundp file-exists-p error "The sdb support requires a valid tags table to work" gud-common-init nil gud-sdb-marker-filter gud-sdb-find-file make-local-variable sdb defalias gud-break #[257 "?\205 \301\302\"\207" [gud-running gud-call "%l b"] 4 "Set breakpoint at current line.\n\n(fn ARG)" #1="p"] local-set-key "" global-set-key vconcat "" gud-tbreak #[257 "?\205 \301\302\"\207" [gud-running gud-call "%l c"] 4 "Set temporary breakpoint at current line.\n\n(fn ARG)" #1#] "" "" gud-remove #[257 "?\205 \301\302\"\207" [gud-running gud-call "%l d"] 4 "Remove breakpoint at current line\n\n(fn ARG)" #1#] "" "" gud-step #[257 "?\205 \301\302\"\207" [gud-running gud-call "s %p"] 4 "Step one source line with display.\n\n(fn ARG)" #1#] "" "" gud-stepi #[257 "?\205 \301\302\"\207" [gud-running gud-call "i %p"] 4 "Step one instruction with display.\n\n(fn ARG)" #1#] " " " " gud-next #[257 "?\205 \301\302\"\207" [gud-running gud-call "S %p"] 4 "Step one line (skip functions).\n\n(fn ARG)" #1#] "" "" gud-cont #[257 "?\205 \301\302\"\207" [gud-running gud-call "c"] 4 "Continue with display.\n\n(fn ARG)" #1#] "" "" gud-print #[257 "?\205 \301\302\"\207" [gud-running gud-call "%e/"] 4 "Evaluate C expression at point.\n\n(fn ARG)" #1#] "" "" "\\(^\\|\n\\)\\*" run-hooks sdb-mode-hook] 7 (#$ . 28008) (byte-code "\300\301!C\207" [gud-query-cmdline sdb] 2)])
(defvar gud-dbx-history nil)
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\207" [custom-declare-variable gud-dbx-directories funcall function #[0 "\300\207" [nil] 1] "A list of directories that dbx should search for source code.\nIf nil, only source files in the program directory\nwill be known to dbx.\n\nThe file names should be absolute, or relative to the directory\ncontaining the executable being debugged." :type (choice (const :tag "Current Directory" nil) (repeat :value ("") directory)) :group gud] 8)
#@18
(fn FILE ARGS)
(defalias 'gud-dbx-massage-args #[514 "\301\203 @\302BB\262A\262\202 \211\237\266\202\244\207" [gud-dbx-directories nil "-I"] 7 (#$ . 30887)])
#@15
(fn STRING)
(defalias 'gud-dbx-marker-filter #[257 "\203\n P\202 \211\302\303\304#\204 \303\305#\2030 \306\307\"\310\306\311\"!B\312\225\262\202
\303\313#\203? \312\225\262\2020 \303\314#\205L \315\312\224\"\210\207" [gud-marker-acc gud-last-frame nil string-match "stopped in .* at line \\([0-9]*\\) in file \"\\([^\"]*\\)\"" "signal .* in .* at line \\([0-9]*\\) in file \"\\([^\"]*\\)\"" match-string 2 string-to-number 1 0 "\n" "\\(stopped\\|signal\\)" substring] 7 (#$ . 31063)])
#@69 Non-nil to assume the MIPS/OSF dbx conventions (argument `-emacs').
(defvar gud-mips-p (byte-code "\301\302\"\206 \301\303\"\206 \301\304\"\206 \301\305\"\207" [system-configuration string-match "^mips-[^-]*-ultrix" "^mips-[^-]*-riscos" "^mips-[^-]*-osf1" "^alpha[^-]*-[^-]*-osf"] 3) (#$ . 31578))
(defvar gud-dbx-command-name (byte-code "\301\205 \302P\207" [gud-mips-p "dbx" " -emacs"] 2))
#@15
(fn STRING)
(defalias 'gud-mipsdbx-marker-filter #[257 "P\302\303\304\"\203+ \305\306\"\307\305\310\"!B\211\311\312\211\224#P\262\311\312\225\"\202 \303\313\"\203E \211\311\312\211\224#P\262\311\312\224\"\202L \211P\262\302\211\207" [gud-marker-acc gud-last-frame "" string-match "[][ 0-9]*\\([^:\n]*\\):\\([0-9]*\\):.*\n" match-string 1 string-to-number 2 substring 0 "[][ 0-9]*.*\\'"] 7 (#$ . 31985)])
#@164 Non-nil to assume the interface appropriate for IRIX dbx.
This works in IRIX 4, 5 and 6, but `gud-dbx-use-stopformat-p' provides
a better solution in 6.1 upwards.
(defvar gud-irix-p nil (#$ . 32421))
#@152 Non-nil to use the dbx feature present at least from Irix 6.1
whereby $stopformat=1 produces an output format compatible with
`gud-dbx-marker-filter'.
(defvar gud-dbx-use-stopformat-p nil (#$ . 32628))
#@15
(fn STRING)
(defalias 'gud-irixdbx-marker-filter #[257 "\305\211\306 \"\204 \306\307\"\203 \nP\262\310\202 \nP\211\203~ \306\311\"\2034 \312\313 !\314\"\210\202~ \306\315\"\203U \316\317\"\320!\203Q \316\317\"\321\316\322\"!B\210\202~ \306\323\"\203~ \324\316\322\"!\211\203u \320!\203u \211\321\316\317\"!B\210\325\326\211\224#\262\211\206\203 \310)\207" [case-fold-search comint-prompt-regexp gud-marker-acc gud-comint-buffer gud-last-frame nil string-match ".*\n" "" "^\\(\\[[0-9]+] \\)?Process +[0-9]+ ([^)]*) [^[]+\\[[^]\n]*]\n" process-send-string get-buffer-process "printf \"%1d:\",(int)$curline;file\n" "^[^ ][^[]*\\[\"\\([^\"]+\\)\":\\([0-9]+\\), [^]]+]\n" match-string 1 file-exists-p string-to-number 2 "\\([0-9]*\\):\\(.*\\)\n" gud-file-name substring 0] 8 (#$ . 32836)])
#@15
(fn STRING)
(defalias 'gud-dguxdbx-marker-filter #[257 "\203\n P\202 \211\302\303\304#\203) \305\306\"\307\305\310\"!B\311\225\262\202 \304\312#\2038 \311\225\262\202) \304\313#\205E \314\311\224\"\266\207" [gud-marker-acc gud-last-frame "^\\(\\(([0-9]+) \\)?Stopped at\\|Frame [0-9]+,\\) line \\([0-9]+\\), routine .*, file \\([^ \n]+\\)" nil string-match match-string 4 string-to-number 3 0 "\n" "Stopped\\|Frame" substring] 8 (#$ . 33658)])
#@179 Run dbx on program FILE in buffer *gud-FILE*.
The directory containing FILE becomes the initial working directory
and source-file directory for your debugger.
(fn COMMAND-LINE)
(defalias 'dbx #[257 "\203
\306\307\310#\210\202 \203 \306\311\312#\210\202 \306\311\313#\210\314\302!\210\315\203u \316\317\320\"\210\321\322\317\"\210\323\324 \325\"\317\"\210\316\326\327\"\210\321\330\326\"\210\323\324 \331\"\326\"\210\316\332\333\"\210\321\334\332\"\210\323\324 \335\"\332\"\210\316\336\337\"\210\321\340\336\"\210\323\324 \341\"\336\"\210\202\f \203\313 \316\332\342\"\210\321\334\332\"\210\323\324 \335\"\332\"\210\316\336\343\"\210\321\340\336\"\210\323\324 \341\"\336\"\210\316\317\344\"\210\321\322\317\"\210\323\324 \325\"\317\"\210\316\326\345\"\210\321\330\326\"\210\323\324 \331\"\326\"\210\346\347\f!\350\"\210\202\f\316\317\351\"\210\321\322\317\"\210\323\324 \325\"\317\"\210\316\326\352\"\210\321\330\326\"\210\323\324 \331\"\326\"\210\316\332\353\"\210\321\334\332\"\210\323\324 \335\"\332\"\210
\203\f\346\347\f!\354\"\210\316\355\356\"\210\321\357\355\"\210\323\324 \360\"\355\"\210\316\361\362\"\210\321\363\361\"\210\323\324 \364\"\361\"\210\316\365\366\"\210\321\367\365\"\210\323\324 \370\"\365\"\210\316\371\372\"\210\321\373\371\"\210\323\324 \374\"\371\"\210\316\375\376\"\210\316\377\201B \"\210\321\201C \377\"\210\323\324 \201D \"\377\"\210\316\201E \201F \"\210\321\201G \201E \"\210\323\324 \201H \"\201E \"\210\316\201I \201J \"\210\201K \211@A\201L \201M !\207" [gud-mips-p gud-irix-p gud-minor-mode gud-key-prefix gud-comint-buffer gud-dbx-use-stopformat-p gud-common-init nil gud-mipsdbx-marker-filter gud-dbx-massage-args gud-irixdbx-marker-filter gud-dbx-marker-filter make-local-variable dbx defalias gud-up #[257 "?\205 \301\302\"\207" [gud-running gud-call "up %p"] 4 "Up (numeric arg) stack frames.\n\n(fn ARG)" #1="p"] local-set-key "<" global-set-key vconcat "<" gud-down #[257 "?\205 \301\302\"\207" [gud-running gud-call "down %p"] 4 "Down (numeric arg) stack frames.\n\n(fn ARG)" #1#] ">" ">" gud-break #[257 "?\205 \301\302\"\207" [gud-running gud-call "stop at \"%f\":%l"] 4 "Set breakpoint at current line.\n\n(fn ARG)" #1#] "" "" gud-finish #[257 "?\205 \301\302\"\207" [gud-running gud-call "return"] 4 "Finish executing current function.\n\n(fn ARG)" #1#] "" "" #[257 "?\205 \301\302\"\207" [gud-running gud-call "stop at \"%d%f\":%l"] 4 "Set breakpoint at current line.\n\n(fn ARG)" #1#] #[257 "?\205 \301\302\"\207" [gud-running gud-call "return"] 4 "Finish executing current function.\n\n(fn ARG)" #1#] #[257 "?\205 \301\302\"\207" [gud-running gud-call "up %p; printf \"%1d:\",(int)$curline;file\n"] 4 "Up (numeric arg) stack frames.\n\n(fn ARG)" #1#] #[257 "?\205 \301\302\"\207" [gud-running gud-call "down %p; printf \"%1d:\",(int)$curline;file\n"] 4 "Down (numeric arg) stack frames.\n\n(fn ARG)" #1#] process-send-string get-buffer-process "printf \"%1d:\",(int)$curline;file\n" #[257 "?\205 \301\302\"\207" [gud-running gud-call "up %p"] 4 "Up (numeric arg) stack frames.\n\n(fn ARG)" #1#] #[257 "?\205 \301\302\"\207" [gud-running gud-call "down %p"] 4 "Down (numeric arg) stack frames.\n\n(fn ARG)" #1#] #[257 "?\205 \301\302\"\207" [gud-running gud-call "file \"%d%f\"\nstop at %l"] 4 "Set breakpoint at current line.\n\n(fn ARG)" #1#] "set $stopformat=1\n" gud-remove #[257 "?\205 \301\302\"\207" [gud-running gud-call "clear %l"] 4 "Remove breakpoint at current line\n\n(fn ARG)" #1#] "" "" gud-step #[257 "?\205 \301\302\"\207" [gud-running gud-call "step %p"] 4 "Step one line with display.\n\n(fn ARG)" #1#] "" "" gud-stepi #[257 "?\205 \301\302\"\207" [gud-running gud-call "stepi %p"] 4 "Step one instruction with display.\n\n(fn ARG)" #1#] " " " " gud-next #[257 "?\205 \301\302\"\207" [gud-running gud-call "next %p"] 4 "Step one line (skip functions).\n\n(fn ARG)" #1#] "" "" gud-nexti #[257 "?\205 \301\302\"\207" [gud-running gud-call "nexti %p"] 4 "Step one instruction (skip functions).\n\n(fn ARG)" #1#] gud-cont comint-prompt-regexp paragraph-start #[257 "?\205 \301\302\"\207" [gud-running gud-call "cont"] 4 "Continue with display.\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-run #[257 "?\205 \301\302\"\207" [gud-running gud-call "run"] 4 "Run the program.\n\n(fn ARG)" #1#] "^[^)\n]*dbx) *" run-hooks dbx-mode-hook] 6 (#$ . 34133) (byte-code "\300\301!C\207" [gud-query-cmdline dbx] 2)])
(defvar gud-xdb-history nil)
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\207" [custom-declare-variable gud-xdb-directories funcall function #[0 "\300\207" [nil] 1] "A list of directories that xdb should search for source code.\nIf nil, only source files in the program directory\nwill be known to xdb.\n\nThe file names should be absolute, or relative to the directory\ncontaining the executable being debugged." :type (choice (const :tag "Current Directory" nil) (repeat :value ("") directory)) :group gud] 8)
#@18
(fn FILE ARGS)
(defalias 'gud-xdb-massage-args #[514 "\301\203 @\302BB\262A\262\202 \211\237\266\202\244\207" [gud-xdb-directories nil "-d"] 7 (#$ . 39251)])
#@15
(fn STRING)
(defalias 'gud-xdb-marker-filter #[257 "\303\304\"\204 \304\305\"\203 P\262\306\202 P\211\203E \304\307\"\204/ \304\310\"\203E \311\312\313\"!\314\312\315\"!\211\203C \211B\266\211\206J \306\207" [comint-prompt-regexp gud-marker-acc gud-last-frame nil string-match ".*\n" "" "\\([^\n :]+\\): [^:]+: \\([0-9]+\\)[: ]" "[^: ]+:[ ]+\\([^:]+\\): [^:]+: \\([0-9]+\\):" string-to-number match-string 2 gud-file-name 1] 7 (#$ . 39427)])
#@330 Run xdb on program FILE in buffer *gud-FILE*.
The directory containing FILE becomes the initial working directory
and source-file directory for your debugger.
You can set the variable `gud-xdb-directories' to a list of program source
directories if your program contains sources from more than one directory.
(fn COMMAND-LINE)
(defalias 'xdb #[257 "\304\305\306#\210\307\300!\210\310\311\312\313\"\210\314\315\312\"\210\316\317 \320\"\312\"\210\311\321\322\"\210\314\323\321\"\210\316\317 \324\"\321\"\210\311\325\326\"\210\314\327\325\"\210\316\317 \330\"\325\"\210\311\331\332\"\210\314\333\331\"\210\316\317 \334\"\331\"\210\311\335\336\"\210\314\337\335\"\210\316\317 \340\"\335\"\210\311\341\342\"\210\314\343\341\"\210\316\317 \344\"\341\"\210\311\345\346\"\210\314\347\345\"\210\316\317 \350\"\345\"\210\311\351\352\"\210\314\353\351\"\210\316\317 \354\"\351\"\210\311\355\356\"\210\314\357\355\"\210\316\317 \360\"\355\"\210\311\361\362\"\210\314\363\361\"\210\316\317 \364\"\361\"\210\365\211\366\367!\207" [gud-minor-mode gud-key-prefix comint-prompt-regexp paragraph-start gud-common-init gud-xdb-massage-args gud-xdb-marker-filter make-local-variable xdb defalias gud-break #[257 "?\205 \301\302\"\207" [gud-running gud-call "b %f:%l"] 4 "Set breakpoint at current line.\n\n(fn ARG)" #1="p"] local-set-key "" global-set-key vconcat "" gud-tbreak #[257 "?\205 \301\302\"\207" [gud-running gud-call "b %f:%l\\t"] 4 "Set temporary breakpoint at current line.\n\n(fn ARG)" #1#] "" "" gud-remove #[257 "?\205 \301\302\"\207" [gud-running gud-call "db"] 4 "Remove breakpoint at current line\n\n(fn ARG)" #1#] "" "" gud-step #[257 "?\205 \301\302\"\207" [gud-running gud-call "s %p"] 4 "Step one line with display.\n\n(fn ARG)" #1#] "" "" gud-next #[257 "?\205 \301\302\"\207" [gud-running gud-call "S %p"] 4 "Step one line (skip functions).\n\n(fn ARG)" #1#] "" "" gud-cont #[257 "?\205 \301\302\"\207" [gud-running gud-call "c"] 4 "Continue with display.\n\n(fn ARG)" #1#] "" "" gud-up #[257 "?\205 \301\302\"\207" [gud-running gud-call "up %p"] 4 "Up (numeric arg) stack frames.\n\n(fn ARG)" #1#] "<" "<" gud-down #[257 "?\205 \301\302\"\207" [gud-running gud-call "down %p"] 4 "Down (numeric arg) stack frames.\n\n(fn ARG)" #1#] ">" ">" gud-finish #[257 "?\205 \301\302\"\207" [gud-running gud-call "bu\\t"] 4 "Finish executing current function.\n\n(fn ARG)" #1#] "" "" gud-print #[257 "?\205 \301\302\"\207" [gud-running gud-call "p %e"] 4 "Evaluate C expression at point.\n\n(fn ARG)" #1#] "" "" "^>" run-hooks xdb-mode-hook] 6 (#$ . 39901) (byte-code "\300\301!C\207" [gud-query-cmdline xdb] 2)])
(defvar gud-perldb-history nil)
#@204 Convert a command line as would be typed normally to run perldb
into one that invokes an Emacs-enabled debugging session.
"-emacs" is inserted where it will be $ARGV[0] (see perl5db.pl).
(fn FILE ARGS)
(defalias 'gud-perldb-massage-args #[514 "\211C\300C\300\301\242\203B \302\303\242@\"\203B \242@\304\232\204B \242@\305\232\204B \242@\306\232\203: \211\"\2047 \307\310!\210\311\262\211\"\210\202 \204] \242\203T \302\303\242@\"\203X \307\312!\210\211\"\210\242\203r \242@\305\232\203r \211\"\210\202} \203} \305\242B\240\210\313\242B\240\210\242\203\221 \211\"\210\202\204 \242\237\266\203\207" [nil #[514 "\211\242\211\242A\240\210\242\242B\240\207" [] 6 "\n\n(fn ARGS NEW-ARGS)"] string-match "^-" "-" "--" "-e" error "No code specified for -e" t "Can't use stdin as the script to debug" "-emacs"] 9 (#$ . 42611)])
#@15
(fn STRING)
(defalias 'gud-perldb-marker-filter #[257 "P\302\303\304\"\203+ \305\306\"\307\305\310\"!B\211\311\312\211\224#P\262\311\312\225\"\202 \303\313\"\203E \211\311\312\211\224#P\262\311\312\224\"\202L \211P\262\302\211\207" [gud-marker-acc gud-last-frame "" string-match "\\(?:(eval [0-9]+)\\[\\(\\(?:[a-zA-Z]:\\)?[^:\n]*\\)\\(?: (i\\.e\\. [^)]*)\\)?:\\([0-9]*\\)\\]\\|\\(?1:\\(?:[a-zA-Z]:\\)?[^:\n]*\\):\\(?2:[0-9]*\\)\\):.*\n" match-string 1 string-to-number 2 substring 0 ".*\\'"] 7 (#$ . 43469)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\207" [custom-declare-variable gud-perldb-command-name funcall function #[0 "\300\207" [#1="perl -d"] 1 #1#] "Default command to execute a Perl script under debugger." :type string :group gud] 8)
#@182 Run perldb on program FILE in buffer *gud-FILE*.
The directory containing FILE becomes the initial working directory
and source-file directory for your debugger.
(fn COMMAND-LINE)
(defalias 'perldb #[257 "\304\305\306#\210\307\300!\210\310\311\312\313\"\210\314\315\312\"\210\316\317 \320\"\312\"\210\311\321\322\"\210\314\323\321\"\210\316\317 \324\"\321\"\210\311\325\326\"\210\314\327\325\"\210\316\317 \330\"\325\"\210\311\331\332\"\210\314\333\331\"\210\316\317 \334\"\331\"\210\311\335\336\"\210\314\337\335\"\210\316\317 \340\"\335\"\210\311\341\342\"\210\314\343\341\"\210\316\317 \344\"\341\"\210\311\345\346\"\210\314\347\345\"\210\316\317 \350\"\345\"\210\351\211\352\353!\207" [gud-minor-mode gud-key-prefix comint-prompt-regexp paragraph-start gud-common-init gud-perldb-massage-args gud-perldb-marker-filter make-local-variable perldb defalias gud-break #[257 "?\205 \301\302\"\207" [gud-running gud-call "b %l"] 4 "Set breakpoint at current line.\n\n(fn ARG)" #1="p"] local-set-key "" global-set-key vconcat "" gud-remove #[257 "?\205 \301\302\"\207" [gud-running gud-call "B %l"] 4 "Remove breakpoint at current line\n\n(fn ARG)" #1#] "" "" gud-step #[257 "?\205 \301\302\"\207" [gud-running gud-call "s"] 4 "Step one source line with display.\n\n(fn ARG)" #1#] "" "" gud-next #[257 "?\205 \301\302\"\207" [gud-running gud-call "n"] 4 "Step one line (skip functions).\n\n(fn ARG)" #1#] "" "" gud-cont #[257 "?\205 \301\302\"\207" [gud-running gud-call "c"] 4 "Continue with display.\n\n(fn ARG)" #1#] "" "" gud-print #[257 "?\205 \301\302\"\207" [gud-running gud-call "p %e"] 4 "Evaluate perl expression at point.\n\n(fn ARG)" #1#] "" "" gud-until #[257 "?\205 \301\302\"\207" [gud-running gud-call "c %l"] 4 "Continue to current line.\n\n(fn ARG)" #1#] "" "" "^ DB<+[0-9]+>+ " run-hooks perldb-mode-hook] 6 (#$ . 44262) (byte-code "\300\301\302 \206 \303\304P\"C\207" [gud-query-cmdline perldb buffer-file-name "-e 0" " "] 4)])
(defvar gud-pdb-history nil)
(defvar gud-pdb-marker-regexp "^> \\([[:graph:] \\]*\\)(\\([0-9]+\\))\\([a-zA-Z0-9_]*\\|\\?\\|<\\(?:module\\|listcomp\\|dictcomp\\|setcomp\\|genexpr\\|lambda\\|\\)>\\)()\\(->[^\n
]*\\)?[\n
]")
(defvar gud-pdb-marker-regexp-file-group 1)
(defvar gud-pdb-marker-regexp-line-group 2)
(defvar gud-pdb-marker-regexp-fnname-group 3)
(defvar gud-pdb-marker-regexp-start "^> ")
#@15
(fn STRING)
(defalias 'gud-pdb-marker-filter #[257 "P\306\307 \"\2039 \310\n\"\311\310 \"!\312\230\203 \f\202# B\266\202\211\313\314\211\225#P\262\313\314\225\"\202 \307
\"\203S \211\313\314\211\224#P\262\313\314\224\"\202Z \211P\262\306\211\207" [gud-marker-acc gud-pdb-marker-regexp gud-pdb-marker-regexp-file-group gud-pdb-marker-regexp-line-group gud-last-frame gud-pdb-marker-regexp-start "" string-match match-string string-to-number "<string>" substring 0] 7 (#$ . 46661)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313& \207" [custom-declare-variable gud-pdb-command-name funcall function #[0 "\300\301!\203 \301\207\302\207" [executable-find "pdb" "python -m pdb"] 2] "Command that executes the Python debugger." :version "27.1" :type string :group gud] 10)
#@356 Run COMMAND-LINE in the `*gud-FILE*' buffer.
COMMAND-LINE should include the pdb executable
name (`gud-pdb-command-name') and the file to be debugged.
If called interactively, the command line will be prompted for.
The directory containing this file becomes the initial working
directory and source-file directory for your debugger.
(fn COMMAND-LINE)
(defalias 'pdb #[257 "\304\305\306#\210\307\300!\210\310\311\312\313\"\210\314\315\312\"\210\316\317 \320\"\312\"\210\311\321\322\"\210\314\323\321\"\210\316\317 \324\"\321\"\210\311\325\326\"\210\314\327\325\"\210\316\317 \330\"\325\"\210\311\331\332\"\210\314\333\331\"\210\316\317 \334\"\331\"\210\311\335\336\"\210\314\337\335\"\210\316\317 \340\"\335\"\210\311\341\342\"\210\314\343\341\"\210\316\317 \344\"\341\"\210\311\345\346\"\210\314\347\345\"\210\316\317 \350\"\345\"\210\311\351\352\"\210\314\353\351\"\210\316\317 \354\"\351\"\210\311\355\356\"\210\314\357\355\"\210\316\317 \360\"\355\"\210\311\361\362\"\210\314\363\361\"\210\316\317 \364\"\361\"\210\365\211\366\367!\207" [gud-minor-mode gud-key-prefix comint-prompt-regexp paragraph-start gud-common-init nil gud-pdb-marker-filter make-local-variable pdb defalias gud-break #[257 "?\205 \301\302\"\207" [gud-running gud-call "break %d%f:%l"] 4 "Set breakpoint at current line.\n\n(fn ARG)" #1="p"] local-set-key "" global-set-key vconcat "" gud-remove #[257 "?\205 \301\302\"\207" [gud-running gud-call "clear %d%f:%l"] 4 "Remove breakpoint at current line\n\n(fn ARG)" #1#] "" "" gud-step #[257 "?\205 \301\302\"\207" [gud-running gud-call "step"] 4 "Step one source line with display.\n\n(fn ARG)" #1#] "" "" gud-next #[257 "?\205 \301\302\"\207" [gud-running gud-call "next"] 4 "Step one line (skip functions).\n\n(fn ARG)" #1#] "" "" gud-cont #[257 "?\205 \301\302\"\207" [gud-running gud-call "continue"] 4 "Continue with display.\n\n(fn ARG)" #1#] "" "" gud-finish #[257 "?\205 \301\302\"\207" [gud-running gud-call "return"] 4 "Finish executing current function.\n\n(fn ARG)" #1#] "" "" gud-up #[257 "?\205 \301\302\"\207" [gud-running gud-call "up"] 4 "Up one stack frame.\n\n(fn ARG)" #1#] "<" "<" gud-down #[257 "?\205 \301\302\"\207" [gud-running gud-call "down"] 4 "Down one stack frame.\n\n(fn ARG)" #1#] ">" ">" gud-print #[257 "?\205 \301\302\"\207" [gud-running gud-call "p %e"] 4 "Evaluate Python expression at point.\n\n(fn ARG)" #1#] "" "" gud-statement #[257 "?\205 \301\302\"\207" [gud-running gud-call "!%e"] 4 "Execute Python statement at point.\n\n(fn ARG)" #1#] "" "" "^(Pdb) *" run-hooks pdb-mode-hook] 6 (#$ . 47479) (byte-code "\300\301!C\207" [gud-query-cmdline pdb] 2)])
(defvar gud-guiler-history nil)
(defvar gud-guiler-lastfile nil)
#@15
(fn STRING)
(defalias 'gud-guiler-marker-filter #[257 "\203\n P\202 \211\304\305\306#\203 \307\310\"\211\202c \305\311#\2038 \307\310\"\211\312\307\313\"!B\211\202c \305\314#\203Q \203m \312\307\310\"!B\211\202c \305 #\204f \315\"\316\230\204m \317\203m \304\225\262\202
\305\320#\203| \304\225\262\202m \315\206\203 \304\"\210\207" [gud-marker-acc gud-guiler-lastfile gud-last-frame comint-prompt-regexp 0 string-match "^In \\(.*\\):" match-string 1 "^\\([^:\n]+\\):\\([0-9]+\\):\\([0-9]+\\):[^\n]*" string-to-number 2 "^[ ]*\\([0-9]+\\):\\([0-9]+\\) [^\n]*" substring "" nil "\n"] 8 (#$ . 50234)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313& \207" [custom-declare-variable gud-guiler-command-name funcall function #[0 "\300\207" [#1="guile"] 1 #1#] "File name for executing the Guile debugger.\nThis should be an executable on your path, or an absolute file name." :version "25.1" :type string :group gud] 10)
#@184 Run guiler on program FILE in buffer `*gud-FILE*'.
The directory containing FILE becomes the initial working directory
and source-file directory for your debugger.
(fn COMMAND-LINE)
(defalias 'guiler #[257 "\304\305\306#\210\307\300!\210\310\311\312\313\"\210\314\315\312\"\210\316\317 \320\"\312\"\210\311\321\322\"\210\314\323\321\"\210\316\317 \324\"\321\"\210\311\325\326\"\210\314\327\325\"\210\316\317 \330\"\325\"\210\311\331\332\"\210\314\333\331\"\210\316\317 \334\"\331\"\210\311\335\336\"\210\314\337\335\"\210\316\317 \340\"\335\"\210\311\341\342\"\210\314\343\341\"\210\316\317 \344\"\341\"\210\311\345\346\"\210\314\347\345\"\210\316\317 \350\"\345\"\210\351\211\352\353!\207" [gud-minor-mode gud-key-prefix comint-prompt-regexp paragraph-start gud-common-init nil gud-guiler-marker-filter make-local-variable guiler defalias gud-break #[257 "?\205 \301\302\"\207" [gud-running gud-call ",break-at-source %f %l"] 4 "Set breakpoint at current line.\n\n(fn ARG)" #1="p"] local-set-key "" global-set-key vconcat "" gud-step #[257 "?\205 \301\302\"\207" [gud-running gud-call ",step"] 4 "Step one source line with display.\n\n(fn ARG)" #1#] "" "" gud-next #[257 "?\205 \301\302\"\207" [gud-running gud-call ",next"] 4 "Step one line (skip functions).\n\n(fn ARG)" #1#] "" "" gud-finish #[257 "?\205 \301\302\"\207" [gud-running gud-call ",finish"] 4 "Finish executing current function.\n\n(fn ARG)" #1#] "" "" gud-up #[257 "?\205 \301\302\"\207" [gud-running gud-call ",up"] 4 "Up one stack frame.\n\n(fn ARG)" #1#] "<" "<" gud-down #[257 "?\205 \301\302\"\207" [gud-running gud-call ",down"] 4 "Down one stack frame.\n\n(fn ARG)" #1#] ">" ">" gud-print #[257 "?\205 \301\302\"\207" [gud-running gud-call "%e"] 4 "Evaluate Guile expression at point.\n\n(fn ARG)" #1#] "" "" "^scheme@([^>]+> " run-hooks guiler-mode-hook] 6 (#$ . 51210) (byte-code "\300\301!C\207" [gud-query-cmdline guiler] 2)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\210\300\312\302\303\313DD\314\306\315\310\311&\207" [custom-declare-variable gud-jdb-command-name funcall function #[0 "\300\207" [#1="jdb"] 1 #1#] "Command that executes the Java debugger." :type string :group gud gud-jdb-use-classpath #[0 "\300\207" [t] 1] "If non-nil, search for Java source files in classpath directories.\nThe list of directories to search is the value of `gud-jdb-classpath'.\nThe file pathname is obtained by converting the fully qualified\nclass information output by jdb to a relative pathname and appending\nit to `gud-jdb-classpath' element by element until a match is found.\n\nThis method has a significant jdb startup time reduction advantage\nsince it does not require the scanning of all `gud-jdb-directories'\nand parsing all Java files for class information.\n\nSet to nil to use `gud-jdb-directories' to scan java sources for\nclass information on jdb startup (original method)." boolean] 8)
#@897 Java/jdb classpath directories list.
If `gud-jdb-use-classpath' is non-nil, gud-jdb derives the `gud-jdb-classpath'
list automatically using the following methods in sequence
(with subsequent successful steps overriding the results of previous
steps):
1) Read the CLASSPATH environment variable,
2) Read any "-classpath" argument used to run jdb,
or detected in jdb output (e.g. if jdb is run by a script
that echoes the actual jdb command before starting jdb),
3) Send a "classpath" command to jdb and scan jdb output for
classpath information if jdb is invoked with an "-attach" (to
an already running VM) argument (This case typically does not
have a "-classpath" command line argument - that is provided
to the VM when it is started).
Note that method 3 cannot be used with oldjdb (or Java 1 jdb) since
those debuggers do not support the classpath command. Use 1) or 2).
(defvar gud-jdb-classpath nil (#$ . 54152))
#@185 Directory list provided by an (optional) "-sourcepath" option to jdb.
This list is prepended to `gud-jdb-classpath' to form the complete
list of directories searched for source files.
(defvar gud-jdb-sourcepath nil (#$ . 55099))
#@202 Maximum number of debugger output characters to keep.
This variable limits the size of `gud-marker-acc' which holds
the most recent debugger output history while searching for
source file information.
(defvar gud-marker-acc-max-length 4000 (#$ . 55335))
#@42 History of argument lists passed to jdb.
(defvar gud-jdb-history nil (#$ . 55595))
#@540 A list of directories that gud jdb should search for source code.
The file names should be absolute, or relative to the current
directory.
The set of .java files residing in the directories listed are
syntactically analyzed to determine the classes they define and the
packages in which these classes belong. In this way gud jdb maps the
package-qualified class names output by the jdb debugger to the source
file from which the class originated. This allows gud mode to keep
the source code display in sync with the debugging session.
(defvar gud-jdb-directories (list ".") (#$ . 55685))
#@59 List of the java source files for this debugging session.
(defvar gud-jdb-source-files nil (#$ . 56283))
#@67 Association list of fully qualified class names and source files.
(defvar gud-jdb-class-source-alist nil (#$ . 56394))
(defvar gud-jdb-analysis-buffer nil)
#@35 Holds temporary classpath values.
(defvar gud-jdb-classpath-string nil (#$ . 56556))
#@210 Return a list of java source files (absolute paths).
PATH gives the directories in which to search for files with
extension EXTN. Normally EXTN is given as the regular expression
"\.java$" .
(fn PATH EXTN)
(defalias 'gud-jdb-build-source-files-list #[514 "\300\301\302\303\304\305!\306\"\307\310%\"\207" [mapcan make-byte-code 257 "\301!\205\f \302\303\300\304$\207" vconcat vector [file-directory-p directory-files t nil] 6 "\n\n(fn D)"] 9 (#$ . 56648)])
(defalias 'gud-jdb-skip-whitespace #[0 "\300\301w\207" [" \n
\f" nil] 2])
(defalias 'gud-jdb-skip-single-line-comment #[0 "\300\207" [nil] 1])
(defalias 'gud-jdb-skip-traditional-or-documentation-comment #[0 "\300u\210\30121 m?\2050 g\302=\203* \303u\210m\204 g\304=\203 \303u\210\305\301\303\"\210\202 \303u\210\202 0\207" [2 break 42 nil 47 throw] 3])
(defalias 'gud-jdb-skip-whitespace-and-comments #[0 "\300 \210\3012- \302\303!\203 \304 \210\300 \210\202 \302\305!\203% \306 \210\300 \210\202 \307\301\310\"\210\202 \207" [gud-jdb-skip-whitespace done looking-at "//" gud-jdb-skip-single-line-comment "/\\*" gud-jdb-skip-traditional-or-documentation-comment throw nil] 3])
(defalias 'gud-jdb-skip-id-ish-thing #[0 "\300\301w\207" ["^ /\n
\f,;{" nil] 2])
(defalias 'gud-jdb-skip-string-literal #[0 "\300u\210g\301=\203 \300u\202 g\302=\204 \300u\210\202 \300u\207" [nil 92 34] 2])
(defalias 'gud-jdb-skip-character-literal #[0 "\300u\210g\301=\203\f \302u\210g\303=\204 \300u\210\202 \300u\207" [nil 92 2 39] 2])
(defalias 'gud-jdb-skip-block #[0 "g\300=\204< \301\302!\203 \303 \210\202 \301\304!\203 \305 \210\202 g\306=\203* \307 \210\202 g\310=\2036 \311 \210\202 \312u\210\202 \312u\210\313\211\314=?\205\235 \301\302!\203S \303 \210\202@ \301\304!\203_ \305 \210\202@ g\306=\203k \307 \210\202@ g\310=\203w \311 \210\202@ g\300=\203\207 \211T\262\312u\210\202@ g\315=\203\227 \211S\262\312u\210\202@ \312u\210\202@ \207" [123 looking-at "//" gud-jdb-skip-single-line-comment "/\\*" gud-jdb-skip-traditional-or-documentation-comment 34 gud-jdb-skip-string-literal 39 gud-jdb-skip-character-literal nil 1 0 125] 3])
#@17
(fn BUF FILE)
(defalias 'gud-jdb-analyze-source #[514 "\300q\210\301\300\211\211\302%\210\303b\210\3042\351 \305\306 \210m?\205\346 g\307=\203( \300u\210\202 \310\311!\2034 \312 \210\202 \310\313!\203@ \314 \210\202 \310\315!\203g \316u\210\317 \210`\320 \210\211`{\321P\262\317 \210g\307=\203c \300u\210\210\202 \310\322!\203\205 \323u\210\317 \210\320 \210\317 \210g\307=\203 \300u\210\202 \310\324!\203\221 \323u\210\202 \310\325!\203\235 \326u\210\202 \310\327!\203\251 \330u\210\202 \310\331!\203\312 \330u\210\317 \210`\320 \210`{PC\244\262\210\332 \210\202 \310\333!\203\331 \334u\210\332 \210\202 \335\336\"\210\337\304\300\"\210\202 \2620\210\211\207" [nil insert-file-contents t 0 abort "" gud-jdb-skip-whitespace 59 looking-at "//" gud-jdb-skip-single-line-comment "/\\*" gud-jdb-skip-traditional-or-documentation-comment "package" 7 gud-jdb-skip-whitespace-and-comments gud-jdb-skip-id-ish-thing "." "import" 6 "public" "abstract" 8 "final" 5 "class" gud-jdb-skip-block "interface" 9 message "Error parsing file %s." throw] 9 (#$ . 58768)])
#@13
(fn FILE)
(defalias 'gud-jdb-build-class-source-alist-for-file #[257 "\301\302\303\304\305\306!\307\"\310\311%\312\"\"\207" [gud-jdb-analysis-buffer mapcar make-byte-code 257 "\211\300B\207" vconcat vector [] 3 "\n\n(fn C)" gud-jdb-analyze-source] 8 (#$ . 59850)])
#@16
(fn SOURCES)
(defalias 'gud-jdb-build-class-source-alist #[257 "\301\302!\303\304\305\306\"\"\307!\210\310\207" [gud-jdb-analysis-buffer get-buffer-create " *gud-jdb-scratch*" apply nconc mapcar gud-jdb-build-class-source-alist-for-file kill-buffer nil] 6 (#$ . 60127)])
#@18
(fn FILE ARGS)
(defalias 'gud-jdb-massage-args #[514 "\211\205v \302\211\203g \211\204g \303\304@\"\211\262\204` \303\305@\"\211\262\204` \303\306@\"\203> \307\310\311\312@\"\211D\"\262\202` \303\313@\"\203X \307\314\311\312@\"\211D\"\262\202` \307@C\"\262A\262\202 \211\203s \315p!\210\316\317!\210\266\202\207" [gud-jdb-classpath-string gud-jdb-sourcepath nil string-match "-classpath$" "-sourcepath$" "-classpath\\(.+\\)" append "-classpath" match-string 1 "-sourcepath\\(.+\\)" "-sourcepath" kill-buffer error "Error: Omit whitespace between '-classpath or -sourcepath' and its value"] 10 (#$ . 60410)])
#@10
(fn P)
(defalias 'gud-jdb-find-source-file #[257 "\301\"A\207" [gud-jdb-class-source-alist assoc] 4 (#$ . 61050)])
(defvar gud-jdb-lowest-stack-level 999)
#@156 Find source file corresponding to fully qualified class P.
Convert P from jdb's output, converted to a pathname
relative to a classpath directory.
(fn P)
(defalias 'gud-jdb-find-source-using-classpath #[257 "\302 \303\304\305\306\307!\310\"\311$\216\312\313\314\315\316\"\203# \317\320\321\211$\202$ \322\"\323#\324P\325 \"\326\203G \327@\323Q!\211\262\204G A\262\202/ \211\205P @\323Q\266\203)\207" [gud-jdb-sourcepath gud-jdb-classpath match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 mapconcat identity split-string string-match "\\$.*" replace-match "" t "\\." "/" ".java" append nil file-readable-p] 10 (#$ . 61216)])
#@214 Alias for function used to locate source files.
Set to `gud-jdb-find-source-using-classpath' or `gud-jdb-find-source-file'
during jdb initialization depending on the value of
`gud-jdb-use-classpath'.
(fn STRING)
(defalias 'gud-jdb-find-source #[257 "\300\207" [nil] 2 (#$ . 61906)])
#@86 Parse the classpath list and convert each item to an absolute pathname.
(fn STRING)
(defalias 'gud-jdb-parse-classpath-string #[257 "\301\302\301\303\304\305\306Q\"\"\"\207" [path-separator mapcar #[257 "\300\301\"\203 \302\303\304\211$\207\207" [string-match "[/\\]$" replace-match "" nil] 6 "\n\n(fn S)"] file-truename split-string "[ \n
,\"" "]+"] 10 (#$ . 62196)])
#@15
(fn STRING)
(defalias 'gud-jdb-marker-filter #[257 "\203\n P\202 \211 \203+ \n\204+ \306\307\"\204\" \306\310\"\203+ \311\312\313\"\211!\314\306\315\"\203\221 \313\224\203U \314\316\317\313\224T\313\225\320Z#!\262\211\fW\205P \211\321\262\202V \321\203\210 \322\312\320\"!\211\262\203\204 \211\316\312\323\"\306\324\"\203{ \325\326\314\211$\202| \211\262!B\202\210 \327\330!\210\317\331\225\"\202, \306 \"\203\233 \332\210G V\203\257 \317 \333_\323\245[\"\207" [gud-marker-acc gud-jdb-use-classpath gud-jdb-classpath-string gud-jdb-classpath gud-jdb-lowest-stack-level gud-last-frame string-match "classpath:[ []+\\([^]]+\\)" "-classpath[ \"]+\\([^ \"]+\\)" gud-jdb-parse-classpath-string match-string 1 nil "\\(\\[[0-9]+] \\)*\\([a-zA-Z0-9.$_]+\\)\\.[a-zA-Z0-9$_<>(),]+ \\(([a-zA-Z0-9.$_]+:\\|line=\\)\\([0-9.,]+\\)" string-to-number substring 2 t gud-jdb-find-source 4 "[.,]" replace-match "" message "Could not find source file." 0 999 3 comint-prompt-regexp gud-marker-acc-max-length] 10 (#$ . 62578)])
#@42 Command that executes the Java debugger.
(defvar gud-jdb-command-name "jdb" (#$ . 63627))
#@592 Run jdb with command line COMMAND-LINE in a buffer.
The buffer is named "*gud*" if no initial class is given or
"*gud-<initial-class-basename>*" if there is. If the "-classpath"
switch is given, omit all whitespace between it and its value.
See `gud-jdb-use-classpath' and `gud-jdb-classpath' documentation for
information on how jdb accesses source files. Alternatively (if
`gud-jdb-use-classpath' is nil), see `gud-jdb-directories' for the
original source file access method.
For general information about commands available to control jdb from
gud, see `gud-mode'.
(fn COMMAND-LINE)
(defalias 'jdb #[257 "\306\211\307\310!\206 \311\211\203 \312\n!\306\313\314\315#\210\316\303!\210\317\n\203* \312\n!\306 \2034 \312 !\320\321\322\"\210\323\324\321\"\210\325\326\f\327\"\321\"\210\320\330\331\"\210\323\332\330\"\210\325\326\f\333\"\330\"\210\320\334\335\"\210\323\336\334\"\210\325\326\f\337\"\334\"\210\320\340\341\"\210\323\342\340\"\210\325\326\f\343\"\340\"\210\320\344\345\"\210\323\346\344\"\210\325\326\f\347\"\344\"\210\320\350\351\"\210\323\352\350\"\210\325\326\f\353\"\350\"\210\320\354\355\"\210\323\356\354\"\210\325\326\f\357\"\354\"\210\320\360\361\"\210\323\362\360\"\210\325\326\f\363\"\360\"\210\320\364\365\"\210\320\366\367\"\210\323\370\366\"\210\325\326\f\371\"\366\"\210\320\372\373\"\210\374\211@\375\376!\210A\203\377\201E \"\203\377 \201F \201G !\210\201H \201I M\207\201J \201K B\201L \"\211C!D\201H \201M M\207" [gud-jdb-classpath gud-jdb-sourcepath gud-jdb-classpath-string gud-minor-mode gud-key-prefix comint-prompt-regexp nil getenv "CLASSPATH" "." gud-jdb-parse-classpath-string gud-common-init gud-jdb-massage-args gud-jdb-marker-filter make-local-variable jdb defalias gud-break #[257 "?\205 \301\302\"\207" [gud-running gud-call "stop at %c:%l"] 4 "Set breakpoint at current line.\n\n(fn ARG)" #1="p"] local-set-key "" global-set-key vconcat "" gud-remove #[257 "?\205 \301\302\"\207" [gud-running gud-call "clear %c:%l"] 4 "Remove breakpoint at current line\n\n(fn ARG)" #1#] "" "" gud-step #[257 "?\205 \301\302\"\207" [gud-running gud-call "step"] 4 "Step one source line with display.\n\n(fn ARG)" #1#] "" "" gud-next #[257 "?\205 \301\302\"\207" [gud-running gud-call "next"] 4 "Step one line (skip functions).\n\n(fn ARG)" #1#] "" "" gud-cont #[257 "?\205 \301\302\"\207" [gud-running gud-call "cont"] 4 "Continue with display.\n\n(fn ARG)" #1#] "" "" gud-finish #[257 "?\205 \301\302\"\207" [gud-running gud-call "step up"] 4 "Continue until current method returns.\n\n(fn ARG)" #1#] "" "" gud-up #[257 "?\205 \301\302\"\207" [gud-running gud-call "up
where"] 4 "Up one stack frame.\n\n(fn ARG)" #1#] "<" "<" gud-down #[257 "?\205 \301\302\"\207" [gud-running gud-call "down
where"] 4 "Up one stack frame.\n\n(fn ARG)" #1#] ">" ">" gud-run #[257 "?\205 \301\302\"\207" [gud-running gud-call "run"] 4 "Run the program.\n\n(fn ARG)" #1#] gud-print #[257 "?\205 \301\302\"\207" [gud-running gud-call "print %e"] 4 "Print value of expression at point.\n\n(fn ARG)" #1#] "" "" gud-pstar #[257 "?\205 \301\302\"\207" [gud-running gud-call "dump %e"] 4 "Print all object information at point.\n\n(fn ARG)" #1#] "^> \\|^[^ ]+\\[[0-9]+\\] " run-hooks jdb-mode-hook string-match paragraph-start gud-jdb-use-classpath gud-jdb-directories gud-jdb-source-files gud-jdb-class-source-alist "-attach" gud-call "classpath" gud-jdb-find-source gud-jdb-find-source-using-classpath gud-jdb-build-class-source-alist gud-jdb-build-source-files-list "\\.java$" gud-jdb-find-source-file] 6 (#$ . 63724) (byte-code "\300\301!C\207" [gud-query-cmdline jdb] 2)])
(defvar gud-delete-prompt-marker nil)
(put 'gud-mode 'mode-class 'special)
(defvar gud-mode-hook nil)
(byte-code "\300\301N\204\f \302\300\301\303#\210\304\305!\204 \302\305\306\307#\210\300\207" [gud-mode-hook variable-documentation put "Hook run after entering Debugger mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it. (This is true for all hook variables.)" boundp gud-mode-map definition-name gud-mode] 4)
(defvar gud-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" [gud-mode-abbrev-table gud-mode-map variable-documentation put purecopy "Keymap for `gud-mode'." boundp gud-mode-syntax-table definition-name gud-mode (lambda (#1=#:def-tmp-var) (defvar gud-mode-syntax-table #1#)) make-syntax-table "Syntax table for `gud-mode'." (lambda (#1#) (defvar gud-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `gud-mode'." derived-mode-parent comint-mode] 5)
#@2385 Major mode for interacting with an inferior debugger process.
You start it up with one of the commands M-x gdb, M-x sdb, M-x dbx,
M-x perldb, M-x xdb, or M-x jdb. Each entry point finishes by executing a
hook; `gdb-mode-hook', `sdb-mode-hook', `dbx-mode-hook',
`perldb-mode-hook', `xdb-mode-hook', or `jdb-mode-hook' respectively.
After startup, the following commands are available in both the GUD
interaction buffer and any source buffer GUD visits due to a breakpoint stop
or step operation:
\[gud-break] sets a breakpoint at the current file and line. In the
GUD buffer, the current file and line are those of the last breakpoint or
step. In a source buffer, they are the buffer's file and current line.
\[gud-remove] removes breakpoints on the current file and line.
\[gud-refresh] displays in the source window the last line referred to
in the gud buffer.
\[gud-step], \[gud-next], and \[gud-stepi] do a step-one-line,
step-one-line (not entering function calls), and step-one-instruction
and then update the source window with the current file and position.
\[gud-cont] continues execution.
\[gud-print] tries to find the largest C lvalue or function-call expression
around point, and sends it to the debugger for value display.
The above commands are common to all supported debuggers except xdb which
does not support stepping instructions.
Under gdb, sdb and xdb, \[gud-tbreak] behaves exactly like \[gud-break],
except that the breakpoint is temporary; that is, it is removed when
execution stops on it.
Under gdb, dbx, and xdb, \[gud-up] pops up through an enclosing stack
frame. \[gud-down] drops back down through one.
If you are using gdb or xdb, \[gud-finish] runs execution to the return from
the current function and stops.
All the keystrokes above are accessible in the GUD buffer
with the prefix C-c, and in all buffers through the prefix C-x C-a.
All pre-defined functions for which the concept make sense repeat
themselves the appropriate number of times if you give a prefix
argument.
You may use the `gud-def' macro in the initialization hook to define other
commands.
Other commands for interacting with the debugger process are inherited from
comint mode, which see.
In addition to any hooks its parent mode `comint-mode' might have run,
this mode runs the hook `gud-mode-hook', as the final or penultimate step
during initialization.
(defalias 'gud-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\317 \333\334#\210\306\335!\210\336 \337\340!\203| \306\340!\210- \306\341!\210\306\342!\210\307\"\306\343!\210\306\344!\210\345 $\346\347\350\336\307$\210)\351\352!\207" [delay-mode-hooks major-mode mode-name gud-mode-map gud-mode-syntax-table gud-mode-abbrev-table make-local-variable t comint-mode gud-mode "Debugger" 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 (":%s") define-key "\f" gud-refresh gud-last-frame nil boundp tool-bar-map comint-prompt-regexp comint-input-ignoredups paragraph-start gud-delete-prompt-marker make-marker add-hook kill-buffer-hook gud-kill-buffer-hook run-mode-hooks gud-mode-hook local-abbrev-table mode-line-process gud-tool-bar-map] 5 (#$ . 68571) nil])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\207" [custom-declare-variable gud-chdir-before-run funcall function #[0 "\300\207" [t] 1] "Non-nil if GUD should `cd' to the debugged executable." :group gud :type boolean] 8)
#@68
(fn COMMAND-LINE MASSAGE-ARGS MARKER-FILTER &optional FIND-FILE)
(defalias 'gud-common-init #[1027 "\306!\211@A\211\203 \211@\307H\310U\203 \211A\262\202 \211\205& \211@\311\240\210\262\211\205/ \312!A\205B \313!\203A \314!\202B \205K \315\316!P\317\320\321Q!\322\323\324\320\321Q!\325\"!\210\211\203k \326!\203k \327\330!\210\203\200 \203\200 \313!\203\200 \313!n\204\207 \331 \210\332\333\261\210\211\203\240 \211@\311=\204\240 \211A\262\202\216 \211\203\255 \211\334!\211\262\240\210\210\335\336\337P\n\340\203\305 \n\"\202\307 %\210\341 \210\342\302!\210\205\327 \316!\266 \342\303!\210\211\203\352 \342\304!\210\211\340\343\326p!\344\"\210\345\326p!\346\"\210\347 \207" [default-directory gud-chdir-before-run gud-target-name gud-marker-filter gud-find-file gud-last-last-frame split-string-and-unquote 0 45 t substitute-in-file-name file-name-directory expand-file-name "-" file-name-nondirectory get-buffer "*gud" "*" select-window display-buffer get-buffer-create ((display-buffer-reuse-window display-buffer-in-previous-window display-buffer-same-window display-buffer-pop-up-window)) get-buffer-process error "This program is already being debugged" newline "Current directory is " "\n" file-local-name apply make-comint "gud" nil gud-mode make-local-variable set-process-filter gud-filter set-process-sentinel gud-sentinel gud-set-buffer] 21 (#$ . 72323)])
(defalias 'gud-set-buffer #[0 "\301\302!\205 p\211\207" [gud-comint-buffer derived-mode-p gud-mode] 2])
#@110 Non-nil means don't process anything from the debugger right now.
It is saved for when this flag is not set.
(defvar gud-filter-defer-flag nil (#$ . 73858))
#@20
(fn PROC STRING)
(defalias 'gud-filter #[514 "\305\211\306\307!!\205\231 \203 \206 \310P\211\202\231 \311 \203' P\262\305r\307!q\210\214~\210\312\n!\203G \311\313!\n|\210\314 \210\n\305\211\223\210)\315!\262\f\205[ `\313!Y\205[ \316p!\262)\317\"\210)\211\203\206 \320!r\321\322\323\324\325!\326\"\327$\216\330@\331\"\210\332 \210*\210\202\220 r\307!q\210\332 \210)) \205\231 \333\310\"\207" [gud-filter-defer-flag gud-filter-pending-text gud-delete-prompt-marker inhibit-read-only gud-last-frame nil buffer-name process-buffer "" t marker-buffer process-mark comint-update-fence gud-marker-filter get-buffer-window comint-output-filter internal--before-with-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-with-selected-window] 2 select-window norecord gud-display-frame gud-filter] 11 (#$ . 74021)])
(defvar gud-minor-mode-type nil)
(defvar gud-overlay-arrow-position nil)
(add-to-list 'overlay-arrow-variable-list 'gud-overlay-arrow-position)
#@17
(fn PROC MSG)
(defalias 'gud-sentinel #[514 "\306\307!!\204+ \310\311\310\"\210\312\301!\203 \313\230\203 \314\n!\210 \315=\203( \316 \207\317 \207\320!\321>\205\206 \310\322\323\f\"\315=\203D \316 \210\202G \317 \210p\324\325\326\327\330!\331\"\332$\216\307!q\210\333\334\320!!P\335 \210m\203s \336!\337\261\210\202\200 \212db\210\336!\337\261\210)\340!)\262\207" [gud-overlay-arrow-position speedbar-initial-expansion-list-name speedbar-previously-used-expansion-list-name gud-minor-mode-type gud-comint-buffer mode-line-process buffer-name process-buffer nil set-process-buffer boundp "GUD" speedbar-change-initial-expansion-list gdbmi gdb-reset gud-reset process-status (signal exit) buffer-local-value gud-minor-mode make-byte-code 0 "\300q\207" vconcat vector [] 1 ":" symbol-name force-mode-line-update 10 " " delete-process mode-name] 9 (#$ . 75033)])
(defalias 'gud-kill-buffer-hook #[0 "\3021 \303\304p!!\210\305\306\307!!0\207\210\310\207" [gud-minor-mode gud-minor-mode-type (error) kill-process get-buffer-process delete-process get-process "gdb-inferior" nil] 3])
(defalias 'gud-reset #[0 "\302 \211\205$ \211@\211=\204 r\211q\210 \203 \303\304\305!\210)A\266\202\202 \207" [gud-comint-buffer gud-minor-mode buffer-list nil kill-local-variable tool-bar-map] 4])
#@143 Find and obey the last filename-and-line marker from the debugger.
Obeying it means displaying in another window the specified file and line.
(defalias 'gud-display-frame #[0 "\205 \302 \210\303@A\"\210\304\211\207" [gud-last-frame gud-last-last-frame gud-set-buffer gud-display-line nil] 3 (#$ . 76347) nil])
#@23
(fn TRUE-FILE LINE)
(defalias 'gud-display-line #[514 "\306r q\210\307!)\211\205 \310!\206 \311\312\"\313\205\233 rq\210\314!\204? \n\204? \315\316\317\320 \"!\203= \321\306\211\"\210\202? \306\214~\210eb\210Sy\210`\262 \204S \322 `p\223\210\323\324!\203t \f\203h \325 \210\202t
\203t \203t \326 \210)\211eW\204\201 \211dV\203\206 ~\210\211b\210)\205\233 \327 \"\210\330=\205\233 \211)\207" [last-nonmenu-event gud-comint-buffer gud-keep-buffer gud-overlay-arrow-position global-hl-line-mode hl-line-mode t gud-find-file get-buffer-window display-buffer (nil (inhibit-same-window . t)) nil verify-visited-file-modtime yes-or-no-p format "File %s changed on disk. Reread from disk? " buffer-name revert-buffer make-marker featurep hl-line global-hl-line-highlight hl-line-highlight set-window-point gdbmi hl-line-sticky-flag gud-minor-mode gdb-source-window] 9 (#$ . 76670)])
#@16
(fn STR ARG)
(defalias 'gud-format-command #[514 "p=? \206 \n\304 \205 \305\304 !\306\203\347 \306\307\310\")\203\347 \311\312\313\"!\306\314\267\202\322 \315\203: \202< @!\262\202\322 \316\203L \202N @!\262\202\322 \317\203^ \202` @!\262\202\322 \320\203\201 \214~\210\321e`\"n\203{ \322\202| \323\\)\202\203 A!\262\202\322 \324 \262\202\322 \325 \262\202\322 \326\203\242 \304 \202\244 @\203\276 \214~\210\321e`\"n\203\270 \322\202\271 \323\\)\202\301 A\"\262\202\322 \205\320 \320!\262\312\322\n\"Q\266\203\327\313\225\"\262\202 \211P\207" [gud-comint-buffer gud-last-frame gud-last-last-frame case-fold-search buffer-file-name file-local-name nil string-match "\\([^%]*\\)%\\([adefFlpc]\\)" string-to-char match-string 2 #s(hash-table size 8 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (102 48 70 66 100 84 108 102 101 137 97 144 99 151 112 199)) file-name-nondirectory file-name-base file-name-directory int-to-string count-lines 1 0 gud-find-expr gud-read-address gud-find-class substring] 13 (#$ . 77578)])
#@75 Return a string containing the core-address found in the buffer at point.
(defalias 'gud-read-address #[0 "\300 \301\302\303\304\305!\306\"\307$\216\212`\310\211\311\312\313Z\314#\205 `\262\2033 \315u\210\316\317!\210\320u\210`{\202J \321\322!\210\323u\210`\262\323u\210\316\322!\210\320u\210\211`{\266\203*\207" [match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 nil search-backward "0x" 7 t 2 re-search-forward "[^0-9a-f]" -1 re-search-backward "[^0-9]" 1] 8 (#$ . 78673)])
#@26
(fn FMT &optional ARG)
(defalias 'gud-call #[513 "\300\"\301\302\"\210\303\304!\210\305!\207" [gud-format-command message "Command: %s" sit-for 0 gud-basic-call] 6 (#$ . 79205)])
#@78 Invoke the debugger COMMAND displaying source in other window.
(fn COMMAND)
(defalias 'gud-basic-call #[257 "\305 \210\306!\211\204 \307\310!\210rq\210\212\214~\210\311 !\203\" b\210\202* \312!b\210\313y\210\314\n!\2035 `\315\223\210 \316=\203D \317\fD\"\202J \320\321P\"+\207" [gud-comint-buffer gud-delete-prompt-marker comint-prompt-regexp gud-minor-mode comint-input-sender gud-set-buffer get-buffer-process error "Current buffer has no process" marker-position process-mark 0 looking-at nil gdbmi apply process-send-string "\n"] 6 (#$ . 79396) nil])
#@78 Fix up a possibly garbled display, and redraw the arrow.
(fn &optional ARG)
(defalias 'gud-refresh #[256 "\204 \302 \210\303!\207" [gud-last-frame gud-last-last-frame gud-display-frame recenter] 3 (#$ . 79968) "P"])
(defvar gud-find-expr-function 'gud-find-c-expr)
#@19
(fn &rest ARGS)
(defalias 'gud-find-expr #[128 "\203 \203 \306 \307 {\202 \310\n\"\311 \312\313\314\315\316!\317\"\320$\216\321\322\"\203- \323\324!\210r q\210\212\325\326 !!b\210\313y\210\327\f!\203L
`\330\223\210\331
\332\"\210\333\334 \"\335=\204Z \336Pc\210+\210\211\207" [transient-mark-mode mark-active gud-find-expr-function gud-comint-buffer comint-prompt-regexp gud-delete-prompt-marker region-beginning region-end apply match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 string-match "\n" error "Expression must not include a newline" process-mark get-buffer-process looking-at nil set-marker-insertion-type t buffer-local-value gud-minor-mode jdb " = "] 9 (#$ . 80245)])
#@39 Return the expr that surrounds point.
(defalias 'gud-find-c-expr #[0 "\212`\300 \301 \211\2035 \302\"\2035 @AB\262@b\210\301 \262@A{\303\235\2031 \304\262\211\262\210\202 b\210\305 \262\302\"\203Q @AB\262\305 \262\202< @A{\266\203)\207" [gud-innermost-expr gud-prev-expr gud-expr-compound ("if" "while" "for") nil gud-next-expr] 6 (#$ . 80987) nil])
#@271 Return the smallest expr that point is in; move point to beginning of it.
The expr is represented as a cons cell, where the car specifies the point in
the current buffer that marks the beginning of the expr and the cdr specifies
the character after the end of the expr.
(defalias 'gud-innermost-expr #[0 "`\300\211\301 \210`\262\302 \210`\262Y\203! \262b\210\302 \210`\262b\210B\207" [nil gud-backward-sexp gud-forward-sexp] 5 (#$ . 81367)])
#@49 Version of `backward-sexp' that catches errors.
(defalias 'gud-backward-sexp #[0 "\3001 \301 0\207\210\302\207" [(error) backward-sexp t] 1 (#$ . 81826)])
#@48 Version of `forward-sexp' that catches errors.
(defalias 'gud-forward-sexp #[0 "\3001 \301 0\207\210\302\207" [(error) forward-sexp t] 1 (#$ . 81988)])
#@263 Return the previous expr, point is set to beginning of that expr.
The expr is represented as a cons cell, where the car specifies the point in
the current buffer that marks the beginning of the expr and the cdr specifies
the character after the end of the expr.
(defalias 'gud-prev-expr #[0 "\300\211\301 \210`\262\302 \210`\262b\210B\207" [nil gud-backward-sexp gud-forward-sexp] 4 (#$ . 82148)])
#@264 Return the following expr, point is set to beginning of that expr.
The expr is represented as a cons cell, where the car specifies the point in
the current buffer that marks the beginning of the expr and the cdr specifies
the character after the end of the expr.
(defalias 'gud-next-expr #[0 "\300\211\301 \210\301 \210`\262\302 \210`\262B\207" [nil gud-forward-sexp gud-backward-sexp] 4 (#$ . 82558)])
#@240 Scan from SPAN-START to SPAN-END for punctuation characters.
If `->' is found, return `?.'. If `.' is found, return `?.'.
If any other punctuation is found, return `??'.
If no punctuation is found, return `?\s'.
(fn SPAN-START SPAN-END)
(defalias 'gud-expr-compound-sep #[514 "\300\301W\203N fz\262\211\300U\204G \211\302U\203G f\262\211\302U\203) \302\262\202G \211\303U\203A Tf\304U\203A \302\262T\262\202G \262\305\262T\262\202 \207" [32 nil 46 45 62 63] 6 (#$ . 82972)])
#@427 Non-nil if concatenating FIRST and SECOND makes a single C expression.
The two exprs are represented as a cons cells, where the car
specifies the point in the current buffer that marks the beginning of the
expr and the cdr specifies the character after the end of the expr.
Link exprs of the form:
Expr -> Expr
Expr . Expr
Expr (Expr)
Expr [Expr]
(Expr) Expr
[Expr] Expr
(fn FIRST SECOND)
(defalias 'gud-expr-compound #[514 "A@\300\301\"\262@@U\203 \300\202i AAU\203# \300\202i \211\302U\203- \303\202i \211\304U\203h Sf\262f\262\305U\203F \303\202i \306U\203P \303\202i \307U\203Z \303\202i \310U\203d \303\202i \300\202i \300\207" [nil gud-expr-compound-sep 46 t 32 41 93 40 91] 8 (#$ . 83474)])
#@571 Find fully qualified class in file F at line LINE.
This function uses the `gud-jdb-classpath' (and optional
`gud-jdb-sourcepath') list(s) to derive a file
pathname relative to its classpath directory. The values in
`gud-jdb-classpath' are assumed to have been converted to absolute
pathname standards using file-truename.
If F is visited by a buffer and its mode is CC-mode(Java),
syntactic information of LINE is used to find the enclosing (nested)
class string which is appended to the top level
class of the file (using s to separate nested class ids).
(fn F LINE)
(defalias 'gud-find-class #[514 "\203\352 \204\f \n\203\352 \304 \305\306\307\310\311!\312\"\313$\216\314\n \"\315!\316\317\320\321\322 !!\262\203T \204T \323@ \"\203M \324\325\326\327 \306\225T\"\330\"\331#\262A\262\202, \203\333 \332\333!\334\232\203\333 rq\210\316\211\335 !\336=\204\302 \335 \262!\337=\204\207 \211A\203\207 \211A\262\202s !\337=\203\244 !b\210\340\341!\210\314\342\343!C\"\262\202f \335 \262!\204\272 \211A\203\272 \211A\262\202\250 !b\210\202f \323@\344P\"\210\345\324\325\344#\346\211$\262\266)\204\345 \347\350 \"\210\266\205)\207\351 \"\211\203\367 \211@\202\375 \347\352\"\210\316\207" [gud-jdb-use-classpath gud-jdb-classpath gud-jdb-sourcepath gud-jdb-class-source-alist match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 append get-file-buffer nil #[257 "\300@!\207" [c-langelem-sym] 3 "\n\n(fn X)"] #[257 "\300@!\207" [c-langelem-pos] 3 "\n\n(fn X)"] file-name-sans-extension file-truename string-match mapconcat identity split-string substring "/" "." symbol-file java-mode "cc-mode" c-guess-basic-syntax topmost-intro inclass looking-at "[A-Za-z0-9 \n]*?class[ \n]+\\([^ \n]+\\)" match-string-no-properties 1 "$" replace-match t message "gud-find-class: class for file %s not found!" rassoc "gud-find-class: class for file %s not found in gud-jdb-class-source-alist!"] 15 (#$ . 84234)])
(defvar gdb-script-mode-syntax-table (byte-code "\300 \301\302\303#\210\301\304\305#\210\301\306\307#\210\211\207" [make-syntax-table modify-syntax-entry 39 "\"" 35 "<" 10 ">"] 5))
(defvar gdb-script-font-lock-keywords '(("^define\\s-+\\(\\(\\w\\|\\s_\\)+\\)" (1 font-lock-function-name-face)) ("\\$\\(\\w+\\)" (1 font-lock-variable-name-face)) ("^\\s-*\\(\\w\\(\\w\\|\\s_\\)*\\)" (1 font-lock-keyword-face))))
(defconst gdb-script-syntax-propertize-function #[514 "b\210`W\205b \300\301\302#\205b \303\224\203\" \304\303\224\303\225\305\306$\210\202 \307\224\203 \310\311!\211A\312\233\241\210\313!\266\314\224eV\203 \315\212\316\314\224S!)8\303=\203 \304\314\224S\314\224\305\317$\210\304\314\224S\314\225\320\302$\210\202 \207" [re-search-forward "^document\\s-.*\\(\n\\)\\|^end\\(\\>\\)" t 1 put-text-property syntax-table (2097163) 2 match-data ints 4 set-match-data 0 7 syntax-ppss (2097164) syntax-multiline] 7 "\n\n(fn START END)"])
#@14
(fn STATE)
(defalias 'gdb-script-font-lock-syntactic-face #[257 "\3038\203 \207\3048\203 \207\n\207" [font-lock-string-face font-lock-doc-face font-lock-comment-face 3 7] 3 (#$ . 87178)])
(defvar gdb-script-basic-indent 2)
#@64 We're just in front of an `end' and we need to go to its head.
(defalias 'gdb-script-skip-to-head #[0 "\300\301\302\303#\205 \304\225\205 \305 \210\202 \207" [re-search-backward "^\\s-*\\(\\(end\\)\\|define\\|document\\|if\\|while\\|commands\\)\\>" nil move 2 gdb-script-skip-to-head] 4 (#$ . 87415)])
(defalias 'gdb-script-calculate-indentation #[0 "\301\302!\203\f \303 \210\304 \207\301\305!\203( \306\307\310\311#\203% \312\225\203% \303 \210\202 \304 \207\313d[!\210\314y\210\315\310w\210\304 \301\316!\203@ \202A \314\\\207" [gdb-script-basic-indent looking-at "end\\>" gdb-script-skip-to-head current-indentation "else\\>" re-search-backward "^\\s-*\\(if\\|\\(end\\)\\)\\>" nil move 2 forward-comment 0 " " "\\(if\\|while\\|define\\|else\\|commands\\)\\>"] 4])
#@36 Indent current line of GDB script.
(defalias 'gdb-script-indent-line #[0 "\301`\302\"=\203 \212\303y\210\304\305w\210\306\307!)\204 \310\207`\31119 \212\303y\210\304\305w\210`Y\2030 \305\262\312 \303])0\202; \210\303\203G \212\313!)\202J \313!\207" [font-lock-doc-face get-text-property face 0 " " nil looking-at "end\\>" noindent (error) gdb-script-calculate-indentation indent-line-to] 4 (#$ . 88195) nil])
#@78 `beginning-of-defun' function for Gdb script mode.
Treats actions as defuns.
(defalias 'gdb-script-beginning-of-defun #[0 "i\300 X\204\n \301\210\302\303\301\304#\203 \305 \210\202 eb\210\304\207" [current-indentation nil re-search-backward "^define \\|^document " t beginning-of-line] 4 (#$ . 88619)])
#@72 `end-of-defun' function for Gdb script mode.
Treats actions as defuns.
(defalias 'gdb-script-end-of-defun #[0 "\300\210\301\302\300\303#\203 \304 \210\202 db\210\303\207" [nil re-search-forward "^end" t beginning-of-line] 4 (#$ . 88931)])
(defvar gdb-script-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-script-mode-hook variable-documentation put "Hook run after entering GDB-Script 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-script-mode-map definition-name gdb-script-mode] 4)
(defvar gdb-script-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-script-mode-abbrev-table gdb-script-mode-map variable-documentation put purecopy "Keymap for `gdb-script-mode'." boundp gdb-script-mode-syntax-table definition-name gdb-script-mode (lambda (#1=#:def-tmp-var) (defvar gdb-script-mode-syntax-table #1#)) make-syntax-table "Syntax table for `gdb-script-mode'." (lambda (#1#) (defvar gdb-script-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `gdb-script-mode'." derived-mode-parent prog-mode] 5)
#@235 Major mode for editing GDB scripts.
In addition to any hooks its parent mode `prog-mode' might have run,
this mode runs the hook `gdb-script-mode-hook', as the final or penultimate step
during initialization.
\{gdb-script-mode-map}
(defalias 'gdb-script-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
1=\204R \326
\3251C#\210\327 !\210\330\f!\210
1\306\331!\210\332\306\333!\210\334\306\335!\210\336 \306\337!\210\340 \306\341!\210\342!\306\343!\210\344#\306\345!\210\346%\306\347!\210\350'\306\351!\2102)\352\353\354\355\356$\210)\357\360!\207" [delay-mode-hooks major-mode mode-name gdb-script-mode-map gdb-script-mode-syntax-table gdb-script-mode-abbrev-table make-local-variable t prog-mode gdb-script-mode "GDB-Script" 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 comment-start "#" comment-start-skip "#+\\s-*" outline-regexp "[ ]" imenu-generic-expression ((nil "^define[ ]+\\(\\w+\\)" 1)) indent-line-function gdb-script-indent-line beginning-of-defun-function gdb-script-beginning-of-defun end-of-defun-function gdb-script-end-of-defun font-lock-defaults (gdb-script-font-lock-keywords nil nil ((95 . "w")) nil (font-lock-syntactic-face-function . gdb-script-font-lock-syntactic-face)) syntax-propertize-function add-hook syntax-propertize-extend-region-functions syntax-propertize-multiline append local run-mode-hooks gdb-script-mode-hook local-abbrev-table gdb-script-syntax-propertize-function] 5 (#$ . 90378) nil])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313\312\314\315\316&
\207" [custom-declare-variable gud-tooltip-mode funcall function #[0 "\300\207" [nil] 1] "Non-nil if Gud-Tooltip mode is enabled.\nSee the `gud-tooltip-mode' 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 `gud-tooltip-mode'." :set custom-set-minor-mode :initialize custom-initialize-default :group gud tooltip :type boolean] 14)
#@301 Toggle the display of GUD tooltips.
If called interactively, enable Gud-Tooltip 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 'gud-tooltip-mode #[256 "\305 \306\300\307=\203 \310\300!?\202 \311!\312V\"\210\313\314!\210\2038 \315\316\317\"\210\315\320\321\"\210\315\322\323\"\210\324 \325\326#\210\202Q \n\204Q \327\320\321\"\210\327\316\317\"\210\327\322\323\"\210\324 \330\331#\210\332 \210 \203\257 \333 !\203\257 \334\304 \"\335=\203\257 \203\245 \336 \211\203\241 \211@\211 =\204\232 r\211q\210\f\335=\203\231 \337\340\333 \"\204\231 \341\342!\210\343 \210\315\344\343\345\346$\210)A\266\202\202m \210\202\257 \347\342!\210\327\344\343\346#\210\350\351\310\300!\203\273 \352\202\274 \353\"\210\354\355!\203\346 \356\300!\210\305 \203\324 \211\305 \232\203\346 \357\360\361\310\300!\203\341 \362\202\342 \363#\266\210\364 \210\310\300!\207" [gud-tooltip-mode global-map tooltip-mode gud-comint-buffer gud-minor-mode current-message set-default toggle default-value prefix-numeric-value 0 require tooltip add-hook change-major-mode-hook gud-tooltip-change-major-mode pre-command-hook tooltip-hide tooltip-functions gud-tooltip-tips define-key [mouse-movement] gud-tooltip-mouse-motion remove-hook [mouse-movement] ignore gud-tooltip-activate-mouse-motions-if-enabled buffer-name buffer-local-value gdbmi buffer-list string-match "\\`\\*.+\\*\\'" make-local-variable gdb-define-alist gdb-create-define-alist after-save-hook nil t kill-local-variable run-hooks gud-tooltip-mode-hook gud-tooltip-mode-on-hook gud-tooltip-mode-off-hook called-interactively-p any customize-mark-as-set "" message "Gud-Tooltip mode %sabled%s" "en" "dis" force-mode-line-update] 9 (#$ . 92689) (byte-code "\206 \301C\207" [current-prefix-arg toggle] 1)])
(defvar gud-tooltip-mode-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\321\323& \210\311\324\313\314\325DD\326\317\327\330\331\321\322\321\323& \210\311\332\313\314\333DD\334\317\335\321\322\321\323& \210\336\332\337\340\341$\207" [gud-tooltip-mode-map gud-tooltip-mode-hook variable-documentation put "Hook run after entering or leaving `gud-tooltip-mode'.\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 gud-tooltip-mode nil boundp custom-declare-variable gud-tooltip-modes funcall function #[0 "\300\207" [(gud-mode c-mode c++-mode fortran-mode python-mode)] 1] "List of modes for which to enable GUD tooltips." :type (repeat (symbol :tag "Major mode")) :group gud tooltip gud-tooltip-display #[0 "\300\207" [((eq (tooltip-event-buffer gud-tooltip-event) (marker-buffer gud-overlay-arrow-position)))] 1] "List of forms determining where GUD tooltips are displayed.\n\nForms in the list are combined with AND. The default is to display\nonly tooltips in the buffer containing the overlay arrow." sexp :risky t gud-tooltip-echo-area #[0 "\300\207" [nil] 1] "Use the echo area instead of frames for GUD tooltips." boolean make-obsolete-variable "disable Tooltip mode instead" "24.4" set] 12)
#@69 Function added to `change-major-mode-hook' when tooltip mode is on.
(defalias 'gud-tooltip-change-major-mode #[0 "\300\301\302\"\207" [add-hook post-command-hook gud-tooltip-activate-mouse-motions-if-enabled] 3 (#$ . 96009)])
#@69 Reconsider for all buffers whether mouse motion events are desired.
(defalias 'gud-tooltip-activate-mouse-motions-if-enabled #[0 "\303\304\305\"\210\306 \211\205. \211@r\211q\210\203\" \n>\203\" \307\310!\210\202& \307\311!\210)A\266\202\202 \207" [gud-tooltip-mode major-mode gud-tooltip-modes remove-hook post-command-hook gud-tooltip-activate-mouse-motions-if-enabled buffer-list gud-tooltip-activate-mouse-motions t nil] 4 (#$ . 96241)])
#@73 Locally t in a buffer if tooltip processing of mouse motion is enabled.
(defvar gud-tooltip-mouse-motions-active nil (#$ . 96693))
#@135 Activate/deactivate mouse motion events for the current buffer.
ACTIVATEP non-nil means activate mouse motion events.
(fn ACTIVATEP)
(defalias 'gud-tooltip-activate-mouse-motions #[257 "\211\203 \302\300!\210\303\302\301!\210\303\211\207\205 \304\300!\210\304\301!\207" [gud-tooltip-mouse-motions-active track-mouse make-local-variable t kill-local-variable] 3 (#$ . 96831)])
#@72 Command handler for mouse movement events in `global-map'.
(fn EVENT)
(defalias 'gud-tooltip-mouse-motion #[257 "\301 \210\302 @\205 \303!\304 \207" [tooltip-last-mouse-motion-event tooltip-hide mouse-pixel-position copy-sequence tooltip-start-delayed-tip] 3 (#$ . 97219) "e"])
#@113 Non-nil means print expressions with a `*' in front of them.
For C this would dereference a pointer expression.
(defvar gud-tooltip-dereference nil (#$ . 97508))
#@119 The mouse movement event that led to a tooltip display.
This event can be examined by forms in `gud-tooltip-display'.
(defvar gud-tooltip-event nil (#$ . 97677))
#@154 Toggle whether tooltips should show `* expr' or `expr'.
With arg, dereference expr if ARG is positive, otherwise do not dereference.
(fn &optional ARG)
(defalias 'gud-tooltip-dereference #[256 "\211\204 ?\202 \301!\302V\303\304\203 \305\202 \306\"\207" [gud-tooltip-dereference prefix-numeric-value 0 message "Dereferencing is now %s." "on" "off"] 4 (#$ . 97846) "P"])
#@79 Process debugger output and show it in a tooltip window.
(fn PROCESS OUTPUT)
(defalias 'gud-tooltip-process-output #[514 "\303\304!\305\"\211\304!=\204 \306\"\210\266\307\310\"\206% \206% \n?\"\207" [gud-tooltip-echo-area tooltip-use-echo-area tooltip-mode advice--remove-function process-filter gud-tooltip-process-output set-process-filter tooltip-show tooltip-strip-prompt] 7 (#$ . 98230)])
#@68 Return a suitable command to print the expression EXPR.
(fn EXPR)
(defalias 'gud-tooltip-print-command #[257 "\301\267\202 \302\303Q\207\207\304P\207\305P\207\211\306P\207\307\207" [gud-minor-mode #s(hash-table size 6 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (gdbmi 6 guiler 11 dbx 12 pdb 16 xdb 16 sdb 20)) "-data-evaluate-expression \"" "\"" "print " "p " "/" nil] 4 (#$ . 98642)])
#@430 Show tip for identifier or selection under the mouse.
The mouse must either point at an identifier or inside a selected
region for the tip window to be shown. If `gud-tooltip-dereference' is t,
add a `*' in front of the printed expression. In the case of a C program
controlled by GDB, show the associated #define directives when program is
not executing.
This function must return nil if it doesn't handle EVENT.
(fn EVENT)
(defalias 'gud-tooltip-tips #[257 "\306\307!\205\355 \205\355 \205\355 \310 !\205\355 \311 !\211\262\205\355 \312\313!!\205\355 \n\314=\2030 \203: \315\316
B!\205\355 \317!\211\205\353 \n\314=\203s \204s r\320!q\210\321/\"\211\205m \322A0\206j 1\206j 2?\"\210\262)\202\353 3\203} \323P\262\324!\203\222 \n\325=\203\222 \300\326!\210\327\330!\210\211\205\351 \n\314=\203\302 4\203\262 \331\332\333Q\334\306\335DE\"\210\202\350 \331\333P\334\306\336DE\"\210\202\350 \337\340\341\342\343\344\345!\346\"\347$\341\350\351\344\345!\352\"\353\354%B\262\355\306$\210\356!\210\262\262\207" [gud-tooltip-mode gud-comint-buffer gud-minor-mode gdb-active-process gud-tooltip-event gud-tooltip-display nil eventp buffer-name get-buffer-process posn-point event-end gdbmi eval and tooltip-expr-to-print tooltip-event-buffer assoc tooltip-show "*" gud-tooltip-print-command gdb -1 message-box "Using GUD tooltips in this mode is unsafe \nso they have been disabled." gdb-input "server macro expand " "\n" lambda gdb-tooltip-print-1 gdb-tooltip-print advice--add-function :override 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)" gud-tooltip-process-output gud-basic-call gdb-define-alist gud-tooltip-echo-area tooltip-use-echo-area tooltip-mode gud-tooltip-dereference gdb-macro-info] 14 (#$ . 99062)])
(provide 'gud)
Zerion Mini Shell 1.0