Mercurial > emacs
annotate lisp/gud.el @ 2262:29579cd51981
Added unlock and relock.
author | Eric S. Raymond <esr@snark.thyrsus.com> |
---|---|
date | Fri, 19 Mar 1993 07:49:20 +0000 |
parents | 6eb6b48f6bf1 |
children | b626f5b9a0df |
rev | line source |
---|---|
810
80303373daae
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
806
diff
changeset
|
1 ;;; gud.el --- Grand Unified Debugger mode for gdb, sdb, or dbx under Emacs |
80303373daae
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
806
diff
changeset
|
2 |
80303373daae
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
806
diff
changeset
|
3 ;; Author: Eric S. Raymond <eric@snark.thyrsus.com> |
80303373daae
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
806
diff
changeset
|
4 ;; Keywords: unix, tools |
80303373daae
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
806
diff
changeset
|
5 |
868
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
6 ;; %W% |
810
80303373daae
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
806
diff
changeset
|
7 |
80303373daae
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
806
diff
changeset
|
8 ;; Copyright (C) 1992 Free Software Foundation, Inc. |
460 | 9 |
10 ;; This file is part of GNU Emacs. | |
11 | |
12 ;; GNU Emacs is free software; you can redistribute it and/or modify | |
13 ;; it under the terms of the GNU General Public License as published by | |
868
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
14 ;; the Free Software Foundation; either version 2, or (at your option) |
460 | 15 ;; any later version. |
16 | |
17 ;; GNU Emacs is distributed in the hope that it will be useful, | |
18 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of | |
19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
20 ;; GNU General Public License for more details. | |
21 | |
22 ;; You should have received a copy of the GNU General Public License | |
23 ;; along with GNU Emacs; see the file COPYING. If not, write to | |
24 ;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. | |
25 | |
810
80303373daae
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
806
diff
changeset
|
26 ;;; Commentary: |
80303373daae
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
806
diff
changeset
|
27 |
460 | 28 ;; The ancestral gdb.el was by W. Schelter <wfs@rascal.ics.utexas.edu> |
868
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
29 ;; It was later rewritten by rms. Some ideas were due to Masanobu. |
810
80303373daae
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
806
diff
changeset
|
30 ;; Grand Unification (sdb/dbx support) by Eric S. Raymond <esr@thyrsus.com> |
460 | 31 ;; The overloading code was then rewritten by Barry Warsaw <bwarsaw@cen.com>, |
32 ;; who also hacked the mode to use comint.el. | |
33 | |
810
80303373daae
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
806
diff
changeset
|
34 ;; Note: use of this package with sdb requires that your tags.el support |
80303373daae
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
806
diff
changeset
|
35 ;; the find-tag-noselect entry point. Stock distributions up to 18.57 do |
80303373daae
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
806
diff
changeset
|
36 ;; *not* include this feature; if it's not included with this file, email |
80303373daae
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
806
diff
changeset
|
37 ;; esr@snark.thyrsus.com for it or get 18.58. |
80303373daae
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
806
diff
changeset
|
38 |
80303373daae
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
806
diff
changeset
|
39 ;; Further note: due to lossage in the Emacs-18 byte compiler, compiled |
80303373daae
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
806
diff
changeset
|
40 ;; versions of this code will fail with a complaint about gud-step if |
80303373daae
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
806
diff
changeset
|
41 ;; you invoke the gdb or sdb initializers. This should be fixed in 19. |
80303373daae
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
806
diff
changeset
|
42 |
80303373daae
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
806
diff
changeset
|
43 ;;; Code: |
80303373daae
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
806
diff
changeset
|
44 |
460 | 45 (require 'comint) |
923 | 46 (require 'etags) |
460 | 47 |
48 ;; ====================================================================== | |
49 ;; the overloading mechanism | |
50 | |
51 (defun gud-overload-functions (gud-overload-alist) | |
52 "Overload functions defined in GUD-OVERLOAD-ALIST. | |
53 This association list has elements of the form | |
54 (ORIGINAL-FUNCTION-NAME OVERLOAD-FUNCTION)" | |
868
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
55 (mapcar |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
56 (function (lambda (p) (fset (car p) (symbol-function (cdr p))))) |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
57 gud-overload-alist)) |
460 | 58 |
59 (defun gud-debugger-startup (f d) | |
60 (error "GUD not properly entered.")) | |
61 | |
62 (defun gud-marker-filter (proc s) | |
63 (error "GUD not properly entered.")) | |
64 | |
65 (defun gud-visit-file (f) | |
66 (error "GUD not properly entered.")) | |
67 | |
1902
6eb6b48f6bf1
* gud.el (gud-break): With a prefix argument, set a temporary
Jim Blandy <jimb@redhat.com>
parents:
1275
diff
changeset
|
68 (defun gud-set-break (proc f n rest) |
460 | 69 (error "GUD not properly entered.")) |
70 | |
71 ;; This macro is used below to define some basic debugger interface commands. | |
810
80303373daae
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
806
diff
changeset
|
72 ;; Of course you may use `gud-def' with any other debugger command, including |
1255 | 73 ;; user defined ones. |
74 | |
75 ;; A macro call like (gud-def FUNC NAME KEY DOC) expands to a form | |
76 ;; which defines FUNC to send the command NAME to the debugger, gives | |
77 ;; it the docstring DOC, and binds that function to KEY. NAME should | |
78 ;; be a string. If a numeric prefix argument is given to FUNC, it | |
79 ;; gets sent after NAME. | |
460 | 80 |
810
80303373daae
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
806
diff
changeset
|
81 (defmacro gud-def (func name key &optional doc) |
460 | 82 (let* ((cstr (list 'if '(not (= 1 arg)) |
1255 | 83 (list 'format "%s %s" name 'arg) |
84 name))) | |
460 | 85 (list 'progn |
86 (list 'defun func '(arg) | |
87 (or doc "") | |
88 '(interactive "p") | |
89 (list 'gud-call cstr)) | |
914
3122c9756a56
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
889
diff
changeset
|
90 (if key |
3122c9756a56
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
889
diff
changeset
|
91 (list 'define-key 'gud-mode-map key (list 'quote func)))))) |
460 | 92 |
1275
68f025a5fdaa
* gud.el (gud-last-frame): Added defvar for this.
Jim Blandy <jimb@redhat.com>
parents:
1274
diff
changeset
|
93 ;; Where gud-display-frame should put the debugging arrow. This is |
68f025a5fdaa
* gud.el (gud-last-frame): Added defvar for this.
Jim Blandy <jimb@redhat.com>
parents:
1274
diff
changeset
|
94 ;; set by the marker-filter, which scans the debugger's output for |
68f025a5fdaa
* gud.el (gud-last-frame): Added defvar for this.
Jim Blandy <jimb@redhat.com>
parents:
1274
diff
changeset
|
95 ;; indications of the current pc. |
68f025a5fdaa
* gud.el (gud-last-frame): Added defvar for this.
Jim Blandy <jimb@redhat.com>
parents:
1274
diff
changeset
|
96 (defvar gud-last-frame nil) |
68f025a5fdaa
* gud.el (gud-last-frame): Added defvar for this.
Jim Blandy <jimb@redhat.com>
parents:
1274
diff
changeset
|
97 |
460 | 98 ;; All debugger-specific information is collected here |
99 ;; Here's how it works, in case you ever need to add a debugger to the table. | |
100 ;; | |
101 ;; Each entry must define the following at startup: | |
102 ;; | |
103 ;;<name> | |
104 ;; comint-prompt-regexp | |
868
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
105 ;; gud-<name>-debugger-startup |
460 | 106 ;; gud-<name>-marker-filter |
868
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
107 ;; gud-<name>-visit-file |
460 | 108 ;; gud-<name>-set-break |
109 ;; | |
477 | 110 ;; The job of the startup-command method is to fire up a copy of the debugger, |
111 ;; given an object file and source directory. | |
112 ;; | |
113 ;; The job of the marker-filter method is to detect file/line markers in | |
114 ;; strings and set the global gud-last-frame to indicate what display | |
115 ;; action (if any) should be triggered by the marker. Note that only | |
116 ;; whetever the method *returns* is displayed in the buffer; thus, you | |
117 ;; can filter the debugger's output, interpreting some and passing on | |
118 ;; the rest. | |
119 ;; | |
120 ;; The job of the visit-file method is to visit and return the buffer indicated | |
121 ;; by the car of gud-tag-frame. This may be a file name, a tag name, or | |
122 ;; something else. | |
123 ;; | |
1902
6eb6b48f6bf1
* gud.el (gud-break): With a prefix argument, set a temporary
Jim Blandy <jimb@redhat.com>
parents:
1275
diff
changeset
|
124 ;; The job of the gud-set-break method is to send the commands |
6eb6b48f6bf1
* gud.el (gud-break): With a prefix argument, set a temporary
Jim Blandy <jimb@redhat.com>
parents:
1275
diff
changeset
|
125 ;; necessary to set a breakpoint at a given line in a given source |
6eb6b48f6bf1
* gud.el (gud-break): With a prefix argument, set a temporary
Jim Blandy <jimb@redhat.com>
parents:
1275
diff
changeset
|
126 ;; file. If its third argument TEMP is non-nil, the breakpoint set |
6eb6b48f6bf1
* gud.el (gud-break): With a prefix argument, set a temporary
Jim Blandy <jimb@redhat.com>
parents:
1275
diff
changeset
|
127 ;; should be temporary - it should be deleted when it is reached. If |
6eb6b48f6bf1
* gud.el (gud-break): With a prefix argument, set a temporary
Jim Blandy <jimb@redhat.com>
parents:
1275
diff
changeset
|
128 ;; the debugger doesn't support such breakpoints, it should set an |
6eb6b48f6bf1
* gud.el (gud-break): With a prefix argument, set a temporary
Jim Blandy <jimb@redhat.com>
parents:
1275
diff
changeset
|
129 ;; ordinary breakpoint. |
477 | 130 ;; |
131 ;; Debugger-specific information begins here: | |
460 | 132 |
133 ;; ====================================================================== | |
134 ;; gdb functions | |
135 | |
136 (defun gud-gdb-debugger-startup (f d) | |
137 (make-comint (concat "gud-" f) "gdb" nil "-fullname" "-cd" d f)) | |
138 | |
1255 | 139 (defun gud-gdb-marker-filter (proc string) |
140 (if (string-match "\032\032\\([^:\n]*\\):\\([0-9]*\\):.*\n" string) | |
460 | 141 (progn |
142 (setq gud-last-frame | |
143 (cons | |
144 (substring string (match-beginning 1) (match-end 1)) | |
145 (string-to-int | |
146 (substring string (match-beginning 2) (match-end 2))))) | |
147 ;; this computation means the ^Z^Z-initiated marker in the | |
148 ;; input string is never emitted. | |
149 (concat | |
150 (substring string 0 (match-beginning 0)) | |
151 (substring string (match-end 0)) | |
152 )) | |
153 string)) | |
154 | |
155 (defun gud-gdb-visit-file (f) | |
156 (find-file-noselect f)) | |
157 | |
1902
6eb6b48f6bf1
* gud.el (gud-break): With a prefix argument, set a temporary
Jim Blandy <jimb@redhat.com>
parents:
1275
diff
changeset
|
158 (defun gud-gdb-set-break (proc f n temp) |
6eb6b48f6bf1
* gud.el (gud-break): With a prefix argument, set a temporary
Jim Blandy <jimb@redhat.com>
parents:
1275
diff
changeset
|
159 (gud-call "%s %s:%d" (if temp "tbreak" "break") f n)) |
460 | 160 |
477 | 161 ;;;###autoload |
460 | 162 (defun gdb (path) |
163 "Run gdb on program FILE in buffer *gud-FILE*. | |
164 The directory containing FILE becomes the initial working directory | |
165 and source-file directory for your debugger." | |
166 (interactive "fRun gdb on file: ") | |
868
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
167 (gud-overload-functions '((gud-debugger-startup . gud-gdb-debugger-startup) |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
168 (gud-marker-filter . gud-gdb-marker-filter) |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
169 (gud-visit-file . gud-gdb-visit-file) |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
170 (gud-set-break . gud-gdb-set-break))) |
460 | 171 |
889
b2fef2e0c761
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
868
diff
changeset
|
172 (gud-def gud-step "step" "\C-c\C-s" "Step one source line with display") |
b2fef2e0c761
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
868
diff
changeset
|
173 (gud-def gud-stepi "stepi" "\C-c\C-i" "Step one instruction with display") |
b2fef2e0c761
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
868
diff
changeset
|
174 (gud-def gud-next "next" "\C-c\C-n" "Step one line (skip functions)") |
1255 | 175 (gud-def gud-cont "cont" "\C-c\C-r" "Continue with display") |
460 | 176 |
810
80303373daae
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
806
diff
changeset
|
177 (gud-def gud-finish "finish" "\C-c\C-f" "Finish executing current function") |
80303373daae
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
806
diff
changeset
|
178 (gud-def gud-up "up" "\C-c<" "Up N stack frames (numeric arg)") |
80303373daae
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
806
diff
changeset
|
179 (gud-def gud-down "down" "\C-c>" "Down N stack frames (numeric arg)") |
460 | 180 |
181 (gud-common-init path) | |
182 | |
183 (setq comint-prompt-regexp "^(.*gdb[+]?) *") | |
184 (run-hooks 'gdb-mode-hook) | |
185 ) | |
186 | |
187 | |
188 ;; ====================================================================== | |
189 ;; sdb functions | |
190 | |
191 (defun gud-sdb-debugger-startup (f d) | |
192 (make-comint (concat "gud-" f) "sdb" nil f "-" d)) | |
193 | |
1255 | 194 (defun gud-sdb-marker-filter (proc string) |
460 | 195 (if (string-match "\\(^0x\\w* in \\|^\\|\n\\)\\([^:\n]*\\):\\([0-9]*\\):.*\n" |
1255 | 196 string) |
460 | 197 (setq gud-last-frame |
198 (cons | |
199 (substring string (match-beginning 2) (match-end 2)) | |
200 (string-to-int | |
201 (substring string (match-beginning 3) (match-end 3)))))) | |
202 string) | |
203 | |
204 (defun gud-sdb-visit-file (f) | |
868
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
205 (find-tag-noselect f)) |
460 | 206 |
1902
6eb6b48f6bf1
* gud.el (gud-break): With a prefix argument, set a temporary
Jim Blandy <jimb@redhat.com>
parents:
1275
diff
changeset
|
207 ;;; We'll just ignore the TEMP argument for now; I don't know how to |
6eb6b48f6bf1
* gud.el (gud-break): With a prefix argument, set a temporary
Jim Blandy <jimb@redhat.com>
parents:
1275
diff
changeset
|
208 ;;; set temporary breakpoints in sdb. (See the description of the |
6eb6b48f6bf1
* gud.el (gud-break): With a prefix argument, set a temporary
Jim Blandy <jimb@redhat.com>
parents:
1275
diff
changeset
|
209 ;;; gud-set-break method for details.) |
6eb6b48f6bf1
* gud.el (gud-break): With a prefix argument, set a temporary
Jim Blandy <jimb@redhat.com>
parents:
1275
diff
changeset
|
210 (defun gud-sdb-set-break (proc f n temp) |
460 | 211 (gud-queue-send (format "e %s" f) (format "%d b" n))) |
212 | |
477 | 213 ;;;###autoload |
460 | 214 (defun sdb (path) |
215 "Run sdb on program FILE in buffer *gud-FILE*. | |
216 The directory containing FILE becomes the initial working directory | |
217 and source-file directory for your debugger." | |
923 | 218 (interactive "fRun sdb on file: ") |
460 | 219 (if (not (and (boundp 'tags-file-name) (file-exists-p tags-file-name))) |
220 (error "The sdb support requires a valid tags table to work.")) | |
868
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
221 (gud-overload-functions '((gud-debugger-startup . gud-sdb-debugger-startup) |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
222 (gud-marker-filter . gud-sdb-marker-filter) |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
223 (gud-visit-file . gud-sdb-visit-file) |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
224 (gud-set-break . gud-sdb-set-break))) |
460 | 225 |
889
b2fef2e0c761
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
868
diff
changeset
|
226 (gud-def gud-step "s" "\C-c\C-s" "Step one source line with display") |
b2fef2e0c761
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
868
diff
changeset
|
227 (gud-def gud-stepi "i" "\C-c\C-i" "Step one instruction with display") |
b2fef2e0c761
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
868
diff
changeset
|
228 (gud-def gud-next "S" "\C-c\C-n" "Step one source line (skip functions)") |
1255 | 229 (gud-def gud-cont "c" "\C-c\C-r" "Continue with display (`resume')") |
460 | 230 |
231 (gud-common-init path) | |
232 | |
1255 | 233 (setq comint-prompt-regexp "\\(^\\|\n\\)\\*") |
460 | 234 (run-hooks 'sdb-mode-hook) |
235 ) | |
236 | |
237 ;; ====================================================================== | |
238 ;; dbx functions | |
239 | |
240 (defun gud-dbx-debugger-startup (f d) | |
1255 | 241 (make-comint (concat "gud-" f) "dbx" nil f)) |
460 | 242 |
1255 | 243 (defun gud-dbx-marker-filter (proc string) |
460 | 244 (if (string-match |
1255 | 245 "stopped in .* at line \\([0-9]*\\) in file \"\\([^\"]*\\)\"" string) |
460 | 246 (setq gud-last-frame |
247 (cons | |
248 (substring string (match-beginning 2) (match-end 2)) | |
249 (string-to-int | |
250 (substring string (match-beginning 1) (match-end 1)))))) | |
251 string) | |
252 | |
253 (defun gud-dbx-visit-file (f) | |
254 (find-file-noselect f)) | |
255 | |
1902
6eb6b48f6bf1
* gud.el (gud-break): With a prefix argument, set a temporary
Jim Blandy <jimb@redhat.com>
parents:
1275
diff
changeset
|
256 ;;; We'll just ignore the TEMP argument for now; I don't know how to |
6eb6b48f6bf1
* gud.el (gud-break): With a prefix argument, set a temporary
Jim Blandy <jimb@redhat.com>
parents:
1275
diff
changeset
|
257 ;;; set temporary breakpoints in dbx. (See the description of the |
6eb6b48f6bf1
* gud.el (gud-break): With a prefix argument, set a temporary
Jim Blandy <jimb@redhat.com>
parents:
1275
diff
changeset
|
258 ;;; gud-set-break method for details.) |
6eb6b48f6bf1
* gud.el (gud-break): With a prefix argument, set a temporary
Jim Blandy <jimb@redhat.com>
parents:
1275
diff
changeset
|
259 (defun gud-dbx-set-break (proc f n temp) |
460 | 260 (gud-call "stop at \"%s\":%d" f n)) |
261 | |
477 | 262 ;;;###autoload |
460 | 263 (defun dbx (path) |
264 "Run dbx on program FILE in buffer *gud-FILE*. | |
265 The directory containing FILE becomes the initial working directory | |
266 and source-file directory for your debugger." | |
267 (interactive "fRun dbx on file: ") | |
868
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
268 (gud-overload-functions '((gud-debugger-startup . gud-dbx-debugger-startup) |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
269 (gud-marker-filter . gud-dbx-marker-filter) |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
270 (gud-visit-file . gud-dbx-visit-file) |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
271 (gud-set-break . gud-dbx-set-break))) |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
272 |
889
b2fef2e0c761
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
868
diff
changeset
|
273 (gud-def gud-step "step" "\C-c\C-s" "Step one source line with display") |
b2fef2e0c761
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
868
diff
changeset
|
274 (gud-def gud-stepi "stepi" "\C-c\C-i" "Step one instruction with display") |
b2fef2e0c761
*** empty log message ***
Richard M. Stallman <rms@gnu.org>
parents:
868
diff
changeset
|
275 (gud-def gud-next "next" "\C-c\C-n" "Step one line (skip functions)") |
1255 | 276 (gud-def gud-cont "cont" "\C-c\C-r" "Continue with display (`resume')") |
868
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
277 |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
278 (gud-def gud-up "up" "\C-c<" "Up N stack frames (numeric arg)") |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
279 (gud-def gud-down "down" "\C-c>" "Down N stack frames (numeric arg)") |
460 | 280 |
810
80303373daae
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
806
diff
changeset
|
281 (gud-common-init path) |
460 | 282 (setq comint-prompt-regexp "^[^)]*dbx) *") |
283 | |
284 (run-hooks 'dbx-mode-hook) | |
285 ) | |
286 | |
287 ;; | |
288 ;; End of debugger-specific information | |
477 | 289 ;; |
460 | 290 |
291 (defvar gud-mode-map nil | |
292 "Keymap for gud-mode.") | |
293 | |
868
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
294 (defvar gud-commands nil |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
295 "List of strings or functions used by send-gud-command. |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
296 It is for customization by you.") |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
297 |
460 | 298 (defvar gud-command-queue nil) |
299 | |
1256
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
300 ;;; When we send a command to the debugger via gud-call, it's annoying |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
301 ;;; to see the command and the new prompt inserted into the debugger's |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
302 ;;; buffer; we have other ways of knowing the command has completed. |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
303 ;;; |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
304 ;;; If the buffer looks like this: |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
305 ;;; -------------------- |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
306 ;;; (gdb) set args foo bar |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
307 ;;; (gdb) -!- |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
308 ;;; -------------------- |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
309 ;;; (the -!- marks the location of point), and we type `C-x SPC' in a |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
310 ;;; source file to set a breakpoint, we want the buffer to end up like |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
311 ;;; this: |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
312 ;;; -------------------- |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
313 ;;; (gdb) set args foo bar |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
314 ;;; Breakpoint 1 at 0x92: file make-docfile.c, line 49. |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
315 ;;; (gdb) -!- |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
316 ;;; -------------------- |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
317 ;;; Essentially, the old prompt is deleted, and the command's output |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
318 ;;; and the new prompt take its place. |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
319 ;;; |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
320 ;;; Not echoing the command is easy enough; you send it directly using |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
321 ;;; process-send-string, and it never enters the buffer. However, |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
322 ;;; getting rid of the old prompt is trickier; you don't want to do it |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
323 ;;; when you send the command, since that will result in an annoying |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
324 ;;; flicker as the prompt is deleted, redisplay occurs while Emacs |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
325 ;;; waits for a response from the debugger, and the new prompt is |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
326 ;;; inserted. Instead, we'll wait until we actually get some output |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
327 ;;; from the subprocess before we delete the prompt. If the command |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
328 ;;; produced no output other than a new prompt, that prompt will most |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
329 ;;; likely be in the first chunk of output received, so we will delete |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
330 ;;; the prompt and then replace it with an identical one. If the |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
331 ;;; command produces output, the prompt is moving anyway, so the |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
332 ;;; flicker won't be annoying. |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
333 ;;; |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
334 ;;; So - when we want to delete the prompt upon receipt of the next |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
335 ;;; chunk of debugger output, we position gud-delete-prompt-marker at |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
336 ;;; the start of the prompt; the process filter will notice this, and |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
337 ;;; delete all text between it and the process output marker. If |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
338 ;;; gud-delete-prompt-marker points nowhere, we leave the current |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
339 ;;; prompt alone. |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
340 (defvar gud-delete-prompt-marker nil) |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
341 |
460 | 342 (if gud-mode-map |
343 nil | |
344 (setq gud-mode-map (copy-keymap comint-mode-map)) | |
1255 | 345 (define-key gud-mode-map "\C-c\C-l" 'gud-refresh)) |
460 | 346 |
868
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
347 ;; Global mappings --- we'll invoke these from a source buffer. |
460 | 348 (define-key ctl-x-map " " 'gud-break) |
349 (define-key ctl-x-map "&" 'send-gud-command) | |
350 | |
351 | |
352 (defun gud-mode () | |
353 "Major mode for interacting with an inferior debugger process. | |
868
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
354 |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
355 You start it up with one of the commands M-x gdb, M-x sdb, or |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
356 M-x dbx. Each entry point finishes by executing a hook; gdb-mode-hook, |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
357 sdb-mode-hook or dbx-mode-hook respectively. |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
358 |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
359 After startup, the following commands are available: |
460 | 360 |
361 \\{gud-mode-map} | |
362 | |
868
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
363 \\[gud-refresh] displays in the other window the last line referred to |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
364 in the gud buffer. |
460 | 365 |
868
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
366 \\[gud-step], \\[gud-next], and \\[gud-stepi] in the gud window, |
460 | 367 do a step-one-line, step-one-line (not entering function calls), and |
368 step-one-instruction and then update the other window | |
369 with the current file and position. \\[gud-cont] continues | |
370 execution. | |
371 | |
868
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
372 The above commands are common to all supported debuggers. If you are |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
373 using gdb or dbx, the following additional commands will be available: |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
374 |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
375 \\[gud-up] pops up through an enclosing stack frame. \\[gud-down] drops |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
376 back down through one. |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
377 |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
378 If you are using gdb, \\[gdb-finish] runs execution to the return from |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
379 the current function and stops. |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
380 |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
381 These functions repeat themselves the appropriate number of times if you give a |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
382 prefix argument. |
460 | 383 |
868
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
384 If you are in a source file, you may do the following: |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
385 |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
386 Set a breakpoint at the current line by doing \\[gud-break]. This causes |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
387 an appropriate set-break to be send to the debugger; of course, if the file |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
388 you're visiting doesn't correspond to any code in the executable this will |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
389 have no effect or raise an error. |
460 | 390 |
868
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
391 Execute a user-defined command at point with \\[send-gud-command]; the |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
392 prefix argument is taken as an index into the list of strings gud-commands. |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
393 A %s in a gud-commands string is substituted with a number or address picked |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
394 up from point. |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
395 |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
396 Other commands for interacting with the debugger process are inherited from |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
397 comint mode, which see." |
460 | 398 (interactive) |
399 (comint-mode) | |
400 ; (kill-all-local-variables) | |
401 (setq major-mode 'gud-mode) | |
402 (setq mode-name "Debugger") | |
403 (setq mode-line-process '(": %s")) | |
404 (use-local-map gud-mode-map) | |
405 (make-local-variable 'gud-last-frame) | |
406 (setq gud-last-frame nil) | |
407 (make-local-variable 'comint-prompt-regexp) | |
1256
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
408 (make-local-variable 'gud-delete-prompt-marker) |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
409 (setq gud-delete-prompt-marker (make-marker)) |
460 | 410 (run-hooks 'gud-mode-hook) |
411 ) | |
412 | |
413 (defvar current-gud-buffer nil) | |
414 | |
415 (defun gud-common-init (path) | |
416 ;; perform initializations common to all debuggers | |
417 (setq path (expand-file-name path)) | |
418 (let ((file (file-name-nondirectory path))) | |
419 (switch-to-buffer (concat "*gud-" file "*")) | |
420 (setq default-directory (file-name-directory path)) | |
421 (or (bolp) (newline)) | |
422 (insert "Current directory is " default-directory "\n") | |
423 (gud-debugger-startup file default-directory)) | |
424 (gud-mode) | |
425 (set-process-filter (get-buffer-process (current-buffer)) 'gud-filter) | |
426 (set-process-sentinel (get-buffer-process (current-buffer)) 'gud-sentinel) | |
427 (setq gud-command-queue nil) | |
428 (gud-set-buffer) | |
429 ) | |
430 | |
431 (defun gud-set-buffer () | |
432 (cond ((eq major-mode 'gud-mode) | |
433 (setq current-gud-buffer (current-buffer))))) | |
434 | |
435 (defun gud-filter (proc string) | |
436 ;; This function is responsible for inserting output from your debugger | |
437 ;; into the buffer. The hard work is done by the method that is | |
438 ;; the value of gud-marker-filter. | |
439 (let ((inhibit-quit t)) | |
440 (gud-filter-insert proc (gud-marker-filter proc string)) | |
441 ;; If we've got queued commands and we see a prompt, pop one and send it. | |
442 ;; In theory we should check that a prompt has been issued before sending | |
443 ;; queued commands. In practice, command responses from the first through | |
444 ;; penultimate elements of a command sequence are short enough that we | |
445 ;; don't really have to bother. | |
446 (if gud-command-queue | |
447 (progn | |
448 (gud-call (car gud-command-queue)) | |
449 (setq gud-command-queue (cdr gud-command-queue)) | |
450 ) | |
451 ))) | |
452 | |
453 (defun gud-filter-insert (proc string) | |
454 ;; Here's where the actual buffer insertion is done | |
1255 | 455 (save-excursion |
460 | 456 (set-buffer (process-buffer proc)) |
1274
4d867d1bedda
* gud.el (gud-filter-insert): Previous changes misunderstood
Jim Blandy <jimb@redhat.com>
parents:
1257
diff
changeset
|
457 (let ((moving (= (point) (process-mark proc))) |
4d867d1bedda
* gud.el (gud-filter-insert): Previous changes misunderstood
Jim Blandy <jimb@redhat.com>
parents:
1257
diff
changeset
|
458 (output-after-point (< (point) (process-mark proc)))) |
4d867d1bedda
* gud.el (gud-filter-insert): Previous changes misunderstood
Jim Blandy <jimb@redhat.com>
parents:
1257
diff
changeset
|
459 (save-excursion |
4d867d1bedda
* gud.el (gud-filter-insert): Previous changes misunderstood
Jim Blandy <jimb@redhat.com>
parents:
1257
diff
changeset
|
460 (goto-char (process-mark proc)) |
4d867d1bedda
* gud.el (gud-filter-insert): Previous changes misunderstood
Jim Blandy <jimb@redhat.com>
parents:
1257
diff
changeset
|
461 ;; If we have been so requested, delete the debugger prompt. |
4d867d1bedda
* gud.el (gud-filter-insert): Previous changes misunderstood
Jim Blandy <jimb@redhat.com>
parents:
1257
diff
changeset
|
462 (if (marker-buffer gud-delete-prompt-marker) |
4d867d1bedda
* gud.el (gud-filter-insert): Previous changes misunderstood
Jim Blandy <jimb@redhat.com>
parents:
1257
diff
changeset
|
463 (progn |
4d867d1bedda
* gud.el (gud-filter-insert): Previous changes misunderstood
Jim Blandy <jimb@redhat.com>
parents:
1257
diff
changeset
|
464 (delete-region (point) gud-delete-prompt-marker) |
4d867d1bedda
* gud.el (gud-filter-insert): Previous changes misunderstood
Jim Blandy <jimb@redhat.com>
parents:
1257
diff
changeset
|
465 (set-marker gud-delete-prompt-marker nil))) |
4d867d1bedda
* gud.el (gud-filter-insert): Previous changes misunderstood
Jim Blandy <jimb@redhat.com>
parents:
1257
diff
changeset
|
466 (insert-before-markers string) |
4d867d1bedda
* gud.el (gud-filter-insert): Previous changes misunderstood
Jim Blandy <jimb@redhat.com>
parents:
1257
diff
changeset
|
467 ;; Check for a filename-and-line number. |
4d867d1bedda
* gud.el (gud-filter-insert): Previous changes misunderstood
Jim Blandy <jimb@redhat.com>
parents:
1257
diff
changeset
|
468 ;; Don't display the specified file |
4d867d1bedda
* gud.el (gud-filter-insert): Previous changes misunderstood
Jim Blandy <jimb@redhat.com>
parents:
1257
diff
changeset
|
469 ;; unless (1) point is at or after the position where output appears |
4d867d1bedda
* gud.el (gud-filter-insert): Previous changes misunderstood
Jim Blandy <jimb@redhat.com>
parents:
1257
diff
changeset
|
470 ;; and (2) this buffer is on the screen. |
4d867d1bedda
* gud.el (gud-filter-insert): Previous changes misunderstood
Jim Blandy <jimb@redhat.com>
parents:
1257
diff
changeset
|
471 (if (and gud-last-frame |
4d867d1bedda
* gud.el (gud-filter-insert): Previous changes misunderstood
Jim Blandy <jimb@redhat.com>
parents:
1257
diff
changeset
|
472 (not output-after-point) |
4d867d1bedda
* gud.el (gud-filter-insert): Previous changes misunderstood
Jim Blandy <jimb@redhat.com>
parents:
1257
diff
changeset
|
473 (get-buffer-window (current-buffer))) |
4d867d1bedda
* gud.el (gud-filter-insert): Previous changes misunderstood
Jim Blandy <jimb@redhat.com>
parents:
1257
diff
changeset
|
474 (gud-display-frame))) |
4d867d1bedda
* gud.el (gud-filter-insert): Previous changes misunderstood
Jim Blandy <jimb@redhat.com>
parents:
1257
diff
changeset
|
475 (if moving (goto-char (process-mark proc)))))) |
460 | 476 |
477 (defun gud-sentinel (proc msg) | |
478 (cond ((null (buffer-name (process-buffer proc))) | |
479 ;; buffer killed | |
480 ;; Stop displaying an arrow in a source file. | |
481 (setq overlay-arrow-position nil) | |
482 (set-process-buffer proc nil)) | |
483 ((memq (process-status proc) '(signal exit)) | |
484 ;; Stop displaying an arrow in a source file. | |
485 (setq overlay-arrow-position nil) | |
486 ;; Fix the mode line. | |
487 (setq mode-line-process | |
488 (concat ": " | |
489 (symbol-name (process-status proc)))) | |
490 (let* ((obuf (current-buffer))) | |
491 ;; save-excursion isn't the right thing if | |
492 ;; process-buffer is current-buffer | |
493 (unwind-protect | |
494 (progn | |
495 ;; Write something in *compilation* and hack its mode line, | |
496 (set-buffer (process-buffer proc)) | |
497 ;; Force mode line redisplay soon | |
498 (set-buffer-modified-p (buffer-modified-p)) | |
499 (if (eobp) | |
500 (insert ?\n mode-name " " msg) | |
501 (save-excursion | |
502 (goto-char (point-max)) | |
503 (insert ?\n mode-name " " msg))) | |
504 ;; If buffer and mode line will show that the process | |
505 ;; is dead, we can delete it now. Otherwise it | |
506 ;; will stay around until M-x list-processes. | |
507 (delete-process proc)) | |
508 ;; Restore old buffer, but don't restore old point | |
509 ;; if obuf is the gud buffer. | |
510 (set-buffer obuf)))))) | |
511 | |
512 | |
513 (defun gud-refresh (&optional arg) | |
514 "Fix up a possibly garbled display, and redraw the arrow." | |
515 (interactive "P") | |
516 (recenter arg) | |
517 (gud-display-frame)) | |
518 | |
519 (defun gud-display-frame () | |
520 "Find and obey the last filename-and-line marker from the debugger. | |
521 Obeying it means displaying in another window the specified file and line." | |
522 (interactive) | |
523 (if gud-last-frame | |
524 (progn | |
525 (gud-set-buffer) | |
526 (gud-display-line (car gud-last-frame) (cdr gud-last-frame)) | |
527 (setq gud-last-frame nil)))) | |
528 | |
529 ;; Make sure the file named TRUE-FILE is in a buffer that appears on the screen | |
530 ;; and that its line LINE is visible. | |
531 ;; Put the overlay-arrow on the line LINE in that buffer. | |
532 | |
533 (defun gud-display-line (true-file line) | |
534 (let* ((buffer (gud-visit-file true-file)) | |
535 (window (display-buffer buffer t)) | |
536 (pos)) | |
537 (save-excursion | |
538 (set-buffer buffer) | |
539 (save-restriction | |
540 (widen) | |
541 (goto-line line) | |
542 (setq pos (point)) | |
543 (setq overlay-arrow-string "=>") | |
544 (or overlay-arrow-position | |
545 (setq overlay-arrow-position (make-marker))) | |
546 (set-marker overlay-arrow-position (point) (current-buffer))) | |
547 (cond ((or (< pos (point-min)) (> pos (point-max))) | |
548 (widen) | |
549 (goto-char pos)))) | |
550 (set-window-point window overlay-arrow-position))) | |
551 | |
552 (defun gud-call (command &rest args) | |
553 "Invoke the debugger COMMAND displaying source in other window." | |
554 (interactive) | |
555 (gud-set-buffer) | |
556 (let ((command (concat (apply 'format command args) "\n")) | |
557 (proc (get-buffer-process current-gud-buffer))) | |
1256
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
558 |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
559 ;; Arrange for the current prompt to get deleted. |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
560 (save-excursion |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
561 (set-buffer current-gud-buffer) |
1257 | 562 (goto-char (process-mark proc)) |
1256
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
563 (beginning-of-line) |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
564 (if (looking-at comint-prompt-regexp) |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
565 (set-marker gud-delete-prompt-marker (point)))) |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
566 |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
567 (goto-char (point-max)) |
ff24725192d3
* gud.el: When we send a command to the debugger via gud-call,
Jim Blandy <jimb@redhat.com>
parents:
1255
diff
changeset
|
568 (process-send-string proc command))) |
460 | 569 |
570 (defun gud-queue-send (&rest cmdlist) | |
571 ;; Send the first command, queue the rest for send after successive | |
572 ;; send on subsequent prompts | |
573 (interactive) | |
574 (gud-call (car cmdlist)) | |
575 (setq gud-command-queue (append gud-command-queue (cdr cmdlist)))) | |
576 | |
1902
6eb6b48f6bf1
* gud.el (gud-break): With a prefix argument, set a temporary
Jim Blandy <jimb@redhat.com>
parents:
1275
diff
changeset
|
577 (defun gud-apply-from-source (func &rest args) |
6eb6b48f6bf1
* gud.el (gud-break): With a prefix argument, set a temporary
Jim Blandy <jimb@redhat.com>
parents:
1275
diff
changeset
|
578 ;; Apply a method from the gud buffer environment, passing it file |
6eb6b48f6bf1
* gud.el (gud-break): With a prefix argument, set a temporary
Jim Blandy <jimb@redhat.com>
parents:
1275
diff
changeset
|
579 ;; and line, then ARGS. This is intended to be used for gud |
6eb6b48f6bf1
* gud.el (gud-break): With a prefix argument, set a temporary
Jim Blandy <jimb@redhat.com>
parents:
1275
diff
changeset
|
580 ;; commands called from a source file. |
460 | 581 (if (not buffer-file-name) |
582 (error "There is no file associated with this buffer")) | |
583 (let ((file (file-name-nondirectory buffer-file-name)) | |
584 (line (save-restriction (widen) (1+ (count-lines 1 (point)))))) | |
585 (save-excursion | |
586 (gud-set-buffer) | |
1902
6eb6b48f6bf1
* gud.el (gud-break): With a prefix argument, set a temporary
Jim Blandy <jimb@redhat.com>
parents:
1275
diff
changeset
|
587 (apply func |
6eb6b48f6bf1
* gud.el (gud-break): With a prefix argument, set a temporary
Jim Blandy <jimb@redhat.com>
parents:
1275
diff
changeset
|
588 (get-buffer-process current-gud-buffer) |
6eb6b48f6bf1
* gud.el (gud-break): With a prefix argument, set a temporary
Jim Blandy <jimb@redhat.com>
parents:
1275
diff
changeset
|
589 file |
6eb6b48f6bf1
* gud.el (gud-break): With a prefix argument, set a temporary
Jim Blandy <jimb@redhat.com>
parents:
1275
diff
changeset
|
590 line |
6eb6b48f6bf1
* gud.el (gud-break): With a prefix argument, set a temporary
Jim Blandy <jimb@redhat.com>
parents:
1275
diff
changeset
|
591 args) |
460 | 592 ))) |
593 | |
1902
6eb6b48f6bf1
* gud.el (gud-break): With a prefix argument, set a temporary
Jim Blandy <jimb@redhat.com>
parents:
1275
diff
changeset
|
594 (defun gud-break (arg) |
6eb6b48f6bf1
* gud.el (gud-break): With a prefix argument, set a temporary
Jim Blandy <jimb@redhat.com>
parents:
1275
diff
changeset
|
595 "Set breakpoint at this source line. |
6eb6b48f6bf1
* gud.el (gud-break): With a prefix argument, set a temporary
Jim Blandy <jimb@redhat.com>
parents:
1275
diff
changeset
|
596 With prefix argument, set a temporary breakpoint, if the debugger in |
6eb6b48f6bf1
* gud.el (gud-break): With a prefix argument, set a temporary
Jim Blandy <jimb@redhat.com>
parents:
1275
diff
changeset
|
597 use supports such things. (A temporary breakpoint is one which will |
6eb6b48f6bf1
* gud.el (gud-break): With a prefix argument, set a temporary
Jim Blandy <jimb@redhat.com>
parents:
1275
diff
changeset
|
598 be deleted when it is reached.)" |
6eb6b48f6bf1
* gud.el (gud-break): With a prefix argument, set a temporary
Jim Blandy <jimb@redhat.com>
parents:
1275
diff
changeset
|
599 (interactive "P") |
6eb6b48f6bf1
* gud.el (gud-break): With a prefix argument, set a temporary
Jim Blandy <jimb@redhat.com>
parents:
1275
diff
changeset
|
600 (gud-apply-from-source 'gud-set-break arg)) |
460 | 601 |
1255 | 602 (defun gud-read-address () |
460 | 603 "Return a string containing the core-address found in the buffer at point." |
604 (save-excursion | |
1255 | 605 (let ((pt (point)) found begin) |
606 (setq found (if (search-backward "0x" (- pt 7) t)(point))) | |
607 (cond | |
608 (found (forward-char 2) | |
609 (buffer-substring found | |
610 (progn (re-search-forward "[^0-9a-f]") | |
611 (forward-char -1) | |
612 (point)))) | |
613 (t (setq begin (progn (re-search-backward "[^0-9]") | |
614 (forward-char 1) | |
615 (point))) | |
616 (forward-char 1) | |
617 (re-search-forward "[^0-9]") | |
618 (forward-char -1) | |
619 (buffer-substring begin (point))))))) | |
460 | 620 |
621 | |
622 (defun send-gud-command (arg) | |
868
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
623 "This command reads the number where the cursor is positioned. A numeric arg |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
624 selects the ARG'th member COMMAND of the list gud-commands. If COMMAND is a |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
625 string, (format COMMAND ADDR) is inserted at the end of the debugger buffer, |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
626 otherwise (funcall COMMAND ADDR) is inserted. |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
627 For example, \"p (rtx)%s->fld[0].rtint\" is a possible string to be a |
0cda1f7b154e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
810
diff
changeset
|
628 member of gud-commands." |
460 | 629 (interactive "P") |
630 (let (comm addr) | |
631 (if arg (setq comm (nth arg gud-commands))) | |
632 (setq addr (gud-read-address)) | |
633 (if (eq (current-buffer) current-gud-buffer) | |
634 (set-mark (point))) | |
635 (cond (comm | |
636 (setq comm | |
637 (if (stringp comm) (format comm addr) (funcall comm addr)))) | |
638 (t (setq comm addr))) | |
639 (switch-to-buffer current-gud-buffer) | |
923 | 640 (goto-char (point-max)) |
460 | 641 (insert-string comm))) |
477 | 642 |
810
80303373daae
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
806
diff
changeset
|
643 ;;; gud.el ends here |