M-x gdb troubles

M-x gdb troubles

[Kim F. Storm]

If I have a running gdb process (M-x gdb ... run), and accidentally do
M-x gdb again (instead of switching to the gdb buffer), things get
really messy...

Maybe the second M-x gdb should just switch to the current gdb buffer 
if I enter the same command line as a previous gdb run.

-- 
Kim F. Storm <storm@cua.dk> http://www.cua.dk

RE: M-x gdb troubles

[Nick Roberts]

> If I have a running gdb process (M-x gdb ... run), and accidentally do
> M-x gdb again (instead of switching to the gdb buffer), things get
> really messy...

> Maybe the second M-x gdb should just switch to the current gdb buffer 
> if I enter the same command line as a previous gdb run.

How about this patch. The catch form would have to be added to the other
debugger functions (dbx, pdb, perldb etc) to be consistent.

*** gud.el.~1.19.~	2004-04-15 20:39:43.000000000 +0100
--- gud.el	2004-04-21 19:27:43.000000000 +0100
***************
*** 526,556 ****
  and source-file directory for your debugger."
    (interactive (list (gud-query-cmdline 'gdb)))
  
!   (gud-common-init command-line nil 'gud-gdb-marker-filter)
!   (set (make-local-variable 'gud-minor-mode) 'gdb)
! 
!   (gud-def gud-break  "break %f:%l"  "\C-b" "Set breakpoint at current line.")
!   (gud-def gud-tbreak "tbreak %f:%l" "\C-t" "Set temporary breakpoint at current line.")
!   (gud-def gud-remove "clear %f:%l"  "\C-d" "Remove breakpoint at current line")
!   (gud-def gud-step   "step %p"      "\C-s" "Step one source line with display.")
!   (gud-def gud-stepi  "stepi %p"     "\C-i" "Step one instruction with display.")
!   (gud-def gud-next   "next %p"      "\C-n" "Step one line (skip functions).")
!   (gud-def gud-nexti  "nexti %p"      nil   "Step one instruction (skip functions).")
!   (gud-def gud-cont   "cont"         "\C-r" "Continue with display.")
!   (gud-def gud-finish "finish"       "\C-f" "Finish executing current function.")
!   (gud-def gud-jump   "tbreak %f:%l\njump %f:%l" "\C-j" "Relocate execution address to line at point in source buffer.")
! 
!   (gud-def gud-up     "up %p"        "<" "Up N stack frames (numeric arg).")
!   (gud-def gud-down   "down %p"      ">" "Down N stack frames (numeric arg).")
!   (gud-def gud-print  "print %e"     "\C-p" "Evaluate C expression at point.")
!   (gud-def gud-until  "until %l"     "\C-u" "Continue to current line.")
!   (gud-def gud-run    "run"	     nil    "Run the program.")
! 
!   (local-set-key "\C-i" 'gud-gdb-complete-command)
!   (setq comint-prompt-regexp "^(.*gdb[+]?) *")
!   (setq paragraph-start comint-prompt-regexp)
!   (setq gdb-first-prompt t)
!   (run-hooks 'gdb-mode-hook))
  
  ;; One of the nice features of GDB is its impressive support for
  ;; context-sensitive command completion.  We preserve that feature
--- 526,557 ----
  and source-file directory for your debugger."
    (interactive (list (gud-query-cmdline 'gdb)))
  
!   (catch 'existing
!     (gud-common-init command-line nil 'gud-gdb-marker-filter)
!     (set (make-local-variable 'gud-minor-mode) 'gdb)
! 
!     (gud-def gud-break  "break %f:%l"  "\C-b" "Set breakpoint at current line.")
!     (gud-def gud-tbreak "tbreak %f:%l" "\C-t" "Set temporary breakpoint at current line.")
!     (gud-def gud-remove "clear %f:%l"  "\C-d" "Remove breakpoint at current line")
!     (gud-def gud-step   "step %p"      "\C-s" "Step one source line with display.")
!     (gud-def gud-stepi  "stepi %p"     "\C-i" "Step one instruction with display.")
!     (gud-def gud-next   "next %p"      "\C-n" "Step one line (skip functions).")
!     (gud-def gud-nexti  "nexti %p"      nil   "Step one instruction (skip functions).")
!     (gud-def gud-cont   "cont"         "\C-r" "Continue with display.")
!     (gud-def gud-finish "finish"       "\C-f" "Finish executing current function.")
!     (gud-def gud-jump   "tbreak %f:%l\njump %f:%l" "\C-j" "Relocate execution address to line at point in source buffer.")
! 
!     (gud-def gud-up     "up %p"        "<" "Up N stack frames (numeric arg).")
!     (gud-def gud-down   "down %p"      ">" "Down N stack frames (numeric arg).")
!     (gud-def gud-print  "print %e"     "\C-p" "Evaluate C expression at point.")
!     (gud-def gud-until  "until %l"     "\C-u" "Continue to current line.")
!     (gud-def gud-run    "run"	     nil    "Run the program.")
! 
!     (local-set-key "\C-i" 'gud-gdb-complete-command)
!     (setq comint-prompt-regexp "^(.*gdb[+]?) *")
!     (setq paragraph-start comint-prompt-regexp)
!     (setq gdb-first-prompt t)
!     (run-hooks 'gdb-mode-hook)))
  
  ;; One of the nice features of GDB is its impressive support for
  ;; context-sensitive command completion.  We preserve that feature
***************
*** 2384,2391 ****
  		    (if (file-name-directory file-subst)
  			(expand-file-name file-subst)
  		      file-subst)))
! 	 (filepart (and file-word (concat "-" (file-name-nondirectory file)))))
      (pop-to-buffer (concat "*gud" filepart "*"))
      ;; Set the dir, in case the buffer already existed with a different dir.
      (setq default-directory dir)
      ;; Set default-directory to the file's directory.
--- 2385,2394 ----
  		    (if (file-name-directory file-subst)
  			(expand-file-name file-subst)
  		      file-subst)))
! 	 (filepart (and file-word (concat "-" (file-name-nondirectory file))))
! 	 (existing-buffer (get-buffer (concat "*gud" filepart "*"))))
      (pop-to-buffer (concat "*gud" filepart "*"))
+     (if existing-buffer (throw 'existing 'existing))
      ;; Set the dir, in case the buffer already existed with a different dir.
      (setq default-directory dir)
      ;; Set default-directory to the file's directory.

*** gdb-ui.el.~1.9.~	2004-04-20 00:21:06.000000000 +0100
--- gdb-ui.el	2004-04-21 19:20:40.000000000 +0100
***************
*** 119,126 ****
    (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))
  
  (defvar gdb-debug-log nil)
  
--- 119,125 ----
    (interactive (list (gud-query-cmdline 'gdba)))
    ;;
    ;; Let's start with a basic gud-gdb buffer and then modify it a bit.
!   (gdb-ann3 (gdb command-line)))
  
  (defvar gdb-debug-log nil)
  
***************
*** 134,200 ****
    :type 'boolean
    :group 'gud)
  
! (defun gdb-ann3 ()
!   (setq gdb-debug-log nil)
!   (set (make-local-variable 'gud-minor-mode) 'gdba)
!   (set (make-local-variable 'gud-marker-filter) 'gud-gdba-marker-filter)
!   ;;
!   (gud-def gud-break (if (not (string-equal mode-name "Machine"))
! 			 (gud-call "break %f:%l" arg)
! 		       (save-excursion
! 			 (beginning-of-line)
! 			 (forward-char 2)
! 			 (gud-call "break *%a" arg)))
! 	   "\C-b" "Set breakpoint at current line or address.")
!   ;;
!   (gud-def gud-remove (if (not (string-equal mode-name "Machine"))
! 			  (gud-call "clear %f:%l" arg)
! 			(save-excursion
! 			  (beginning-of-line)
! 			  (forward-char 2)
! 			  (gud-call "clear *%a" arg)))
! 	   "\C-d" "Remove breakpoint at current line or address.")
!   ;;
!   (gud-def gud-until  (if (not (string-equal mode-name "Machine"))
! 			  (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.")
! 
!   (define-key gud-minor-mode-map [left-margin mouse-1]
!     'gdb-mouse-toggle-breakpoint)
!   (define-key gud-minor-mode-map [left-fringe mouse-1]
!     'gdb-mouse-toggle-breakpoint)
  
!   (setq comint-input-sender 'gdb-send)
!   ;;
!   ;; (re-)initialise
!   (setq gdb-current-address "main")
!   (setq gdb-previous-address nil)
!   (setq gdb-previous-frame nil)
!   (setq gdb-current-frame "main")
!   (setq gdb-view-source t)
!   (setq gdb-selected-view 'source)
!   (setq gdb-var-list nil)
!   (setq gdb-var-changed nil)
!   (setq gdb-first-prompt nil)
!   ;;
!   (mapc 'make-local-variable gdb-variables)
!   (setq gdb-buffer-type 'gdba)
!   ;;
!   (if gdb-use-inferior-io-buffer (gdb-clear-inferior-io))
!   ;;
!   (if (eq window-system 'w32)
!       (gdb-enqueue-input (list "set new-console off\n" 'ignore)))
!   (gdb-enqueue-input (list "set height 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
!   (gdb-enqueue-input (list "server info source\n" 'gdb-source-info))
!   ;;
!   (run-hooks 'gdba-mode-hook))
  
  (defcustom gdb-use-colon-colon-notation nil
    "Non-nil means use FUNCTION::VARIABLE format to display variables in the
--- 133,200 ----
    :type 'boolean
    :group 'gud)
  
! (defun gdb-ann3 (arg)
!   (unless (eq arg 'existing)
!     (setq gdb-debug-log nil)
!     (set (make-local-variable 'gud-minor-mode) 'gdba)
!     (set (make-local-variable 'gud-marker-filter) 'gud-gdba-marker-filter)
!     ;;
!     (gud-def gud-break (if (not (string-equal mode-name "Machine"))
! 			   (gud-call "break %f:%l" arg)
! 			 (save-excursion
! 			   (beginning-of-line)
! 			   (forward-char 2)
! 			   (gud-call "break *%a" arg)))
! 	     "\C-b" "Set breakpoint at current line or address.")
!     ;;
!     (gud-def gud-remove (if (not (string-equal mode-name "Machine"))
! 			    (gud-call "clear %f:%l" arg)
! 			  (save-excursion
! 			    (beginning-of-line)
! 			    (forward-char 2)
! 			    (gud-call "clear *%a" arg)))
! 	     "\C-d" "Remove breakpoint at current line or address.")
!     ;;
!     (gud-def gud-until  (if (not (string-equal mode-name "Machine"))
! 			    (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.")
! 
!     (define-key gud-minor-mode-map [left-margin mouse-1]
!       'gdb-mouse-toggle-breakpoint)
!     (define-key gud-minor-mode-map [left-fringe mouse-1]
!       'gdb-mouse-toggle-breakpoint)
  
!     (setq comint-input-sender 'gdb-send)
!     ;;
!     ;; (re-)initialise
!     (setq gdb-current-address "main")
!     (setq gdb-previous-address nil)
!     (setq gdb-previous-frame nil)
!     (setq gdb-current-frame "main")
!     (setq gdb-view-source t)
!     (setq gdb-selected-view 'source)
!     (setq gdb-var-list nil)
!     (setq gdb-var-changed nil)
!     (setq gdb-first-prompt nil)
!     ;;
!     (mapc 'make-local-variable gdb-variables)
!     (setq gdb-buffer-type 'gdba)
!     ;;
!     (if gdb-use-inferior-io-buffer (gdb-clear-inferior-io))
!     ;;
!     (if (eq window-system 'w32)
! 	(gdb-enqueue-input (list "set new-console off\n" 'ignore)))
!     (gdb-enqueue-input (list "set height 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
!     (gdb-enqueue-input (list "server info source\n" 'gdb-source-info))
!     ;;
!     (run-hooks 'gdba-mode-hook)))
  
  (defcustom gdb-use-colon-colon-notation nil
    "Non-nil means use FUNCTION::VARIABLE format to display variables in the
***************
*** 721,727 ****
  (defun gdb-prompt (ignored)
    "An annotation handler for `prompt'.
  This sends the next command (if any) to gdb."
!   (when gdb-first-prompt (gdb-ann3))
    (let ((sink (gdb-get-output-sink)))
      (cond
       ((eq sink 'user) t)
--- 721,727 ----
  (defun gdb-prompt (ignored)
    "An annotation handler for `prompt'.
  This sends the next command (if any) to gdb."
!   (when gdb-first-prompt (gdb-ann3 nil))
    (let ((sink (gdb-get-output-sink)))
      (cond
       ((eq sink 'user) t)

Re: M-x gdb troubles

[Stefan Monnier]

>> If I have a running gdb process (M-x gdb ... run), and accidentally do
>> M-x gdb again (instead of switching to the gdb buffer), things get
>> really messy...

>> Maybe the second M-x gdb should just switch to the current gdb buffer 
>> if I enter the same command line as a previous gdb run.

> How about this patch. The catch form would have to be added to the other
> debugger functions (dbx, pdb, perldb etc) to be consistent.

Yuck.  I'd much rather just throw an error and be done with it.
Let the user switch to the gdb buffer manually.


        Stefan


PS: while I'm here: it occurred to me that the gdb-ui stuff should be split
    into a "frame/window management" part (the gdb-many-windows stuff) and
    an "annotation=3" part.  The frame/window-management would be extended
    to include the "old GUD" style, would be made non-GDB specific, and
    moved to gud.el.  This way the new frame system (with a special
    gud-source-window and such) would also be available for other debuggers.

    Of course, this is only seen from a conceptual point of view.
    From a coding point of view, it might require a complete
    rewrite/redesign: I wouldn't know.  Tho I do understand that the
    frame/window-management is already partly separate so maybe it wouldn't
    be that hard to do.

Re: M-x gdb troubles

[Nick Roberts]

 > > Yuck.  I'd much rather just throw an error and be done with it.
 > > Let the user switch to the gdb buffer manually.
 > > 
 > 
 > Well, what if it jumped to the existing buffer and then signalled an error
 > (e.g. gdb already running).
 > 
 > I could live with that...  :-)

The patch does jump to the existing buffer. In the case of "annotate=3", I had
meant to call gdb-restore-windows when there was an existing buffer. However,
this just restores to a standard layout and probably doesn't warrant the
ugliness of using catch.

It also removes the problem with the debuggers in gud which would insert an
unwanted "Current directory is ..." into the GUD buffer.

So shall I use error where I've put throw and take out the catch part?

Nick

Re: M-x gdb troubles

[Miles Bader]

On Wed, Apr 21, 2004 at 11:09:45PM +0100, Nick Roberts wrote:
> So shall I use error where I've put throw and take out the catch part?

I like the idea of an error, without the unnecessary "Current directory ..."
-- I was actually rather often surprised by the previous gud behavior, and
would have typed some commands by the time I realized it wasn't a new
session, so having a beep to wake me up would be useful.

Thanks,

-Miles
-- 
I'm beginning to think that life is just one long Yoko Ono album; no rhyme
or reason, just a lot of incoherent shrieks and then it's over.  --Ian Wolff

Re: M-x gdb troubles

[Kim F. Storm]

Stefan Monnier <monnier@iro.umontreal.ca> writes:

> >> If I have a running gdb process (M-x gdb ... run), and accidentally do
> >> M-x gdb again (instead of switching to the gdb buffer), things get
> >> really messy...
> 
> >> Maybe the second M-x gdb should just switch to the current gdb buffer 
> >> if I enter the same command line as a previous gdb run.
> 
> > How about this patch. The catch form would have to be added to the other
> > debugger functions (dbx, pdb, perldb etc) to be consistent.

I haven't had time to try this.

> 
> Yuck.  I'd much rather just throw an error and be done with it.
> Let the user switch to the gdb buffer manually.
> 

Well, what if it jumped to the existing buffer and then signalled an error
(e.g. gdb already running).

I could live with that...  :-)

-- 
Kim F. Storm <storm@cua.dk> http://www.cua.dk

Re: M-x gdb troubles

[Kim F. Storm]

Nick Roberts <nick@nick.uklinux.net> writes:

>  > > Yuck.  I'd much rather just throw an error and be done with it.
>  > > Let the user switch to the gdb buffer manually.
>  > > 
>  > 
>  > Well, what if it jumped to the existing buffer and then signalled an error
>  > (e.g. gdb already running).
>  > 
>  > I could live with that...  :-)
> 
> The patch does jump to the existing buffer. In the case of "annotate=3", I had
> meant to call gdb-restore-windows when there was an existing buffer. However,
> this just restores to a standard layout and probably doesn't warrant the
> ugliness of using catch.
> 
> It also removes the problem with the debuggers in gud which would insert an
> unwanted "Current directory is ..." into the GUD buffer.
> 
> So shall I use error where I've put throw and take out the catch part?

I prefer if things work smoothly -- so I like your patch (and don't object).

However, if others object to that approach, I can live with less...
So if you don't get more objections, I think you can install your patch.
(Stefan may disagree of course).

-- 
Kim F. Storm <storm@cua.dk> http://www.cua.dk

Re: M-x gdb troubles

[Nick Roberts]

 > PS: while I'm here: it occurred to me that the gdb-ui stuff should be split
 >     into a "frame/window management" part (the gdb-many-windows stuff) and
 >     an "annotation=3" part.  The frame/window-management would be extended
 >     to include the "old GUD" style, would be made non-GDB specific, and
 >     moved to gud.el.  This way the new frame system (with a special
 >     gud-source-window and such) would also be available for other debuggers.

It could be split but, currently, the other debuggers couldn't use these other
windows. To run the relevant commands (stack, locals, breakpoint list) behind
the users back places requirements on the syntax of the debugger output.  I've
approached the Python developers about this but met with limited interest.
With Java, I think different debuggers generate different output. Without a
formally defined interface, parsing the output is a precarious approach that
is likely to break. Hopefully, I can help GDB's interface evolve but I have no
input to the other debuggers.

Nick

Re: M-x gdb troubles

[Stefan Monnier]

> It could be split but, currently, the other debuggers couldn't use these
> other windows.

AFAIU, they indeed don't use most of them, but they all use "a source
window", except that they just use pop-to-buffer to display it rather than
gdb-source-window.

I personally like the use of pop-to-buffer over gdb-source-window because of
my Emacs setup so I'd like gdb-ui to be able to use this simpler gud
scheme, but I expect other people will like the gdb-source-window kind of
usage and will want it to be used for other gud modes as well.

Hence a sort of merge.  As said, I'm proposing this without having really
looked at the code, so it may be impractical.  But I think we should move
in this direction.


        Stefan

Re: M-x gdb troubles

[Nick Roberts]

 > > It could be split but, currently, the other debuggers couldn't use these
 > > other windows.
 > 
 > AFAIU, they indeed don't use most of them, but they all use "a source
 > window", except that they just use pop-to-buffer to display it rather than
 > gdb-source-window.

I don't quite follow as I removed gdb-source-window on 2004-04-08.

 > I personally like the use of pop-to-buffer over gdb-source-window because of
 > my Emacs setup so I'd like gdb-ui to be able to use this simpler gud
 > scheme, but I expect other people will like the gdb-source-window kind of
 > usage and will want it to be used for other gud modes as well.

gdb-ui now just uses gdb-display-buffer (a variant of gud-display-buffer from
gdba.el)

Also if you create new frames for the different buffers, say through the
menubar:

Gud->GDB-Frames->Threads
                 Breakpoints
		 Stack
                 ...

then the bahaviour should be improved.

 > Hence a sort of merge.  As said, I'm proposing this without having really
 > looked at the code, so it may be impractical.  But I think we should move
 > in this direction.
 
Are the changes that I have made in the direction that you are talking about?

Nick

Re: M-x gdb troubles

[Stefan Monnier]

>> Hence a sort of merge.  As said, I'm proposing this without having really
>> looked at the code, so it may be impractical.  But I think we should move
>> in this direction.
> Are the changes that I have made in the direction that you are talking about?

Yes, very much so.
I think all that's left is to merge gdb-display-buffer into
gud-display-buffer.


        Stefan