;ELC ;;; compiled by rms@mole.gnu.ai.mit.edu on Tue Jun 20 12:34:23 1995 ;;; from file /home/fsf/rms/e19/lisp/gud.el ;;; emacs version 19.28.95.3. ;;; 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.28.90"))) (error "`gud.el' was compiled for Emacs 19.29 or later")) (byte-code "!!" [require comint etags] 2) #@48 Prefix of all GUD commands valid in C buffers. (defvar gud-key-prefix "" (#$ . 515)) (byte-code " P\" #!  B #!+ B #" [global-set-key gud-key-prefix "\f" gud-refresh define-key ctl-x-map " " gud-break boundp gud-marker-filter nil current-load-list put permanent-local t gud-find-file] 4) (defalias 'gud-marker-filter #[(&rest args) " \n\"" [apply gud-marker-filter args] 3]) (defalias 'gud-find-file #[(file) "\n\"ʼn\n$\n!" [string-match "//+" file replace-match "/" t gud-find-file] 5]) (byte-code "!\n!\fB # # # # # # # # # # # #" [boundp gud-menu-map make-sparse-keymap "Gud" current-load-list define-key [refresh] ("Refresh" . gud-refresh) [remove] ("Remove Breakpoint" . gud-remove) [tbreak] nil [break] ("Set Breakpoint" . gud-break) [up] [down] [print] ("Print Expression" . gud-print) [finish] [stepi] ("Step Instruction" . gud-stepi) [step] ("Step Line" . gud-step) [next] ("Next Line" . gud-next) [cont] ("Continue" . gud-cont)] 4) #@828 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). (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 (#$ . 1576)])) (byte-code "! B! B!  B‡" [boundp gud-last-frame nil current-load-list gud-last-last-frame gud-gdb-history] 2) (defalias 'gud-gdb-massage-args #[(file args) " B" ["-fullname" args] 2]) (byte-code "! ưB!B!" [boundp gud-gdb-marker-regexp "\\([^" path-separator "\n]*\\)" "\\([0-9]*\\)" ".*\n" current-load-list gud-marker-acc "" make-variable-buffer-local] 7) (defalias 'gud-gdb-marker-filter #[(string) " P \"/ƔƕOȔȕO!B ʉOPʕO\"G ʉOPʔOM P )" [gud-marker-acc string "" output string-match gud-gdb-marker-regexp 1 string-to-int 2 gud-last-frame 0 nil ".*\\'"] 5]) #@65 Return a new keymap which inherits from MAP and has name `Gud'. (defalias 'gud-new-keymap #[(map) "!\n" [make-sparse-keymap "Gud" map] 2 (#$ . 3367)]) #@165 Make sure the current local map has a [menu-bar debug] submap. If it doesn't, replace it with a new map that inherits it, and create such a submap in that new map. (defalias 'gud-make-debug-menu #[nil " \n \"? !! !B#" [current-local-map lookup-key [menu-bar debug] use-local-map gud-new-keymap define-key [menu-bar debug] "Gud" gud-menu-map] 6 (#$ . 3529)]) (defalias 'gud-gdb-find-file #[(f) " !q \"\"\"\"\n*" [find-file-noselect f buf gud-make-debug-menu local-set-key [menu-bar debug tbreak] ("Temporary Breakpoint" . gud-tbreak) [menu-bar debug finish] ("Finish Function" . gud-finish) [menu-bar debug up] ("Up Stack" . gud-up) [menu-bar debug down] ("Down Stack" . gud-down)] 4]) #@57 Keymap for minibuffer prompting of gdb startup command. (defvar gdb-minibuffer-local-map nil (#$ . 4265)) (byte-code "\n!#" [gdb-minibuffer-local-map copy-keymap minibuffer-local-map define-key " " comint-dynamic-complete-filename] 4) #@160 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. (defalias 'gdb #[(command-line) " $M # P\"M # P\"M # P\"M # P\"M # P\"M # P\"M # P\"M # P\"M # P\"M # P\"M # P\"\"\"\"\"\"@ABC!" [gud-common-init command-line gud-gdb-massage-args gud-gdb-marker-filter gud-gdb-find-file 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 temporary breakpoint at current line." "p"] "" "" gud-remove #[(arg) "\n\"" [gud-call "clear %f:%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 [menu-bar debug tbreak] ("Temporary Breakpoint" . gud-tbreak) [menu-bar debug finish] ("Finish Function" . gud-finish) [menu-bar debug up] ("Up Stack" . gud-up) [menu-bar debug down] ("Down Stack" . gud-down) "^(.*gdb[+]?) *" comint-prompt-regexp paragraph-start run-hooks gdb-mode-hook] 5 (#$ . 4520) (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 " B B B B! BLJ" [gud-gdb-complete-in-progress current-load-list gud-gdb-complete-string gud-gdb-complete-break gud-gdb-complete-list boundp gud-comint-buffer nil] 2) #@159 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. (defalias 'gud-gdb-complete-command #[nil "`y !b`{)\f\"ɔ\n\f\nO\f\fP!I!!:)\\@\"\\!\"A@@AjAo*GU@  #T\"U PC+\"+" [end 0 looking-at comint-prompt-regexp command nil command-word string-match "\\(\\`\\| \\)\\([^ ]*\\)\\'" 2 gud-gdb-complete-break gud-gdb-complete-filter gud-marker-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 1 count pos str "\\([^'\\]\\|\\\\'\\)*'" mod "'" comint-dynamic-simple-complete] 5 (#$ . 7005) nil]) (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]) (byte-code "! B‡" [boundp gud-sdb-history nil current-load-list] 2) #@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 "!?" [file-exists-p "/var"] 2) (#$ . 8350)) (byte-code "! B‡" [boundp gud-sdb-lastfile nil current-load-list] 2) (defalias 'gud-sdb-massage-args #[(file args) "" [args] 1]) (defalias 'gud-sdb-marker-filter #[(string) "\n P  #+ƔƕOȔȕO!B  #KƔƕO ȔȕO!B  #_ƔƕO  } #} ΔΕO!B ‰ ϕ #ϕ GU O) " [gud-marker-acc string nil start string-match "\\(^0x\\w* in \\|^\\|\n\\)\\([^:\n]*\\):\\([0-9]*\\):.*\n" 2 string-to-int 3 gud-last-frame "^\\(BREAKPOINT\\|STEPPED\\) process [0-9]+ function [^ ]+ in \\(.+\\)\n\\([0-9]+\\):" gud-sdb-lastfile "^\\(BREAKPOINT\\|STEPPED\\) process [0-9]+ function [^ ]+ in \\(.+\\)\n" "^\\([0-9]+\\):" 1 0 "\n"] 6]) (defalias 'gud-sdb-find-file #[(f) " \n!\n!q \"\f*" [gud-sdb-needs-tags find-tag-noselect f find-file-noselect buf gud-make-debug-menu local-set-key [menu-bar debug tbreak] ("Temporary Breakpoint" . gud-tbreak)] 4]) #@160 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. (defalias 'sdb #[(command-line) "!\n;\n!!$M #P\"M #P\"M #P\"M #P\"M #P\"M #P\"M #P\"M #P\"01\"!" [gud-sdb-needs-tags boundp tags-file-name file-exists-p error "The sdb support requires a valid tags table to work." gud-common-init command-line gud-sdb-massage-args gud-sdb-marker-filter gud-sdb-find-file 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 local-set-key [menu-bar debug tbreak] ("Temporary Breakpoint" . gud-tbreak) run-hooks sdb-mode-hook] 5 (#$ . 9449) (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 "! B‡" [boundp gud-dbx-history nil current-load-list] 2) (defalias 'gud-dbx-massage-args #[(file args) "" [args] 1]) (defalias 'gud-dbx-marker-filter #[(string) "\n P  # #5ǔǕOɔɕO!B\n˕ #C˕5 #P˔O) " [gud-marker-acc string nil start string-match "stopped in .* at line \\([0-9]*\\) in file \"\\([^\"]*\\)\"" "signal .* in .* at line \\([0-9]*\\) in file \"\\([^\"]*\\)\"" 2 string-to-int 1 gud-last-frame 0 "\n" "\\(stopped\\|signal\\)"] 5]) #@69 Non-nil to assume the MIPS/OSF dbx conventions (argument `-emacs'). (defvar gud-mips-p (byte-code "\n\"\n\"\n\"\n\"" [string-match "^mips-[^-]*-ultrix" system-configuration "^mips-[^-]*-riscos" "^mips-[^-]*-osf1" "^alpha-[^-]*-osf"] 3) (#$ . 11767)) (defalias 'gud-mipsdbx-massage-args #[(file args) " B" ["-emacs" args] 2]) (defalias 'gud-mipsdbx-marker-filter #[(string) " P\"/ƔƕOȔȕO!B ʉOPʕO\"G ʉOPʔOM P )" [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]) #@90 Non-nil to assume the interface appropriate for IRIX dbx. This works in IRIX 4, 5 and 6. (defvar gud-irix-p (string-match "^mips-[^-]*-irix" system-configuration) (#$ . 12404)) (defalias 'gud-irixdbx-marker-filter #[(string) "\f \" \" P# P\n\n\"9\f!\"\n\"d\nϔϕO!`\nϔϕO\nӔӕO!B)\n\"\nӔӕO!\nϔϕO!B)\n։O\n*" [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:\",(long)$curline;file\n" "^[^ ][^[]*\\[\"\\([^\"]+\\)\":\\([0-9]+\\), [^]]+]\n" 1 file file-exists-p string-to-int 2 gud-last-frame "\\([0-9]*\\):\\(.*\\)\n" 0] 5]) (defalias 'gud-dbx-find-file #[(f) " !q \"\"\n*" [find-file-noselect f buf gud-make-debug-menu local-set-key [menu-bar debug up] ("Up Stack" . gud-up) [menu-bar debug down] ("Down Stack" . gud-down)] 4]) #@160 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. (defalias 'dbx #[(command-line) "\n$$\n$$\n$wM #P\"M #P\"M #P\"M #P\"\fM #P\"M #P\"M #P\"M #P\"$!\"\fM #P\"M #P\"M #P\"M #P\"M #P\"M #P\"M #P\"M #P\"M #@P\"ABACDEF\"DGH\"IJ!" [gud-mips-p gud-common-init command-line gud-mipsdbx-massage-args gud-mipsdbx-marker-filter gud-dbx-find-file gud-irix-p gud-dbx-massage-args gud-irixdbx-marker-filter gud-dbx-marker-filter gud-up #[(arg) "\n\"" [gud-call "up %p" arg] 3 "Up (numeric arg) stack frames." "p"] define-key current-local-map "<" global-set-key gud-key-prefix "<" gud-down #[(arg) "\n\"" [gud-call "down %p" arg] 3 "Down (numeric arg) stack frames." "p"] ">" ">" gud-break #[(arg) "\n\"" [gud-call "stop at \"%f\":%l" arg] 3 "Set breakpoint at current line." "p"] "" "" 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"] #[(arg) "\n\"" [gud-call "up %p; printf \"%1ld:\",(long)$curline;file\n" arg] 3 "Up (numeric arg) stack frames." "p"] #[(arg) "\n\"" [gud-call "down %p; printf \"%1ld:\",(long)$curline;file\n" arg] 3 "Down (numeric arg) stack frames." "p"] process-send-string get-buffer-process gud-comint-buffer "printf \"%1d:\",(long)$curline;file\n" #[(arg) "\n\"" [gud-call "up %p" arg] 3 "Up (numeric arg) stack frames." "p"] #[(arg) "\n\"" [gud-call "down %p" arg] 3 "Down (numeric arg) stack frames." "p"] #[(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-print #[(arg) "\n\"" [gud-call "print %e" arg] 3 "Evaluate C expression at point." "p"] "" "" "^[^)\n]*dbx) *" comint-prompt-regexp paragraph-start local-set-key [menu-bar debug up] ("Up Stack" . gud-up) [menu-bar debug down] ("Down Stack" . gud-down) run-hooks dbx-mode-hook] 5 (#$ . 13427) (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 "! B‡" [boundp gud-xdb-history nil current-load-list] 2) #@244 *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. (defvar gud-xdb-directories nil (#$ . -16580)) (defalias 'gud-xdb-massage-args #[(file args) " @\nBB A\n* " [gud-xdb-directories nil result directories "-d" args] 4]) #@62 Transform a relative pathname to a full pathname in xdb mode (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 (#$ . 17014)]) (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]) (defalias 'gud-xdb-find-file #[(f) " !)\n!q \"\"\"\"\f)*" [gud-xdb-file-name f realf find-file-noselect buf gud-make-debug-menu local-set-key [menu-bar debug tbreak] ("Temporary Breakpoint" . gud-tbreak) [menu-bar debug finish] ("Finish Function" . gud-finish) [menu-bar debug up] ("Up Stack" . gud-up) [menu-bar debug down] ("Down Stack" . gud-down)] 4]) #@311 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. (defalias 'xdb #[(command-line) " $M # P\"M # P\"M # P\"M # P\"M # P\"M # P\"M # P\"M # P\"M # P\"M # P\"23\"\"\"\"!" [gud-common-init command-line gud-xdb-massage-args gud-xdb-marker-filter gud-xdb-find-file 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 local-set-key [menu-bar debug tbreak] ("Temporary Breakpoint" . gud-tbreak) [menu-bar debug finish] ("Finish Function" . gud-finish) [menu-bar debug up] ("Up Stack" . gud-up) [menu-bar debug down] ("Down Stack" . gud-down) run-hooks xdb-mode-hook] 5 (#$ . 18047) (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 "! B‡" [boundp gud-perldb-history nil current-load-list] 2) (defalias 'gud-perldb-massage-args #[(file args) " @ ABBB" ["-d" args "-emacs"] 4]) (byte-code "! B" [boundp gud-perldb-marker-acc "" current-load-list] 2) (defalias 'gud-perldb-marker-filter #[(string) " P\"/ƔƕOȔȕO!B ʉOPʕO\"G ʉOPʔOM P )" [gud-marker-acc string "" output string-match "\\([^:\n]*\\):\\([0-9]*\\):.*\n" 1 string-to-int 2 gud-last-frame 0 nil ".*\\'"] 5]) (defalias 'gud-perldb-find-file #[(f) " !q \n*" [find-file-noselect f buf gud-make-debug-menu] 3]) #@163 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. (defalias 'perldb #[(command-line) " $M # P\"M # P\"M # P\"M # P\"M # P\"M # P\"\"#!" [gud-common-init command-line gud-perldb-massage-args gud-perldb-marker-filter gud-perldb-find-file 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] 5 (#$ . 20879) (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 "! B‡" [boundp gud-delete-prompt-marker nil current-load-list] 2) #@2157 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. (defalias 'gud-mode #[nil " ! #!!!! !" [comint-mode gud-mode major-mode "Debugger" mode-name (":%s") mode-line-process use-local-map comint-mode-map gud-make-debug-menu 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 (#$ . 22319) nil]) (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]) (defalias 'gud-common-init #[(command-line massage-args marker-filter find-file) " !@\nA\f@HU\fA\f(\f@\fǠ)3!\n\nA N\n!L\n!N\n[!PQ!w!w!n~ ر \f@=\fA\f\f)P  \"%. !! !#\"p!\"p!\" " [gud-chop-words command-line words program w 0 45 t file-word substitute-in-file-name file-subst args file-name-directory expand-file-name file "-" file-name-nondirectory filepart switch-to-buffer "*gud" "*" default-directory newline "Current directory is " "\n" apply make-comint "gud" nil massage-args gud-mode make-local-variable gud-marker-filter marker-filter gud-find-file find-file set-process-filter get-buffer-process gud-filter set-process-sentinel gud-sentinel gud-set-buffer] 9]) (defalias 'gud-set-buffer #[nil "= p" [major-mode gud-mode gud-comint-buffer] 2]) (defalias 'gud-filter #[(proc string) "\f!!D\f!q!$\f!| !\n?`\f!Y?p!? \f \"))" [nil output buffer-name 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]) (defalias 'gud-sentinel #[(proc msg) "\n!!\n\"\n!>Q\n!!P\np ̎\n!q m?Mdb)\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)) force-mode-line-update 10 mode-name " " msg delete-process] 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 #[nil " @A\"ĉ" [gud-last-frame gud-set-buffer gud-display-line gud-last-last-frame nil] 3 (#$ . 26663) nil]) (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]) (defalias '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]) #@75 Return a string containing the core-address found in the buffer at point. (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 (#$ . 27849)]) (defalias 'gud-call #[(fmt &optional arg) " \n\" \"! !)" [gud-format-command fmt arg msg message "Command: %s" sit-for 0 gud-basic-call] 3]) #@64 Invoke the debugger COMMAND displaying source in other window. (defalias 'gud-basic-call #[(command) " P\f! !\fq !by !,\f`͓) \"*" [gud-set-buffer command "\n" get-buffer-process gud-comint-buffer proc error "Current buffer has no process" process-mark 0 looking-at comint-prompt-regexp gud-delete-prompt-marker nil process-send-string] 3 (#$ . 28309) nil]) #@58 Fix up a possibly garbled display, and redraw the arrow. (defalias 'gud-refresh #[(&optional arg) " !\n\n  " [recenter arg gud-last-frame gud-last-last-frame gud-display-frame] 2 (#$ . 28701) "P"]) #@42 Returns the C expr that surrounds point. (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 (#$ . 28912) nil]) #@268 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-cur #[nil "` ` ` Y  b `\nb\n +B" [nil end begin p expr-backward-sexp expr-forward-sexp] 3 (#$ . 29157)]) #@49 Version of `backward-sexp' that catches errors. (defalias 'expr-backward-sexp #[nil "" [nil (backward-sexp) ((error t))] 3 (#$ . 29573)]) #@48 Version of `forward-sexp' that catches errors. (defalias 'expr-forward-sexp #[nil "" [nil (forward-sexp) ((error t))] 3 (#$ . 29722)]) #@264 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-prev #[nil " ` `\nb\n *B" [nil end begin expr-backward-sexp expr-forward-sexp] 2 (#$ . 29869)]) #@266 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-next #[nil " ` ` *B" [nil end begin expr-forward-sexp expr-backward-sexp] 3 (#$ . 30263)]) #@93 Returns '.' for '->' & '.', returns ' ' for white space, returns '?' for other punctuation. (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 (#$ . 30656)]) #@405 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 (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 (#$ . 30975)]) (provide (quote gud))