comparison lisp/gdb-ui.el @ 48641:da382393fb77

Get rid of (quote ..); use match-string and ignore.

48640:7bc8b0b65a02

  (setq gdb-proc (get-buffer-process (current-buffer)))
  (gdb-make-instance)
  (if gdb-first-time (gdb-clear-inferior-io))

; find source file and compilation directory here
  (gdb-instance-enqueue-idle-input (list "server list\n"
					 '(lambda () nil)))
  (gdb-instance-enqueue-idle-input (list "server info source\n"
					 '(lambda () (gdb-source-info)))))

(defun gud-break (arg)
  "Set breakpoint at current line or address."
  (interactive "p")
  (if (not (string-equal mode-name "Assembler"))

(defun gud-display1 (expr)
  (goto-char (point-min))
    (if (re-search-forward "\*" nil t)
	(gdb-instance-enqueue-idle-input
	 (list (concat "server display* " expr "\n")
	       '(lambda () nil)))
;else
      (gdb-instance-enqueue-idle-input
       (list (concat "server display " expr "\n")
	     '(lambda () nil)))))


;; The completion process filter is installed temporarily to slurp the
;; output of GDB up to the next prompt and build the completion list.
;; It must also handle annotations.

(defun gdb-source (args)
  (string-match gdb-source-spec-regexp args)
  ;; Extract the frame position from the marker.
  (setq gud-last-frame
	(cons
	 (substring args (match-beginning 1) (match-end 1))
	 (string-to-int (substring args
				   (match-beginning 2)
				   (match-end 2)))))
  (setq gdb-current-address (substring args (match-beginning 3)
				       (match-end 3)))
  (setq gdb-main-or-pc gdb-current-address)
;update with new frame for machine code if necessary
  (gdb-invalidate-assembler))

(defun gdb-prompt (ignored)

  (set-buffer (gdb-get-instance-buffer 'gdb-partial-output-buffer))
  (goto-char (point-min))
  (search-forward ": ")
  (looking-at "\\(.*?\\) =")
  (let ((char "")
	(gdb-temp-value (buffer-substring (match-beginning 1)
					  (match-end 1))))
;move * to front of expression if necessary
    (if (looking-at ".*\\*")
	(progn
	  (setq char "*")
	  (setq gdb-temp-value (substring gdb-temp-value 1 nil))))

	  (beginning-of-line)
	  (setq gdb-point (point))
	  (gdb-array-format)))
    (if (looking-at "field-begin \\(.\\)")
	(progn
	  (setq gdb-annotation-arg (buffer-substring (match-beginning 1)
						     (match-end 1)))
	  (gdb-field-format-begin))))
  (save-excursion
  (set-buffer gdb-expression-buffer-name)
  (if gdb-dive-display-number
      (progn

(defun gdb-display-go-back ()
  ; delete display so they don't accumulate and delete buffer
  (let ((number gdb-display-number))
    (gdb-instance-enqueue-idle-input
     (list (concat "server delete display " number "\n")
	   '(lambda () nil)))
    (switch-to-buffer (concat "*display " gdb-dive-display-number "*"))
    (kill-buffer (get-buffer (concat "*display " number "*")))))

; prefix annotations with ## and process whole output in one chunk
; in gdb-partial-output-buffer (to allow recursion).

	(setq gdb-nesting-level (+ gdb-nesting-level 1))
	(while (re-search-forward "##" nil t)
; keep making recursive calls...
	  (if (looking-at "field-begin \\(.\\)")
	      (progn
		(setq gdb-annotation-arg (buffer-substring (match-beginning 1)
							   (match-end 1)))
		(gdb-field-format-begin)))
; until field-end.
	  (if (looking-at "field-end") (gdb-field-format-end))))

(defun gdb-field-format-end ()

	  (end (progn (end-of-line) (point)))
	  (gdb-part-expression "") (gdb-last-field nil) (gdb-display-char nil))
      (beginning-of-line)
      (if (looking-at "\*") (setq gdb-display-char "*"))
      (re-search-forward "\\(\\S-+\\) = " end t)
      (setq gdb-last-field (buffer-substring-no-properties
			    (match-beginning 1)
			    (match-end 1)))
      (goto-char (match-beginning 1))
      (let ((last-column (current-column)))
	(while (re-search-backward "\\s-\\(\\S-+\\) = {" nil t)
	  (goto-char (match-beginning 1))
	  (if (and (< (current-column) last-column)
		   (> (count-lines 1 (point)) 1))
	      (progn
		(setq gdb-part-expression
		      (concat "." (buffer-substring-no-properties
				   (match-beginning 1)
				   (match-end 1)) gdb-part-expression))
		(setq last-column (current-column))))))
; * not needed for components of a pointer to a structure in gdb
      (if (string-equal "*" (substring gdb-full-expression 0 1))
	  (setq gdb-full-expression (substring gdb-full-expression 1 nil)))
      (setq gdb-full-expression
	    (concat gdb-full-expression gdb-part-expression "." gdb-last-field))
      (gdb-instance-enqueue-idle-input (list
					(concat "server display" gdb-display-char
						" " gdb-full-expression "\n")
			      '(lambda () nil))))))

(defun gdb-insert-field ()
  (let ((start (progn (point)))
	(end (progn (next-line) (point)))
	(num 0))

		      (> (aref indices num) (aref gdb-array-stop num)))
		  (setq flag nil))
	    (aset gdb-array-size num (aref indices num)))
	  (setq num (+ num 1)))
	(if flag
	    (let ((gdb-display-value (substring (car gdb-value-list)
						(match-beginning 1)
						(match-end 1))))
	      (setq gdb-display-string (concat gdb-display-string " "
					       gdb-display-value))
	      (insert
	       (concat indices-string "\t" gdb-display-value "\n"))))
	(setq indices-string "")

	  ;; Start accumulating output for the GUD buffer
	  (output ""))

      ;; Process all the complete markers in this chunk.
      (while (string-match "\n\032\032\\(.*\\)\n" burst)
	(let ((annotation (substring burst
				     (match-beginning 1)
				     (match-end 1))))

	  ;; Stuff prior to the match is just ordinary output.
	  ;; It is either concatenated to OUTPUT or directed
	  ;; elsewhere.
	  (setq output

	  ;; Take that stuff off the burst.
	  (setq burst (substring burst (match-end 0)))

	  ;; Parse the tag from the annotation, and maybe its arguments.
	  (string-match "\\(\\S-*\\) ?\\(.*\\)" annotation)
	  (let* ((annotation-type (substring annotation
					     (match-beginning 1)
					     (match-end 1)))
		 (annotation-arguments (substring annotation
						  (match-beginning 2)
						  (match-end 2)))
		 (annotation-rule (assoc annotation-type
					 gdb-annotation-rules)))
	    ;; Call the handler for this annotation.
	    (if annotation-rule
		(funcall (car (cdr annotation-rule))

		    (buffer-read-only nil))
		(delete-region (point-min) (point-max))
		(insert-buffer (gdb-get-create-instance-buffer
				'gdb-partial-output-buffer))
		(goto-char p)))))
; put customisation here
     (,custom-defun)))

(defmacro def-gdb-auto-updated-buffer
  (buffer-key trigger-name gdb-command output-handler-name custom-defun)
   `(progn
     (def-gdb-auto-update-trigger ,trigger-name
       ;; The demand predicate:
       (lambda ()
	 (gdb-get-instance-buffer ',buffer-key))
       ,gdb-command
       ,output-handler-name)
     (def-gdb-auto-update-handler ,output-handler-name
       ,trigger-name ,buffer-key ,custom-defun)))

		(looking-at "\\([0-9]*\\)\\s-*\\S-*\\s-*\\S-*\\s-*\\(.\\)")
		(setq flag (char-after (match-beginning 2)))
		(beginning-of-line)
		(re-search-forward "in\\s-+\\S-+\\s-+at\\s-+")
		(looking-at "\\(\\S-*\\):\\([0-9]+\\)")
		(let ((line (buffer-substring (match-beginning 2)
					      (match-end 2)))
		      (file (buffer-substring (match-beginning 1)
					      (match-end 1))))
		  (save-excursion
		    (set-buffer
		     (if (file-exists-p file)
			 (find-file-noselect file)
		     ;else
		       (find-file-noselect (concat gdb-cdir "/" file))))
		    (with-current-buffer (current-buffer)
		      (progn
			(set (make-local-variable 'gud-minor-mode) 'gdba)
			(set (make-local-variable 'tool-bar-map)
			     gud-tool-bar-map)
			(setq left-margin-width 2)
			(if (get-buffer-window (current-buffer))
			    (set-window-margins (get-buffer-window
						 (current-buffer))
						left-margin-width
						right-margin-width))))
			      ; only want one breakpoint icon at each location
		    (save-excursion
		      (goto-line (string-to-number line))
		      (let ((start (progn (beginning-of-line) (- (point) 1)))
			    (end (progn (end-of-line) (+ (point) 1))))
			(if (display-graphic-p)

       (list
	(concat
	 (if (eq ?y (char-after (match-beginning 2)))
	     "server disable "
	   "server enable ")
	 (buffer-substring (match-beginning 0)
			   (match-end 1))
	 "\n")
	'(lambda () nil))))))

(defun gdb-delete-bp-this-line ()
"Delete the breakpoint on this line."
  (interactive)
    (beginning-of-line 1)

	(error "Not recognized as break/watchpoint line")
      (gdb-instance-enqueue-idle-input
       (list
	(concat
	 "server delete "
	 (buffer-substring (match-beginning 0)
			   (match-end 1))
	 "\n")
	'(lambda () nil)))))

(defvar gdb-source-window nil)

(defun gdb-goto-bp-this-line ()
"Display the file at the specified breakpoint."
  (interactive)
  (save-excursion
    (beginning-of-line 1)
    (re-search-forward "in\\s-+\\S-+\\s-+at\\s-+")
    (looking-at "\\(\\S-*\\):\\([0-9]+\\)"))
  (let ((line (buffer-substring (match-beginning 2)
				  (match-end 2)))
	(file (buffer-substring (match-beginning 1)
				(match-end 1))))
    (if (file-exists-p file)
	(set-window-buffer gdb-source-window (find-file-noselect file))
      ;else
      (setq file (concat gdb-cdir "/" file))
      (set-window-buffer gdb-source-window (find-file-noselect file)))
    (goto-line (string-to-number line))))

;;
;; Frames buffers.  These display a perpetually correct bactracktrace
;; (from the command `where').

  (save-excursion
    (set-buffer (gdb-get-instance-buffer 'gdb-stack-buffer))
    (let ((buffer-read-only nil))
      (goto-char (point-min))
      (looking-at "\\S-*\\s-*\\(\\S-*\\)")
      (setq gdb-current-frame (buffer-substring (match-beginning 1) (match-end 1)))
      (while (< (point) (point-max))
	(put-text-property (progn (beginning-of-line) (point))
			   (progn (end-of-line) (point))
			   'mouse-face 'highlight)
	(forward-line 1)))))

  (gdb-invalidate-frames))

(defun gdb-get-frame-number ()
  (save-excursion
    (let* ((pos (re-search-backward "^#\\([0-9]*\\)" nil t))
	   (n (or (and pos
		       (string-to-int
			(buffer-substring (match-beginning 1)
					  (match-end 1))))
		  0)))
      n)))

(defun gdb-frames-select-by-mouse (e)
"Display the source of the selected frame."
  (interactive "e")

	(setq selection (gdb-get-frame-number))))
    (select-window (posn-window (event-end e)))
    (save-excursion
      (set-buffer (gdb-get-instance-buffer 'gdba))
  (gdb-instance-enqueue-idle-input
   (list
    (concat (gud-format-command "server frame %p" selection)
		 "\n")
    '(lambda () nil)))
      (gud-display-frame))))


;;
;; Registers buffers
;;

  gdb-info-locals-custom)


;Abbreviate for arrays and structures. These can be expanded using gud-display
(defun gdb-info-locals-handler nil
  (set-gdb-instance-pending-triggers (delq (quote gdb-invalidate-locals)
					   (gdb-instance-pending-triggers)))
  (let ((buf (gdb-get-instance-buffer (quote gdb-partial-output-buffer))))
    (save-excursion
      (set-buffer buf)
      (goto-char (point-min))
      (replace-regexp "^ .*\n" "")
      (goto-char (point-min))
      (replace-regexp "{[-0-9, {}\]*\n" "(array);\n")))
      (goto-char (point-min))
      (replace-regexp "{.*=.*\n" "(structure);\n")
  (let ((buf (gdb-get-instance-buffer (quote gdb-locals-buffer))))
    (and buf (save-excursion
	       (set-buffer buf)
	       (let ((p (point))
		     (buffer-read-only nil))
		 (delete-region (point-min) (point-max))
		 (insert-buffer (gdb-get-create-instance-buffer
				 (quote gdb-partial-output-buffer)))
		 (goto-char p)))))
  (run-hooks (quote gdb-info-locals-hook)))

(defun gdb-info-locals-custom ()
  nil)

(gdb-set-instance-buffer-rules 'gdb-locals-buffer

       (list
	(concat
	 (if (eq ?y (char-after (match-beginning 2)))
	     "server disable display "
	   "server enable display ")
	 (buffer-substring (match-beginning 0)
			   (match-end 1))
	 "\n")
	'(lambda () nil))))))

(defun gdb-delete-disp-this-line ()
"Delete the displayed expression on this line."
  (interactive)
  (save-excursion
    (set-buffer
     (gdb-get-instance-buffer 'gdb-display-buffer))
    (beginning-of-line 1)
    (if (not (looking-at "\\([0-9]+\\):   \\([ny]\\)"))
	(error "No expression on this line")
      (let ((number (buffer-substring (match-beginning 0)
				      (match-end 1))))
	(gdb-instance-enqueue-idle-input
	 (list (concat "server delete display " number "\n")
	       '(lambda () nil)))
	(if (not (display-graphic-p))
	    (kill-buffer (get-buffer (concat "*display " number "*")))
	  ;else
	  (catch 'frame-found
	    (let ((frames (frame-list)))

  (if (eq (selected-window) (minibuffer-window))
      (other-window 1))
  (delete-other-windows))

(defun gdb-source-info ()
"Finds the source file where the program starts and displays it with related
buffers."
  (goto-char (point-min))
  (re-search-forward "directory is ")
  (looking-at "\\(\\S-*\\)")
  (setq gdb-cdir (buffer-substring (match-beginning 1) (match-end 1)))
  (re-search-forward "Located in ")
  (looking-at "\\(\\S-*\\)")
  (setq gdb-main-file (buffer-substring (match-beginning 1) (match-end 1)))
  ;; Make sure we are not in the minibuffer window when we try to delete
  ;; all other windows.
  (if (eq (selected-window) (minibuffer-window))
      (other-window 1))
  (delete-other-windows)
  (if gdb-many-windows
      (gdb-setup-windows)
;else
    (gdb-display-breakpoints-buffer)
    (gdb-display-display-buffer)
    (gdb-display-stack-buffer)
    (delete-other-windows)
    (split-window)

(defun gdb-delete-display ()
  "Delete displayed expression and its frame."
  (interactive)
  (gdb-instance-enqueue-idle-input
   (list (concat "server delete display " gdb-display-number "\n")
	 '(lambda () nil)))
  (kill-buffer nil)
  (delete-frame))

;;
;; Assembler buffer

	(if (looking-at "[^\t].*breakpoint")
	    (progn
	      (looking-at
	       "\\([0-9]*\\)\\s-*\\S-*\\s-*\\S-*\\s-*\\(.\\)\\s-*0x0\\(\\S-*\\)")
	      ; info break gives '0x0' (8 digit) while dump gives '0x' (7 digit)
	      (setq address (concat "0x" (buffer-substring (match-beginning 3)
							   (match-end 3))))
	      (setq flag (char-after (match-beginning 2)))
	      (save-excursion
		(set-buffer buffer)
		(goto-char (point-min))
		(if (re-search-forward address nil t)

(defvar gdb-prev-main-or-pc nil)

; modified because if gdb-main-or-pc has changed value a new command
; must be enqueued to update the buffer with the new output
(defun gdb-invalidate-assembler (&optional ignored)
  (if (and ((lambda ()
	      (gdb-get-instance-buffer (quote gdb-assembler-buffer))))
	   (or (not (member (quote gdb-invalidate-assembler)
			(gdb-instance-pending-triggers)))
	   (not (string-equal gdb-main-or-pc gdb-prev-main-or-pc))))
      (progn

        ; take previous disassemble command off the queue
	(save-excursion
	  (set-buffer (gdb-get-instance-buffer 'gdba))
	   (let ((queue gdb-idle-input-queue) (item))
	     (while queue
	       (setq item (car queue))
	       (if (equal (cdr item) '(gdb-assembler-handler))
		   (delete item gdb-idle-input-queue))
		 (setq queue (cdr queue)))))

	(gdb-instance-enqueue-idle-input
	 (list (concat "server disassemble " gdb-main-or-pc "\n")
			     (quote gdb-assembler-handler)))
	     (set-gdb-instance-pending-triggers
	      (cons (quote gdb-invalidate-assembler)
			     (gdb-instance-pending-triggers)))
	     (setq gdb-prev-main-or-pc gdb-main-or-pc))))

(defun gdb-delete-line ()
  "Delete the current line."
(interactive)
  (let ((start (progn (beginning-of-line) (point)))

48641:da382393fb77

  (setq gdb-proc (get-buffer-process (current-buffer)))
  (gdb-make-instance)
  (if gdb-first-time (gdb-clear-inferior-io))

; find source file and compilation directory here
  (gdb-instance-enqueue-idle-input (list "server list\n" 'ignore))
  (gdb-instance-enqueue-idle-input (list "server info source\n"
					 'gdb-source-info)))

(defun gud-break (arg)
  "Set breakpoint at current line or address."
  (interactive "p")
  (if (not (string-equal mode-name "Assembler"))

(defun gud-display1 (expr)
  (goto-char (point-min))
    (if (re-search-forward "\*" nil t)
	(gdb-instance-enqueue-idle-input
	 (list (concat "server display* " expr "\n") 'ignore))
;else
      (gdb-instance-enqueue-idle-input
       (list (concat "server display " expr "\n") 'ignore))))


;; The completion process filter is installed temporarily to slurp the
;; output of GDB up to the next prompt and build the completion list.
;; It must also handle annotations.

(defun gdb-source (args)
  (string-match gdb-source-spec-regexp args)
  ;; Extract the frame position from the marker.
  (setq gud-last-frame
	(cons
	 (match-string 1 args)
	 (string-to-int (match-string 2 args))))
  (setq gdb-current-address (match-string 3 args))
  (setq gdb-main-or-pc gdb-current-address)
;update with new frame for machine code if necessary
  (gdb-invalidate-assembler))

(defun gdb-prompt (ignored)

  (set-buffer (gdb-get-instance-buffer 'gdb-partial-output-buffer))
  (goto-char (point-min))
  (search-forward ": ")
  (looking-at "\\(.*?\\) =")
  (let ((char "")
	(gdb-temp-value (match-string 1)))
;move * to front of expression if necessary
    (if (looking-at ".*\\*")
	(progn
	  (setq char "*")
	  (setq gdb-temp-value (substring gdb-temp-value 1 nil))))

	  (beginning-of-line)
	  (setq gdb-point (point))
	  (gdb-array-format)))
    (if (looking-at "field-begin \\(.\\)")
	(progn
	  (setq gdb-annotation-arg (match-string 1))
	  (gdb-field-format-begin))))
  (save-excursion
  (set-buffer gdb-expression-buffer-name)
  (if gdb-dive-display-number
      (progn

(defun gdb-display-go-back ()
  ; delete display so they don't accumulate and delete buffer
  (let ((number gdb-display-number))
    (gdb-instance-enqueue-idle-input
     (list (concat "server delete display " number "\n") 'ignore))
    (switch-to-buffer (concat "*display " gdb-dive-display-number "*"))
    (kill-buffer (get-buffer (concat "*display " number "*")))))

; prefix annotations with ## and process whole output in one chunk
; in gdb-partial-output-buffer (to allow recursion).

	(setq gdb-nesting-level (+ gdb-nesting-level 1))
	(while (re-search-forward "##" nil t)
; keep making recursive calls...
	  (if (looking-at "field-begin \\(.\\)")
	      (progn
		(setq gdb-annotation-arg (match-string 1))
		(gdb-field-format-begin)))
; until field-end.
	  (if (looking-at "field-end") (gdb-field-format-end))))

(defun gdb-field-format-end ()

	  (end (progn (end-of-line) (point)))
	  (gdb-part-expression "") (gdb-last-field nil) (gdb-display-char nil))
      (beginning-of-line)
      (if (looking-at "\*") (setq gdb-display-char "*"))
      (re-search-forward "\\(\\S-+\\) = " end t)
      (setq gdb-last-field (match-string-no-properties 1))
      (goto-char (match-beginning 1))
      (let ((last-column (current-column)))
	(while (re-search-backward "\\s-\\(\\S-+\\) = {" nil t)
	  (goto-char (match-beginning 1))
	  (if (and (< (current-column) last-column)
		   (> (count-lines 1 (point)) 1))
	      (progn
		(setq gdb-part-expression
		      (concat "." (match-string-no-properties 1)
			      gdb-part-expression))
		(setq last-column (current-column))))))
      ;; * not needed for components of a pointer to a structure in gdb
      (if (string-equal "*" (substring gdb-full-expression 0 1))
	  (setq gdb-full-expression (substring gdb-full-expression 1 nil)))
      (setq gdb-full-expression
	    (concat gdb-full-expression gdb-part-expression "." gdb-last-field))
      (gdb-instance-enqueue-idle-input
       (list (concat "server display" gdb-display-char
		     " " gdb-full-expression "\n")
	     'ignore)))))

(defun gdb-insert-field ()
  (let ((start (progn (point)))
	(end (progn (next-line) (point)))
	(num 0))

		      (> (aref indices num) (aref gdb-array-stop num)))
		  (setq flag nil))
	    (aset gdb-array-size num (aref indices num)))
	  (setq num (+ num 1)))
	(if flag
	    (let ((gdb-display-value (match-string 1 (car gdb-value-list))))
	      (setq gdb-display-string (concat gdb-display-string " "
					       gdb-display-value))
	      (insert
	       (concat indices-string "\t" gdb-display-value "\n"))))
	(setq indices-string "")

	  ;; Start accumulating output for the GUD buffer
	  (output ""))

      ;; Process all the complete markers in this chunk.
      (while (string-match "\n\032\032\\(.*\\)\n" burst)
	(let ((annotation (match-string 1 burst)))

	  ;; Stuff prior to the match is just ordinary output.
	  ;; It is either concatenated to OUTPUT or directed
	  ;; elsewhere.
	  (setq output

	  ;; Take that stuff off the burst.
	  (setq burst (substring burst (match-end 0)))

	  ;; Parse the tag from the annotation, and maybe its arguments.
	  (string-match "\\(\\S-*\\) ?\\(.*\\)" annotation)
	  (let* ((annotation-type (match-string 1 annotation))
		 (annotation-arguments (match-string 2 annotation))
		 (annotation-rule (assoc annotation-type
					 gdb-annotation-rules)))
	    ;; Call the handler for this annotation.
	    (if annotation-rule
		(funcall (car (cdr annotation-rule))

		    (buffer-read-only nil))
		(delete-region (point-min) (point-max))
		(insert-buffer (gdb-get-create-instance-buffer
				'gdb-partial-output-buffer))
		(goto-char p)))))
     ;; put customisation here
     (,custom-defun)))

(defmacro def-gdb-auto-updated-buffer (buffer-key trigger-name gdb-command
				       output-handler-name custom-defun)
   `(progn
     (def-gdb-auto-update-trigger ,trigger-name
       ;; The demand predicate:
       (lambda () (gdb-get-instance-buffer ',buffer-key))
       ,gdb-command
       ,output-handler-name)
     (def-gdb-auto-update-handler ,output-handler-name
       ,trigger-name ,buffer-key ,custom-defun)))

		(looking-at "\\([0-9]*\\)\\s-*\\S-*\\s-*\\S-*\\s-*\\(.\\)")
		(setq flag (char-after (match-beginning 2)))
		(beginning-of-line)
		(re-search-forward "in\\s-+\\S-+\\s-+at\\s-+")
		(looking-at "\\(\\S-*\\):\\([0-9]+\\)")
		(let ((line (match-string 2))
		      (file (match-string 1)))
		  (save-excursion
		    (set-buffer
		     (find-file-noselect (if (file-exists-p file)
					     file
					   (expand-file-name file gdb-cdir))))
		    (save-current-buffer
		      (set (make-local-variable 'gud-minor-mode) 'gdba)
		      (set (make-local-variable 'tool-bar-map)
			   gud-tool-bar-map)
		      (setq left-margin-width 2)
		      (if (get-buffer-window (current-buffer))
			  (set-window-margins (get-buffer-window
					       (current-buffer))
					      left-margin-width
					      right-margin-width)))
		    ;; only want one breakpoint icon at each location
		    (save-excursion
		      (goto-line (string-to-number line))
		      (let ((start (progn (beginning-of-line) (- (point) 1)))
			    (end (progn (end-of-line) (+ (point) 1))))
			(if (display-graphic-p)

       (list
	(concat
	 (if (eq ?y (char-after (match-beginning 2)))
	     "server disable "
	   "server enable ")
	 (match-string 1)
	 "\n")
	'ignore)))))

(defun gdb-delete-bp-this-line ()
"Delete the breakpoint on this line."
  (interactive)
    (beginning-of-line 1)

	(error "Not recognized as break/watchpoint line")
      (gdb-instance-enqueue-idle-input
       (list
	(concat
	 "server delete "
	 (match-string 1)
	 "\n")
	'ignore))))

(defvar gdb-source-window nil)

(defun gdb-goto-bp-this-line ()
"Display the file at the specified breakpoint."
  (interactive)
  (save-excursion
    (beginning-of-line 1)
    (re-search-forward "in\\s-+\\S-+\\s-+at\\s-+")
    (looking-at "\\(\\S-*\\):\\([0-9]+\\)"))
  (let ((line (match-string 2))
	(file (match-string 1)))
    (set-window-buffer gdb-source-window
		       (find-file-noselect
			(if (file-exists-p file)
			    file
			  (expand-file-name file gdb-cdir))))
    (goto-line (string-to-number line))))

;;
;; Frames buffers.  These display a perpetually correct bactracktrace
;; (from the command `where').

  (save-excursion
    (set-buffer (gdb-get-instance-buffer 'gdb-stack-buffer))
    (let ((buffer-read-only nil))
      (goto-char (point-min))
      (looking-at "\\S-*\\s-*\\(\\S-*\\)")
      (setq gdb-current-frame (match-string 1))
      (while (< (point) (point-max))
	(put-text-property (progn (beginning-of-line) (point))
			   (progn (end-of-line) (point))
			   'mouse-face 'highlight)
	(forward-line 1)))))

  (gdb-invalidate-frames))

(defun gdb-get-frame-number ()
  (save-excursion
    (let* ((pos (re-search-backward "^#\\([0-9]*\\)" nil t))
	   (n (or (and pos (string-to-int (match-string 1))) 0)))
      n)))

(defun gdb-frames-select-by-mouse (e)
"Display the source of the selected frame."
  (interactive "e")

	(setq selection (gdb-get-frame-number))))
    (select-window (posn-window (event-end e)))
    (save-excursion
      (set-buffer (gdb-get-instance-buffer 'gdba))
  (gdb-instance-enqueue-idle-input
   (list (gud-format-command "server frame %p\n" selection)
	 'ignore))
  (gud-display-frame))))


;;
;; Registers buffers
;;

  gdb-info-locals-custom)


;Abbreviate for arrays and structures. These can be expanded using gud-display
(defun gdb-info-locals-handler nil
  (set-gdb-instance-pending-triggers (delq 'gdb-invalidate-locals
					   (gdb-instance-pending-triggers)))
  (let ((buf (gdb-get-instance-buffer 'gdb-partial-output-buffer)))
    (save-excursion
      (set-buffer buf)
      (goto-char (point-min))
      (replace-regexp "^ .*\n" "")
      (goto-char (point-min))
      (replace-regexp "{[-0-9, {}\]*\n" "(array);\n")))
      (goto-char (point-min))
      (replace-regexp "{.*=.*\n" "(structure);\n")
  (let ((buf (gdb-get-instance-buffer 'gdb-locals-buffer)))
    (and buf (save-excursion
	       (set-buffer buf)
	       (let ((p (point))
		     (buffer-read-only nil))
		 (delete-region (point-min) (point-max))
		 (insert-buffer (gdb-get-create-instance-buffer
				 'gdb-partial-output-buffer))
		 (goto-char p)))))
  (run-hooks 'gdb-info-locals-hook))

(defun gdb-info-locals-custom ()
  nil)

(gdb-set-instance-buffer-rules 'gdb-locals-buffer

       (list
	(concat
	 (if (eq ?y (char-after (match-beginning 2)))
	     "server disable display "
	   "server enable display ")
	 (match-string 1)
	 "\n")
	'ignore)))))

(defun gdb-delete-disp-this-line ()
"Delete the displayed expression on this line."
  (interactive)
  (save-excursion
    (set-buffer
     (gdb-get-instance-buffer 'gdb-display-buffer))
    (beginning-of-line 1)
    (if (not (looking-at "\\([0-9]+\\):   \\([ny]\\)"))
	(error "No expression on this line")
      (let ((number (match-string 1)))
	(gdb-instance-enqueue-idle-input
	 (list (concat "server delete display " number "\n")
	       'ignore))
	(if (not (display-graphic-p))
	    (kill-buffer (get-buffer (concat "*display " number "*")))
	  ;else
	  (catch 'frame-found
	    (let ((frames (frame-list)))

  (if (eq (selected-window) (minibuffer-window))
      (other-window 1))
  (delete-other-windows))

(defun gdb-source-info ()
  "Find the source file where the program starts and displays it with related
buffers."
  (goto-char (point-min))
  (search-forward "directory is ")
  (looking-at "\\S-*")
  (setq gdb-cdir (match-string 0))
  (search-forward "Located in ")
  (looking-at "\\S-*")
  (setq gdb-main-file (match-string 0))
  ;; Make sure we are not in the minibuffer window when we try to delete
  ;; all other windows.
  (if (window-minibuffer-p (selected-window))
      (other-window 1))
  (delete-other-windows)
  (if gdb-many-windows
      (gdb-setup-windows)
    (gdb-display-breakpoints-buffer)
    (gdb-display-display-buffer)
    (gdb-display-stack-buffer)
    (delete-other-windows)
    (split-window)

(defun gdb-delete-display ()
  "Delete displayed expression and its frame."
  (interactive)
  (gdb-instance-enqueue-idle-input
   (list (concat "server delete display " gdb-display-number "\n")
	 'ignore))
  (kill-buffer nil)
  (delete-frame))

;;
;; Assembler buffer

	(if (looking-at "[^\t].*breakpoint")
	    (progn
	      (looking-at
	       "\\([0-9]*\\)\\s-*\\S-*\\s-*\\S-*\\s-*\\(.\\)\\s-*0x0\\(\\S-*\\)")
	      ; info break gives '0x0' (8 digit) while dump gives '0x' (7 digit)
	      (setq address (concat "0x" (match-string 3)))
	      (setq flag (char-after (match-beginning 2)))
	      (save-excursion
		(set-buffer buffer)
		(goto-char (point-min))
		(if (re-search-forward address nil t)

(defvar gdb-prev-main-or-pc nil)

; modified because if gdb-main-or-pc has changed value a new command
; must be enqueued to update the buffer with the new output
(defun gdb-invalidate-assembler (&optional ignored)
  (if (and (gdb-get-instance-buffer 'gdb-assembler-buffer)
	   (or (not (member 'gdb-invalidate-assembler
			    (gdb-instance-pending-triggers)))
	       (not (string-equal gdb-main-or-pc gdb-prev-main-or-pc))))
      (progn

	;; take previous disassemble command off the queue
	(save-excursion
	  (set-buffer (gdb-get-instance-buffer 'gdba))
	  (let ((queue gdb-idle-input-queue) (item))
	    (while queue
	      (setq item (car queue))
	      (if (equal (cdr item) '(gdb-assembler-handler))
		  (delete item gdb-idle-input-queue))
	      (setq queue (cdr queue)))))

	(gdb-instance-enqueue-idle-input
	 (list (concat "server disassemble " gdb-main-or-pc "\n")
	       'gdb-assembler-handler))
	(set-gdb-instance-pending-triggers
	 (cons 'gdb-invalidate-assembler
	       (gdb-instance-pending-triggers)))
	(setq gdb-prev-main-or-pc gdb-main-or-pc))))

(defun gdb-delete-line ()
  "Delete the current line."
(interactive)
  (let ((start (progn (beginning-of-line) (point)))