| blob | dac53a13469b2a97eef6a4d026fc7bd52d558576 |
1 ;;; gud.el --- Grand Unified Debugger mode for gdb, sdb, dbx, or xdb
2 ;;; under Emacs
4 ;; Author: Eric S. Raymond <esr@snark.thyrsus.com>
5 ;; Maintainer: FSF
6 ;; Keywords: unix, tools
8 ;; Copyright (C) 1992, 1993, 1994 Free Software Foundation, Inc.
10 ;; This file is part of GNU Emacs.
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
14 ;; the Free Software Foundation; either version 2, or (at your option)
15 ;; any later version.
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.
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.
26 ;;; Commentary:
28 ;; The ancestral gdb.el was by W. Schelter <wfs@rascal.ics.utexas.edu>
29 ;; It was later rewritten by rms. Some ideas were due to Masanobu.
30 ;; Grand Unification (sdb/dbx support) by Eric S. Raymond <esr@thyrsus.com>
31 ;; The overloading code was then rewritten by Barry Warsaw <bwarsaw@cen.com>,
32 ;; who also hacked the mode to use comint.el. Shane Hartman <shane@spr.com>
33 ;; added support for xdb (HPUX debugger). Rick Sladkey <jrs@world.std.com>
34 ;; wrote the GDB command completion code. Dave Love <d.love@dl.ac.uk>
35 ;; added the IRIX kluge, re-implemented the Mips-ish variant and added
36 ;; a menu.
38 ;;; Code:
43 ;; ======================================================================
44 ;; GUD commands must be visible in C buffers visited by GUD
66 ;; Don't get confused by double slashes in the name that comes from GDB.
70 \f
71 ;; ======================================================================
72 ;; command definition
74 ;; This macro is used below to define some basic debugger interface commands.
75 ;; Of course you may use `gud-def' with any other debugger command, including
76 ;; user defined ones.
78 ;; A macro call like (gud-def FUNC NAME KEY DOC) expands to a form
79 ;; which defines FUNC to send the command NAME to the debugger, gives
80 ;; it the docstring DOC, and binds that function to KEY in the GUD
81 ;; major mode. The function is also bound in the global keymap with the
82 ;; GUD prefix.
85 "Define FUNC to be a command sending STR and bound to KEY, with
86 optional doc string DOC. Certain %-escapes in the string arguments
87 are interpreted specially if present. These are:
89 %f name (without directory) of current source file.
90 %d directory of current source file.
91 %l number of current source line
92 %e text of the C lvalue or function-call expression surrounding point.
93 %a text of the hexadecimal address surrounding point
94 %p prefix argument to the command (if any) as a number
96 The `current' source file is the file of the current buffer (if
97 we're in a C file) or the source file current at the last break or
98 step (if we're in the GUD buffer).
99 The `current' line is that of the current buffer (if we're in a
100 source file) or the source line number at the last break or step (if
101 we're in the GUD buffer)."
117 ;; Where gud-display-frame should put the debugging arrow. This is
118 ;; set by the marker-filter, which scans the debugger's output for
119 ;; indications of the current program counter.
122 ;; Used by gud-refresh, which should cause gud-display-frame to redisplay
123 ;; the last frame, even if it's been called before and gud-last-frame has
124 ;; been set to nil.
127 ;; All debugger-specific information is collected here.
128 ;; Here's how it works, in case you ever need to add a debugger to the mode.
129 ;;
130 ;; Each entry must define the following at startup:
131 ;;
132 ;;<name>
133 ;; comint-prompt-regexp
134 ;; gud-<name>-massage-args
135 ;; gud-<name>-marker-filter
136 ;; gud-<name>-find-file
137 ;;
138 ;; The job of the massage-args method is to modify the given list of
139 ;; debugger arguments before running the debugger.
140 ;;
141 ;; The job of the marker-filter method is to detect file/line markers in
142 ;; strings and set the global gud-last-frame to indicate what display
143 ;; action (if any) should be triggered by the marker. Note that only
144 ;; whatever the method *returns* is displayed in the buffer; thus, you
145 ;; can filter the debugger's output, interpreting some and passing on
146 ;; the rest.
147 ;;
148 ;; The job of the find-file method is to visit and return the buffer indicated
149 ;; by the car of gud-tag-frame. This may be a file name, a tag name, or
150 ;; something else. It would be good if it also copied the Gud menubar entry.
151 \f
152 ;; ======================================================================
153 ;; gdb functions
155 ;;; History of argument lists passed to gdb.
161 ;; There's no guarantee that Emacs will hand the filter the entire
162 ;; marker at once; it could be broken up across several strings. We
163 ;; might even receive a big chunk with several markers in it. If we
164 ;; receive a chunk of text which looks like it might contain the
165 ;; beginning of a marker, we save it here between calls to the
166 ;; filter.
174 ;; Process all the complete markers in this chunk.
176 gud-marker-acc)
179 ;; Extract the frame position from the marker.
180 gud-last-frame
186 ;; Append any text before the marker to the output we're going
187 ;; to return - we don't include the marker in this text.
191 ;; Set the accumulator to the remaining text.
194 ;; Does the remaining text look like it might end with the
195 ;; beginning of another marker? If it does, then keep it in
196 ;; gud-marker-acc until we receive the rest of it. Since we
197 ;; know the full marker regexp above failed, it's pretty simple to
198 ;; test for marker starts.
201 ;; Everything before the potential marker start can be output.
205 ;; Everything after, we save, to combine with later input.
212 output))
220 ()
225 ;;;###autoload
227 "Run gdb on program FILE in buffer *gud-FILE*.
228 The directory containing FILE becomes the initial working directory
229 and source-file directory for your debugger."
235 gdb-minibuffer-local-map nil
261 )
263 ;; One of the nice features of GDB is its impressive support for
264 ;; context-sensitive command completion. We preserve that feature
265 ;; in the GUD buffer by using a GDB command designed just for Emacs.
267 ;; The completion process filter indicates when it is finished.
270 ;; Since output may arrive in fragments we accumulate partials strings here.
273 ;; We need to know how much of the completion to chop off.
276 ;; The completion list is constructed by the process filter.
282 "Perform completion on the GDB command preceding point.
283 This is implemented using the GDB `complete' command which isn't
284 available with older versions of GDB."
292 command-word)
293 ;; Find the word break. This match will always succeed.
297 ;; Temporarily install our filter function.
299 ;; Issue the command to GDB.
302 gud-gdb-complete-string nil
303 gud-gdb-complete-list nil)
304 ;; Slurp the output.
307 ;; Protect against old versions of GDB.
312 ;; Sort the list like readline.
315 ;; Remove duplicates.
323 ;; Add a trailing single quote if there is a unique completion
324 ;; and it contains an odd number of unquoted single quotes.
334 ;; Let comint handle the rest.
337 ;; The completion process filter is installed temporarily to slurp the
338 ;; output of GDB up to the next prompt and build the completion list.
344 gud-gdb-complete-list))
349 string)
354 \f
355 ;; ======================================================================
356 ;; sdb functions
358 ;;; History of argument lists passed to sdb.
373 ;; Process all complete markers in this chunk
376 ;; System V Release 3.2 uses this format
378 gud-marker-acc start)
384 ;; System V Release 4.0 quite often clumps two lines together
385 ((string-match "^\\(BREAKPOINT\\|STEPPED\\) process [0-9]+ function [^ ]+ in \\(.+\\)\n\\([0-9]+\\):"
386 gud-marker-acc start)
391 gud-sdb-lastfile
394 ;; System V Release 4.0
396 gud-marker-acc start)
400 gud-marker-acc start))
403 gud-sdb-lastfile
410 ;; Search for the last incomplete line in this chunk
414 ;; If we have an incomplete line, store it in gud-marker-acc.
415 ;; Otherwise clear gud-marker-acc. to avoid an
416 ;; unnecessary concat when this function runs next.
420 nil)))
421 string)
428 ;;;###autoload
430 "Run sdb on program FILE in buffer *gud-FILE*.
431 The directory containing FILE becomes the initial working directory
432 and source-file directory for your debugger."
438 nil nil
463 )
464 \f
465 ;; ======================================================================
466 ;; dbx functions
468 ;;; History of argument lists passed to dbx.
478 ;; Process all complete markers in this chunk.
481 gud-marker-acc start)
484 gud-marker-acc start))
492 ;; Search for the last incomplete line in this chunk
496 ;; If the incomplete line APPEARS to begin with another marker, keep it
497 ;; in the accumulator. Otherwise, clear the accumulator to avoid an
498 ;; unnecessary concat during the next call.
502 nil)))
503 string)
505 ;; Functions for Mips-style dbx. Given the option `-emacs', documented in
506 ;; OSF1, not necessarily elsewhere, it produces markers similar to gdb's.
509 ;; We haven't tested gud on this system:
511 ;; It's documented on OSF/1.3
519 ;; This is just like the gdb one except for the regexps since we need to cope
520 ;; with an optional breakpoint number in [] before the ^Z^Z
525 ;; Process all the complete markers in this chunk.
527 ;; This is like th gdb marker but with an optional
528 ;; leading break point number like `[1] '
530 gud-marker-acc)
533 ;; Extract the frame position from the marker.
534 gud-last-frame
540 ;; Append any text before the marker to the output we're going
541 ;; to return - we don't include the marker in this text.
545 ;; Set the accumulator to the remaining text.
548 ;; Does the remaining text look like it might end with the
549 ;; beginning of another marker? If it does, then keep it in
550 ;; gud-marker-acc until we receive the rest of it. Since we
551 ;; know the full marker regexp above failed, it's pretty simple to
552 ;; test for marker starts.
555 ;; Everything before the potential marker start can be output.
559 ;; Everything after, we save, to combine with later input.
566 output))
568 ;; The dbx in IRIX is a pain. It doesn't print the file name when
569 ;; stopping at a breakpoint (but you do get it from the `up' and
570 ;; `down' commands...). The only way to extract the information seems
571 ;; to be with a `file' command, although the current line number is
572 ;; available in $curline. Thus we have to look for output which
573 ;; appears to indicate a breakpoint. Then we prod the dbx sub-process
574 ;; to output the information we want with a combination of the
575 ;; `printf' and `file' commands as a pseudo marker which we can
576 ;; recognise next time through the marker-filter. This would be like
577 ;; the gdb marker but you can't get the file name without a newline...
578 ;; Note that gud-remove won't work since Irix dbx expects a breakpoint
579 ;; number rather than a line number etc. Maybe this could be made to
580 ;; work by listing all the breakpoints and picking the one(s) with the
581 ;; correct line number, but life's too short.
582 ;; d.love@dl.ac.uk (Dave Love) can be blamed for this
585 "Non-nil to assume the interface appropriate for IRIX dbx.
587 ;; [Irix dbx seems to be a moving target. The dbx output changed
588 ;; subtly sometime between OS v4.0.5 and v5.2 so that, for instance,
589 ;; the output from `up' is no longer spotted by gud (and it's probably
590 ;; not distinctive enough to try to match it -- use C-<, C->
591 ;; exclusively) . For 5.3 and 6.0, the $curline variable changed to
592 ;; `long long'(why?!), so the printf stuff needed changing. The line
593 ;; number is cast to `long' as a compromise between the new `long
594 ;; long' and the original `int'. The process filter is also somewhat
595 ;; unreliable, sometimes not spotting the markers; I don't know
596 ;; whether there's anything that can be done about that. It would be
597 ;; much better if SGI could be persuaded to (re?)instate the MIPS
598 ;; -emacs flag for gdb-like output (which ought to be possible as most
599 ;; of the communication I've had over it has been from sgi.com).]
601 ;; this filter is influenced by the xdb one rather than the gdb one
611 ;; look for breakpoint or signal indication e.g.:
612 ;; [2] Process 1267 (pplot) stopped at [params:338 ,0x400ec0]
613 ;; Process 1281 (pplot) stopped at [params:339 ,0x400ec8]
614 ;; Process 1270 (pplot) Floating point exception [._read._read:16 ,0x452188]
617 result)
618 ;; prod dbx into printing out the line number and file
619 ;; name in a form we can grok as below
622 ;; look for result of, say, "up" e.g.:
623 ;; .pplot.pplot(0x800) ["src/pplot.f":261, 0x400c7c]
624 ;; (this will also catch one of the lines printed by "where")
627 result)
638 result)
645 file
655 ;;;###autoload
657 "Run dbx on program FILE in buffer *gud-FILE*.
658 The directory containing FILE becomes the initial working directory
659 and source-file directory for your debugger."
665 nil nil
694 ;; Make dbx give out the source location info that we need.
715 )
716 \f
717 ;; ======================================================================
718 ;; xdb (HP PARISC debugger) functions
720 ;;; History of argument lists passed to xdb.
724 "*A list of directories that xdb should search for source code.
725 If nil, only source files in the program directory
726 will be known to xdb.
728 The file names should be absolute, or relative to the directory
738 args))
741 "Transform a relative pathname to a full pathname in xdb mode"
750 directories nil)))
752 result))
754 ;; xdb does not print the lines all at once, so we have to accumulate them
765 result))
778 ;;;###autoload
780 "Run xdb on program FILE in buffer *gud-FILE*.
781 The directory containing FILE becomes the initial working directory
782 and source-file directory for your debugger.
784 You can set the variable 'gud-xdb-directories' to a list of program source
785 directories if your program contains sources from more than one directory."
791 nil nil
816 \f
817 ;; ======================================================================
818 ;; perldb functions
820 ;;; History of argument lists passed to perldb.
826 ;; There's no guarantee that Emacs will hand the filter the entire
827 ;; marker at once; it could be broken up across several strings. We
828 ;; might even receive a big chunk with several markers in it. If we
829 ;; receive a chunk of text which looks like it might contain the
830 ;; beginning of a marker, we save it here between calls to the
831 ;; filter.
838 ;; Process all the complete markers in this chunk.
840 gud-marker-acc)
843 ;; Extract the frame position from the marker.
844 gud-last-frame
850 ;; Append any text before the marker to the output we're going
851 ;; to return - we don't include the marker in this text.
855 ;; Set the accumulator to the remaining text.
858 ;; Does the remaining text look like it might end with the
859 ;; beginning of another marker? If it does, then keep it in
860 ;; gud-marker-acc until we receive the rest of it. Since we
861 ;; know the full marker regexp above failed, it's pretty simple to
862 ;; test for marker starts.
865 ;; Everything before the potential marker start can be output.
869 ;; Everything after, we save, to combine with later input.
876 output))
881 ;;;###autoload
883 "Run perldb on program FILE in buffer *gud-FILE*.
884 The directory containing FILE becomes the initial working directory
885 and source-file directory for your debugger."
891 nil nil
902 ; (gud-def gud-finish "finish" "\C-f" "Finish executing current function.")
903 ; (gud-def gud-up "up %p" "<" "Up N stack frames (numeric arg).")
904 ; (gud-def gud-down "down %p" ">" "Down N stack frames (numeric arg).")
910 )
912 ;;
913 ;; End of debugger-specific information
914 ;;
916 \f
917 ;;; When we send a command to the debugger via gud-call, it's annoying
918 ;;; to see the command and the new prompt inserted into the debugger's
919 ;;; buffer; we have other ways of knowing the command has completed.
920 ;;;
921 ;;; If the buffer looks like this:
922 ;;; --------------------
923 ;;; (gdb) set args foo bar
924 ;;; (gdb) -!-
925 ;;; --------------------
926 ;;; (the -!- marks the location of point), and we type `C-x SPC' in a
927 ;;; source file to set a breakpoint, we want the buffer to end up like
928 ;;; this:
929 ;;; --------------------
930 ;;; (gdb) set args foo bar
931 ;;; Breakpoint 1 at 0x92: file make-docfile.c, line 49.
932 ;;; (gdb) -!-
933 ;;; --------------------
934 ;;; Essentially, the old prompt is deleted, and the command's output
935 ;;; and the new prompt take its place.
936 ;;;
937 ;;; Not echoing the command is easy enough; you send it directly using
938 ;;; process-send-string, and it never enters the buffer. However,
939 ;;; getting rid of the old prompt is trickier; you don't want to do it
940 ;;; when you send the command, since that will result in an annoying
941 ;;; flicker as the prompt is deleted, redisplay occurs while Emacs
942 ;;; waits for a response from the debugger, and the new prompt is
943 ;;; inserted. Instead, we'll wait until we actually get some output
944 ;;; from the subprocess before we delete the prompt. If the command
945 ;;; produced no output other than a new prompt, that prompt will most
946 ;;; likely be in the first chunk of output received, so we will delete
947 ;;; the prompt and then replace it with an identical one. If the
948 ;;; command produces output, the prompt is moving anyway, so the
949 ;;; flicker won't be annoying.
950 ;;;
951 ;;; So - when we want to delete the prompt upon receipt of the next
952 ;;; chunk of debugger output, we position gud-delete-prompt-marker at
953 ;;; the start of the prompt; the process filter will notice this, and
954 ;;; delete all text between it and the process output marker. If
955 ;;; gud-delete-prompt-marker points nowhere, we leave the current
956 ;;; prompt alone.
959 \f
961 "Major mode for interacting with an inferior debugger process.
963 You start it up with one of the commands M-x gdb, M-x sdb, M-x dbx,
964 or M-x xdb. Each entry point finishes by executing a hook; `gdb-mode-hook',
965 `sdb-mode-hook', `dbx-mode-hook' or `xdb-mode-hook' respectively.
967 After startup, the following commands are available in both the GUD
968 interaction buffer and any source buffer GUD visits due to a breakpoint stop
969 or step operation:
972 GUD buffer, the current file and line are those of the last breakpoint or
973 step. In a source buffer, they are the buffer's file and current line.
978 in the gud buffer.
981 step-one-line (not entering function calls), and step-one-instruction
982 and then update the source window with the current file and position.
986 around point, and sends it to the debugger for value display.
988 The above commands are common to all supported debuggers except xdb which
989 does not support stepping instructions.
992 except that the breakpoint is temporary; that is, it is removed when
993 execution stops on it.
999 the current function and stops.
1001 All the keystrokes above are accessible in the GUD buffer
1002 with the prefix C-c, and in all buffers through the prefix C-x C-a.
1004 All pre-defined functions for which the concept make sense repeat
1005 themselves the appropriate number of times if you give a prefix
1006 argument.
1008 You may use the `gud-def' macro in the initialization hook to define other
1009 commands.
1011 Other commands for interacting with the debugger process are inherited from
1012 comint mode, which see."
1020 ;; Keymap definitions for menu bar entries common to all debuggers
1021 ;; and slots for debugger-dependent ones. The menu should be made
1022 ;; to propagate to buffers found by gud-find-file.
1030 nil)
1034 nil)
1036 nil)
1039 ; buffer until it gets a menu...
1041 nil)
1058 ;; Chop STRING into words separated by SPC or TAB and return a list of them.
1076 ;; Perform initializations common to all debuggers.
1077 ;; The first arg is the specified command line,
1078 ;; which starts with the program to debug.
1079 ;; The other three args specify the values to use
1080 ;; for local variables in the debugger buffer.
1091 ;; If a directory was specified, expand the file name.
1092 ;; Otherwise, don't expand it, so GDB can use the PATH.
1093 ;; A file name without directory is literally valid
1094 ;; only if the file exists in ., and in that case,
1095 ;; omitting the expansion here has no visible effect.
1099 file-subst)))
1102 ;; Set default-directory to the file's directory.
1104 ;; Don't set default-directory if no directory was specified.
1105 ;; In that case, either the file is found in the current directory,
1106 ;; in which case this setq is a no-op,
1107 ;; or it is found by searching PATH,
1108 ;; in which case we don't know what directory it was found in.
1115 ;; Since comint clobbered the mode, we don't set it until now.
1127 )
1133 ;; These functions are responsible for inserting output from your debugger
1134 ;; into the buffer. The hard work is done by the method that is
1135 ;; the value of gud-marker-filter.
1138 ;; Here's where the actual buffer insertion is done
1143 ;; If we have been so requested, delete the debugger prompt.
1148 ;; Save the process output, checking for source file markers.
1150 ;; Check for a filename-and-line number.
1151 ;; Don't display the specified file
1152 ;; unless (1) point is at or after the position where output appears
1153 ;; and (2) this buffer is on the screen.
1158 ;; Let the comint filter do the actual insertion.
1159 ;; That lets us inherit various comint features.
1164 ;; buffer killed
1165 ;; Stop displaying an arrow in a source file.
1169 ;; Stop displaying an arrow in a source file.
1171 ;; Fix the mode line.
1176 ;; save-excursion isn't the right thing if
1177 ;; process-buffer is current-buffer
1180 ;; Write something in *compilation* and hack its mode line,
1182 ;; Force mode line redisplay soon
1189 ;; If buffer and mode line will show that the process
1190 ;; is dead, we can delete it now. Otherwise it
1191 ;; will stay around until M-x list-processes.
1193 ;; Restore old buffer, but don't restore old point
1194 ;; if obuf is the gud buffer.
1198 "Find and obey the last filename-and-line marker from the debugger.
1199 Obeying it means displaying in another window the specified file and line."
1206 gud-last-frame nil))))
1208 ;; Make sure the file named TRUE-FILE is in a buffer that appears on the screen
1209 ;; and that its line LINE is visible.
1210 ;; Put the overlay-arrow on the line LINE in that buffer.
1211 ;; Most of the trickiness in here comes from wanting to preserve the current
1212 ;; region-restriction if that's possible. We use an explicit display-buffer
1213 ;; to get around the fact that this is called inside a save-excursion.
1220 ;;; (if (equal buffer (current-buffer))
1221 ;;; nil
1222 ;;; (setq buffer-read-only nil))
1224 ;;; (setq buffer-read-only t)
1239 ;;; The gud-call function must do the right thing whether its invoking
1240 ;;; keystroke is from the GUD buffer itself (via major-mode binding)
1241 ;;; or a C buffer. In the former case, we want to supply data from
1242 ;;; gud-last-frame. Here's how we do it:
1247 result)
1250 subst)
1275 subst)))
1277 ;; There might be text left in STR when the loop ends.
1281 "Return a string containing the core-address found in the buffer at point."
1306 "Invoke the debugger COMMAND displaying source in other window."
1312 ;; Arrange for the current prompt to get deleted.
1322 "Fix up a possibly garbled display, and redraw the arrow."
1327 \f
1328 ;;; Code for parsing expressions out of C code. The single entry point is
1329 ;;; find-c-expr, which tries to return an lvalue expression from around point.
1330 ;;;
1331 ;;; The rest of this file is a hacked version of gdbsrc.el by
1332 ;;; Debby Ayers <ayers@asc.slb.com>,
1333 ;;; Rich Schaefer <schaefer@asc.slb.com> Schlumberger, Austin, Tx.
1336 "Returns the C expr that surrounds point."
1352 )
1356 "Returns the expr that point is in; point is set to beginning of expr.
1357 The expr is represented as a cons cell, where the car specifies the point in
1358 the current buffer that marks the beginning of the expr and the cdr specifies
1359 the character after the end of the expr."
1371 )
1372 )
1377 "Version of `backward-sexp' that catches errors."
1383 "Version of `forward-sexp' that catches errors."
1389 "Returns the previous expr, point is set to beginning of that expr.
1390 The expr is represented as a cons cell, where the car specifies the point in
1391 the current buffer that marks the beginning of the expr and the cdr specifies
1392 the character after the end of the expr"
1402 "Returns the following expr, point is set to beginning of that expr.
1403 The expr is represented as a cons cell, where the car specifies the point in
1404 the current buffer that marks the beginning of the expr and the cdr specifies
1405 the character after the end of the expr."
1415 "Returns '.' for '->' & '.', returns ' ' for white space,
1416 returns '?' for other punctuation."
1432 result))
1435 "Non-nil if concatenating FIRST and SECOND makes a single C token.
1436 The two exprs are represented as a cons cells, where the car
1437 specifies the point in the current buffer that marks the beginning of the
1438 expr and the cdr specifies the character after the end of the expr.
1439 Link exprs of the form:
1440 Expr -> Expr
1441 Expr . Expr
1442 Expr (Expr)
1443 Expr [Expr]
1444 (Expr) Expr
1445 [Expr] Expr"
1463 )
1468 ;;; gud.el ends here