;;
;; Known Bugs:
;;
-;; 0) VALUES OF WATCH EXPRESSIONS DON'T UPDATE.
;; 1) Cannot handle programs that need input without separating the I/O
;; of GDB with that of program.
;; 2) Completion doesn't work.
;; 3) To avoid extra output in the GUD buffer it is best not to use run, step,
-;; next or continue etc but their MI counterparts through gud-run, gud-step
-;; etc, e.g clicking on the appropriate icon in the toolbar.
-;; 4) With the "start" command the *stopped output doesn't give a reason field.
-;; so this mode fails.
-;; 5) Hangs when you try to quit with q or ^d.
+;; next or continue etc but their MI counterparts through gud-run, gud-step
+;; etc, e.g clicking on the appropriate icon in the toolbar.
+;; 4) With the "tbreak" or "start" command the *stopped output doesn't give a
+;; reason field so this mode fails.
;; TODO:
;; 1) Use MI command -data-read-memory for memory window.
"List of variables in watch window.
Each element has the form (VARNUM EXPRESSION NUMCHILD TYPE VALUE STATUS) where
STATUS is nil (unchanged), `changed' or `out-of-scope'.")
-(defvar gdb-force-update t
- "Non-nil means that view of watch expressions will be updated in the speedbar.")
(defvar gdb-main-file nil "Source file from which program execution begins.")
(defvar gdb-overlay-arrow-position nil)
+(defvar gdb-stack-position nil)
(defvar gdb-server-prefix nil)
(defvar gdb-location-alist nil
"Alist of breakpoint numbers and full filenames.")
(defvar gdb-handler-alist '())
(defvar gdb-handler-number nil)
(defvar gdb-source-file-list nil)
+(defvar gdb-first-done-or-error t)
(defvar gdb-source-window nil)
(defvar gdb-continuation nil)
; Note: This mode seems to require a separate buffer for inferior IO.
(defcustom gdb-use-separate-io-buffer t
- "Non-nil means display output from the inferior in a separate buffer."
+ "Non-nil means display output from the debugged program in a separate buffer."
:type 'boolean
:group 'gud
:version "22.1")
(defun gdb-use-separate-io-buffer (arg)
- "Toggle separate IO for inferior.
+ "Toggle separate IO for debugged program.
With arg, use separate IO iff arg is positive."
(interactive "P")
(setq gdb-use-separate-io-buffer
(if (null arg)
(not gdb-use-separate-io-buffer)
(> (prefix-numeric-value arg) 0)))
- (message (format "Separate inferior IO %sabled"
+ (message (format "Separate IO %sabled"
(if gdb-use-separate-io-buffer "en" "dis")))
(if (and gud-comint-buffer
(buffer-name gud-comint-buffer))
'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]
- 'gdb-mouse-until)
+ (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-2]
+ (define-key gud-minor-mode-map [left-margin mouse-3]
+ 'gdb-mouse-until)
+ (define-key gud-minor-mode-map [left-fringe mouse-3]
'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-2]
+ (define-key gud-minor-mode-map [left-fringe C-mouse-3]
'gdb-mouse-jump)
- (define-key gud-minor-mode-map [left-margin C-mouse-2]
+ (define-key gud-minor-mode-map [left-margin C-mouse-3]
'gdb-mouse-jump)
- (define-key gud-minor-mode-map [left-margin mouse-3]
- 'gdb-mouse-toggle-breakpoint-margin)
- (define-key gud-minor-mode-map [left-fringe mouse-3]
- 'gdb-mouse-toggle-breakpoint-fringe)
(setq comint-input-sender 'gdbmi-send)
;;
gdb-current-frame nil
gdb-frame-number nil
gdb-var-list nil
- gdb-force-update t
gdb-pending-triggers nil
gdb-output-sink 'user
gdb-location-alist nil
gdb-handler-alist '()
gdb-handler-number nil
gdb-prompt-name nil
+ gdb-first-done-or-error t
gdb-buffer-fringe-width (car (window-fringes))
gdb-source-window nil
gdb-continuation nil)
(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-input
- (list (concat"-var-create - * " expr "\n")
- `(lambda () (gdb-var-create-handler ,expr))))))))
+ (set-text-properties 0 (length expr) nil expr)
+ (gdb-input
+ (list (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
(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"))
(list
(concat "-var-evaluate-expression " (car var) "\n")
`(lambda () (gdb-var-evaluate-expression-handler
- ,(car var) nil))))
- (with-current-buffer gud-comint-buffer
- (speedbar-timer-fn)))
+ ,(car var) nil)))))
(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-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)
(goto-char (point-min))
(re-search-forward ".*value=\\(\".*\"\\)" nil t)
(when var
(if changed (setcar (nthcdr 5 var) 'changed))
(setcar (nthcdr 4 var) (read (match-string 1)))))
- (with-current-buffer gud-comint-buffer
- (speedbar-timer-fn)))
+ (gdb-speedbar-update))
; Uses "-var-list-children --all-values". Needs GDB 6.1 onwards.
(defun gdbmi-var-list-children (varnum)
`(lambda () (gdbmi-var-list-children-handler ,varnum)))))
(defconst gdbmi-var-list-children-regexp
- "name=\"\\(.+?\\)\",exp=\"\\(.+?\\)\",numchild=\"\\(.+?\\)\",\
-value=\\(\".*?\"\\),type=\"\\(.+?\\)\"}")
+ "child={.*?name=\"\\(.+?\\)\",.*?exp=\"\\(.+?\\)\",.*?\
+numchild=\"\\(.+?\\)\",.*?value=\\(\".*?\"\\),.*?type=\"\\(.+?\\)\".*?}")
(defun gdbmi-var-list-children-handler (varnum)
(goto-char (point-min))
(progn
(push var var-list)
(while (re-search-forward gdbmi-var-list-children-regexp nil t)
- (let ((varchild (list (match-string 2)
- (match-string 1)
+ (let ((varchild (list (match-string 1)
+ (match-string 2)
(match-string 3)
(match-string 5)
(read (match-string 4))
(push varchild var-list))))
(push var var-list)))
(setq gdb-var-list (nreverse var-list))))
- (setq gdb-force-update t)
- (with-current-buffer gud-comint-buffer
- (speedbar-refresh)))
+ (gdb-speedbar-update))
; Uses "-var-update --all-values". Needs GDB 6.4 onwards.
(defun gdbmi-var-update ()
- (gdb-input (list "-var-update --all-values *\n" 'gdbmi-var-update-handler)))
+ (if (not (member 'gdb-var-update gdb-pending-triggers))
+ (gdb-input
+ (list "-var-update --all-values *\n" 'gdbmi-var-update-handler)))
+ (push 'gdb-var-update gdb-pending-triggers))
-(defconst gdbmi-var-update-regexp "name=\"\\(.*?\\)\",in_scope=\"\\(.*?\\)\"")
+(defconst gdbmi-var-update-regexp
+ "{.*?name=\"\\(.*?\\)\",.*?\\(?:value=\\(\".*?\"\\),\\)?.*?\
+in_scope=\"\\(.*?\\)\".*?}")
(defun gdbmi-var-update-handler ()
(dolist (var gdb-var-list)
(setcar (nthcdr 5 var) 'changed)
(setcar (nthcdr 4 var)
(read (match-string 2)))))))
- (with-current-buffer gud-comint-buffer
- (speedbar-timer-fn)))
+ (setq gdb-pending-triggers
+ (delq 'gdb-var-update gdb-pending-triggers))
+ (gdb-speedbar-update))
(defun gdb-var-delete ()
"Delete watch expression at point from the speedbar."
(setq gdb-var-list (delq var gdb-var-list))
(dolist (varchild gdb-var-list)
(if (string-match (concat (car var) "\\.") (car varchild))
- (setq gdb-var-list (delq varchild gdb-var-list)))))))
- (with-current-buffer gud-comint-buffer
- (speedbar-refresh)))
+ (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."
(interactive)
(if gdb-use-separate-io-buffer
(gdb-display-buffer
- (gdb-get-buffer-create 'gdb-inferior-io))))
+ (gdb-get-buffer-create 'gdb-inferior-io) t)))
(defconst gdb-frame-parameters
'((height . 14) (width . 80)
(minibuffer . nil)))
(defun gdb-frame-separate-io-buffer ()
- "Display IO of inferior in a new frame."
+ "Display IO of debugged program in a new frame."
(interactive)
(if gdb-use-separate-io-buffer
(let ((special-display-regexps (append special-display-regexps '(".*")))
(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"
(defun gdb-inferior-filter (proc string)
(unless (string-equal string "")
- (gdb-display-buffer (gdb-get-buffer-create 'gdb-inferior-io)))
+ (gdb-display-buffer (gdb-get-buffer-create 'gdb-inferior-io) t))
(with-current-buffer (gdb-get-buffer-create 'gdb-inferior-io)
(insert-before-markers string)))
-(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
(push (cons 'mi-send (concat string "\n")) gdb-debug-ring))
(if (string-match "^-" string)
;; MI command
- (process-send-string proc (concat string "\n"))
+ (progn
+ (setq gdb-first-done-or-error t)
+ (process-send-string proc (concat string "\n")))
;; CLI command
(if (string-match "\\\\$" string)
(setq gdb-continuation (concat gdb-continuation string "\n"))
+ (setq gdb-first-done-or-error t)
(process-send-string proc (concat "-interpreter-exec console-quoted \""
gdb-continuation string "\"\n"))
(setq gdb-continuation nil))))
(defun gdb-input (item)
(if gdb-enable-debug (push (cons 'send-item item) gdb-debug-ring))
- (unless (stringp item)
- (setq gdb-token-number (1+ gdb-token-number))
- (setcar item (concat (number-to-string gdb-token-number) (car item)))
- (push (cons gdb-token-number (car (cdr item))) gdb-handler-alist))
+ (setq gdb-token-number (1+ gdb-token-number))
+ (setcar item (concat (number-to-string gdb-token-number) (car item)))
+ (push (cons gdb-token-number (car (cdr item))) gdb-handler-alist)
(process-send-string (get-buffer-process gud-comint-buffer)
(car item)))
\f
;; fullname added GDB 6.4+.
(defconst gdb-stopped-regexp
- "\\*stopped,reason=.*?addr=\"\\(.*?\\)\",func=\"\\(.*?\\)\".*?,file=\".*?\"\
-,fullname=\"\\(.*?\\)\",line=\"\\(.*?\\)\"}\n")
+ "\\*stopped,reason=\"\\(.*?\\)\",\\(exit-code=.*?\\|\
+.*?file=\".*?\",fullname=\"\\(.*?\\)\",line=\"\\(.*?\\)\"\\).*?\n")
(defconst gdb-console-regexp "~\\(\".*?[^\\]\"\\)\n")
(gdbmi-invalidate-registers)
(gdbmi-invalidate-locals)
(when (and (boundp 'speedbar-frame) (frame-live-p speedbar-frame))
- (setq gdb-force-update t)
+ (dolist (var gdb-var-list)
+ (setcar (nthcdr 5 var) nil))
(gdbmi-var-update)))
;; GUD displays the selected GDB frame. This might might not be the current
(let ((output "") (output-record) (preamble))
(if (string-match gdb-running-regexp gud-marker-acc)
- (setq gud-marker-acc (concat (substring gud-marker-acc 0 (match-beginning 0))
- (substring gud-marker-acc (match-end 0)))
+ (setq gud-marker-acc (substring gud-marker-acc (match-end 0))
gud-running t))
(when (string-match gdb-stopped-regexp gud-marker-acc)
- (setq
-
- gdb-current-frame (match-string 2 gud-marker-acc)
-
- ;; Extract the frame position from the marker.
- gud-last-frame (cons (match-string 3 gud-marker-acc)
- (string-to-number
- (match-string 4 gud-marker-acc)))
-
- gud-marker-acc (concat (substring gud-marker-acc 0 (match-beginning 0))
- (substring gud-marker-acc (match-end 0)))
- gud-running nil)
- (gdbmi-update))
+ (unless (string-equal (match-string 1 gud-marker-acc) "exited")
+ (setq
+ ;; Extract the frame position from the marker.
+ gud-last-frame (cons (match-string 3 gud-marker-acc)
+ (string-to-number
+ (match-string 4 gud-marker-acc))))
+ (gdbmi-update))
+
+ (setq gud-marker-acc
+ (concat (substring gud-marker-acc 0 (match-beginning 0))
+ (substring gud-marker-acc (match-end 0)))
+ gud-running nil))
;; process command outputs one by one.
(while (string-match gdb-gdb-regexp gud-marker-acc)
gud-marker-acc (substring gud-marker-acc (match-end 0)))
(if (string-match gdb-done-or-error-regexp output-record)
-
- (progn
- (unless gdb-handler-alist (gdbmi-update))
-
- ;; Identify the handler from token number
- (let ((match (or (match-string 2 output-record)
- (match-string 3 output-record))))
+
+ ;; Identify the handler from token number
+ (let ((match (or (match-string 2 output-record)
+ (match-string 3 output-record))))
- (if (string-equal match "")
- ;; Output from command entered by user
- (progn
- (setq gdb-output-sink 'user)
- (setq gdb-handler-number nil)
- ;; MI error - send to minibuffer
- (if (match-string 3 output-record)
- (message (read (match-string 4 output-record)))))
- ;; Output from command from frontend.
- (setq gdb-handler-number (string-to-number match))
- (setq gdb-output-sink 'emacs))
-
- (gdb-clear-partial-output)
- ;; preamble should just be console and log stream
- (setq preamble (substring output-record 0 (match-beginning 0)))
- (setq output-record (substring output-record (match-end 0)))))
-
- (setq preamble output-record)
- (setq output-record "")
- (setq gdb-handler-number nil))
+ (if (string-equal match "")
+ ;; Output from command entered by user
+ (progn
+ (setq gdb-output-sink 'user)
+ (setq gdb-handler-number nil)
+ ;; MI error - send to minibuffer
+ (if (match-string 3 output-record)
+ (message (read (match-string 4 output-record)))))
+ ;; Output from command from frontend.
+ (setq gdb-handler-number (string-to-number match))
+ (setq gdb-output-sink 'emacs))
+
+ (gdb-clear-partial-output)
+ ;; preamble should just be console, log stream or inferior output
+ (setq preamble (substring output-record 0 (match-beginning 0)))
+ (setq output-record (substring output-record (match-end 0)))
+ (when gdb-first-done-or-error
+ (gdbmi-update)
+ (setq gdb-first-done-or-error nil)))
+
+ (setq preamble output-record
+ output-record ""
+ gdb-handler-number nil
+ gud-running nil))
+
+ ;; FIXME: Order of console, log stream and inferior output might be lost
+ ;; with what follows:
;; Remove the trimmings from the console stream and send to GUD buffer
;; (frontend MI commands should not print to this stream)
error-message)
error-message))
- preamble (substring preamble (match-end 0))))
+ preamble (substring preamble (match-end 0))))
+ ;; Preamble here should just be inferior output.
+ (setq output (gdbmi-concat-output output preamble))
(setq output (gdbmi-concat-output output output-record))
(when gdb-handler-number
(assq-delete-all gdb-handler-number gdb-handler-alist))))
(unless gdb-handler-alist
- (if (string-equal gud-marker-acc "")
- (setq output (concat output gdb-prompt-name)))
+ (setq output (gdbmi-concat-output output gud-marker-acc))
+ (unless gud-running (setq output (concat output gdb-prompt-name)))
+ (setq gud-marker-acc "")
(setq gdb-output-sink 'user))
output))
(concat
(nth 0 breakpoint) " "
(nth 1 breakpoint) " "
- (nth 2 breakpoint) " "
- (nth 3 breakpoint) " "
+ (nth 2 breakpoint) " "
+ (propertize (nth 3 breakpoint)
+ 'face (if (eq (string-to-char (nth 3 breakpoint)) ?y)
+ font-lock-warning-face
+ font-lock-type-face)) " "
(nth 9 breakpoint) " "
(nth 4 breakpoint) " "
(if (nth 5 breakpoint)
"Display status of user-settable breakpoints."
(interactive)
(gdb-display-buffer
- (gdb-get-buffer-create '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."
(let* ((buffer (find-file-noselect
(if (file-exists-p file) file
(cdr (assoc bptno gdb-location-alist)))))
- (window (unless (gdb-display-source-buffer buffer)
+ (window (or (gdb-display-source-buffer buffer)
(display-buffer buffer))))
(setq gdb-source-window window)
(with-current-buffer buffer
(concat
(nth 0 frame) "\t"
(nth 1 frame) "\t"
- (nth 2 frame) "\t"
+ (propertize (nth 2 frame)
+ 'face font-lock-function-name-face) "\t"
(if (nth 3 frame)
(concat "at "(nth 3 frame) ":" (nth 4 frame) "\n")
(concat "from " (nth 5 frame) "\n")))))
'(mouse-face highlight
help-echo "mouse-2, RET: Select frame"))
(beginning-of-line)
- (when (and (looking-at "^[0-9]+\\s-+\\(\\S-+\\)")
+ (when (and (looking-at "^[0-9]+\\s-+\\S-+\\s-+\\(\\S-+\\)")
(equal (match-string 1) gdb-selected-frame))
- (put-text-property (point-at-bol) (point-at-eol)
- 'face '(:inverse-video t)))
+ (if (> (car (window-fringes)) 0)
+ (progn
+ (or gdb-stack-position
+ (setq gdb-stack-position (make-marker)))
+ (set-marker gdb-stack-position (point)))
+ (set-marker gdb-stack-position nil)
+ (let ((bl (point-at-bol)))
+ (put-text-property bl (+ bl 4)
+ 'face '(:inverse-video t)))))
(forward-line 1))))))
(defun gdb-stack-buffer-name ()
"Display backtrace of current stack."
(interactive)
(gdb-display-buffer
- (gdb-get-buffer-create '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."
(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)
(run-mode-hooks 'gdb-frames-mode-hook)
(defvar gdb-locals-watch-map
(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))))
+ (gud-basic-call
+ (concat gdb-server-prefix"set variable " var " = " value)))))
+
;; Dont display values of arrays or structures.
;; These can be expanded using gud-watch.
(defun gdb-stack-list-locals-handler nil
(let* ((window (get-buffer-window buf 0))
(start (window-start window))
(p (window-point window))
- (buffer-read-only nil))
+ (buffer-read-only nil) (name) (value))
(erase-buffer)
(dolist (local locals-list)
(setq name (car local))
- (if (or (not (nth 2 local))
- (string-match "\\0x" (nth 2 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)
- name))
+ 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" (nth 2 local) "\n")))
"Display local variables of current stack and their values."
(interactive)
(gdb-display-buffer
- (gdb-get-buffer-create '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."
"Display integer register contents."
(interactive)
(gdb-display-buffer
- (gdb-get-buffer-create 'gdb-registers-buffer)))
+ (gdb-get-buffer-create 'gdb-registers-buffer) t))
(defun gdb-frame-registers-buffer ()
"Display integer register contents in a new frame."
(setq gdb-prompt-name (match-string 1)))
;;;; 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
(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
'("Disassembly" . gdb-display-assembler-buffer))
(define-key menu [registers] '("Registers" . gdb-display-registers-buffer))
(define-key menu [inferior]
- '(menu-item "Inferior IO" gdb-display-separate-io-buffer
+ '(menu-item "Separate IO" gdb-display-separate-io-buffer
:enable gdb-use-separate-io-buffer))
(define-key menu [locals] '("Locals" . gdb-display-locals-buffer))
(define-key menu [frames] '("Stack" . gdb-display-stack-buffer))
(define-key menu [disassembly] '("Disassembly" . gdb-frame-assembler-buffer))
(define-key menu [registers] '("Registers" . gdb-frame-registers-buffer))
(define-key menu [inferior]
- '(menu-item "Inferior IO" gdb-frame-separate-io-buffer
+ '(menu-item "Separate IO" gdb-frame-separate-io-buffer
:enable gdb-use-separate-io-buffer))
(define-key menu [locals] '("Locals" . gdb-frame-locals-buffer))
(define-key menu [frames] '("Stack" . gdb-frame-stack-buffer))
(define-key gud-menu-map [mi]
`(menu-item "GDB-MI" ,menu :visible (eq gud-minor-mode 'gdbmi)))
(define-key menu [gdb-use-separate-io]
- '(menu-item "Separate inferior IO" gdb-use-separate-io-buffer
- :help "Toggle separate IO for inferior."
+ '(menu-item "Separate IO" gdb-use-separate-io-buffer
+ :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
"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)))
+ (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)
"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
+of the debugged program. Non-nil means display the layout shown for
`gdbmi'."
:type 'boolean
:group 'gud
(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)))
- (if (and (boundp 'speedbar-frame) (frame-live-p speedbar-frame))
- (speedbar-refresh))
+ (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)
(remove-hook 'after-save-hook 'gdb-create-define-alist t))
(display-buffer (get-buffer-create "xbacktrace"))))
(provide 'gdb-mi)
-;;; gdbmiasync.el ends here
+;;; gdb-mi.el ends here
projects / thirdparty / binutils-gdb.git / commitdiff
