;ELC ;;; compiled by rms@mole.gnu.ai.mit.edu on Sun Aug 28 02:14:22 1994 ;;; from file /home/fsf/rms/e19/lisp/gud.el ;;; emacs version 19.25.94.1. ;;; bytecomp version FSF 2.10 ;;; optimization is on. ;;; this file uses opcodes which do not exist in Emacs 18. (if (and (boundp 'emacs-version) (or (and (boundp 'epoch::version) epoch::version) (string-lessp emacs-version "19"))) (error "`/home/fsf/rms/e19/lisp/gud.el' was compiled for Emacs 19")) (byte-code "!!" [require comint etags] 2) (defvar gud-key-prefix "" "\ Prefix of all GUD commands valid in C buffers.") (byte-code " P\" #" [global-set-key gud-key-prefix "\f" gud-refresh define-key ctl-x-map " " gud-break] 4) (defalias 'gud-overload-functions #[(gud-overload-alist) "\n\"" [mapcar #[(p) "@AKM" [p] 2] gud-overload-alist] 3 "\ Overload functions defined in GUD-OVERLOAD-ALIST. This association list has elements of the form (ORIGINAL-FUNCTION-NAME OVERLOAD-FUNCTION)"]) (byte-code "\"\"\"" [defalias gud-massage-args #[(file args) "!" [error "GUD not properly entered"] 2] gud-marker-filter #[(str) "!" [error "GUD not properly entered"] 2] gud-find-file #[(f) "!" [error "GUD not properly entered"] 2]] 3) (defalias 'gud-def '(macro . #[(func cmd key &optional doc) "\n\f E\n \nP\nDF\n/\nE\nDEF" [progn defun func (arg) doc "" (interactive "p") gud-call cmd arg key define-key (current-local-map) "" quote global-set-key concat gud-key-prefix] 9 "\ Define FUNC to be a command sending STR 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. %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 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)."])) (byte-code "!!!\"!&!\"\"" [boundp gud-last-frame nil gud-last-last-frame gud-gdb-history defalias gud-gdb-massage-args #[(file args) " \nBB" ["-fullname" file args] 3] gud-marker-acc "" make-variable-buffer-local gud-gdb-marker-filter #[(string) " Ž \fP \"7 ɔɕO ˔˕O!B\f ͉OP ͕O\f \"Q ͉OP ͔OY P+" [match-data match-data ((store-match-data match-data)) gud-marker-acc string "" output string-match "\\([^:\n]*\\):\\([0-9]*\\):.*\n" 1 string-to-int 2 gud-last-frame 0 nil ".*\\'"] 5] gud-gdb-find-file #[(f) " !" [find-file-noselect f] 2]] 3) (defvar gdb-minibuffer-local-map nil "\ Keymap for minibuffer prompting of gdb startup command.") (byte-code "\n!#" [gdb-minibuffer-local-map copy-keymap minibuffer-local-map define-key " " comint-dynamic-complete-filename] 4) (defalias 'gdb #[(command-line) "! !M #\nP\"M #\nP\"M #\nP\"M #\nP\"M #\nP\"M #\nP\"M #\nP\"M #\nP\"M #\nP\"M #\nP\"M #\nP\"\"78!" [gud-overload-functions ((gud-massage-args . gud-gdb-massage-args) (gud-marker-filter . gud-gdb-marker-filter) (gud-find-file . gud-gdb-find-file)) gud-common-init command-line gud-break #[(arg) "\n\"" [gud-call "break %f:%l" arg] 3 "Set breakpoint at current line." "p"] define-key current-local-map "" global-set-key gud-key-prefix "" gud-tbreak #[(arg) "\n\"" [gud-call "tbreak %f:%l" arg] 3 "Set breakpoint at current line." "p"] "" "" gud-remove #[(arg) "\n\"" [gud-call "clear %l" arg] 3 "Remove breakpoint at current line" "p"] "" "" gud-step #[(arg) "\n\"" [gud-call "step %p" arg] 3 "Step one source line with display." "p"] "" "" gud-stepi #[(arg) "\n\"" [gud-call "stepi %p" arg] 3 "Step one instruction with display." "p"] " " " " gud-next #[(arg) "\n\"" [gud-call "next %p" arg] 3 "Step one line (skip functions)." "p"] "" "" gud-cont #[(arg) "\n\"" [gud-call "cont" arg] 3 "Continue with display." "p"] "" "" gud-finish #[(arg) "\n\"" [gud-call "finish" arg] 3 "Finish executing current function." "p"] "" "" gud-up #[(arg) "\n\"" [gud-call "up %p" arg] 3 "Up N stack frames (numeric arg)." "p"] "<" "<" gud-down #[(arg) "\n\"" [gud-call "down %p" arg] 3 "Down N stack frames (numeric arg)." "p"] ">" ">" gud-print #[(arg) "\n\"" [gud-call "print %e" arg] 3 "Evaluate C expression at point." "p"] "" "" local-set-key gud-gdb-complete-command "^(.*gdb[+]?) *" comint-prompt-regexp paragraph-start run-hooks gdb-mode-hook] 4 "\ Run gdb on program FILE in buffer *gud-FILE*. The directory containing FILE becomes the initial working directory and source-file directory for your debugger." (list (read-from-minibuffer "Run gdb (like this): " (if (consp gud-gdb-history) (car gud-gdb-history) "gdb ") gdb-minibuffer-local-map nil (quote (gud-gdb-history . 1))))]) (byte-code "!‡" [boundp gud-comint-buffer nil] 2) (defalias 'gud-gdb-complete-command #[nil "`y !b`{)\f\"ɔ\n\f\nOˎ!\fP!L!!=)_@\"_!\"A@@AmAr*\"+" [end 0 looking-at comint-prompt-regexp command nil command-word string-match "\\(\\`\\| \\)\\([^ ]*\\)\\'" 2 gud-gdb-complete-break ((byte-code "!" [gud-overload-functions ((gud-marker-filter . gud-gdb-marker-filter))] 2)) gud-overload-functions ((gud-marker-filter . gud-gdb-complete-filter)) gud-basic-call "complete " t gud-gdb-complete-in-progress gud-gdb-complete-string gud-gdb-complete-list accept-process-output get-buffer-process gud-comint-buffer "^Undefined command: \"complete\"" error "This version of GDB doesn't support the `complete' command." sort string-lessp second first comint-dynamic-simple-complete] 4 "\ Perform completion on the GDB command preceding point. This is implemented using the GDB `complete' command which isn't available with older versions of GDB." nil]) (byte-code "\"! Ň" [defalias gud-gdb-complete-filter #[(string) " P \" \fŔOB ŕO \"+ ʇ" [gud-gdb-complete-string string string-match "\n" gud-gdb-complete-break 0 gud-gdb-complete-list nil comint-prompt-regexp gud-gdb-complete-in-progress ""] 3] boundp gud-sdb-history nil] 3) (defvar gud-sdb-needs-tags (byte-code "!?" [file-exists-p "/var"] 2) "\ If nil, we're on a System V Release 4 and don't need the tags hack.") (byte-code "!\"\"\"" [boundp gud-sdb-lastfile nil defalias gud-sdb-massage-args #[(file args) " B" [file args] 2] gud-sdb-marker-filter #[(string) "\n\"\nÔÕO\nŔŕO!BL\n\"-\nÔÕOLI\n\"I\nʔʕO!BL\n" [string-match "\\(^0x\\w* in \\|^\\|\n\\)\\([^:\n]*\\):\\([0-9]*\\):.*\n" string 2 string-to-int 3 gud-last-frame "^\\(BREAKPOINT\\|STEPPED\\) process [0-9]+ function [^ ]+ in \\(.+\\)\n" gud-sdb-lastfile "^\\([0-9]+\\):" 1 nil] 5] gud-sdb-find-file #[(f) "\n!\n!" [gud-sdb-needs-tags find-tag-noselect f find-file-noselect] 2]] 3) (defalias 'sdb #[(command-line) "!\n;\n!!! !M #P\"M #P\"M #P\"M #P\"M #P\"M #P\"M #P\"M #P\"/0!" [gud-sdb-needs-tags boundp tags-file-name file-exists-p error "The sdb support requires a valid tags table to work." gud-overload-functions ((gud-massage-args . gud-sdb-massage-args) (gud-marker-filter . gud-sdb-marker-filter) (gud-find-file . gud-sdb-find-file)) gud-common-init command-line gud-break #[(arg) "\n\"" [gud-call "%l b" arg] 3 "Set breakpoint at current line." "p"] define-key current-local-map "" global-set-key gud-key-prefix "" gud-tbreak #[(arg) "\n\"" [gud-call "%l c" arg] 3 "Set temporary breakpoint at current line." "p"] "" "" gud-remove #[(arg) "\n\"" [gud-call "%l d" arg] 3 "Remove breakpoint at current line" "p"] "" "" gud-step #[(arg) "\n\"" [gud-call "s %p" arg] 3 "Step one source line with display." "p"] "" "" gud-stepi #[(arg) "\n\"" [gud-call "i %p" arg] 3 "Step one instruction with display." "p"] " " " " gud-next #[(arg) "\n\"" [gud-call "S %p" arg] 3 "Step one line (skip functions)." "p"] "" "" gud-cont #[(arg) "\n\"" [gud-call "c" arg] 3 "Continue with display." "p"] "" "" gud-print #[(arg) "\n\"" [gud-call "%e/" arg] 3 "Evaluate C expression at point." "p"] "" "" "\\(^\\|\n\\)\\*" comint-prompt-regexp paragraph-start run-hooks sdb-mode-hook] 4 "\ 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." (list (read-from-minibuffer "Run sdb (like this): " (if (consp gud-sdb-history) (car gud-sdb-history) "sdb ") nil nil (quote (gud-sdb-history . 1))))]) (byte-code "!\"\"" [boundp gud-dbx-history nil defalias gud-dbx-massage-args #[(file args) " B" [file args] 2] gud-dbx-marker-filter #[(string) "\n\"\n\"\nĔĕO\nƔƕO!B\n" [string-match "stopped in .* at line \\([0-9]*\\) in file \"\\([^\"]*\\)\"" string "signal .* in .* at line \\([0-9]*\\) in file \"\\([^\"]*\\)\"" 2 string-to-int 1 gud-last-frame] 5]] 3) (defvar gud-mips-p (byte-code "\n\"\n\"\n\"\n\"" [string-match "^mips-[^-]*-ultrix" system-configuration "^mips-[^-]*-riscos" "^mips-[^-]*-osf1" "^alpha-[^-]*-osf"] 3) "\ Non-nil to assume the MIPS/OSF dbx conventions (argument `-emacs').") (byte-code "\"\"" [defalias gud-mipsdbx-massage-args #[(file args) " \nBB" ["-emacs" file args] 3] gud-mipsdbx-marker-filter #[(string) " Ž \fP \"7 ɔɕO ˔˕O!B\f ͉OP ͕O\f \"Q ͉OP ͔OY P+" [match-data match-data ((store-match-data match-data)) gud-marker-acc string "" output string-match "[][ 0-9]*\\([^:\n]*\\):\\([0-9]*\\):.*\n" 1 string-to-int 2 gud-last-frame 0 nil "[][ 0-9]*.*\\'"] 5]] 3) (defvar gud-irix-p (string-match "^mips-[^-]*-irix" system-configuration) "\ Non-nil to assume the interface appropriate for IRIX dbx. This works in IRIX 4 and probably IRIX 5.") (byte-code "\"\"" [defalias gud-irixdbx-marker-filter #[(string) " ŽÉ\"\"&\nP\n-\nP\n \"C!\" \"n ҔҕO!j ҔҕO ֔֕O!B) \" ֔֕O! ҔҕO!B) ىO ," [match-data match-data ((store-match-data match-data)) nil case-fold-search result string-match comint-prompt-regexp string ".*\n" gud-marker-acc "" "^\\(\\[[0-9]+] \\)?Process +[0-9]+ ([^)]*) [^[]+\\[[^]\n]*]\n" process-send-string get-buffer-process gud-comint-buffer "printf \"%1d:\",$curline;file\n" "^[^ ][^[]*\\[\"\\([^\"]+\\)\":\\([0-9]+\\), [^]]+]\n" 1 file file-exists-p string-to-int 2 gud-last-frame "\\([0-9]*\\):\\(.*\\)\n" 0] 5] gud-dbx-find-file #[(f) " !" [find-file-noselect f] 2]] 3) (defalias 'dbx #[(command-line) " ‚ Ă!! FM #P\"M #P\" {M #P\"M #P\"!\"M #P\"M #P\"M #P\"M #P\"M #P\"M #P\"M #P\"M #P\"M #P\"<=!" [gud-overload-functions gud-mips-p ((gud-massage-args . gud-mipsdbx-massage-args) (gud-marker-filter . gud-mipsdbx-marker-filter) (gud-find-file . gud-dbx-find-file)) gud-irix-p ((gud-massage-args . gud-dbx-massage-args) (gud-marker-filter . gud-irixdbx-marker-filter) (gud-find-file . gud-dbx-find-file)) ((gud-massage-args . gud-dbx-massage-args) (gud-marker-filter . gud-dbx-marker-filter) (gud-find-file . gud-dbx-find-file)) gud-common-init command-line gud-break #[(arg) "\n\"" [gud-call "stop at \"%f\":%l" arg] 3 "Set breakpoint at current line." "p"] define-key current-local-map "" global-set-key gud-key-prefix "" gud-finish #[(arg) "\n\"" [gud-call "return" arg] 3 "Finish executing current function." "p"] "" "" #[(arg) "\n\"" [gud-call "stop at \"%d%f\":%l" arg] 3 "Set breakpoint at current line." "p"] #[(arg) "\n\"" [gud-call "return" arg] 3 "Finish executing current function." "p"] process-send-string get-buffer-process gud-comint-buffer "printf \"%1d:\",$curline;file\n" #[(arg) "\n\"" [gud-call "file \"%d%f\"\nstop at %l" arg] 3 "Set breakpoint at current line." "p"] gud-remove #[(arg) "\n\"" [gud-call "clear %l" arg] 3 "Remove breakpoint at current line" "p"] "" "" gud-step #[(arg) "\n\"" [gud-call "step %p" arg] 3 "Step one line with display." "p"] "" "" gud-stepi #[(arg) "\n\"" [gud-call "stepi %p" arg] 3 "Step one instruction with display." "p"] " " " " gud-next #[(arg) "\n\"" [gud-call "next %p" arg] 3 "Step one line (skip functions)." "p"] "" "" gud-cont #[(arg) "\n\"" [gud-call "cont" arg] 3 "Continue with display." "p"] "" "" gud-up #[(arg) "\n\"" [gud-call "up %p" arg] 3 "Up (numeric arg) stack frames." "p"] "<" "<" gud-down #[(arg) "\n\"" [gud-call "down %p" arg] 3 "Down (numeric arg) stack frames." "p"] ">" ">" gud-print #[(arg) "\n\"" [gud-call "print %e" arg] 3 "Evaluate C expression at point." "p"] "" "" "^[^)\n]*dbx) *" comint-prompt-regexp paragraph-start run-hooks dbx-mode-hook] 4 "\ 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." (list (read-from-minibuffer "Run dbx (like this): " (if (consp gud-dbx-history) (car gud-dbx-history) "dbx ") nil nil (quote (gud-dbx-history . 1))))]) (byte-code "!‡" [boundp gud-xdb-history nil] 2) (defvar gud-xdb-directories nil "\ *A list of directories that xdb should search for source code. If nil, only source files in the program directory will be known to xdb. The file names should be absolute, or relative to the directory containing the executable being debugged.") (defalias (quote gud-xdb-massage-args) #[(file args) " @\nBB A \nB*" [gud-xdb-directories nil result directories "-d" file args] 4]) (defalias 'gud-xdb-file-name #[(f) " ! !8 7@ Q!-!)A) )" [nil result file-exists-p f expand-file-name gud-xdb-directories directories "/" path] 4 "\ Transform a relative pathname to a full pathname in xdb mode"]) (byte-code "\"\"" [defalias gud-xdb-marker-filter #[(string) " \f\"\f\"\fP!\fP T \"3 \"T ˔˕O! ͔͕O!SB* Y)" [nil result string-match comint-prompt-regexp string ".*\n" gud-marker-acc "" "\\([^\n :]+\\): [^:]+: \\([0-9]+\\):" "[^: ]+:[ ]+\\([^:]+\\): [^:]+: \\([0-9]+\\):" string-to-int 2 gud-xdb-file-name 1 file line gud-last-frame] 5] gud-xdb-find-file #[(f) " ! \n!)" [gud-xdb-file-name f realf find-file-noselect] 3]] 3) (defalias 'xdb #[(command-line) "! !M #\nP\"M #\nP\"M #\nP\"M #\nP\"M #\nP\"M #\nP\"M #\nP\"M #\nP\"M #\nP\"M #\nP\"12!" [gud-overload-functions ((gud-massage-args . gud-xdb-massage-args) (gud-marker-filter . gud-xdb-marker-filter) (gud-find-file . gud-xdb-find-file)) gud-common-init command-line gud-break #[(arg) "\n\"" [gud-call "b %f:%l" arg] 3 "Set breakpoint at current line." "p"] define-key current-local-map "" global-set-key gud-key-prefix "" gud-tbreak #[(arg) "\n\"" [gud-call "b %f:%l\\t" arg] 3 "Set temporary breakpoint at current line." "p"] "" "" gud-remove #[(arg) "\n\"" [gud-call "db" arg] 3 "Remove breakpoint at current line" "p"] "" "" gud-step #[(arg) "\n\"" [gud-call "s %p" arg] 3 "Step one line with display." "p"] "" "" gud-next #[(arg) "\n\"" [gud-call "S %p" arg] 3 "Step one line (skip functions)." "p"] "" "" gud-cont #[(arg) "\n\"" [gud-call "c" arg] 3 "Continue with display." "p"] "" "" gud-up #[(arg) "\n\"" [gud-call "up %p" arg] 3 "Up (numeric arg) stack frames." "p"] "<" "<" gud-down #[(arg) "\n\"" [gud-call "down %p" arg] 3 "Down (numeric arg) stack frames." "p"] ">" ">" gud-finish #[(arg) "\n\"" [gud-call "bu\\t" arg] 3 "Finish executing current function." "p"] "" "" gud-print #[(arg) "\n\"" [gud-call "p %e" arg] 3 "Evaluate C expression at point." "p"] "" "" "^>" comint-prompt-regexp paragraph-start run-hooks xdb-mode-hook] 4 "\ 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." (list (read-from-minibuffer "Run xdb (like this): " (if (consp gud-xdb-history) (car gud-xdb-history) "xdb ") nil nil (quote (gud-xdb-history . 1))))]) (byte-code "!\"!\"\"" [boundp gud-perldb-history nil defalias gud-perldb-massage-args #[(file args) " BBB" ["-d" file "-emacs" args] 4] gud-perldb-marker-acc "" gud-perldb-marker-filter #[(string) " Ž \fP \"7 ɔɕO ˔˕O!B\f ͉OP ͕O\f \"Q ͉OP ͔OY P+" [match-data match-data ((store-match-data match-data)) gud-marker-acc string "" output string-match "\\([^:\n]*\\):\\([0-9]*\\):.*\n" 1 string-to-int 2 gud-last-frame 0 nil ".*\\'"] 5] gud-perldb-find-file #[(f) " !" [find-file-noselect f] 2]] 3) (defalias 'perldb #[(command-line) "! !M #\nP\"M #\nP\"M #\nP\"M #\nP\"M #\nP\"M #\nP\"!\"!" [gud-overload-functions ((gud-massage-args . gud-perldb-massage-args) (gud-marker-filter . gud-perldb-marker-filter) (gud-find-file . gud-perldb-find-file)) gud-common-init command-line gud-break #[(arg) "\n\"" [gud-call "b %l" arg] 3 "Set breakpoint at current line." "p"] define-key current-local-map "" global-set-key gud-key-prefix "" gud-remove #[(arg) "\n\"" [gud-call "d %l" arg] 3 "Remove breakpoint at current line" "p"] "" "" gud-step #[(arg) "\n\"" [gud-call "s" arg] 3 "Step one source line with display." "p"] "" "" gud-next #[(arg) "\n\"" [gud-call "n" arg] 3 "Step one line (skip functions)." "p"] "" "" gud-cont #[(arg) "\n\"" [gud-call "c" arg] 3 "Continue with display." "p"] "" "" gud-print #[(arg) "\n\"" [gud-call "%e" arg] 3 "Evaluate perl expression at point." "p"] "" "" "^ DB<[0-9]+> " comint-prompt-regexp paragraph-start run-hooks perldb-mode-hook] 4 "\ 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." (list (read-from-minibuffer "Run perldb (like this): " (if (consp gud-perldb-history) (car gud-perldb-history) "perl ") nil nil (quote (gud-perldb-history . 1))))]) (byte-code "!‡" [boundp gud-delete-prompt-marker nil] 2) (defalias 'gud-mode #[nil "  !! #!!!! !" [comint-mode gud-mode major-mode "Debugger" mode-name (":%s") mode-line-process use-local-map copy-keymap comint-mode-map define-key current-local-map "\f" gud-refresh make-local-variable gud-last-frame nil comint-prompt-regexp paragraph-start gud-delete-prompt-marker make-marker run-hooks gud-mode-hook] 4 "\ 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, or M-x xdb. Each entry point finishes by executing a hook; `gdb-mode-hook', `sdb-mode-hook', `dbx-mode-hook' or `xdb-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." nil]) (byte-code "\"\"\"\"\"" [defalias gud-chop-words #[(string) " G\fWK H>B O BT\fW: H>: T& T T \fWX O B ," [0 string nil words len beg i (9 32) (9 32)] 5] gud-common-init #[(command-line) " !@\nA\f@HU\fA\f@)\nA\" 6!!\fA\f!Q!V\f!n] ֱP w\f \"%. p!\"p!\" " [gud-chop-words command-line words program w 0 45 file-word delq args expand-file-name substitute-in-file-name file file-name-nondirectory filepart switch-to-buffer "*gud-" "*" file-name-directory default-directory newline "Current directory is " "\n" apply make-comint "gud-" nil gud-massage-args gud-mode set-process-filter get-buffer-process gud-filter set-process-sentinel gud-sentinel gud-set-buffer] 9] gud-set-buffer #[nil "= p" [major-mode gud-mode gud-comint-buffer] 2] gud-filter #[(proc string) " !q! !|\n! 9` !Y9p!9 \n\"+" [t nil output inhibit-quit process-buffer proc marker-buffer gud-delete-prompt-marker process-mark gud-marker-filter string gud-last-frame get-buffer-window gud-display-frame comint-output-filter] 3] gud-sentinel #[(proc msg) "\n!!\n\"\n!>S\n!!P\np ̎\n!q !mAOdb)\n!*" [buffer-name process-buffer proc nil overlay-arrow-position set-process-buffer process-status (signal exit) ":" symbol-name mode-line-process obuf ((set-buffer obuf)) set-buffer-modified-p buffer-modified-p 10 mode-name " " msg delete-process] 4]] 3) (defalias 'gud-display-frame #[nil " @A\"ĉ" [gud-last-frame gud-set-buffer gud-display-line gud-last-last-frame nil] 3 "\ Find and obey the last filename-and-line marker from the debugger. Obeying it means displaying in another window the specified file and line." nil]) (byte-code "\"\"" [defalias gud-display-line #[(true-file line) " !\f!\fq~\n!`\f )   `p)eW>dVD~b) \"," [t last-nonmenu-event gud-find-file true-file buffer display-buffer window nil pos goto-line line "=>" overlay-arrow-string overlay-arrow-position make-marker set-window-point] 3] gud-format-command #[(str arg) "p=? \n\"˔O!\f =A9 ; @!\f =[S U @!\f =~wy~`\"T*y A\f = \f = \f =!\f\f֔֕O\fQ*˕O\fP+" [gud-comint-buffer gud-last-frame gud-last-last-frame nil result frame insource str string-match "\\([^%]*\\)%\\([adeflp]\\)" string-to-char 2 subst key 102 file-name-nondirectory buffer-file-name 100 file-name-directory 108 0 count-lines 1 101 find-c-expr 97 gud-read-address 112 arg int-to-string ""] 5]] 3) (defalias 'gud-read-address #[nil "` Z#`'u\n!u`{=!u`u!u `{," [nil begin found pt search-backward "0x" 7 t 2 re-search-forward "[^0-9a-f]" -1 re-search-backward "[^0-9]" 1] 5 "\ Return a string containing the core-address found in the buffer at point."]) (defalias (quote gud-call) #[(fmt &optional arg) " \n\" \"! !)" [gud-format-command fmt arg msg message "Command: %s" sit-for 0 gud-basic-call] 3]) (defalias 'gud-basic-call #[(command) " P\f!\fq !by !$\n`˓) \"*" [gud-set-buffer command "\n" get-buffer-process gud-comint-buffer proc process-mark 0 looking-at comint-prompt-regexp gud-delete-prompt-marker nil process-send-string] 3 "\ Invoke the debugger COMMAND displaying source in other window." nil]) (defalias 'gud-refresh #[(&optional arg) " !\n\n  " [recenter arg gud-last-frame gud-last-last-frame gud-display-frame] 2 "\ Fix up a possibly garbled display, and redraw the arrow." "P"]) (defalias 'find-c-expr #[nil "`   \n\"& @\nAB@b  b \n \"?\n@ AB ,\n@\nA{," [nil test-expr expr p expr-cur expr-prev expr-compound expr-next] 4 "\ Returns the C expr that surrounds point." nil]) (defalias 'expr-cur #[nil "` ` ` Y  b `\nb\n +B" [nil end begin p expr-backward-sexp expr-forward-sexp] 3 "\ Returns the expr that point is in; point is set to beginning of 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 'expr-backward-sexp #[nil "" [nil (backward-sexp) ((error t))] 3 "\ Version of `backward-sexp' that catches errors."]) (defalias 'expr-forward-sexp #[nil "" [nil (forward-sexp) ((error t))] 3 "\ Version of `forward-sexp' that catches errors."]) (defalias 'expr-prev #[nil " ` `\nb\n *B" [nil end begin expr-backward-sexp expr-forward-sexp] 2 "\ Returns 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 'expr-next #[nil " ` ` *B" [nil end begin expr-forward-sexp expr-backward-sexp] 3 "\ Returns 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 'expr-compound-sep #[(span-start span-end) "\f WL\ffzUD\nUD\ffU(D\nU@\f\\fU@\f\\D \f\\ *" [32 nil syntax result span-start span-end 46 45 1 62 63] 3 "\ Returns '.' for '->' & '.', returns ' ' for white space, returns '?' for other punctuation."]) (defalias 'expr-compound #[(first second) "A @ \f\"@ @U‚jA AU%‚j U/Ȃj Ui Zf\ff UGȂj UQȂj\fU[Ȃj\fUeȂj‚j+" [first second nil syntax span-end span-start expr-compound-sep 46 t 32 1 41 93 40 91] 3 "\ Non-nil if concatenating FIRST and SECOND makes a single C token. 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"]) (provide (quote gud))