;; Maintainer: FSF
;; Keywords: unix, tools
-;; Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+;; Copyright (C) 2002, 2003, 2004, 2005, 2006
+;; Free Software Foundation, Inc.
;; This file is part of GNU Emacs.
;; You don't need to know about annotations to use this mode as a debugger,
;; but if you are interested developing the mode itself, then see the
;; Annotations section in the GDB info manual.
-;;
+
;; GDB developers plan to make the annotation interface obsolete. A new
;; interface called GDB/MI (machine interface) has been designed to replace
;; it. Some GDB/MI commands are used in this file through the CLI command
;; GDB (6.2 onwards) that uses GDB/MI as the primary interface to GDB. It is
;; still under development and is part of a process to migrate Emacs from
;; annotations to GDB/MI.
-;;
-;; This mode SHOULD WORK WITH GDB 5.0 ONWARDS but you will NEED GDB 6.0
-;; ONWARDS TO USE WATCH EXPRESSIONS.
-;;
-;; Windows Platforms:
-;;
+
+;; This mode SHOULD WORK WITH GDB 5.0 onwards but you will NEED GDB 6.0
+;; onwards to use watch expressions. It works best with GDB 6.4 where
+;; watch expressions will update more quickly.
+
+;;; Windows Platforms:
+
;; If you are using Emacs and GDB on Windows you will need to flush the buffer
;; explicitly in your program if you want timely display of I/O in Emacs.
;; Alternatively you can make the output stream unbuffered, for example, by
;; using a macro:
-;;
+
;; #ifdef UNBUFFERED
;; setvbuf (stdout, (char *) NULL, _IONBF, 0);
;; #endif
-;;
+
;; and compiling with -DUNBUFFERED while debugging.
-;;
-;; Known Bugs:
-;;
-;; TODO:
+
+;;; Known Bugs:
+
+;; 1) Strings that are watched don't update in the speedbar when their
+;; contents change unless the first character changes.
+;; 2) Cannot handle multiple debug sessions.
+;; 3) M-x gdb doesn't work with "run" command in .gdbinit, use M-x gdba instead.
+;; 4) M-x gdb doesn't work if the corefile is specified in the command in the
+;; minibuffer, use M-x gdba instead (or specify the core in the GUD buffer).
+;; 5) If you wish to call procedures from your program in GDB
+;; e.g "call myproc ()", "p mysquare (5)" then use level 2 annotations
+;; "gdb --annotate=2 myprog" to keep source buffer/selected frame fixed.
+
+;;; Problems with watch expressions, GDB/MI:
+;; 1) They go out of scope when the inferior is re-run.
+;; 2) -stack-list-locals has a type field but also prints type in values field.
+;; 3) VARNUM increments even when variable object is not created
+;; (maybe trivial).
+
+;;; TODO:
;; 1) Use MI command -data-read-memory for memory window.
-;; 2) Highlight changed register values (use MI commands
-;; -data-list-register-values and -data-list-changed-registers instead
-;; of 'info registers'.
-;; 3) Use tree-widget.el instead of the speedbar for watch-expressions?
-;; 4) Mark breakpoint locations on scroll-bar of source buffer?
-;; 5) After release of 22.1 use '-var-list-children --all-values'
-;; and '-stack-list-locals 2' which need GDB 6.1 onwards.
-;; 6) With gud-print and gud-pstar, print the variable name in the GUD
-;; buffer instead of the value's history number.
+;; 2) Use tree-widget.el instead of the speedbar for watch-expressions?
+;; 3) Mark breakpoint locations on scroll-bar of source buffer?
;;; Code:
(require 'gud)
(defvar tool-bar-map)
+(defvar speedbar-initial-expansion-list-name)
-(defvar gdb-frame-address "main" "Initialization for Assembler buffer.")
+(defvar gdb-pc-address nil "Initialization for Assembler buffer.
+Set to \"main\" at start if gdb-show-main is t.")
+(defvar gdb-frame-address nil "Identity of frame for watch expression.")
(defvar gdb-previous-frame-address nil)
(defvar gdb-memory-address "main")
(defvar gdb-previous-frame nil)
(defvar gdb-selected-frame nil)
(defvar gdb-frame-number nil)
(defvar gdb-current-language nil)
-(defvar gdb-var-list nil "List of variables in watch window.")
-(defvar gdb-var-changed nil "Non-nil means that `gdb-var-list' has changed.")
+(defvar gdb-var-list nil
+ "List of variables in watch window.
+Each element has the form (VARNUM EXPRESSION NUMCHILD TYPE VALUE STATUS FP)
+where STATUS is nil (unchanged), `changed' or `out-of-scope', FP the frame
+address for root variables.")
(defvar gdb-main-file nil "Source file from which program execution begins.")
+(defvar gud-old-arrow nil)
(defvar gdb-overlay-arrow-position nil)
+(defvar gdb-stack-position nil)
(defvar gdb-server-prefix nil)
(defvar gdb-flush-pending-output nil)
(defvar gdb-location-alist nil
"Alist of breakpoint numbers and full filenames.")
-(defvar gdb-find-file-unhook nil)
(defvar gdb-active-process nil "GUD tooltips display variable values when t, \
and #define directives otherwise.")
(defvar gdb-error "Non-nil when GDB is reporting an error.")
(defvar gdb-macro-info nil
"Non-nil if GDB knows that the inferior includes preprocessor macro info.")
(defvar gdb-buffer-fringe-width nil)
+(defvar gdb-signalled nil)
+(defvar gdb-source-window nil)
+(defvar gdb-inferior-status nil)
+(defvar gdb-continuation nil)
+(defvar gdb-look-up-stack nil)
+(defvar gdb-frame-begin nil
+ "Non-nil when GDB generates frame-begin annotation.")
+(defvar gdb-printing t)
(defvar gdb-buffer-type nil
"One of the symbols bound in `gdb-buffer-rules'.")
"A list of trigger functions that have run later than their output
handlers.")
-;; end of gdb variables
+(defvar gdb-first-post-prompt nil)
+(defvar gdb-version nil)
+(defvar gdb-locals-font-lock-keywords nil)
+(defvar gdb-source-file-list nil
+ "List of source files for the current executable")
+(defconst gdb-error-regexp "\\^error,msg=\"\\(.+\\)\"")
+
+(defvar gdb-locals-font-lock-keywords-1
+ '(
+ ;; var = (struct struct_tag) value
+ ( "\\(^\\(\\sw\\|[_.]\\)+\\) += +(\\(struct\\) \\(\\(\\sw\\|[_.]\\)+\\)"
+ (1 font-lock-variable-name-face)
+ (3 font-lock-keyword-face)
+ (4 font-lock-type-face))
+ ;; var = (type) value
+ ( "\\(^\\(\\sw\\|[_.]\\)+\\) += +(\\(\\(\\sw\\|[_.]\\)+\\)"
+ (1 font-lock-variable-name-face)
+ (3 font-lock-type-face))
+ ;; var = val
+ ( "\\(^\\(\\sw\\|[_.]\\)+\\) += +[^(]"
+ (1 font-lock-variable-name-face))
+ )
+ "Font lock keywords used in `gdb-local-mode'.")
+
+(defvar gdb-locals-font-lock-keywords-2
+ '(
+ ;; var = type value
+ ( "\\(^\\(\\sw\\|[_.]\\)+\\)\t+\\(\\(\\sw\\|[_.]\\)+\\)"
+ (1 font-lock-variable-name-face)
+ (3 font-lock-type-face))
+ )
+ "Font lock keywords used in `gdb-local-mode'.")
+
+;; Variables for GDB 6.4+
+(defvar gdb-register-names nil "List of register names.")
+(defvar gdb-changed-registers nil
+ "List of changed register numbers (strings).")
;;;###autoload
(defun gdba (command-line)
If `gdb-many-windows' is t, regardless of the value of
`gdb-show-main', the layout below will appear unless
-`gdb-use-inferior-io-buffer' is nil when the source buffer
-occupies the full width of the frame. Keybindings are given in
-relevant buffer.
+`gdb-use-separate-io-buffer' is nil when the source buffer
+occupies the full width of the frame. Keybindings are shown in
+some of the buffers.
Watch expressions appear in the speedbar/slowbar.
detailed description of this mode.
-+--------------------------------------------------------------+
-| GDB Toolbar |
-+-------------------------------+------------------------------+
-| GUD buffer (I/O of GDB) | Locals buffer |
-| | |
-| | |
-| | |
-+-------------------------------+------------------------------+
-| Source buffer | I/O buffer (of inferior) |
-| | (comint-mode) |
-| | |
-| | |
-| | |
-| | |
-| | |
-| | |
-+-------------------------------+------------------------------+
-| Stack buffer | Breakpoints buffer |
-| RET gdb-frames-select | SPC gdb-toggle-breakpoint |
-| | RET gdb-goto-breakpoint |
-| | d gdb-delete-breakpoint |
-+-------------------------------+------------------------------+"
++----------------------------------------------------------------------+
+| GDB Toolbar |
++-----------------------------------+----------------------------------+
+| GUD buffer (I/O of GDB) | Locals buffer |
+| | |
+| | |
+| | |
++-----------------------------------+----------------------------------+
+| Source buffer | I/O buffer (of debugged program) |
+| | (comint-mode) |
+| | |
+| | |
+| | |
+| | |
+| | |
+| | |
++-----------------------------------+----------------------------------+
+| Stack buffer | Breakpoints buffer |
+| RET gdb-frames-select | SPC gdb-toggle-breakpoint |
+| | RET gdb-goto-breakpoint |
+| | D gdb-delete-breakpoint |
++-----------------------------------+----------------------------------+"
;;
(interactive (list (gud-query-cmdline 'gdba)))
;;
;; Let's start with a basic gud-gdb buffer and then modify it a bit.
(gdb command-line)
- (gdb-ann3))
+ (gdb-init-1))
-(defvar gdb-debug-log nil)
+(defcustom gdb-debug-ring-max 128
+ "Maximum size of `gdb-debug-ring'."
+ :group 'gud
+ :type 'integer
+ :version "22.1")
+
+(defvar gdb-debug-ring nil
+ "List of commands, most recent first, sent to and replies received from GDB.
+This variable is used to debug GDB-UI.")
;;;###autoload
-(defcustom gdb-enable-debug-log nil
- "Non-nil means record the process input and output in `gdb-debug-log'."
+(defcustom gdb-enable-debug nil
+ "Non-nil means record the process input and output in `gdb-debug-ring'."
:type 'boolean
:group 'gud
:version "22.1")
:group 'gud
:version "22.1")
+(defcustom gdb-many-windows nil
+ "nil means just pop up the GUD buffer unless `gdb-show-main' is t.
+In this case it starts with two windows: one displaying the GUD
+buffer and the other with the source file with the main routine
+of the debugged program. Non-nil means display the layout shown for
+`gdba'."
+ :type 'boolean
+ :group 'gud
+ :version "22.1")
-(defcustom gdb-use-inferior-io-buffer nil
- "Non-nil means display output from the inferior in a separate buffer."
+(defcustom gdb-use-separate-io-buffer nil
+ "Non-nil means display output from the debugged program in a separate buffer."
:type 'boolean
:group 'gud
:version "22.1")
-(defun gdb-use-inferior-io-buffer (arg)
- "Toggle separate IO for inferior.
+(defun gdb-force-mode-line-update (status)
+ (let ((buffer gud-comint-buffer))
+ (if (and buffer (buffer-name buffer))
+ (with-current-buffer buffer
+ (setq mode-line-process
+ (format ":%s [%s]"
+ (process-status (get-buffer-process buffer)) status))
+ ;; Force mode line redisplay soon.
+ (force-mode-line-update)))))
+
+(defun gdb-many-windows (arg)
+ "Toggle the number of windows in the basic arrangement.
+With arg, display additional buffers iff arg is positive."
+ (interactive "P")
+ (setq gdb-many-windows
+ (if (null arg)
+ (not gdb-many-windows)
+ (> (prefix-numeric-value arg) 0)))
+ (message (format "Display of other windows %sabled"
+ (if gdb-many-windows "en" "dis")))
+ (if (and gud-comint-buffer
+ (buffer-name gud-comint-buffer))
+ (condition-case nil
+ (gdb-restore-windows)
+ (error nil))))
+
+(defun gdb-use-separate-io-buffer (arg)
+ "Toggle separate IO for debugged program.
With arg, use separate IO iff arg is positive."
(interactive "P")
- (setq gdb-use-inferior-io-buffer
+ (setq gdb-use-separate-io-buffer
(if (null arg)
- (not gdb-use-inferior-io-buffer)
+ (not gdb-use-separate-io-buffer)
(> (prefix-numeric-value arg) 0)))
+ (message (format "Separate IO %sabled"
+ (if gdb-use-separate-io-buffer "en" "dis")))
(if (and gud-comint-buffer
(buffer-name gud-comint-buffer))
(condition-case nil
- (if gdb-use-inferior-io-buffer
- (gdb-restore-windows)
+ (if gdb-use-separate-io-buffer
+ (if gdb-many-windows (gdb-restore-windows))
(kill-buffer (gdb-inferior-io-name)))
(error nil))))
(list t nil) nil "-c"
(concat gdb-cpp-define-alist-program " "
gdb-cpp-define-alist-flags)))))
- (define-list (split-string output "\n" t))
- (name))
+ (define-list (split-string output "\n" t)) (name))
(setq gdb-define-alist nil)
(dolist (define define-list)
(setq name (nth 1 (split-string define "[( ]")))
(push (cons name define) gdb-define-alist))))
-(defun gdb-tooltip-print ()
+(defun gdb-tooltip-print (expr)
(tooltip-show
(with-current-buffer (gdb-get-buffer 'gdb-partial-output-buffer)
- (let ((string (buffer-string)))
+ (goto-char (point-min))
+ (let ((string
+ (if (search-forward "=" nil t)
+ (concat expr (buffer-substring (- (point) 2) (point-max)))
+ (buffer-string))))
;; remove newline for gud-tooltip-echo-area
(substring string 0 (- (length string) 1))))
(or gud-tooltip-echo-area tooltip-use-echo-area)))
(unless (looking-at "\\S-+.*(.*).*")
(gdb-enqueue-input
(list (concat gdb-server-prefix "print " expr "\n")
- 'gdb-tooltip-print))))))
-
-(defun gdb-set-gud-minor-mode (buffer)
- "Set `gud-minor-mode' from find-file if appropriate."
- (goto-char (point-min))
- (unless (search-forward "No source file named " nil t)
- (condition-case nil
- (gdb-enqueue-input
- (list (concat gdb-server-prefix "info source\n")
- `(lambda () (gdb-set-gud-minor-mode-1 ,buffer))))
- (error (setq gdb-find-file-unhook t)))))
+ `(lambda () (gdb-tooltip-print ,expr))))))))
-(defun gdb-set-gud-minor-mode-1 (buffer)
- (goto-char (point-min))
- (when (and (search-forward "Located in " nil t)
- (looking-at "\\S-+")
- (string-equal (buffer-file-name buffer)
- (match-string 0)))
- (with-current-buffer buffer
- (set (make-local-variable 'gud-minor-mode) 'gdba)
- (set (make-local-variable 'tool-bar-map) gud-tool-bar-map)
- (when gud-tooltip-mode
- (make-local-variable 'gdb-define-alist)
- (gdb-create-define-alist)
- (add-hook 'after-save-hook 'gdb-create-define-alist nil t)))))
+(defconst gdb-source-file-regexp "\\(.+?\\), \\|\\([^, \n].*$\\)")
(defun gdb-set-gud-minor-mode-existing-buffers ()
- (dolist (buffer (buffer-list))
- (let ((file (buffer-file-name buffer)))
- (if file
- (progn
- (gdb-enqueue-input
- (list (concat gdb-server-prefix "list "
- (file-name-nondirectory file) ":1\n")
- `(lambda () (gdb-set-gud-minor-mode ,buffer)))))))))
-
-(defun gdb-ann3 ()
- (setq gdb-debug-log nil)
+ "Create list of source files for current GDB session."
+ (goto-char (point-min))
+ (when (search-forward "read in on demand:" nil t)
+ (while (re-search-forward gdb-source-file-regexp nil t)
+ (push (file-name-nondirectory (or (match-string 1) (match-string 2)))
+ gdb-source-file-list))
+ (dolist (buffer (buffer-list))
+ (with-current-buffer buffer
+ (when (and buffer-file-name
+ (member (file-name-nondirectory buffer-file-name)
+ gdb-source-file-list))
+ (set (make-local-variable 'gud-minor-mode) 'gdba)
+ (set (make-local-variable 'tool-bar-map) gud-tool-bar-map)
+ (when gud-tooltip-mode
+ (make-local-variable 'gdb-define-alist)
+ (gdb-create-define-alist)
+ (add-hook 'after-save-hook 'gdb-create-define-alist nil t))))))
+ (gdb-force-mode-line-update
+ (propertize "ready" 'face font-lock-variable-name-face)))
+
+(defun gdb-find-watch-expression ()
+ (let* ((var (nth (- (line-number-at-pos (point)) 2) gdb-var-list))
+ (varnum (car var)) expr array)
+ (string-match "\\(var[0-9]+\\)\\.\\(.*\\)" varnum)
+ (let ((var1 (assoc (match-string 1 varnum) gdb-var-list)) var2 varnumlet
+ (component-list (split-string (match-string 2 varnum) "\\." t)))
+ (setq expr (nth 1 var1))
+ (setq varnumlet (car var1))
+ (dolist (component component-list)
+ (setq var2 (assoc varnumlet gdb-var-list))
+ (setq expr (concat expr
+ (if (string-match ".*\\[[0-9]+\\]$" (nth 3 var2))
+ (concat "[" component "]")
+ (concat "." component))))
+ (setq varnumlet (concat varnumlet "." component)))
+ expr)))
+
+(defun gdb-init-1 ()
(set (make-local-variable 'gud-minor-mode) 'gdba)
(set (make-local-variable 'gud-marker-filter) 'gud-gdba-marker-filter)
;;
(gud-call "clear *%a" arg)))
"\C-d" "Remove breakpoint at current line or address.")
;;
- (gud-def gud-until (if (not (string-match "Machine" mode-name))
- (gud-call "until %f:%l" arg)
- (save-excursion
- (beginning-of-line)
- (forward-char 2)
- (gud-call "until *%a" arg)))
+ (gud-def gud-until (if (not (string-match "Machine" mode-name))
+ (gud-call "until %f:%l" arg)
+ (save-excursion
+ (beginning-of-line)
+ (forward-char 2)
+ (gud-call "until *%a" arg)))
"\C-u" "Continue to current line or address.")
+ ;;
+ (gud-def gud-go (gud-call (if gdb-active-process "continue" "run") arg)
+ nil "Start or continue execution.")
+
+ ;; For debugging Emacs only.
+ (gud-def gud-pp
+ (gud-call
+ (concat
+ "pp1 " (if (eq (buffer-local-value
+ 'major-mode (window-buffer)) 'speedbar-mode)
+ (gdb-find-watch-expression) "%e")) arg)
+ nil "Print the emacs s-expression.")
(define-key gud-minor-mode-map [left-margin mouse-1]
'gdb-mouse-set-clear-breakpoint)
(define-key gud-minor-mode-map [left-fringe mouse-1]
'gdb-mouse-set-clear-breakpoint)
- (define-key gud-minor-mode-map [left-fringe mouse-2]
+ (define-key gud-minor-mode-map [left-margin C-mouse-1]
+ 'gdb-mouse-toggle-breakpoint-margin)
+ (define-key gud-minor-mode-map [left-fringe C-mouse-1]
+ 'gdb-mouse-toggle-breakpoint-fringe)
+
+ (define-key gud-minor-mode-map [left-margin drag-mouse-1]
'gdb-mouse-until)
(define-key gud-minor-mode-map [left-fringe drag-mouse-1]
'gdb-mouse-until)
(define-key gud-minor-mode-map [left-margin mouse-3]
- 'gdb-mouse-toggle-breakpoint-margin)
+ 'gdb-mouse-until)
(define-key gud-minor-mode-map [left-fringe mouse-3]
- 'gdb-mouse-toggle-breakpoint-fringe)
+ 'gdb-mouse-until)
+
+ (define-key gud-minor-mode-map [left-margin C-drag-mouse-1]
+ 'gdb-mouse-jump)
+ (define-key gud-minor-mode-map [left-fringe C-drag-mouse-1]
+ 'gdb-mouse-jump)
+ (define-key gud-minor-mode-map [left-fringe C-mouse-3]
+ 'gdb-mouse-jump)
+ (define-key gud-minor-mode-map [left-margin C-mouse-3]
+ 'gdb-mouse-jump)
(setq comint-input-sender 'gdb-send)
- ;;
+
;; (re-)initialize
- (setq gdb-frame-address (if gdb-show-main "main" nil))
+ (setq gdb-pc-address (if gdb-show-main "main" nil))
(setq gdb-previous-frame-address nil
gdb-memory-address "main"
gdb-previous-frame nil
gdb-current-language nil
gdb-frame-number nil
gdb-var-list nil
- gdb-var-changed nil
- gdb-first-prompt nil
+ gdb-main-file nil
+ gdb-first-post-prompt t
gdb-prompting nil
gdb-input-queue nil
gdb-current-item nil
gdb-server-prefix "server "
gdb-flush-pending-output nil
gdb-location-alist nil
- gdb-find-file-unhook nil
+ gdb-source-file-list nil
gdb-error nil
gdb-macro-info nil
- gdb-buffer-fringe-width (car (window-fringes)))
- ;;
+ gdb-buffer-fringe-width (car (window-fringes))
+ gdb-debug-ring nil
+ gdb-signalled nil
+ gdb-source-window nil
+ gdb-inferior-status nil
+ gdb-continuation nil
+ gdb-look-up-stack nil
+ gdb-frame-begin nil
+ gdb-printing t
+ gud-old-arrow nil)
+
(setq gdb-buffer-type 'gdba)
- ;;
- (if gdb-use-inferior-io-buffer (gdb-clear-inferior-io))
- ;;
+
+ (if gdb-use-separate-io-buffer (gdb-clear-inferior-io))
+
+ ;; Hack to see test for GDB 6.4+ (-stack-info-frame was implemented in 6.4)
+ (gdb-enqueue-input (list "server interpreter mi -stack-info-frame\n"
+ 'gdb-get-version)))
+
+(defun gdb-init-2 ()
(if (eq window-system 'w32)
(gdb-enqueue-input (list "set new-console off\n" 'ignore)))
(gdb-enqueue-input (list "set height 0\n" 'ignore))
(gdb-enqueue-input (list "set width 0\n" 'ignore))
- ;; find source file and compilation directory here
- (gdb-enqueue-input (list "server list main\n" 'ignore)) ; C program
- (gdb-enqueue-input (list "server list MAIN__\n" 'ignore)) ; Fortran program
+
+ (if (string-equal gdb-version "pre-6.4")
+ (progn
+ (gdb-enqueue-input (list (concat gdb-server-prefix "info sources\n")
+ 'gdb-set-gud-minor-mode-existing-buffers))
+ (setq gdb-locals-font-lock-keywords gdb-locals-font-lock-keywords-1))
+ (gdb-enqueue-input
+ (list "server interpreter mi -data-list-register-names\n"
+ 'gdb-get-register-names))
+ ; Needs GDB 6.2 onwards.
+ (gdb-enqueue-input
+ (list "server interpreter mi \"-file-list-exec-source-files\"\n"
+ 'gdb-set-gud-minor-mode-existing-buffers-1))
+ (setq gdb-locals-font-lock-keywords gdb-locals-font-lock-keywords-2))
+
+ ;; Find source file and compilation directory here.
+ ;; Works for C, C++, Fortran and Ada but not Java (GDB 6.4)
+ (gdb-enqueue-input (list "server list\n" 'ignore))
(gdb-enqueue-input (list "server info source\n" 'gdb-source-info))
- ;;
- (gdb-set-gud-minor-mode-existing-buffers)
+
(run-hooks 'gdba-mode-hook))
+(defun gdb-get-version ()
+ (goto-char (point-min))
+ (if (re-search-forward "Undefined\\( mi\\)* command:" nil t)
+ (setq gdb-version "pre-6.4")
+ (setq gdb-version "6.4+"))
+ (gdb-init-2))
+
(defun gdb-mouse-until (event)
- "Execute source lines by dragging the overlay arrow (fringe) with the mouse."
+ "Continue running until a source line past the current line.
+The destination source line can be selected either by clicking with mouse-2
+on the fringe/margin or dragging the arrow with mouse-1 (default bindings)."
(interactive "e")
(if gud-overlay-arrow-position
(let ((start (event-start event))
(forward-char 2)
(gud-call (concat "until *%a")))))))))
+(defun gdb-mouse-jump (event)
+ "Set execution address/line.
+The destination source line can be selected either by clicking with mouse-2
+on the fringe/margin or dragging the arrow with mouse-1 (default bindings).
+Unlike gdb-mouse-until the destination address can be before the current
+line, and no execution takes place."
+ (interactive "e")
+ (if gud-overlay-arrow-position
+ (let ((start (event-start event))
+ (end (event-end event))
+ (buffer (marker-buffer gud-overlay-arrow-position)) (line))
+ (if (not (string-match "Machine" mode-name))
+ (if (equal buffer (window-buffer (posn-window end)))
+ (with-current-buffer buffer
+ (when (or (equal start end)
+ (equal (posn-point start)
+ (marker-position
+ gud-overlay-arrow-position)))
+ (setq line (line-number-at-pos (posn-point end)))
+ (progn (gud-call (concat "tbreak " (number-to-string line)))
+ (gud-call (concat "jump " (number-to-string line)))))))
+ (if (equal (marker-buffer gdb-overlay-arrow-position)
+ (window-buffer (posn-window end)))
+ (when (or (equal start end)
+ (equal (posn-point start)
+ (marker-position
+ gdb-overlay-arrow-position)))
+ (save-excursion
+ (goto-line (line-number-at-pos (posn-point end)))
+ (forward-char 2)
+ (progn
+ (gud-call (concat "tbreak *%a"))
+ (gud-call (concat "jump *%a"))))))))))
+
+(defcustom gdb-speedbar-auto-raise nil
+ "If non-nil raise speedbar every time display of watch expressions is\
+ updated."
+ :type 'boolean
+ :group 'gud
+ :version "22.1")
+
+(defun gdb-speedbar-auto-raise (arg)
+ "Toggle automatic raising of the speedbar for watch expressions.
+With arg, automatically raise speedbar iff arg is positive."
+ (interactive "P")
+ (setq gdb-speedbar-auto-raise
+ (if (null arg)
+ (not gdb-speedbar-auto-raise)
+ (> (prefix-numeric-value arg) 0)))
+ (message (format "Auto raising %sabled"
+ (if gdb-speedbar-auto-raise "en" "dis"))))
+
(defcustom gdb-use-colon-colon-notation nil
"If non-nil use FUN::VAR format to display variables in the speedbar."
:type 'boolean
:group 'gud
:version "22.1")
-(defun gud-watch ()
- "Watch expression at point."
- (interactive)
- (require 'tooltip)
- (save-selected-window
- (let ((expr (tooltip-identifier-from-point (point))))
- (if (and (string-equal gdb-current-language "c")
- gdb-use-colon-colon-notation gdb-selected-frame)
- (setq expr (concat gdb-selected-frame "::" expr)))
- (catch 'already-watched
- (dolist (var gdb-var-list)
- (if (string-equal expr (car var)) (throw 'already-watched nil)))
- (set-text-properties 0 (length expr) nil expr)
- (gdb-enqueue-input
- (list
- (if (eq gud-minor-mode 'gdba)
- (concat "server interpreter mi \"-var-create - * " expr "\"\n")
- (concat"-var-create - * " expr "\n"))
- `(lambda () (gdb-var-create-handler ,expr))))))))
+(define-key gud-minor-mode-map "\C-c\C-w" 'gud-watch)
+(define-key global-map (concat gud-key-prefix "\C-w") 'gud-watch)
+
+(defun gud-watch (&optional arg event)
+ "Watch expression at point.
+With arg, enter name of variable to be watched in the minibuffer."
+ (interactive (list current-prefix-arg last-input-event))
+ (let ((minor-mode (buffer-local-value 'gud-minor-mode gud-comint-buffer)))
+ (if (memq minor-mode '(gdbmi gdba))
+ (progn
+ (if event (posn-set-point (event-end event)))
+ (require 'tooltip)
+ (save-selected-window
+ (let ((expr
+ (if arg
+ (completing-read "Name of variable: "
+ 'gud-gdb-complete-command)
+ (if (and transient-mark-mode mark-active)
+ (buffer-substring (region-beginning) (region-end))
+ (tooltip-identifier-from-point (point))))))
+ (speedbar 1)
+ (catch 'already-watched
+ (dolist (var gdb-var-list)
+ (unless (string-match "\\." (car var))
+ (if (string-equal expr (nth 1 var))
+ (throw 'already-watched nil))))
+ (set-text-properties 0 (length expr) nil expr)
+ (gdb-enqueue-input
+ (list
+ (if (eq minor-mode 'gdba)
+ (concat
+ "server interpreter mi \"-var-create - * " expr "\"\n")
+ (concat"-var-create - * " expr "\n"))
+ `(lambda () (gdb-var-create-handler ,expr))))))))
+ (message "gud-watch is a no-op in this mode."))))
(defconst gdb-var-create-regexp
- "name=\"\\(.*?\\)\",numchild=\"\\(.*?\\)\",type=\"\\(.*?\\)\"")
+ "name=\"\\(.*?\\)\",.*numchild=\"\\(.*?\\)\",.*type=\"\\(.*?\\)\"")
(defun gdb-var-create-handler (expr)
- (with-current-buffer (gdb-get-create-buffer 'gdb-partial-output-buffer)
- (goto-char (point-min))
- (if (re-search-forward gdb-var-create-regexp nil t)
- (let ((var (list expr
- (match-string 1)
- (match-string 2)
- (match-string 3)
- nil nil)))
- (push var gdb-var-list)
- (speedbar 1)
- (unless (string-equal
- speedbar-initial-expansion-list-name "GUD")
- (speedbar-change-initial-expansion-list "GUD"))
- (if (equal (nth 2 var) "0")
- (gdb-enqueue-input
- (list
- (if (with-current-buffer
- gud-comint-buffer (eq gud-minor-mode 'gdba))
- (concat "server interpreter mi \"-var-evaluate-expression "
- (nth 1 var) "\"\n")
- (concat "-var-evaluate-expression " (nth 1 var) "\n"))
- `(lambda () (gdb-var-evaluate-expression-handler
- ,(nth 1 var) nil))))
- (setq gdb-var-changed t)))
- (if (re-search-forward "Undefined command" nil t)
- (message-box "Watching expressions requires gdb 6.0 onwards")
- (message "No symbol \"%s\" in current context." expr)))))
+ (goto-char (point-min))
+ (if (re-search-forward gdb-var-create-regexp nil t)
+ (let ((var (list
+ (match-string 1)
+ (if (and (string-equal gdb-current-language "c")
+ gdb-use-colon-colon-notation gdb-selected-frame)
+ (setq expr (concat gdb-selected-frame "::" expr))
+ expr)
+ (match-string 2)
+ (match-string 3)
+ nil nil gdb-frame-address)))
+ (push var gdb-var-list)
+ (unless (string-equal
+ speedbar-initial-expansion-list-name "GUD")
+ (speedbar-change-initial-expansion-list "GUD"))
+ (gdb-enqueue-input
+ (list
+ (if (eq (buffer-local-value 'gud-minor-mode gud-comint-buffer) 'gdba)
+ (concat "server interpreter mi \"0-var-evaluate-expression "
+ (car var) "\"\n")
+ (concat "0-var-evaluate-expression " (car var) "\n"))
+ `(lambda () (gdb-var-evaluate-expression-handler
+ ,(car var) nil)))))
+ (if (search-forward "Undefined command" nil t)
+ (message-box "Watching expressions requires GDB 6.0 onwards")
+ (message-box "No symbol \"%s\" in current context." expr))))
+
+(defun gdb-speedbar-update ()
+ (when (and (boundp 'speedbar-frame) (frame-live-p speedbar-frame))
+ ;; Dummy command to update speedbar even when idle.
+ (gdb-enqueue-input (list "server pwd\n" 'gdb-speedbar-timer-fn))
+ ;; Keep gdb-pending-triggers non-nil till end.
+ (push 'gdb-speedbar-timer gdb-pending-triggers)))
+
+(defun gdb-speedbar-timer-fn ()
+ (setq gdb-pending-triggers
+ (delq 'gdb-speedbar-timer gdb-pending-triggers))
+ (speedbar-timer-fn))
(defun gdb-var-evaluate-expression-handler (varnum changed)
- (with-current-buffer (gdb-get-create-buffer 'gdb-partial-output-buffer)
- (goto-char (point-min))
- (re-search-forward ".*value=\"\\(.*?\\)\"" nil t)
- (catch 'var-found
- (let ((num 0))
- (dolist (var gdb-var-list)
- (if (string-equal varnum (cadr var))
- (progn
- (if changed (setcar (nthcdr 5 var) t))
- (setcar (nthcdr 4 var) (match-string 1))
- (setcar (nthcdr num gdb-var-list) var)
- (throw 'var-found nil)))
- (setq num (+ num 1))))))
- (setq gdb-var-changed t))
+ (goto-char (point-min))
+ (re-search-forward "\\(.+\\)\\^done,value=\\(\".*\"\\)" nil t)
+ (setq gdb-pending-triggers
+ (delq (string-to-number (match-string 1)) gdb-pending-triggers))
+ (let ((var (assoc varnum gdb-var-list)))
+ (when var
+ (if changed (setcar (nthcdr 5 var) 'changed))
+ (setcar (nthcdr 4 var) (read (match-string 2)))))
+ (gdb-speedbar-update))
(defun gdb-var-list-children (varnum)
(gdb-enqueue-input
`(lambda () (gdb-var-list-children-handler ,varnum)))))
(defconst gdb-var-list-children-regexp
- "name=\"\\(.*?\\)\",exp=\"\\(.*?\\)\",numchild=\"\\(.*?\\)\"")
+ "child={.*?name=\"\\(.*?\\)\",.*?exp=\"\\(.*?\\)\",.*?\
+numchild=\"\\(.*?\\)\"\\(}\\|,.*?\\(type=\"\\(.*?\\)\"\\)?.*?}\\)")
(defun gdb-var-list-children-handler (varnum)
- (with-current-buffer (gdb-get-create-buffer 'gdb-partial-output-buffer)
- (goto-char (point-min))
- (let ((var-list nil))
- (catch 'child-already-watched
- (dolist (var gdb-var-list)
- (if (string-equal varnum (cadr var))
- (progn
- (push var var-list)
- (while (re-search-forward gdb-var-list-children-regexp nil t)
- (let ((varchild (list (match-string 2)
- (match-string 1)
- (match-string 3)
- nil nil nil)))
- (if (looking-at ",type=\"\\(.*?\\)\"")
- (setcar (nthcdr 3 varchild) (match-string 1)))
- (dolist (var1 gdb-var-list)
- (if (string-equal (cadr var1) (cadr varchild))
- (throw 'child-already-watched nil)))
- (push varchild var-list)
- (if (equal (nth 2 varchild) "0")
- (gdb-enqueue-input
- (list
- (concat
- "server interpreter mi \"-var-evaluate-expression "
- (nth 1 varchild) "\"\n")
- `(lambda () (gdb-var-evaluate-expression-handler
- ,(nth 1 varchild) nil))))))))
- (push var var-list)))
- (setq gdb-var-list (nreverse var-list))))))
+ (goto-char (point-min))
+ (let ((var-list nil))
+ (catch 'child-already-watched
+ (dolist (var gdb-var-list)
+ (if (string-equal varnum (car var))
+ (progn
+ (push var var-list)
+ (while (re-search-forward gdb-var-list-children-regexp nil t)
+ (let ((varchild (list (match-string 1)
+ (match-string 2)
+ (match-string 3)
+ (match-string 6)
+ nil nil)))
+ (if (assoc (car varchild) gdb-var-list)
+ (throw 'child-already-watched nil))
+ (push varchild var-list)
+ (gdb-enqueue-input
+ (list
+ (concat
+ "server interpreter mi \"0-var-evaluate-expression "
+ (car varchild) "\"\n")
+ `(lambda () (gdb-var-evaluate-expression-handler
+ ,(car varchild) nil)))))))
+ (push var var-list)))
+ (setq gdb-var-list (nreverse var-list)))))
(defun gdb-var-update ()
(when (not (member 'gdb-var-update gdb-pending-triggers))
'gdb-var-update-handler))
(push 'gdb-var-update gdb-pending-triggers)))
-(defconst gdb-var-update-regexp "name=\"\\(.*?\\)\"")
+(defconst gdb-var-update-regexp
+ "{.*?name=\"\\(.*?\\)\",.*?in_scope=\"\\(.*?\\)\",.*?\
+type_changed=\".*?\".*?}")
(defun gdb-var-update-handler ()
- (with-current-buffer (gdb-get-create-buffer 'gdb-partial-output-buffer)
- (goto-char (point-min))
+ (dolist (var gdb-var-list)
+ (setcar (nthcdr 5 var) nil))
+ (goto-char (point-min))
+ (let ((n 0))
(while (re-search-forward gdb-var-update-regexp nil t)
- (let ((varnum (match-string 1)))
+ (let ((varnum (match-string 1)))
+ (if (string-equal (match-string 2) "false")
+ (let ((var (assoc varnum gdb-var-list)))
+ (if var (setcar (nthcdr 5 var) 'out-of-scope)))
+ (setq n (1+ n))
+ (push n gdb-pending-triggers)
(gdb-enqueue-input
(list
- (concat "server interpreter mi \"-var-evaluate-expression "
- varnum "\"\n")
- `(lambda () (gdb-var-evaluate-expression-handler ,varnum t)))))))
+ (concat "server interpreter mi \"" (number-to-string n)
+ "-var-evaluate-expression " varnum "\"\n")
+ `(lambda () (gdb-var-evaluate-expression-handler ,varnum t))))))))
(setq gdb-pending-triggers
- (delq 'gdb-var-update gdb-pending-triggers))
- (when (and (boundp 'speedbar-frame) (frame-live-p speedbar-frame))
- ;; Dummy command to update speedbar at right time.
- (gdb-enqueue-input (list "server pwd\n" 'gdb-speedbar-timer-fn))
- ;; Keep gdb-pending-triggers non-nil till end.
- (push 'gdb-speedbar-timer gdb-pending-triggers)))
-
-(defun gdb-speedbar-timer-fn ()
- (setq gdb-pending-triggers
- (delq 'gdb-speedbar-timer gdb-pending-triggers))
- (with-current-buffer gud-comint-buffer
- (speedbar-timer-fn)))
+ (delq 'gdb-var-update gdb-pending-triggers)))
(defun gdb-var-delete ()
"Delete watch expression at point from the speedbar."
(interactive)
- (if (with-current-buffer
- gud-comint-buffer (memq gud-minor-mode '(gdbmi gdba)))
+ (if (memq (buffer-local-value 'gud-minor-mode gud-comint-buffer)
+ '(gdbmi gdba))
(let ((text (speedbar-line-text)))
- (string-match "\\(\\S-+\\)" text)
- (let* ((expr (match-string 1 text))
- (var (assoc expr gdb-var-list))
- (varnum (cadr var)))
- (unless (string-match "\\." varnum)
+ ;; Can't use \\S-+ for whitespace because
+ ;; speedbar has a whacky syntax table.
+ (string-match "\\([^ \t]+\\)" text)
+ (let ((expr (match-string 1 text)) var varnum)
+ (catch 'expr-found
+ (dolist (var1 gdb-var-list)
+ (when (string-equal expr (nth 1 var1))
+ (setq var var1)
+ (setq varnum (car var1))
+ (throw 'expr-found nil))))
+ (unless (string-match "\\." (car var))
(gdb-enqueue-input
(list
- (if (with-current-buffer gud-comint-buffer
- (eq gud-minor-mode 'gdba))
+ (if (eq (buffer-local-value 'gud-minor-mode gud-comint-buffer)
+ 'gdba)
(concat "server interpreter mi \"-var-delete " varnum "\"\n")
(concat "-var-delete " varnum "\n"))
'ignore))
(setq gdb-var-list (delq var gdb-var-list))
(dolist (varchild gdb-var-list)
- (if (string-match (concat (nth 1 var) "\\.") (nth 1 varchild))
- (setq gdb-var-list (delq varchild gdb-var-list))))
- (setq gdb-var-changed t))))))
+ (if (string-match (concat (car var) "\\.") (car varchild))
+ (setq gdb-var-list (delq varchild gdb-var-list)))))))))
(defun gdb-edit-value (text token indent)
"Assign a value to a variable displayed in the speedbar."
(let* ((var (nth (- (count-lines (point-min) (point)) 2) gdb-var-list))
- (varnum (cadr var)) (value))
+ (varnum (car var)) (value))
(setq value (read-string "New value: "))
(gdb-enqueue-input
(list
- (if (with-current-buffer gud-comint-buffer
- (eq gud-minor-mode 'gdba))
+ (if (eq (buffer-local-value 'gud-minor-mode gud-comint-buffer) 'gdba)
(concat "server interpreter mi \"-var-assign "
varnum " " value "\"\n")
(concat "-var-assign " varnum " " value "\n"))
- 'ignore))))
+ `(lambda () (gdb-edit-value-handler ,value))))))
+
+(defun gdb-edit-value-handler (value)
+ (goto-char (point-min))
+ (if (re-search-forward gdb-error-regexp nil t)
+ (message-box "Invalid number or expression (%s)" value)))
(defcustom gdb-show-changed-values t
- "If non-nil highlight values that have recently changed in the speedbar.
-The highlighting is done with `font-lock-warning-face'."
+ "If non-nil change the face of out of scope variables and changed values.
+Out of scope variables are suppressed with `shadow' face.
+Changed values are highlighted with the face `font-lock-warning-face'."
:type 'boolean
:group 'gud
:version "22.1")
TEXT is the text of the button we clicked on, a + or - item.
TOKEN is data related to this node.
INDENT is the current indentation depth."
- (cond ((string-match "+" text) ;expand this node
- (if (with-current-buffer gud-comint-buffer (eq gud-minor-mode 'gdba))
- (gdb-var-list-children token)
- (progn
- (gdbmi-var-update)
- (gdbmi-var-list-children token))))
- ((string-match "-" text) ;contract this node
- (dolist (var gdb-var-list)
- (if (string-match (concat token "\\.") (nth 1 var))
- (setq gdb-var-list (delq var gdb-var-list))))
- (setq gdb-var-changed t)
- (with-current-buffer gud-comint-buffer
- (speedbar-timer-fn)))))
+ (if (and gud-comint-buffer (buffer-name gud-comint-buffer))
+ (progn
+ (cond ((string-match "+" text) ;expand this node
+ (if (and (eq (buffer-local-value
+ 'gud-minor-mode gud-comint-buffer) 'gdba)
+ (string-equal gdb-version "pre-6.4"))
+ (gdb-var-list-children token)
+ (gdb-var-list-children-1 token)))
+ ((string-match "-" text) ;contract this node
+ (dolist (var gdb-var-list)
+ (if (string-match (concat token "\\.") (car var))
+ (setq gdb-var-list (delq var gdb-var-list))))
+ (speedbar-change-expand-button-char ?+)
+ (speedbar-delete-subblock indent))
+ (t (error "Ooops... not sure what to do")))
+ (speedbar-center-buffer-smartly))
+ (message-box "GUD session has been killed")))
(defun gdb-get-target-string ()
(with-current-buffer gud-comint-buffer
;; The usual gdb interaction buffer is given the type `gdba' and
;; is constructed specially.
;;
-;; Others are constructed by gdb-get-create-buffer and
+;; Others are constructed by gdb-get-buffer-create and
;; named according to the rules set forth in the gdb-buffer-rules-assoc
(defvar gdb-buffer-rules-assoc '())
(save-excursion
(gdb-look-for-tagged-buffer key (buffer-list))))
-(defun gdb-get-create-buffer (key)
+(defun gdb-get-buffer-create (key)
"Create a new gdb buffer of the type specified by KEY.
The key should be one of the cars in `gdb-buffer-rules-assoc'."
(or (gdb-get-buffer key)
(setq trigger (funcall (car (cdr (cdr rules))))))
(setq gdb-buffer-type key)
(set (make-local-variable 'gud-minor-mode)
- (with-current-buffer gud-comint-buffer gud-minor-mode))
+ (buffer-local-value 'gud-minor-mode gud-comint-buffer))
(set (make-local-variable 'tool-bar-map) gud-tool-bar-map)
(if trigger (funcall trigger)))
new))))
;; GUD buffers are an exception to the rules
(gdb-set-buffer-rules 'gdba 'error)
-;;
;; Partial-output buffer : This accumulates output from a command executed on
;; behalf of emacs (rather than the user).
;;
(gdb-get-target-string)
"*"))
-(defun gdb-display-inferior-io-buffer ()
- "Display IO of inferior in a separate window."
+(defun gdb-display-separate-io-buffer ()
+ "Display IO of debugged program in a separate window."
(interactive)
- (if gdb-use-inferior-io-buffer
+ (if gdb-use-separate-io-buffer
(gdb-display-buffer
- (gdb-get-create-buffer 'gdb-inferior-io))))
+ (gdb-get-buffer-create 'gdb-inferior-io) t)))
(defconst gdb-frame-parameters
'((height . 14) (width . 80)
(menu-bar-lines . nil)
(minibuffer . nil)))
-(defun gdb-frame-inferior-io-buffer ()
- "Display IO of inferior in a new frame."
+(defun gdb-frame-separate-io-buffer ()
+ "Display IO of debugged program in a new frame."
(interactive)
- (if gdb-use-inferior-io-buffer
+ (if gdb-use-separate-io-buffer
(let ((special-display-regexps (append special-display-regexps '(".*")))
(special-display-frame-alist gdb-frame-parameters))
- (display-buffer (gdb-get-create-buffer 'gdb-inferior-io)))))
+ (display-buffer (gdb-get-buffer-create 'gdb-inferior-io)))))
(defvar gdb-inferior-io-mode-map
(let ((map (make-sparse-keymap)))
- (define-key map "\C-c\C-c" 'gdb-inferior-io-interrupt)
- (define-key map "\C-c\C-z" 'gdb-inferior-io-stop)
- (define-key map "\C-c\C-\\" 'gdb-inferior-io-quit)
- (define-key map "\C-c\C-d" 'gdb-inferior-io-eof)
- (define-key map "\C-d" 'gdb-inferior-io-eof)
+ (define-key map "\C-c\C-c" 'gdb-separate-io-interrupt)
+ (define-key map "\C-c\C-z" 'gdb-separate-io-stop)
+ (define-key map "\C-c\C-\\" 'gdb-separate-io-quit)
+ (define-key map "\C-c\C-d" 'gdb-separate-io-eof)
+ (define-key map "\C-d" 'gdb-separate-io-eof)
map))
(define-derived-mode gdb-inferior-io-mode comint-mode "Inferior I/O"
(process-send-string proc string)
(process-send-string proc "\n")))
-(defun gdb-inferior-io-interrupt ()
+(defun gdb-separate-io-interrupt ()
"Interrupt the program being debugged."
(interactive)
(interrupt-process
(get-buffer-process gud-comint-buffer) comint-ptyp))
-(defun gdb-inferior-io-quit ()
+(defun gdb-separate-io-quit ()
"Send quit signal to the program being debugged."
(interactive)
(quit-process
(get-buffer-process gud-comint-buffer) comint-ptyp))
-(defun gdb-inferior-io-stop ()
+(defun gdb-separate-io-stop ()
"Stop the program being debugged."
(interactive)
(stop-process
(get-buffer-process gud-comint-buffer) comint-ptyp))
-(defun gdb-inferior-io-eof ()
+(defun gdb-separate-io-eof ()
"Send end-of-file to the program being debugged."
(interactive)
(process-send-eof
(get-buffer-process gud-comint-buffer)))
\f
-;;
;; gdb communications
;;
(with-current-buffer gud-comint-buffer
(let ((inhibit-read-only t))
(remove-text-properties (point-min) (point-max) '(face))))
- (let ((item (concat string "\n")))
(if gud-running
- (progn
- (if gdb-enable-debug-log (push (cons 'send item) gdb-debug-log))
- (process-send-string proc item))
- (gdb-enqueue-input item))))
+ (progn
+ (let ((item (concat string "\n")))
+ (if gdb-enable-debug (push (cons 'send item) gdb-debug-ring))
+ (process-send-string proc item)))
+ (if (and (string-match "\\\\$" string)
+ (not comint-input-sender-no-newline)) ;;Try to catch C-d.
+ (setq gdb-continuation (concat gdb-continuation string "\n"))
+ (let ((item (concat gdb-continuation string "\n")))
+ (gdb-enqueue-input item)
+ (setq gdb-continuation nil)))))
;; Note: Stuff enqueued here will be sent to the next prompt, even if it
;; is a query, or other non-top-level prompt.
(defun gdb-enqueue-input (item)
- (if gdb-prompting
- (progn
- (gdb-send-item item)
- (setq gdb-prompting nil))
- (push item gdb-input-queue)))
+ (if (not gud-running)
+ (if gdb-prompting
+ (progn
+ (gdb-send-item item)
+ (setq gdb-prompting nil))
+ (push item gdb-input-queue))))
(defun gdb-dequeue-input ()
(let ((queue gdb-input-queue))
(defun gdb-send-item (item)
(setq gdb-flush-pending-output nil)
- (if gdb-enable-debug-log (push (cons 'send-item item) gdb-debug-log))
+ (if gdb-enable-debug (push (cons 'send-item item) gdb-debug-ring))
(setq gdb-current-item item)
- (with-current-buffer gud-comint-buffer
- (if (eq gud-minor-mode 'gdba)
+ (let ((process (get-buffer-process gud-comint-buffer)))
+ (if (eq (buffer-local-value 'gud-minor-mode gud-comint-buffer) 'gdba)
(if (stringp item)
(progn
(setq gdb-output-sink 'user)
- (process-send-string (get-buffer-process gud-comint-buffer) item))
+ (process-send-string process item))
(progn
(gdb-clear-partial-output)
(setq gdb-output-sink 'pre-emacs)
- (process-send-string (get-buffer-process gud-comint-buffer)
+ (process-send-string process
(car item))))
;; case: eq gud-minor-mode 'gdbmi
(gdb-clear-partial-output)
(setq gdb-output-sink 'emacs)
- (process-send-string (get-buffer-process gud-comint-buffer)
- (car item)))))
+ (process-send-string process (car item)))))
\f
;;
;; output -- things gdb prints to emacs
("source" gdb-source)
("starting" gdb-starting)
("exited" gdb-exited)
- ("signalled" gdb-exited)
- ("signal" gdb-stopping)
+ ("signalled" gdb-signalled)
+ ("signal" gdb-signal)
("breakpoint" gdb-stopping)
("watchpoint" gdb-stopping)
("frame-begin" gdb-frame-begin)
(defun gdb-resync()
(setq gdb-flush-pending-output t)
(setq gud-running nil)
+ (gdb-force-mode-line-update
+ (propertize "stopped"'face font-lock-warning-face))
(setq gdb-output-sink 'user)
(setq gdb-input-queue nil)
(setq gdb-pending-triggers nil)
(cons
(match-string 1 args)
(string-to-number (match-string 2 args))))
- (setq gdb-frame-address (match-string 3 args))
+ (setq gdb-pc-address (match-string 3 args))
;; cover for auto-display output which comes *before*
;; stopped annotation
(if (eq gdb-output-sink 'inferior) (setq gdb-output-sink 'user)))
"An annotation handler for `pre-prompt'.
This terminates the collection of output from a previous command if that
happens to be in effect."
+ (setq gdb-error nil)
(let ((sink gdb-output-sink))
(cond
((eq sink 'user) t)
(defun gdb-prompt (ignored)
"An annotation handler for `prompt'.
This sends the next command (if any) to gdb."
- (when gdb-first-prompt (gdb-ann3))
+ (when gdb-first-prompt
+ (gdb-force-mode-line-update
+ (propertize "initializing..." 'face font-lock-variable-name-face))
+ (gdb-init-1)
+ (setq gdb-first-prompt nil))
(let ((sink gdb-output-sink))
(cond
((eq sink 'user) t)
(setq gdb-output-sink 'user)
(let ((handler
(car (cdr gdb-current-item))))
- (with-current-buffer (gdb-get-create-buffer 'gdb-partial-output-buffer)
+ (with-current-buffer (gdb-get-buffer-create 'gdb-partial-output-buffer)
(funcall handler))))
(t
(gdb-resync)
This says that I/O for the subprocess is now the program being debugged,
not GDB."
(setq gdb-active-process t)
+ (setq gdb-printing t)
(let ((sink gdb-output-sink))
(cond
((eq sink 'user)
(progn
(setq gud-running t)
- (if gdb-use-inferior-io-buffer
+ (setq gdb-inferior-status "running")
+ (setq gdb-signalled nil)
+ (gdb-force-mode-line-update
+ (propertize gdb-inferior-status 'face font-lock-type-face))
+ (gdb-remove-text-properties)
+ (setq gud-old-arrow gud-overlay-arrow-position)
+ (setq gud-overlay-arrow-position nil)
+ (setq gdb-overlay-arrow-position nil)
+ (setq gdb-stack-position nil)
+ (if gdb-use-separate-io-buffer
(setq gdb-output-sink 'inferior))))
(t
(gdb-resync)
(error "Unexpected `starting' annotation")))))
+(defun gdb-signal (ignored)
+ (setq gdb-inferior-status "signal")
+ (gdb-force-mode-line-update
+ (propertize gdb-inferior-status 'face font-lock-warning-face))
+ (gdb-stopping ignored))
+
(defun gdb-stopping (ignored)
"An annotation handler for `breakpoint' and other annotations.
They say that I/O for the subprocess is now GDB, not the program
being debugged."
- (if gdb-use-inferior-io-buffer
+ (if gdb-use-separate-io-buffer
(let ((sink gdb-output-sink))
(cond
((eq sink 'inferior)
(setq gdb-active-process nil)
(setq gud-overlay-arrow-position nil)
(setq gdb-overlay-arrow-position nil)
+ (setq gdb-stack-position nil)
+ (setq gud-old-arrow nil)
+ (setq gdb-inferior-status "exited")
+ (gdb-force-mode-line-update
+ (propertize gdb-inferior-status 'face font-lock-warning-face))
(gdb-stopping ignored))
+(defun gdb-signalled (ignored)
+ (setq gdb-signalled t))
+
(defun gdb-frame-begin (ignored)
+ (setq gdb-frame-begin t)
+ (setq gdb-printing nil)
(let ((sink gdb-output-sink))
(cond
((eq sink 'inferior)
(gdb-resync)
(error "Unexpected frame-begin annotation (%S)" sink)))))
+(defcustom gdb-same-frame focus-follows-mouse
+ "Non-nil means pop up GUD buffer in same frame."
+ :group 'gud
+ :type 'boolean
+ :version "22.1")
+
+(defcustom gdb-find-source-frame nil
+ "Non-nil means try to find a source frame further up stack e.g after signal."
+ :group 'gud
+ :type 'boolean
+ :version "22.1")
+
+(defun gdb-find-source-frame (arg)
+ "Toggle trying to find a source frame further up stack.
+With arg, look for a source frame further up stack iff arg is positive."
+ (interactive "P")
+ (setq gdb-find-source-frame
+ (if (null arg)
+ (not gdb-find-source-frame)
+ (> (prefix-numeric-value arg) 0)))
+ (message (format "Looking for source frame %sabled"
+ (if gdb-find-source-frame "en" "dis"))))
+
(defun gdb-stopped (ignored)
"An annotation handler for `stopped'.
It is just like `gdb-stopping', except that if we already set the output
sink to `user' in `gdb-stopping', that is fine."
(setq gud-running nil)
+ (unless (or gud-overlay-arrow-position gud-last-frame)
+ (if (and gdb-frame-begin gdb-printing)
+ (setq gud-overlay-arrow-position gud-old-arrow)
+ ;;Pop up GUD buffer to display current frame when it doesn't have source
+ ;;information i.e id not compiled with -g as with libc routines generally.
+ (if gdb-same-frame
+ (gdb-display-gdb-buffer)
+ (gdb-frame-gdb-buffer))
+ (if gdb-find-source-frame
+ ;;Try to find source further up stack e.g after signal.
+ (setq gdb-look-up-stack
+ (if (gdb-get-buffer 'gdb-stack-buffer)
+ 'keep
+ (progn
+ (gdb-get-buffer-create 'gdb-stack-buffer)
+ (gdb-invalidate-frames)
+ 'delete))))))
+ (unless (member gdb-inferior-status '("exited" "signal"))
+ (setq gdb-inferior-status "stopped")
+ (gdb-force-mode-line-update
+ (propertize gdb-inferior-status 'face font-lock-warning-face)))
(let ((sink gdb-output-sink))
(cond
((eq sink 'inferior)
((eq sink 'user) t)
(t
(gdb-resync)
- (error "Unexpected stopped annotation")))))
+ (error "Unexpected stopped annotation"))))
+ (if gdb-signalled (gdb-exited ignored)))
(defun gdb-error (ignored)
(setq gdb-error (not gdb-error)))
"An annotation handler for `post-prompt'.
This begins the collection of output from the current command if that
happens to be appropriate."
- (unless gdb-pending-triggers
+ ;; Don't add to queue if there outstanding items or gdb-version is not known
+ ;; yet.
+ (unless (or gdb-pending-triggers gdb-first-post-prompt)
(gdb-get-selected-frame)
(gdb-invalidate-frames)
+ ;; Regenerate breakpoints buffer in case it has been inadvertantly deleted.
+ (gdb-get-buffer-create 'gdb-breakpoints-buffer)
(gdb-invalidate-breakpoints)
;; Do this through gdb-get-selected-frame -> gdb-frame-handler
- ;; so gdb-frame-address is updated.
+ ;; so gdb-pc-address is updated.
;; (gdb-invalidate-assembler)
- (gdb-invalidate-registers)
+
+ (if (string-equal gdb-version "pre-6.4")
+ (gdb-invalidate-registers)
+ (gdb-get-changed-registers)
+ (gdb-invalidate-registers-1))
+
(gdb-invalidate-memory)
- (gdb-invalidate-locals)
+ (if (string-equal gdb-version "pre-6.4")
+ (gdb-invalidate-locals)
+ (gdb-invalidate-locals-1))
+
(gdb-invalidate-threads)
(unless (eq system-type 'darwin) ;Breaks on Darwin's GDB-5.3.
;; FIXME: with GDB-6 on Darwin, this might very well work.
;; Only needed/used with speedbar/watch expressions.
(when (and (boundp 'speedbar-frame) (frame-live-p speedbar-frame))
- (setq gdb-var-changed t) ; force update
- (dolist (var gdb-var-list)
- (setcar (nthcdr 5 var) nil))
- (gdb-var-update))))
+ (if (string-equal gdb-version "pre-6.4")
+ (gdb-var-update)
+ (gdb-var-update-1)))))
+ (setq gdb-first-post-prompt nil)
(let ((sink gdb-output-sink))
(cond
((eq sink 'user) t)
(gdb-resync)
(error "Phase error in gdb-post-prompt (got %s)" sink)))))
+(defconst gdb-buffer-list
+'(gdb-stack-buffer gdb-locals-buffer gdb-registers-buffer gdb-threads-buffer))
+
+(defun gdb-remove-text-properties ()
+ (dolist (buffertype gdb-buffer-list)
+ (let ((buffer (gdb-get-buffer buffertype)))
+ (if buffer
+ (with-current-buffer buffer
+ (let ((inhibit-read-only t))
+ (remove-text-properties
+ (point-min) (point-max) '(mouse-face nil help-echo nil))))))))
+
+;; GUD displays the selected GDB frame. This might might not be the current
+;; GDB frame (after up, down etc). If no GDB frame is visible but the last
+;; visited breakpoint is, use that window.
+(defun gdb-display-source-buffer (buffer)
+ (let* ((last-window (if gud-last-last-frame
+ (get-buffer-window
+ (gud-find-file (car gud-last-last-frame)))))
+ (source-window (or last-window
+ (if (and gdb-source-window
+ (window-live-p gdb-source-window))
+ gdb-source-window))))
+ (when source-window
+ (setq gdb-source-window source-window)
+ (set-window-buffer source-window buffer))
+ source-window))
+
(defun gud-gdba-marker-filter (string)
"A gud marker filter for gdb. Handle a burst of output from GDB."
(if gdb-flush-pending-output
nil
- (if gdb-enable-debug-log (push (cons 'recv string) gdb-debug-log))
+ (when gdb-enable-debug
+ (push (cons 'recv string) gdb-debug-ring)
+ (if (> (length gdb-debug-ring) gdb-debug-ring-max)
+ (setcdr (nthcdr (1- gdb-debug-ring-max) gdb-debug-ring) nil)))
;; Recall the left over gud-marker-acc from last time.
(setq gud-marker-acc (concat gud-marker-acc string))
;; Start accumulating output for the GUD buffer.
(error "Bogon output sink %S" sink)))))
(defun gdb-append-to-partial-output (string)
- (with-current-buffer (gdb-get-create-buffer 'gdb-partial-output-buffer)
+ (with-current-buffer (gdb-get-buffer-create 'gdb-partial-output-buffer)
(goto-char (point-max))
(insert string)))
(defun gdb-clear-partial-output ()
- (with-current-buffer (gdb-get-create-buffer 'gdb-partial-output-buffer)
+ (with-current-buffer (gdb-get-buffer-create 'gdb-partial-output-buffer)
(erase-buffer)))
(defun gdb-append-to-inferior-io (string)
- (with-current-buffer (gdb-get-create-buffer 'gdb-inferior-io)
+ (with-current-buffer (gdb-get-buffer-create 'gdb-inferior-io)
(goto-char (point-max))
(insert-before-markers string))
(if (not (string-equal string ""))
- (gdb-display-buffer (gdb-get-create-buffer 'gdb-inferior-io))))
+ (gdb-display-buffer (gdb-get-buffer-create 'gdb-inferior-io) t)))
(defun gdb-clear-inferior-io ()
- (with-current-buffer (gdb-get-create-buffer 'gdb-inferior-io)
+ (with-current-buffer (gdb-get-buffer-create 'gdb-inferior-io)
(erase-buffer)))
\f
(and buf
(with-current-buffer buf
(let* ((window (get-buffer-window buf 0))
+ (start (window-start window))
(p (window-point window))
(buffer-read-only nil))
(erase-buffer)
- (insert-buffer-substring (gdb-get-create-buffer
+ (insert-buffer-substring (gdb-get-buffer-create
'gdb-partial-output-buffer))
+ (set-window-start window start)
(set-window-point window p)))))
;; put customisation here
(,custom-defun)))
(defvar breakpoint-disabled-icon nil
"Icon for disabled breakpoint in display margin.")
-;; Bitmap for breakpoint in fringe
(and (display-images-p)
+ ;; Bitmap for breakpoint in fringe
(define-fringe-bitmap 'breakpoint
- "\x3c\x7e\xff\xff\xff\xff\x7e\x3c"))
+ "\x3c\x7e\xff\xff\xff\xff\x7e\x3c")
+ ;; Bitmap for gud-overlay-arrow in fringe
+ (define-fringe-bitmap 'hollow-right-triangle
+ "\xe0\x90\x88\x84\x84\x88\x90\xe0"))
(defface breakpoint-enabled
'((t
:weight bold))
"Face for enabled breakpoint icon in fringe."
:group 'gud)
-;; Compatibility alias for old name.
-(put 'breakpoint-enabled-bitmap-face 'face-alias 'breakpoint-enabled)
(defface breakpoint-disabled
;; We use different values of grey for different background types,
;; so that on low-color displays it will end up as something visible
;; if it has to be approximated.
- '((((background dark)) :foreground "grey60")
- (((background light)) :foreground "grey40"))
+ '((t :foreground "grey70"))
"Face for disabled breakpoint icon in fringe."
:group 'gud)
;; Remove all breakpoint-icons in source buffers but not assembler buffer.
(dolist (buffer (buffer-list))
(with-current-buffer buffer
- (if (and (eq gud-minor-mode 'gdba)
+ (if (and (memq gud-minor-mode '(gdba gdbmi))
(not (string-match "\\`\\*.+\\*\\'" (buffer-name))))
(gdb-remove-breakpoint-icons (point-min) (point-max)))))
(with-current-buffer (gdb-get-buffer 'gdb-breakpoints-buffer)
(save-excursion
+ (let ((buffer-read-only nil))
(goto-char (point-min))
(while (< (point) (- (point-max) 1))
(forward-line 1)
- (if (looking-at "[^\t].*?breakpoint")
+ (if (looking-at gdb-breakpoint-regexp)
(progn
- (looking-at "\\([0-9]+\\)\\s-+\\S-+\\s-+\\S-+\\s-+\\(.\\)")
(setq bptno (match-string 1))
(setq flag (char-after (match-beginning 2)))
- (beginning-of-line)
- (if (re-search-forward " in \\(.*\\) at\\s-+" nil t)
- (progn
- (let ((buffer-read-only nil))
- (add-text-properties (match-beginning 1) (match-end 1)
- '(face font-lock-function-name-face)))
- (looking-at "\\(\\S-+\\):\\([0-9]+\\)")
- (let ((line (match-string 2)) (buffer-read-only nil)
- (file (match-string 1)))
- (add-text-properties (line-beginning-position)
- (line-end-position)
- '(mouse-face highlight
- help-echo "mouse-2, RET: visit breakpoint"))
- (unless (file-exists-p file)
- (setq file (cdr (assoc bptno gdb-location-alist))))
- (if (and file
- (not (string-equal file "File not found")))
- (with-current-buffer
- (find-file-noselect file 'nowarn)
- (set (make-local-variable 'gud-minor-mode)
- 'gdba)
- (set (make-local-variable 'tool-bar-map)
- gud-tool-bar-map)
- ;; Only want one breakpoint icon at each
- ;; location.
- (save-excursion
- (goto-line (string-to-number line))
- (gdb-put-breakpoint-icon (eq flag ?y) bptno)))
- (gdb-enqueue-input
- (list
- (concat "list "
- (match-string-no-properties 1) ":1\n")
- 'ignore))
- (gdb-enqueue-input
- (list "info source\n"
- `(lambda () (gdb-get-location
- ,bptno ,line ,flag))))))))))
- (end-of-line)))))
+ (add-text-properties
+ (match-beginning 2) (match-end 2)
+ (if (eq flag ?y)
+ '(face font-lock-warning-face)
+ '(face font-lock-type-face)))
+ (let ((bl (point))
+ (el (line-end-position)))
+ (if (re-search-forward " in \\(.*\\) at\\s-+" el t)
+ (progn
+ (add-text-properties
+ (match-beginning 1) (match-end 1)
+ '(face font-lock-function-name-face))
+ (looking-at "\\(\\S-+\\):\\([0-9]+\\)")
+ (let ((line (match-string 2))
+ (file (match-string 1)))
+ (add-text-properties bl el
+ '(mouse-face highlight
+ help-echo "mouse-2, RET: visit breakpoint"))
+ (unless (file-exists-p file)
+ (setq file (cdr (assoc bptno gdb-location-alist))))
+ (if (and file
+ (not (string-equal file "File not found")))
+ (with-current-buffer
+ (find-file-noselect file 'nowarn)
+ (set (make-local-variable 'gud-minor-mode)
+ 'gdba)
+ (set (make-local-variable 'tool-bar-map)
+ gud-tool-bar-map)
+ ;; Only want one breakpoint icon at each
+ ;; location.
+ (save-excursion
+ (goto-line (string-to-number line))
+ (gdb-put-breakpoint-icon (eq flag ?y) bptno)))
+ (gdb-enqueue-input
+ (list
+ (concat gdb-server-prefix "list "
+ (match-string-no-properties 1) ":1\n")
+ 'ignore))
+ (gdb-enqueue-input
+ (list (concat gdb-server-prefix "info source\n")
+ `(lambda () (gdb-get-location
+ ,bptno ,line ,flag)))))))
+ (if (re-search-forward
+ "<\\(\\(\\sw\\|[_.]\\)+\\)\\(\\+[0-9]+\\)?>"
+ el t)
+ (add-text-properties
+ (match-beginning 1) (match-end 1)
+ '(face font-lock-function-name-face))
+ (end-of-line)
+ (re-search-backward "\\s-\\(\\S-*\\)"
+ bl t)
+ (add-text-properties
+ (match-beginning 1) (match-end 1)
+ '(face font-lock-variable-name-face)))))))
+ (end-of-line))))))
(if (gdb-get-buffer 'gdb-assembler-buffer) (gdb-assembler-custom)))
(defun gdb-mouse-set-clear-breakpoint (event)
(list
(let ((bptno (get-text-property
0 'gdb-bptno (car (posn-string posn)))))
- (concat
+ (concat gdb-server-prefix
(if (get-text-property
0 'gdb-enabled (car (posn-string posn)))
"disable "
(when (stringp obj)
(gdb-enqueue-input
(list
- (concat
+ (concat gdb-server-prefix
(if (get-text-property 0 'gdb-enabled obj)
"disable "
"enable ")
"Display status of user-settable breakpoints."
(interactive)
(gdb-display-buffer
- (gdb-get-create-buffer 'gdb-breakpoints-buffer)))
+ (gdb-get-buffer-create 'gdb-breakpoints-buffer) t))
(defun gdb-frame-breakpoints-buffer ()
"Display status of user-settable breakpoints in a new frame."
(interactive)
(let ((special-display-regexps (append special-display-regexps '(".*")))
(special-display-frame-alist gdb-frame-parameters))
- (display-buffer (gdb-get-create-buffer 'gdb-breakpoints-buffer))))
+ (display-buffer (gdb-get-buffer-create 'gdb-breakpoints-buffer))))
(defvar gdb-breakpoints-mode-map
(let ((map (make-sparse-keymap))
(menu (make-sparse-keymap "Breakpoints")))
- (define-key menu [quit] '("Quit" . kill-this-buffer))
+ (define-key menu [quit] '("Quit" . gdb-delete-frame-or-window))
(define-key menu [goto] '("Goto" . gdb-goto-breakpoint))
(define-key menu [delete] '("Delete" . gdb-delete-breakpoint))
(define-key menu [toggle] '("Toggle" . gdb-toggle-breakpoint))
(suppress-keymap map)
(define-key map [menu-bar breakpoints] (cons "Breakpoints" menu))
(define-key map " " 'gdb-toggle-breakpoint)
- (define-key map "d" 'gdb-delete-breakpoint)
- (define-key map "q" 'kill-this-buffer)
+ (define-key map "D" 'gdb-delete-breakpoint)
+ ;; Don't bind "q" to kill-this-buffer as we need it for breakpoint icons.
+ (define-key map "q" 'gdb-delete-frame-or-window)
(define-key map "\r" 'gdb-goto-breakpoint)
(define-key map [mouse-2] 'gdb-goto-breakpoint)
(define-key map [follow-link] 'mouse-face)
map))
+(defun gdb-delete-frame-or-window ()
+ "Delete frame if there is only one window. Otherwise delete the window."
+ (interactive)
+ (if (one-window-p) (delete-frame)
+ (delete-window)))
+
(defun gdb-breakpoints-mode ()
"Major mode for gdb breakpoints.
(use-local-map gdb-breakpoints-mode-map)
(setq buffer-read-only t)
(run-mode-hooks 'gdb-breakpoints-mode-hook)
- (if (with-current-buffer gud-comint-buffer (eq gud-minor-mode 'gdba))
+ (if (eq (buffer-local-value 'gud-minor-mode gud-comint-buffer) 'gdba)
'gdb-invalidate-breakpoints
'gdbmi-invalidate-breakpoints))
+(defconst gdb-breakpoint-regexp
+ "\\([0-9]+\\).*?\\(?:point\\|catch\\s-+\\S-+\\)\\s-+\\S-+\\s-+\\(.\\)\\s-+")
+
(defun gdb-toggle-breakpoint ()
"Enable/disable breakpoint at current line."
(interactive)
(save-excursion
(beginning-of-line 1)
- (if (if (with-current-buffer gud-comint-buffer (eq gud-minor-mode 'gdba))
- (looking-at "\\([0-9]+\\).*?point\\s-+\\S-+\\s-+\\(.\\)\\s-+")
- (looking-at
- "\\([0-9]+\\)\\s-+\\S-+\\s-+\\S-+\\s-+\\(.\\)\\s-+\\S-+\\s-+\\S-+:[0-9]+"))
+ (if (looking-at gdb-breakpoint-regexp)
(gdb-enqueue-input
(list
(concat gdb-server-prefix
"Delete the breakpoint at current line."
(interactive)
(beginning-of-line 1)
- (if (if (with-current-buffer gud-comint-buffer (eq gud-minor-mode 'gdba))
- (looking-at "\\([0-9]+\\).*?point\\s-+\\S-+\\s-+\\(.\\)")
- (looking-at
- "\\([0-9]+\\)\\s-+\\S-+\\s-+\\S-+\\s-+\\s-+\\S-+\\s-+\\S-+:[0-9]+"))
+ (if (looking-at gdb-breakpoint-regexp)
(gdb-enqueue-input
(list
(concat gdb-server-prefix "delete " (match-string 1) "\n") 'ignore))
(defun gdb-goto-breakpoint (&optional event)
"Display the breakpoint location specified at current line."
(interactive (list last-input-event))
- (if event (mouse-set-point event))
- ;; Hack to stop gdb-goto-breakpoint displaying in GUD buffer.
- (let ((window (get-buffer-window gud-comint-buffer)))
- (if window (save-selected-window (select-window window))))
+ (if event (posn-set-point (event-end event)))
(save-excursion
(beginning-of-line 1)
- (if (if (with-current-buffer gud-comint-buffer (eq gud-minor-mode 'gdba))
- (looking-at "\\([0-9]+\\) .+ in .+ at\\s-+\\(\\S-+\\):\\([0-9]+\\)")
- (looking-at
- "\\([0-9]+\\)\\s-+\\S-+\\s-+\\S-+\\s-+.\\s-+\\S-+\\s-+\
-\\(\\S-+\\):\\([0-9]+\\)"))
+ (if (looking-at "\\([0-9]+\\) .+ in .+ at\\s-+\\(\\S-+\\):\\([0-9]+\\)")
(let ((bptno (match-string 1))
(file (match-string 2))
(line (match-string 3)))
(save-selected-window
- (let* ((buf (find-file-noselect
+ (let* ((buffer (find-file-noselect
(if (file-exists-p file) file
(cdr (assoc bptno gdb-location-alist)))))
- (window (display-buffer buf)))
- (with-current-buffer buf
+ (window (or (gdb-display-source-buffer buffer)
+ (display-buffer buffer))))
+ (setq gdb-source-window window)
+ (with-current-buffer buffer
(goto-line (string-to-number line))
(set-window-point window (point))))))
- (error "Not recognized as break/watchpoint line"))))
+ (error "No location specified."))))
\f
;; Frames buffer. This displays a perpetually correct bactracktrace
(def-gdb-auto-updated-buffer gdb-stack-buffer
gdb-invalidate-frames
- "server where\n"
- gdb-info-frames-handler
- gdb-info-frames-custom)
+ "server info stack\n"
+ gdb-info-stack-handler
+ gdb-info-stack-custom)
-(defun gdb-info-frames-custom ()
+(defun gdb-info-stack-custom ()
(with-current-buffer (gdb-get-buffer 'gdb-stack-buffer)
(save-excursion
- (let ((buffer-read-only nil)
- bl el)
- (goto-char (point-min))
- (while (< (point) (point-max))
- (setq bl (line-beginning-position)
- el (line-end-position))
- (unless (looking-at "No ")
- (add-text-properties bl el
- '(mouse-face highlight
- help-echo "mouse-2, RET: Select frame")))
- (goto-char bl)
- (when (looking-at "^#\\([0-9]+\\)")
- (when (string-equal (match-string 1) gdb-frame-number)
- (put-text-property bl (+ bl 4)
- 'face '(:inverse-video t)))
- (when (re-search-forward
- (concat
- (if (string-equal (match-string 1) "0") "" " in ")
- "\\([^ ]+\\) (") el t)
- (put-text-property (match-beginning 1) (match-end 1)
- 'face font-lock-function-name-face)
- (setq bl (match-end 0))
- (while (re-search-forward "<\\([^>]+\\)>" el t)
+ (unless (eq gdb-look-up-stack 'delete)
+ (let ((buffer-read-only nil)
+ bl el)
+ (goto-char (point-min))
+ (while (< (point) (point-max))
+ (setq bl (line-beginning-position)
+ el (line-end-position))
+ (when (looking-at "#")
+ (add-text-properties bl el
+ '(mouse-face highlight
+ help-echo "mouse-2, RET: Select frame")))
+ (goto-char bl)
+ (when (looking-at "^#\\([0-9]+\\)")
+ (when (string-equal (match-string 1) gdb-frame-number)
+ (if (> (car (window-fringes)) 0)
+ (progn
+ (or gdb-stack-position
+ (setq gdb-stack-position (make-marker)))
+ (set-marker gdb-stack-position (point)))
+ (put-text-property bl (+ bl 4)
+ 'face '(:inverse-video t))))
+ (when (re-search-forward
+ (concat
+ (if (string-equal (match-string 1) "0") "" " in ")
+ "\\([^ ]+\\) (") el t)
(put-text-property (match-beginning 1) (match-end 1)
+ 'face font-lock-function-name-face)
+ (setq bl (match-end 0))
+ (while (re-search-forward "<\\([^>]+\\)>" el t)
+ (put-text-property (match-beginning 1) (match-end 1)
'face font-lock-function-name-face))
- (goto-char bl)
- (while (re-search-forward "\\(\\(\\sw\\|[_.]\\)+\\)=" el t)
- (put-text-property (match-beginning 1) (match-end 1)
- 'face font-lock-variable-name-face))))
- (forward-line 1))))))
+ (goto-char bl)
+ (while (re-search-forward "\\(\\(\\sw\\|[_.]\\)+\\)=" el t)
+ (put-text-property (match-beginning 1) (match-end 1)
+ 'face font-lock-variable-name-face))))
+ (forward-line 1))))
+ (when gdb-look-up-stack
+ (goto-char (point-min))
+ (when (re-search-forward "\\(\\S-+?\\):\\([0-9]+\\)" nil t)
+ (let ((start (line-beginning-position))
+ (file (match-string 1))
+ (line (match-string 2)))
+ (re-search-backward "^#*\\([0-9]+\\)" start t)
+ (gdb-enqueue-input
+ (list (concat gdb-server-prefix "frame "
+ (match-string 1) "\n") 'gdb-set-hollow))
+ (gdb-enqueue-input
+ (list (concat gdb-server-prefix "frame 0\n") 'ignore)))))))
+ (if (eq gdb-look-up-stack 'delete)
+ (kill-buffer (gdb-get-buffer 'gdb-stack-buffer)))
+ (setq gdb-look-up-stack nil))
+
+(defun gdb-set-hollow ()
+ (if gud-last-last-frame
+ (with-current-buffer (gud-find-file (car gud-last-last-frame))
+ (setq fringe-indicator-alist
+ '((overlay-arrow . hollow-right-triangle))))))
(defun gdb-stack-buffer-name ()
(with-current-buffer gud-comint-buffer
"Display backtrace of current stack."
(interactive)
(gdb-display-buffer
- (gdb-get-create-buffer 'gdb-stack-buffer)))
+ (gdb-get-buffer-create 'gdb-stack-buffer) t))
(defun gdb-frame-stack-buffer ()
"Display backtrace of current stack in a new frame."
(interactive)
(let ((special-display-regexps (append special-display-regexps '(".*")))
(special-display-frame-alist gdb-frame-parameters))
- (display-buffer (gdb-get-create-buffer 'gdb-stack-buffer))))
+ (display-buffer (gdb-get-buffer-create 'gdb-stack-buffer))))
(defvar gdb-frames-mode-map
(let ((map (make-sparse-keymap)))
map))
(defun gdb-frames-mode ()
- "Major mode for gdb frames.
+ "Major mode for gdb call stack.
\\{gdb-frames-mode-map}"
(kill-all-local-variables)
(setq major-mode 'gdb-frames-mode)
(setq mode-name "Frames")
+ (setq gdb-stack-position nil)
+ (add-to-list 'overlay-arrow-variable-list 'gdb-stack-position)
(setq buffer-read-only t)
(use-local-map gdb-frames-mode-map)
- (font-lock-mode -1)
(run-mode-hooks 'gdb-frames-mode-hook)
- (if (with-current-buffer gud-comint-buffer (eq gud-minor-mode 'gdba))
+ (if (eq (buffer-local-value 'gud-minor-mode gud-comint-buffer) 'gdba)
'gdb-invalidate-frames
'gdbmi-invalidate-frames))
(defun gdb-get-frame-number ()
(save-excursion
(end-of-line)
- (let* ((pos (re-search-backward "^#*\\([0-9]*\\)" nil t))
+ (let* ((start (line-beginning-position))
+ (pos (re-search-backward "^#*\\([0-9]+\\)" start t))
(n (or (and pos (match-string-no-properties 1)) "0")))
n)))
(defun gdb-frames-select (&optional event)
"Select the frame and display the relevant source."
(interactive (list last-input-event))
- (if event (mouse-set-point event))
+ (if event (posn-set-point (event-end event)))
(gdb-enqueue-input
(list (concat gdb-server-prefix "frame "
- (gdb-get-frame-number) "\n") 'ignore))
- (gud-display-frame))
+ (gdb-get-frame-number) "\n") 'ignore)))
\f
;; Threads buffer. This displays a selectable thread list.
(defun gdb-info-threads-custom ()
(with-current-buffer (gdb-get-buffer 'gdb-threads-buffer)
(let ((buffer-read-only nil))
- (goto-char (point-min))
- (while (< (point) (point-max))
- (unless (looking-at "No ")
- (add-text-properties (line-beginning-position) (line-end-position)
- '(mouse-face highlight
+ (save-excursion
+ (goto-char (point-min))
+ (while (< (point) (point-max))
+ (unless (looking-at "No ")
+ (add-text-properties (line-beginning-position) (line-end-position)
+ '(mouse-face highlight
help-echo "mouse-2, RET: select thread")))
- (forward-line 1)))))
+ (forward-line 1))))))
(defun gdb-threads-buffer-name ()
(with-current-buffer gud-comint-buffer
"Display IDs of currently known threads."
(interactive)
(gdb-display-buffer
- (gdb-get-create-buffer 'gdb-threads-buffer)))
+ (gdb-get-buffer-create 'gdb-threads-buffer) t))
(defun gdb-frame-threads-buffer ()
"Display IDs of currently known threads in a new frame."
(interactive)
(let ((special-display-regexps (append special-display-regexps '(".*")))
(special-display-frame-alist gdb-frame-parameters))
- (display-buffer (gdb-get-create-buffer 'gdb-threads-buffer))))
+ (display-buffer (gdb-get-buffer-create 'gdb-threads-buffer))))
(defvar gdb-threads-mode-map
(let ((map (make-sparse-keymap)))
(define-key map "q" 'kill-this-buffer)
(define-key map "\r" 'gdb-threads-select)
(define-key map [mouse-2] 'gdb-threads-select)
+ (define-key map [follow-link] 'mouse-face)
map))
(defvar gdb-threads-font-lock-keywords
- '(
- (") +\\([^ ]+\\) (" (1 font-lock-function-name-face))
+ '((") +\\([^ ]+\\) (" (1 font-lock-function-name-face))
("in \\([^ ]+\\) (" (1 font-lock-function-name-face))
- ("\\(\\(\\sw\\|[_.]\\)+\\)=" (1 font-lock-variable-name-face))
- )
+ ("\\(\\(\\sw\\|[_.]\\)+\\)=" (1 font-lock-variable-name-face)))
"Font lock keywords used in `gdb-threads-mode'.")
(defun gdb-threads-mode ()
- "Major mode for gdb frames.
+ "Major mode for gdb threads.
\\{gdb-threads-mode-map}"
(kill-all-local-variables)
(defun gdb-threads-select (&optional event)
"Select the thread and display the relevant source."
(interactive (list last-input-event))
- (if event (mouse-set-point event))
+ (if event (posn-set-point (event-end event)))
(gdb-enqueue-input
- (list (concat "thread " (gdb-get-thread-number) "\n") 'ignore))
+ (list (concat gdb-server-prefix "thread "
+ (gdb-get-thread-number) "\n") 'ignore))
(gud-display-frame))
\f
(with-current-buffer (gdb-get-buffer 'gdb-registers-buffer)
(save-excursion
(let ((buffer-read-only nil)
- bl)
+ start end)
(goto-char (point-min))
(while (< (point) (point-max))
- (setq bl (line-beginning-position))
+ (setq start (line-beginning-position))
+ (setq end (line-end-position))
(when (looking-at "^[^ ]+")
(unless (string-equal (match-string 0) "The")
- (put-text-property bl (match-end 0)
- 'face font-lock-variable-name-face)))
+ (put-text-property start (match-end 0)
+ 'face font-lock-variable-name-face)
+ (add-text-properties start end
+ '(help-echo "mouse-2: edit value"
+ mouse-face highlight))))
(forward-line 1))))))
+(defun gdb-edit-register-value (&optional event)
+ (interactive (list last-input-event))
+ (save-excursion
+ (if event (posn-set-point (event-end event)))
+ (beginning-of-line)
+ (let* ((register (current-word))
+ (value (read-string (format "New value (%s): " register))))
+ (gdb-enqueue-input
+ (list (concat gdb-server-prefix "set $" register "=" value "\n")
+ 'ignore)))))
+
(defvar gdb-registers-mode-map
(let ((map (make-sparse-keymap)))
(suppress-keymap map)
- (define-key map " " 'toggle-gdb-all-registers)
+ (define-key map "\r" 'gdb-edit-register-value)
+ (define-key map [mouse-2] 'gdb-edit-register-value)
+ (define-key map " " 'gdb-all-registers)
(define-key map "q" 'kill-this-buffer)
map))
\\{gdb-registers-mode-map}"
(kill-all-local-variables)
(setq major-mode 'gdb-registers-mode)
- (setq mode-name "Registers:")
+ (setq mode-name "Registers")
(setq buffer-read-only t)
(use-local-map gdb-registers-mode-map)
(run-mode-hooks 'gdb-registers-mode-hook)
- (if (with-current-buffer gud-comint-buffer (eq gud-minor-mode 'gdba))
- 'gdb-invalidate-registers
- 'gdbmi-invalidate-registers))
+ (if (string-equal gdb-version "pre-6.4")
+ (progn
+ (if gdb-all-registers (setq mode-name "Registers:All"))
+ 'gdb-invalidate-registers)
+ 'gdb-invalidate-registers-1))
(defun gdb-registers-buffer-name ()
(with-current-buffer gud-comint-buffer
"Display integer register contents."
(interactive)
(gdb-display-buffer
- (gdb-get-create-buffer 'gdb-registers-buffer)))
+ (gdb-get-buffer-create 'gdb-registers-buffer) t))
(defun gdb-frame-registers-buffer ()
"Display integer register contents in a new frame."
(interactive)
(let ((special-display-regexps (append special-display-regexps '(".*")))
(special-display-frame-alist gdb-frame-parameters))
- (display-buffer (gdb-get-create-buffer 'gdb-registers-buffer))))
+ (display-buffer (gdb-get-buffer-create 'gdb-registers-buffer))))
-(defun toggle-gdb-all-registers ()
- "Toggle the display of floating-point registers."
+(defun gdb-all-registers ()
+ "Toggle the display of floating-point registers (pre GDB 6.4 only)."
(interactive)
- (if gdb-all-registers
- (progn
- (setq gdb-all-registers nil)
- (with-current-buffer (gdb-get-buffer 'gdb-registers-buffer)
- (setq mode-name "Registers:")))
- (setq gdb-all-registers t)
- (with-current-buffer (gdb-get-buffer 'gdb-registers-buffer)
- (setq mode-name "Registers:All")))
- (gdb-invalidate-registers))
+ (when (string-equal gdb-version "pre-6.4")
+ (if gdb-all-registers
+ (progn
+ (setq gdb-all-registers nil)
+ (with-current-buffer (gdb-get-buffer-create 'gdb-registers-buffer)
+ (setq mode-name "Registers")))
+ (setq gdb-all-registers t)
+ (with-current-buffer (gdb-get-buffer-create 'gdb-registers-buffer)
+ (setq mode-name "Registers:All")))
+ (message (format "Display of floating-point registers %sabled"
+ (if gdb-all-registers "en" "dis")))
+ (gdb-invalidate-registers)))
\f
;; Memory buffer.
(customize-set-variable 'gdb-memory-format "x")
(gdb-invalidate-memory))
-(defvar gdb-memory-format-keymap
+(defvar gdb-memory-format-map
(let ((map (make-sparse-keymap)))
(define-key map [header-line down-mouse-3] 'gdb-memory-format-menu-1)
map)
(customize-set-variable 'gdb-memory-unit "b")
(gdb-invalidate-memory))
-(defvar gdb-memory-unit-keymap
+(defvar gdb-memory-unit-map
(let ((map (make-sparse-keymap)))
(define-key map [header-line down-mouse-3] 'gdb-memory-unit-menu-1)
map)
'local-map
(gdb-make-header-line-mouse-map
'mouse-1
- #'(lambda () (interactive)
- (let ((gdb-memory-address
- ;; Let GDB do the arithmetic.
- (concat
- gdb-memory-address " - "
- (number-to-string
- (* gdb-memory-repeat-count
- (cond ((string= gdb-memory-unit "b") 1)
- ((string= gdb-memory-unit "h") 2)
- ((string= gdb-memory-unit "w") 4)
- ((string= gdb-memory-unit "g") 8)))))))
- (gdb-invalidate-memory)))))
+ (lambda () (interactive)
+ (let ((gdb-memory-address
+ ;; Let GDB do the arithmetic.
+ (concat
+ gdb-memory-address " - "
+ (number-to-string
+ (* gdb-memory-repeat-count
+ (cond ((string= gdb-memory-unit "b") 1)
+ ((string= gdb-memory-unit "h") 2)
+ ((string= gdb-memory-unit "w") 4)
+ ((string= gdb-memory-unit "g") 8)))))))
+ (gdb-invalidate-memory)))))
"|"
(propertize "+"
'face font-lock-warning-face
'mouse-face 'mode-line-highlight
'local-map (gdb-make-header-line-mouse-map
'mouse-1
- #'(lambda () (interactive)
- (let ((gdb-memory-address nil))
- (gdb-invalidate-memory)))))
+ (lambda () (interactive)
+ (let ((gdb-memory-address nil))
+ (gdb-invalidate-memory)))))
"]: "
(propertize gdb-memory-address
'face font-lock-warning-face
'face font-lock-warning-face
'help-echo "mouse-3: Select display format"
'mouse-face 'mode-line-highlight
- 'local-map gdb-memory-format-keymap)
+ 'local-map gdb-memory-format-map)
" Unit Size: "
(propertize gdb-memory-unit
'face font-lock-warning-face
'help-echo "mouse-3: Select unit size"
'mouse-face 'mode-line-highlight
- 'local-map gdb-memory-unit-keymap))))
+ 'local-map gdb-memory-unit-map))))
(set (make-local-variable 'font-lock-defaults)
'(gdb-memory-font-lock-keywords))
(run-mode-hooks 'gdb-memory-mode-hook)
"Display memory contents."
(interactive)
(gdb-display-buffer
- (gdb-get-create-buffer 'gdb-memory-buffer)))
+ (gdb-get-buffer-create 'gdb-memory-buffer) t))
(defun gdb-frame-memory-buffer ()
"Display memory contents in a new frame."
(interactive)
- (let ((special-display-regexps (append special-display-regexps '(".*")))
- (special-display-frame-alist gdb-frame-parameters))
- (display-buffer (gdb-get-create-buffer 'gdb-memory-buffer))))
+ (let* ((special-display-regexps (append special-display-regexps '(".*")))
+ (special-display-frame-alist
+ (cons '(left-fringe . 0)
+ (cons '(right-fringe . 0)
+ (cons '(width . 83) gdb-frame-parameters)))))
+ (display-buffer (gdb-get-buffer-create 'gdb-memory-buffer))))
\f
;; Locals buffer.
"server info locals\n"
gdb-info-locals-handler)
+(defvar gdb-locals-watch-map
+ (let ((map (make-sparse-keymap)))
+ (suppress-keymap map)
+ (define-key map "\r" (lambda () (interactive)
+ (beginning-of-line)
+ (gud-watch)))
+ (define-key map [mouse-2] (lambda (event) (interactive "e")
+ (mouse-set-point event)
+ (beginning-of-line)
+ (gud-watch)))
+ map)
+ "Keymap to create watch expression of a complex data type local variable.")
+
+(defconst gdb-struct-string
+ (concat (propertize "[struct/union]"
+ 'mouse-face 'highlight
+ 'help-echo "mouse-2: create watch expression"
+ 'local-map gdb-locals-watch-map) "\n"))
+
+(defconst gdb-array-string
+ (concat " " (propertize "[array]"
+ 'mouse-face 'highlight
+ 'help-echo "mouse-2: create watch expression"
+ 'local-map gdb-locals-watch-map) "\n"))
+
;; Abbreviate for arrays and structures.
;; These can be expanded using gud-display.
(defun gdb-info-locals-handler ()
(replace-match "" nil nil))
(goto-char (point-min))
(while (re-search-forward "{\\(.*=.*\n\\|\n\\)" nil t)
- (replace-match "(structure);\n" nil nil))
+ (replace-match gdb-struct-string nil nil))
(goto-char (point-min))
(while (re-search-forward "\\s-*{.*\n" nil t)
- (replace-match " (array);\n" nil nil))))
+ (replace-match gdb-array-string nil nil))))
(let ((buf (gdb-get-buffer 'gdb-locals-buffer)))
(and buf
(with-current-buffer buf
(let* ((window (get-buffer-window buf 0))
+ (start (window-start window))
(p (window-point window))
(buffer-read-only nil))
(erase-buffer)
- (insert-buffer-substring (gdb-get-create-buffer
+ (insert-buffer-substring (gdb-get-buffer-create
'gdb-partial-output-buffer))
- (set-window-point window p)))))
+ (set-window-start window start)
+ (set-window-point window p))
+)))
(run-hooks 'gdb-info-locals-hook))
(defvar gdb-locals-mode-map
(define-key map "q" 'kill-this-buffer)
map))
-(defvar gdb-locals-font-lock-keywords
- '(
- ;; var = (struct struct_tag) value
- ( "\\(^\\(\\sw\\|[_.]\\)+\\) += +(\\(struct\\) \\(\\(\\sw\\|[_.]\\)+\\)"
- (1 font-lock-variable-name-face)
- (3 font-lock-keyword-face)
- (4 font-lock-type-face))
- ;; var = (type) value
- ( "\\(^\\(\\sw\\|[_.]\\)+\\) += +(\\(\\(\\sw\\|[_.]\\)+\\)"
- (1 font-lock-variable-name-face)
- (3 font-lock-type-face))
- ;; var = val
- ( "\\(^\\(\\sw\\|[_.]\\)+\\) += +[^(]"
- (1 font-lock-variable-name-face))
- )
- "Font lock keywords used in `gdb-local-mode'.")
-
(defun gdb-locals-mode ()
"Major mode for gdb locals.
(set (make-local-variable 'font-lock-defaults)
'(gdb-locals-font-lock-keywords))
(run-mode-hooks 'gdb-locals-mode-hook)
- (if (with-current-buffer gud-comint-buffer (eq gud-minor-mode 'gdba))
+ (if (and (eq (buffer-local-value 'gud-minor-mode gud-comint-buffer) 'gdba)
+ (string-equal gdb-version "pre-6.4"))
'gdb-invalidate-locals
- 'gdbmi-invalidate-locals))
+ 'gdb-invalidate-locals-1))
(defun gdb-locals-buffer-name ()
(with-current-buffer gud-comint-buffer
"Display local variables of current stack and their values."
(interactive)
(gdb-display-buffer
- (gdb-get-create-buffer 'gdb-locals-buffer)))
+ (gdb-get-buffer-create 'gdb-locals-buffer) t))
(defun gdb-frame-locals-buffer ()
"Display local variables of current stack and their values in a new frame."
(interactive)
(let ((special-display-regexps (append special-display-regexps '(".*")))
(special-display-frame-alist gdb-frame-parameters))
- (display-buffer (gdb-get-create-buffer 'gdb-locals-buffer))))
+ (display-buffer (gdb-get-buffer-create 'gdb-locals-buffer))))
\f
;;;; Window management
-(defun gdb-display-buffer (buf &optional size)
+(defun gdb-display-buffer (buf dedicated &optional size)
(let ((answer (get-buffer-window buf 0))
(must-split nil))
(if answer
(pop-to-buffer gud-comint-buffer) ;Select the right frame.
(let ((window (get-lru-window)))
(if (and window
- (not (eq window (get-buffer-window gud-comint-buffer))))
+ (not (memq window `(,(get-buffer-window gud-comint-buffer)
+ ,gdb-source-window))))
(progn
(set-window-buffer window buf)
(setq answer window))
(new-size (and size (< size cur-size) (- cur-size size))))
(setq answer (split-window largest new-size))
(set-window-buffer answer buf)
- (set-window-dedicated-p answer t)))
+ (set-window-dedicated-p answer dedicated)))
answer)))
\f
:visible (memq gud-minor-mode '(gdbmi gdba))))
(define-key menu [gdb] '("Gdb" . gdb-display-gdb-buffer))
(define-key menu [threads] '("Threads" . gdb-display-threads-buffer))
+ (define-key menu [inferior]
+ '(menu-item "Separate IO" gdb-display-separate-io-buffer
+ :enable gdb-use-separate-io-buffer))
(define-key menu [memory] '("Memory" . gdb-display-memory-buffer))
+ (define-key menu [registers] '("Registers" . gdb-display-registers-buffer))
(define-key menu [disassembly]
'("Disassembly" . gdb-display-assembler-buffer))
- (define-key menu [registers] '("Registers" . gdb-display-registers-buffer))
- (define-key menu [inferior]
- '(menu-item "Inferior IO" gdb-display-inferior-io-buffer
- :enable gdb-use-inferior-io-buffer))
- (define-key menu [locals] '("Locals" . gdb-display-locals-buffer))
- (define-key menu [frames] '("Stack" . gdb-display-stack-buffer))
(define-key menu [breakpoints]
- '("Breakpoints" . gdb-display-breakpoints-buffer)))
+ '("Breakpoints" . gdb-display-breakpoints-buffer))
+ (define-key menu [locals] '("Locals" . gdb-display-locals-buffer))
+ (define-key menu [frames] '("Stack" . gdb-display-stack-buffer)))
(let ((menu (make-sparse-keymap "GDB-Frames")))
(define-key gud-menu-map [frames]
(define-key menu [gdb] '("Gdb" . gdb-frame-gdb-buffer))
(define-key menu [threads] '("Threads" . gdb-frame-threads-buffer))
(define-key menu [memory] '("Memory" . gdb-frame-memory-buffer))
- (define-key menu [disassembly] '("Disassembiy" . gdb-frame-assembler-buffer))
- (define-key menu [registers] '("Registers" . gdb-frame-registers-buffer))
(define-key menu [inferior]
- '(menu-item "Inferior IO" gdb-frame-inferior-io-buffer
- :enable gdb-use-inferior-io-buffer))
- (define-key menu [locals] '("Locals" . gdb-frame-locals-buffer))
- (define-key menu [frames] '("Stack" . gdb-frame-stack-buffer))
+ '(menu-item "Separate IO" gdb-frame-separate-io-buffer
+ :enable gdb-use-separate-io-buffer))
+ (define-key menu [registers] '("Registers" . gdb-frame-registers-buffer))
+ (define-key menu [disassembly] '("Disassembly" . gdb-frame-assembler-buffer))
(define-key menu [breakpoints]
- '("Breakpoints" . gdb-frame-breakpoints-buffer)))
+ '("Breakpoints" . gdb-frame-breakpoints-buffer))
+ (define-key menu [locals] '("Locals" . gdb-frame-locals-buffer))
+ (define-key menu [frames] '("Stack" . gdb-frame-stack-buffer)))
-(let ((menu (make-sparse-keymap "GDB-UI")))
+(let ((menu (make-sparse-keymap "GDB-UI/MI")))
(define-key gud-menu-map [ui]
- `(menu-item "GDB-UI" ,menu :visible (eq gud-minor-mode 'gdba)))
- (define-key menu [gdb-use-inferior-io]
- '(menu-item "Separate inferior IO" gdb-use-inferior-io-buffer
- :help "Toggle separate IO for inferior."
- :button (:toggle . gdb-use-inferior-io-buffer)))
+ `(menu-item (if (eq gud-minor-mode 'gdba) "GDB-UI" "GDB-MI")
+ ,menu :visible (memq gud-minor-mode '(gdbmi gdba))))
+ (define-key menu [gdb-find-source-frame]
+ '(menu-item "Look For Source Frame" gdb-find-source-frame
+ :visible (eq gud-minor-mode 'gdba)
+ :help "Toggle look for source frame."
+ :button (:toggle . gdb-find-source-frame)))
+ (define-key menu [gdb-use-separate-io]
+ '(menu-item "Separate IO" gdb-use-separate-io-buffer
+ :visible (eq gud-minor-mode 'gdba)
+ :help "Toggle separate IO for debugged program."
+ :button (:toggle . gdb-use-separate-io-buffer)))
(define-key menu [gdb-many-windows]
'(menu-item "Display Other Windows" gdb-many-windows
:help "Toggle display of locals, stack and breakpoint information"
"Display GUD buffer in a new frame."
(interactive)
(let ((special-display-regexps (append special-display-regexps '(".*")))
- (special-display-frame-alist gdb-frame-parameters)
+ (special-display-frame-alist
+ (remove '(menu-bar-lines) (remove '(tool-bar-lines)
+ gdb-frame-parameters)))
(same-window-regexps nil))
(display-buffer gud-comint-buffer)))
(switch-to-buffer
(if gud-last-last-frame
(gud-find-file (car gud-last-last-frame))
- (gud-find-file gdb-main-file)))
- (when gdb-use-inferior-io-buffer
+ (if gdb-main-file
+ (gud-find-file gdb-main-file)
+ ;; Put buffer list in window if we
+ ;; can't find a source file.
+ (list-buffers-noselect))))
+ (setq gdb-source-window (selected-window))
+ (when gdb-use-separate-io-buffer
(split-window-horizontally)
(other-window 1)
(gdb-set-window-buffer
- (gdb-get-create-buffer 'gdb-inferior-io)))
+ (gdb-get-buffer-create 'gdb-inferior-io)))
(other-window 1)
(gdb-set-window-buffer (gdb-stack-buffer-name))
(split-window-horizontally)
(gdb-set-window-buffer (gdb-breakpoints-buffer-name))
(other-window 1))
-(defcustom gdb-many-windows nil
- "Nil means just pop up the GUD buffer unless `gdb-show-main' is t.
-In this case it starts with two windows: one displaying the GUD
-buffer and the other with the source file with the main routine
-of the inferior. Non-nil means display the layout shown for
-`gdba'."
- :type 'boolean
- :group 'gud
- :version "22.1")
-
-(defun gdb-many-windows (arg)
- "Toggle the number of windows in the basic arrangement.
-With arg, display additional buffers iff arg is positive."
- (interactive "P")
- (setq gdb-many-windows
- (if (null arg)
- (not gdb-many-windows)
- (> (prefix-numeric-value arg) 0)))
- (if (and gud-comint-buffer
- (buffer-name gud-comint-buffer))
- (condition-case nil
- (gdb-restore-windows)
- (error nil))))
-
(defun gdb-restore-windows ()
"Restore the basic arrangement of windows used by gdba.
This arrangement depends on the value of `gdb-many-windows'."
(if gud-last-last-frame
(gud-find-file (car gud-last-last-frame))
(gud-find-file gdb-main-file)))
+ (setq gdb-source-window (selected-window))
(other-window 1))))
(defun gdb-reset ()
"Exit a debugging session cleanly.
-Kills the gdb buffers and resets the source buffers."
+Kills the gdb buffers, and resets variables and the source buffers."
(dolist (buffer (buffer-list))
(unless (eq buffer gud-comint-buffer)
(with-current-buffer buffer
(setq gud-minor-mode nil)
(kill-local-variable 'tool-bar-map)
(kill-local-variable 'gdb-define-alist))))))
- (when (markerp gdb-overlay-arrow-position)
- (move-marker gdb-overlay-arrow-position nil)
- (setq gdb-overlay-arrow-position nil))
+ (setq gdb-overlay-arrow-position nil)
(setq overlay-arrow-variable-list
(delq 'gdb-overlay-arrow-position overlay-arrow-variable-list))
+ (setq fringe-indicator-alist '((overlay-arrow . right-triangle)))
+ (setq gdb-stack-position nil)
+ (setq overlay-arrow-variable-list
+ (delq 'gdb-stack-position overlay-arrow-variable-list))
+ (if (boundp 'speedbar-frame) (speedbar-timer-fn))
(setq gud-running nil)
(setq gdb-active-process nil)
+ (setq gdb-var-list nil)
(remove-hook 'after-save-hook 'gdb-create-define-alist t))
(defun gdb-source-info ()
(setq gdb-macro-info t))
(if gdb-many-windows
(gdb-setup-windows)
- (gdb-get-create-buffer 'gdb-breakpoints-buffer)
+ (gdb-get-buffer-create 'gdb-breakpoints-buffer)
(if gdb-show-main
(let ((pop-up-windows t))
(display-buffer (gud-find-file gdb-main-file))))))
(add-hook 'find-file-hook 'gdb-find-file-hook)
(defun gdb-find-file-hook ()
-"Set up buffer for debugging if file is part of the source code
+ "Set up buffer for debugging if file is part of the source code
of the current session."
- (if (and (not gdb-find-file-unhook)
+ (if (and (buffer-name gud-comint-buffer)
;; in case gud or gdb-ui is just loaded
gud-comint-buffer
- (buffer-name gud-comint-buffer)
- (with-current-buffer gud-comint-buffer
- (eq gud-minor-mode 'gdba)))
- (condition-case nil
- (gdb-enqueue-input
- (list (concat gdb-server-prefix "list "
- (file-name-nondirectory buffer-file-name)
- ":1\n")
- `(lambda () (gdb-set-gud-minor-mode ,(current-buffer)))))
- (error (setq gdb-find-file-unhook t)))))
+ (memq (buffer-local-value 'gud-minor-mode gud-comint-buffer)
+ '(gdba gdbmi)))
+ ;;Pre GDB 6.3 "info sources" doesn't give absolute file name.
+ (if (member (if (string-equal gdb-version "pre-6.4")
+ (file-name-nondirectory buffer-file-name)
+ buffer-file-name)
+ gdb-source-file-list)
+ (with-current-buffer (find-buffer-visiting buffer-file-name)
+ (set (make-local-variable 'gud-minor-mode)
+ (buffer-local-value 'gud-minor-mode gud-comint-buffer))
+ (set (make-local-variable 'tool-bar-map) gud-tool-bar-map)))))
;;from put-image
(defun gdb-put-string (putstring pos &optional dprop &rest sprops)
'gdb-assembler-buffer-name
'gdb-assembler-mode)
-(def-gdb-auto-update-handler gdb-assembler-handler
- gdb-invalidate-assembler
- gdb-assembler-buffer
- gdb-assembler-custom)
+;; We can't use def-gdb-auto-update-handler because we don't want to use
+;; window-start but keep the overlay arrow/current line visible.
+(defun gdb-assembler-handler ()
+ (setq gdb-pending-triggers
+ (delq 'gdb-invalidate-assembler
+ gdb-pending-triggers))
+ (let ((buf (gdb-get-buffer 'gdb-assembler-buffer)))
+ (and buf
+ (with-current-buffer buf
+ (let* ((window (get-buffer-window buf 0))
+ (p (window-point window))
+ (buffer-read-only nil))
+ (erase-buffer)
+ (insert-buffer-substring (gdb-get-buffer-create
+ 'gdb-partial-output-buffer))
+ (set-window-point window p)))))
+ ;; put customisation here
+ (gdb-assembler-custom))
(defun gdb-assembler-custom ()
(let ((buffer (gdb-get-buffer 'gdb-assembler-buffer))
(pos 1) (address) (flag) (bptno))
(with-current-buffer buffer
(save-excursion
- (if (not (equal gdb-frame-address "main"))
+ (if (not (equal gdb-pc-address "main"))
(progn
(goto-char (point-min))
- (if (and gdb-frame-address
- (re-search-forward gdb-frame-address nil t))
+ (if (and gdb-pc-address
+ (search-forward gdb-pc-address nil t))
(progn
(setq pos (point))
(beginning-of-line)
+ (setq fringe-indicator-alist
+ (if (string-equal gdb-frame-number "0")
+ nil
+ '((overlay-arrow . hollow-right-triangle))))
(or gdb-overlay-arrow-position
(setq gdb-overlay-arrow-position (make-marker)))
- (set-marker gdb-overlay-arrow-position
- (point) (current-buffer))))))
+ (set-marker gdb-overlay-arrow-position (point))))))
;; remove all breakpoint-icons in assembler buffer before updating.
(gdb-remove-breakpoint-icons (point-min) (point-max))))
(with-current-buffer (gdb-get-buffer 'gdb-breakpoints-buffer)
(with-current-buffer buffer
(save-excursion
(goto-char (point-min))
- (if (re-search-forward address nil t)
+ (if (search-forward address nil t)
(gdb-put-breakpoint-icon (eq flag ?y) bptno))))))))
- (if (not (equal gdb-frame-address "main"))
- (set-window-point (get-buffer-window buffer 0) pos))))
+ (if (not (equal gdb-pc-address "main"))
+ (with-current-buffer buffer
+ (set-window-point (get-buffer-window buffer 0) pos)))))
(defvar gdb-assembler-mode-map
(let ((map (make-sparse-keymap)))
(interactive)
(setq gdb-previous-frame nil)
(gdb-display-buffer
- (gdb-get-create-buffer 'gdb-assembler-buffer)))
+ (gdb-get-buffer-create 'gdb-assembler-buffer) t))
(defun gdb-frame-assembler-buffer ()
"Display disassembly view in a new frame."
(setq gdb-previous-frame nil)
(let ((special-display-regexps (append special-display-regexps '(".*")))
(special-display-frame-alist gdb-frame-parameters))
- (display-buffer (gdb-get-create-buffer 'gdb-assembler-buffer))))
+ (display-buffer (gdb-get-buffer-create 'gdb-assembler-buffer))))
-;; modified because if gdb-frame-address has changed value a new command
+;; modified because if gdb-pc-address has changed value a new command
;; must be enqueued to update the buffer with the new output
(defun gdb-invalidate-assembler (&optional ignored)
(if (gdb-get-buffer 'gdb-assembler-buffer)
(string-equal gdb-selected-frame gdb-previous-frame))
(if (or (not (member 'gdb-invalidate-assembler
gdb-pending-triggers))
- (not (string-equal gdb-frame-address
+ (not (string-equal gdb-pc-address
gdb-previous-frame-address)))
(progn
;; take previous disassemble command, if any, off the queue
(gdb-enqueue-input
(list
(concat gdb-server-prefix "disassemble "
- (if (member gdb-frame-address '(nil "main")) nil "0x")
- gdb-frame-address "\n")
+ (if (member gdb-pc-address '(nil "main")) nil "0x")
+ gdb-pc-address "\n")
'gdb-assembler-handler))
(push 'gdb-invalidate-assembler gdb-pending-triggers)
- (setq gdb-previous-frame-address gdb-frame-address)
+ (setq gdb-previous-frame-address gdb-pc-address)
(setq gdb-previous-frame gdb-selected-frame)))))))
(defun gdb-get-selected-frame ()
(defun gdb-frame-handler ()
(setq gdb-pending-triggers
(delq 'gdb-get-selected-frame gdb-pending-triggers))
- (with-current-buffer (gdb-get-create-buffer 'gdb-partial-output-buffer)
- (goto-char (point-min))
- (if (re-search-forward "Stack level \\([0-9]+\\)" nil t)
- (setq gdb-frame-number (match-string 1)))
- (goto-char (point-min))
- (if (re-search-forward
- ".*=\\s-+0x0*\\(\\S-*\\)\\s-+in\\s-+\\(\\S-*?\\);? " nil t)
- (progn
- (setq gdb-selected-frame (match-string 2))
- (if (gdb-get-buffer 'gdb-locals-buffer)
- (with-current-buffer (gdb-get-buffer 'gdb-locals-buffer)
- (setq mode-name (concat "Locals:" gdb-selected-frame))))
- (if (gdb-get-buffer 'gdb-assembler-buffer)
- (with-current-buffer (gdb-get-buffer 'gdb-assembler-buffer)
- (setq mode-name (concat "Machine:" gdb-selected-frame))))
- (setq gdb-frame-address (match-string 1))))
- (goto-char (point-min))
- (if (re-search-forward " source language \\(\\S-*\\)\." nil t)
- (setq gdb-current-language (match-string 1))))
- (gdb-invalidate-assembler))
+ (goto-char (point-min))
+ (when (re-search-forward
+ "Stack level \\([0-9]+\\), frame at \\(0x[[:xdigit:]]+\\)" nil t)
+ (setq gdb-frame-number (match-string 1))
+ (setq gdb-frame-address (match-string 2)))
+ (goto-char (point-min))
+ (when (re-search-forward ".*=\\s-+0x0*\\(\\S-*\\)\\s-+in\\s-+\\(.*?\\)\
+\\(?: (\\(\\S-+?\\):[0-9]+?)\\)*; "
+ nil t)
+ (setq gdb-selected-frame (match-string 2))
+ (if (gdb-get-buffer 'gdb-locals-buffer)
+ (with-current-buffer (gdb-get-buffer 'gdb-locals-buffer)
+ (setq mode-name (concat "Locals:" gdb-selected-frame))))
+ (if (gdb-get-buffer 'gdb-assembler-buffer)
+ (with-current-buffer (gdb-get-buffer 'gdb-assembler-buffer)
+ (setq mode-name (concat "Machine:" gdb-selected-frame))))
+ (setq gdb-pc-address (match-string 1))
+ (if (and (match-string 3) gud-overlay-arrow-position)
+ (let ((buffer (marker-buffer gud-overlay-arrow-position))
+ (position (marker-position gud-overlay-arrow-position)))
+ (when (and buffer
+ (string-equal (buffer-name buffer)
+ (file-name-nondirectory (match-string 3))))
+ (with-current-buffer buffer
+ (setq fringe-indicator-alist
+ (if (string-equal gdb-frame-number "0")
+ nil
+ '((overlay-arrow . hollow-right-triangle))))
+ (set-marker gud-overlay-arrow-position position))))))
+ (goto-char (point-min))
+ (if (re-search-forward " source language \\(\\S-+\\)\." nil t)
+ (setq gdb-current-language (match-string 1)))
+ (gdb-invalidate-assembler))
+
+\f
+;; Code specific to GDB 6.4
+(defconst gdb-source-file-regexp-1 "fullname=\"\\(.*?\\)\"")
+
+(defun gdb-set-gud-minor-mode-existing-buffers-1 ()
+ "Create list of source files for current GDB session.
+If buffers already exist for any of these files, gud-minor-mode
+is set in them."
+ (goto-char (point-min))
+ (while (re-search-forward gdb-source-file-regexp-1 nil t)
+ (push (match-string 1) gdb-source-file-list))
+ (dolist (buffer (buffer-list))
+ (with-current-buffer buffer
+ (when (member buffer-file-name gdb-source-file-list)
+ (set (make-local-variable 'gud-minor-mode)
+ (buffer-local-value 'gud-minor-mode gud-comint-buffer))
+ (set (make-local-variable 'tool-bar-map) gud-tool-bar-map)
+ (when gud-tooltip-mode
+ (make-local-variable 'gdb-define-alist)
+ (gdb-create-define-alist)
+ (add-hook 'after-save-hook 'gdb-create-define-alist nil t)))))
+ (gdb-force-mode-line-update
+ (propertize "ready" 'face font-lock-variable-name-face)))
+
+; Uses "-var-list-children --all-values". Needs GDB 6.1 onwards.
+(defun gdb-var-list-children-1 (varnum)
+ (gdb-enqueue-input
+ (list
+ (if (eq (buffer-local-value 'gud-minor-mode gud-comint-buffer) 'gdba)
+ (concat "server interpreter mi \"-var-list-children --all-values "
+ varnum "\"\n")
+ (concat "-var-list-children --all-values " varnum "\n"))
+ `(lambda () (gdb-var-list-children-handler-1 ,varnum)))))
+
+(defconst gdb-var-list-children-regexp-1
+ "child={.*?name=\"\\(.+?\\)\",.*?exp=\"\\(.+?\\)\",.*?\
+numchild=\"\\(.+?\\)\",.*?value=\\(\".*?\"\\)\
+\\(}\\|,.*?\\(type=\"\\(.+?\\)\"\\)?.*?}\\)")
+
+(defun gdb-var-list-children-handler-1 (varnum)
+ (goto-char (point-min))
+ (let ((var-list nil))
+ (catch 'child-already-watched
+ (dolist (var gdb-var-list)
+ (if (string-equal varnum (car var))
+ (progn
+ (push var var-list)
+ (while (re-search-forward gdb-var-list-children-regexp-1 nil t)
+ (let ((varchild (list (match-string 1)
+ (match-string 2)
+ (match-string 3)
+ (match-string 7)
+ (read (match-string 4))
+ nil)))
+ (if (assoc (car varchild) gdb-var-list)
+ (throw 'child-already-watched nil))
+ (push varchild var-list))))
+ (push var var-list)))
+ (setq gdb-var-list (nreverse var-list))))
+ (gdb-speedbar-update))
+
+; Uses "-var-update --all-values". Needs GDB 6.4 onwards.
+(defun gdb-var-update-1 ()
+ (if (not (member 'gdb-var-update gdb-pending-triggers))
+ (progn
+ (gdb-enqueue-input
+ (list
+ (if (eq (buffer-local-value 'gud-minor-mode gud-comint-buffer) 'gdba)
+ "server interpreter mi \"-var-update --all-values *\"\n"
+ "-var-update --all-values *\n")
+ 'gdb-var-update-handler-1))
+ (push 'gdb-var-update gdb-pending-triggers))))
+
+(defconst gdb-var-update-regexp-1
+ "{.*?name=\"\\(.*?\\)\",.*?\\(?:value=\\(\".*?\"\\),\\)?.*?\
+in_scope=\"\\(.*?\\)\".*?}")
+
+(defun gdb-var-update-handler-1 ()
+ (dolist (var gdb-var-list)
+ (setcar (nthcdr 5 var) nil))
+ (goto-char (point-min))
+ (while (re-search-forward gdb-var-update-regexp-1 nil t)
+ (let* ((varnum (match-string 1))
+ (var (assoc varnum gdb-var-list)))
+ (when var
+ (if (string-equal (match-string 3) "false")
+ (setcar (nthcdr 5 var) 'out-of-scope)
+ (setcar (nthcdr 5 var) 'changed)
+ (setcar (nthcdr 4 var)
+ (read (match-string 2)))))))
+ (setq gdb-pending-triggers
+ (delq 'gdb-var-update gdb-pending-triggers))
+ (gdb-speedbar-update))
+
+;; Registers buffer.
+;;
+(gdb-set-buffer-rules 'gdb-registers-buffer
+ 'gdb-registers-buffer-name
+ 'gdb-registers-mode)
+
+(def-gdb-auto-update-trigger gdb-invalidate-registers-1
+ (gdb-get-buffer 'gdb-registers-buffer)
+ (if (eq (buffer-local-value 'gud-minor-mode gud-comint-buffer) 'gdba)
+ "server interpreter mi \"-data-list-register-values x\"\n"
+ "-data-list-register-values x\n")
+ gdb-data-list-register-values-handler)
+
+(defconst gdb-data-list-register-values-regexp
+ "{.*?number=\"\\(.*?\\)\",.*?value=\"\\(.*?\\)\".*?}")
+
+(defun gdb-data-list-register-values-handler ()
+ (setq gdb-pending-triggers (delq 'gdb-invalidate-registers-1
+ gdb-pending-triggers))
+ (goto-char (point-min))
+ (if (re-search-forward gdb-error-regexp nil t)
+ (let ((err (match-string 1)))
+ (with-current-buffer (gdb-get-buffer 'gdb-registers-buffer)
+ (let ((buffer-read-only nil))
+ (erase-buffer)
+ (put-text-property 0 (length err) 'face font-lock-warning-face err)
+ (insert err)
+ (goto-char (point-min)))))
+ (let ((register-list (reverse gdb-register-names))
+ (register nil) (register-string nil) (register-values nil))
+ (goto-char (point-min))
+ (while (re-search-forward gdb-data-list-register-values-regexp nil t)
+ (setq register (pop register-list))
+ (setq register-string (concat register "\t" (match-string 2) "\n"))
+ (if (member (match-string 1) gdb-changed-registers)
+ (put-text-property 0 (length register-string)
+ 'face 'font-lock-warning-face
+ register-string))
+ (setq register-values
+ (concat register-values register-string)))
+ (let ((buf (gdb-get-buffer 'gdb-registers-buffer)))
+ (with-current-buffer buf
+ (let* ((window (get-buffer-window buf 0))
+ (start (window-start window))
+ (p (window-point window))
+ (buffer-read-only nil))
+ (erase-buffer)
+ (insert register-values)
+ (set-window-start window start)
+ (set-window-point window p))))))
+ (gdb-data-list-register-values-custom))
+
+(defun gdb-data-list-register-values-custom ()
+ (with-current-buffer (gdb-get-buffer 'gdb-registers-buffer)
+ (save-excursion
+ (let ((buffer-read-only nil)
+ start end)
+ (goto-char (point-min))
+ (while (< (point) (point-max))
+ (setq start (line-beginning-position))
+ (setq end (line-end-position))
+ (when (looking-at "^[^\t]+")
+ (unless (string-equal (match-string 0) "No registers.")
+ (put-text-property start (match-end 0)
+ 'face font-lock-variable-name-face)
+ (add-text-properties start end
+ '(help-echo "mouse-2: edit value"
+ mouse-face highlight))))
+ (forward-line 1))))))
+
+;; Needs GDB 6.4 onwards (used to fail with no stack).
+(defun gdb-get-changed-registers ()
+ (if (and (gdb-get-buffer 'gdb-registers-buffer)
+ (not (member 'gdb-get-changed-registers gdb-pending-triggers)))
+ (progn
+ (gdb-enqueue-input
+ (list
+ (if (eq (buffer-local-value 'gud-minor-mode gud-comint-buffer) 'gdba)
+ "server interpreter mi -data-list-changed-registers\n"
+ "-data-list-changed-registers\n")
+ 'gdb-get-changed-registers-handler))
+ (push 'gdb-get-changed-registers gdb-pending-triggers))))
+
+(defconst gdb-data-list-register-names-regexp "\"\\(.*?\\)\"")
+
+(defun gdb-get-changed-registers-handler ()
+ (setq gdb-pending-triggers
+ (delq 'gdb-get-changed-registers gdb-pending-triggers))
+ (setq gdb-changed-registers nil)
+ (goto-char (point-min))
+ (while (re-search-forward gdb-data-list-register-names-regexp nil t)
+ (push (match-string 1) gdb-changed-registers)))
+\f
+
+;; Locals buffer.
+;;
+;; uses "-stack-list-locals --simple-values". Needs GDB 6.1 onwards.
+(gdb-set-buffer-rules 'gdb-locals-buffer
+ 'gdb-locals-buffer-name
+ 'gdb-locals-mode)
+
+(def-gdb-auto-update-trigger gdb-invalidate-locals-1
+ (gdb-get-buffer 'gdb-locals-buffer)
+ (if (eq (buffer-local-value 'gud-minor-mode gud-comint-buffer) 'gdba)
+ "server interpreter mi -\"stack-list-locals --simple-values\"\n"
+ "-stack-list-locals --simple-values\n")
+ gdb-stack-list-locals-handler)
+
+(defconst gdb-stack-list-locals-regexp
+ "{.*?name=\"\\(.*?\\)\",.*?type=\"\\(.*?\\)\"")
+
+(defvar gdb-locals-watch-map-1
+ (let ((map (make-sparse-keymap)))
+ (suppress-keymap map)
+ (define-key map "\r" 'gud-watch)
+ (define-key map [mouse-2] 'gud-watch)
+ map)
+ "Keymap to create watch expression of a complex data type local variable.")
+
+(defvar gdb-edit-locals-map-1
+ (let ((map (make-sparse-keymap)))
+ (suppress-keymap map)
+ (define-key map "\r" 'gdb-edit-locals-value)
+ (define-key map [mouse-2] 'gdb-edit-locals-value)
+ map)
+ "Keymap to edit value of a simple data type local variable.")
+
+(defun gdb-edit-locals-value (&optional event)
+ "Assign a value to a variable displayed in the locals buffer."
+ (interactive (list last-input-event))
+ (save-excursion
+ (if event (posn-set-point (event-end event)))
+ (beginning-of-line)
+ (let* ((var (current-word))
+ (value (read-string (format "New value (%s): " var))))
+ (gdb-enqueue-input
+ (list (concat gdb-server-prefix"set variable " var " = " value "\n")
+ 'ignore)))))
+
+;; Dont display values of arrays or structures.
+;; These can be expanded using gud-watch.
+(defun gdb-stack-list-locals-handler ()
+ (setq gdb-pending-triggers (delq 'gdb-invalidate-locals-1
+ gdb-pending-triggers))
+ (goto-char (point-min))
+ (if (re-search-forward gdb-error-regexp nil t)
+ (let ((err (match-string 1)))
+ (with-current-buffer (gdb-get-buffer 'gdb-locals-buffer)
+ (let ((buffer-read-only nil))
+ (erase-buffer)
+ (insert err)
+ (goto-char (point-min)))))
+ (let (local locals-list)
+ (goto-char (point-min))
+ (while (re-search-forward gdb-stack-list-locals-regexp nil t)
+ (let ((local (list (match-string 1)
+ (match-string 2)
+ nil)))
+ (if (looking-at ",value=\\(\".*\"\\).*?}")
+ (setcar (nthcdr 2 local) (read (match-string 1))))
+ (push local locals-list)))
+ (let ((buf (gdb-get-buffer 'gdb-locals-buffer)))
+ (and buf (with-current-buffer buf
+ (let* ((window (get-buffer-window buf 0))
+ (start (window-start window))
+ (p (window-point window))
+ (buffer-read-only nil) (name) (value))
+ (erase-buffer)
+ (dolist (local locals-list)
+ (setq name (car local))
+ (setq value (nth 2 local))
+ (if (or (not value)
+ (string-match "^\\0x" value))
+ (add-text-properties 0 (length name)
+ `(mouse-face highlight
+ help-echo "mouse-2: create watch expression"
+ local-map ,gdb-locals-watch-map-1)
+ name)
+ (add-text-properties 0 (length value)
+ `(mouse-face highlight
+ help-echo "mouse-2: edit value"
+ local-map ,gdb-edit-locals-map-1)
+ value))
+ (insert
+ (concat name "\t" (nth 1 local)
+ "\t" value "\n")))
+ (set-window-start window start)
+ (set-window-point window p))))))))
+
+(defun gdb-get-register-names ()
+ "Create a list of register names."
+ (goto-char (point-min))
+ (setq gdb-register-names nil)
+ (while (re-search-forward gdb-data-list-register-names-regexp nil t)
+ (push (match-string 1) gdb-register-names)))
(provide 'gdb-ui)