Re: Extend gdb to filter registers

[Yuan Fu <casouri@gmail.com>]

[-- Attachment #1: Type: text/plain, Size: 507 bytes --]

> If the buffer is narrowed so that point-min as greater than 1, you
> cannot goto position 1; trying that will signal an error.

Thanks, I’ve fixed it.

Here is the latest patch. I added a customizable variable that controls
the default directory in where we store/restore window config file.

By now I’ve collected 3 patches: register, memory and store/retore
window config. They all seem to work pretty well but I haven’t used them
too much since I’ve finished my bomblab...

Yuan


[-- Attachment #2: store-window.patch --]
[-- Type: text/x-patch, Size: 9116 bytes --]

From 1a39dc1cb80a6ea54edcf17c9d59362c2cc40a33 Mon Sep 17 00:00:00 2001
From: Yuan Fu <casouri@gmail.com>
Date: Thu, 17 Oct 2019 17:35:48 -0400
Subject: [PATCH 1/2] Add with-selected-window-undedicated

* lisp/window.el (with-selected-window-undedicated): new
---
 lisp/window.el | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/lisp/window.el b/lisp/window.el
index d93ec0add6..ba48354572 100644
--- a/lisp/window.el
+++ b/lisp/window.el
@@ -278,6 +278,16 @@ with-displayed-buffer-window
 	     (funcall ,vquit-function ,window ,value)
 	   ,value)))))
 
+(defmacro with-selected-window-undedicated (&rest body)
+  "Run BODY in the selected window with window-dedicated temporarily disabled."
+  (let ((window-dedicated-sym (gensym)))
+    `(let ((,window-dedicated-sym (window-dedicated-p)))
+       (when ,window-dedicated-sym
+         (set-window-dedicated-p nil nil))
+       ,@body
+       (when ,window-dedicated-sym
+         (set-window-dedicated-p nil t)))))
+
 ;; The following two functions are like `window-next-sibling' and
 ;; `window-prev-sibling' but the WINDOW argument is _not_ optional (so
 ;; they don't substitute the selected window for nil), and they return
-- 
2.23.0


From 1036eccc4bf8e585f0b1ecf9f676db0003adf0f1 Mon Sep 17 00:00:00 2001
From: Yuan Fu <casouri@gmail.com>
Date: Mon, 14 Oct 2019 21:11:43 -0400
Subject: [PATCH 2/2] Add window configuration save/restore feature for gdb-mi
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Now you can save a gdb window configuration to a file with
‘gdb-store-window-configuration’ and restore it from a file
with ‘gdb-restore-window-configuration’.

* lisp/progmodes/gdb-mi.el (require): add pcase, wrap inside
‘eval-when-compile’
(gdb-store-window-directory, gdb-buffer-p, gdb-function-buffer-p,
gdb--buffer-type, gdb--inhibit-window-dedicated,
gdb-store-window-configuration, gdb-restore-window-configuration): new
---
 lisp/progmodes/gdb-mi.el | 130 ++++++++++++++++++++++++++++++++++++++-
 1 file changed, 129 insertions(+), 1 deletion(-)

diff --git a/lisp/progmodes/gdb-mi.el b/lisp/progmodes/gdb-mi.el
index 60852e4ad6..5d220caa42 100644
--- a/lisp/progmodes/gdb-mi.el
+++ b/lisp/progmodes/gdb-mi.el
@@ -91,7 +91,8 @@
 (require 'gud)
 (require 'json)
 (require 'bindat)
-(require 'cl-lib)
+(eval-when-compile (require 'cl-lib))
+(eval-when-compile (require 'pcase))
 
 (declare-function speedbar-change-initial-expansion-list
                   "speedbar" (new-default))
@@ -589,6 +590,13 @@ gdb-show-main
   :group 'gdb
   :version "22.1")
 
+(defcustom gdb-store-window-directory user-emacs-directory
+  "The default directory where window configuration files are stored.
+If nil, use `default-directory'."
+  :type 'string
+  :group 'gdb
+  :version "27.1")
+
 (defvar gdbmi-debug-mode nil
   "When non-nil, print the messages sent/received from GDB/MI in *Messages*.")
 
@@ -4609,6 +4617,126 @@ gdb-setup-windows
                              nil win5))
     (select-window win0)))
 
+(defun gdb-buffer-p (buffer)
+  "Return t if BUFFER is gdb-related."
+  (with-current-buffer buffer
+    (eq gud-minor-mode 'gdbmi)))
+
+(defun gdb-function-buffer-p (buffer)
+  "Return t if BUFFER is a gdb function buffer.
+
+E.g., locals buffer, registers buffer, but don't include the main
+command buffer (the one in where you type gdb commands) or source
+buffers."
+  (with-current-buffer buffer
+    (derived-mode-p 'gdb-parent-mode 'gdb-inferior-io-mode)))
+
+(defun gdb--buffer-type (buffer)
+  "Return the buffer type of BUFFER or nil.
+
+Buffer type is like `gdb-registers-type', `gdb-stack-buffer'.
+This symbol can be passed to `gdb-get-buffer-create'.
+
+Return nil if BUFFER isn't a gdb function buffer."
+  (with-current-buffer buffer
+    (cl-loop for rule in gdb-buffer-rules
+             for mode-name = (gdb-rules-buffer-mode rule)
+             for type = (car rule)
+             if (eq mode-name major-mode)
+             return type
+             finally return nil)))
+
+(defun gdb-store-window-configuration (file)
+  "Save current window configuration to FILE.
+
+You can later restore this configuration from that file by
+`gdb-restore-window-configuration'."
+  (interactive (list (read-file-name
+                      "Save window configuration to file: "
+                      (or gdb-store-window-directory default-directory))))
+  ;; we replace the buffer in each window with a placeholder, set
+  ;; window parameter as the buffer type (register, breakpoint, etc),
+  ;; and store window configuration
+  (save-window-excursion
+    (let ((placeholder (get-buffer-create " *gdb-placeholder*"))
+          (window-persistent-parameters
+           (cons '(gdb-buffer-type . writable) window-persistent-parameters))
+          window-config)
+      (dolist (win (window-list nil 'no-minibuffer))
+        (select-window win)
+        (when (gdb-buffer-p (current-buffer))
+          (set-window-parameter
+           nil 'gdb-buffer-type
+           (cond ((gdb-function-buffer-p (current-buffer))
+                  ;; we save this gdb-buffer-type symbol so
+                  ;; we can later pass it to `gdb-get-buffer-create'
+                  ;; one example: `gdb-registers-buffer'
+                  (or (gdb--buffer-type (current-buffer))
+                      (error "Unrecognized gdb buffer mode: %s" major-mode)))
+                 ;; command buffer
+                 ((derived-mode-p 'gud-mode) 'command)
+                 ((member (selected-window) gdb-source-window) 'source)))
+          (with-selected-window-undedicated
+           (set-window-buffer nil placeholder)
+           (set-window-prev-buffers (selected-window) nil)
+           (set-window-next-buffers (selected-window) nil))))
+      ;; save the window configuration to FILE
+      (setq window-config (window-state-get nil t))
+      (let ((buffer (find-file file)))
+        (unwind-protect
+            (with-current-buffer buffer
+              (if buffer-read-only
+                  (user-error "Error: file read only")
+                (erase-buffer)
+                (prin1 window-config (current-buffer))
+                (save-buffer)))
+          (kill-buffer buffer)
+          (kill-buffer placeholder))))))
+
+(defun gdb-restore-window-configuration (file)
+  "Restore window configuration from FILE.
+
+FILE is saved by `gdb-store-window-configuration'."
+  (interactive (list (read-file-name
+                      "Restore window configuration from file: "
+                      (or gdb-store-window-directory default-directory))))
+  ;; basically we restore window configuration and go through each
+  ;; window and restore the function buffers
+  (let* ((config-buffer (find-file-noselect file))
+         (placeholder (get-buffer-create " *gdb-placeholder*")))
+    (unwind-protect ; don't leak buffer
+        (let ((window-config (with-current-buffer config-buffer
+                               (goto-char (point-min))
+                               (read (current-buffer))))
+              ;; a list of existing gdb buffers
+              (existing-gdb-buffer-list (cl-remove-if-not
+                                         #'gdb-function-buffer-p
+                                         (buffer-list)))
+              buffer-type
+              (source-buffer (when gdb-source-window
+                               (window-buffer gdb-source-window))))
+          (window-state-put window-config (frame-root-window))
+          (dolist (window (window-list nil 'no-minibuffer))
+            (select-window window)
+            (setq buffer-type (window-parameter nil 'gdb-buffer-type))
+            (pcase buffer-type
+              ('source (when source-buffer
+                         (set-window-buffer nil source-buffer)
+                         (setq gdb-source-window (selected-window))))
+              ('command (switch-to-buffer gud-comint-buffer))
+              ;; locally shadow `buffer-list', it should be safe
+              (_ (let ((buffer (cl-labels ((buffer-list () existing-gdb-buffer-list))
+                                 (gdb-get-buffer-create buffer-type))))
+                   (with-selected-window-undedicated
+                    (set-window-buffer nil buffer))
+                   ;; each time when we display a gdb function buffer in a window
+                   ;; we remove that buffer from `existing-gdb-buffer-list'
+                   ;; this way we avoid displaying the same buffer in two windows
+                   (setq existing-gdb-buffer-list
+                         (remove buffer existing-gdb-buffer-list)))))))
+      (kill-buffer config-buffer)
+      (kill-buffer placeholder))))
+
 (define-minor-mode gdb-many-windows
   "If nil just pop up the GUD buffer unless `gdb-show-main' is t.
 In this case it starts with two windows: one displaying the GUD
-- 
2.23.0