Re: Extend gdb to filter registers

[Yuan Fu <casouri@gmail.com>]

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

Here is another patch that allows a user to save and restore window
configurations. It seems to work for me and I welcome you to try it out.

Yuan


[-- Attachment #2: 0001-Add-window-configuration-save-restore-feature-for-gd.patch --]
[-- Type: text/x-patch, Size: 7264 bytes --]

From a88ede26b81a1372a74696314fe6c7ed288f730e Mon Sep 17 00:00:00 2001
From: Yuan Fu <casouri@gmail.com>
Date: Mon, 14 Oct 2019 21:11:43 -0400
Subject: [PATCH] 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
(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 | 126 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 126 insertions(+)

diff --git a/lisp/progmodes/gdb-mi.el b/lisp/progmodes/gdb-mi.el
index 60852e4ad6..4cb09da181 100644
--- a/lisp/progmodes/gdb-mi.el
+++ b/lisp/progmodes/gdb-mi.el
@@ -92,6 +92,7 @@
 (require 'json)
 (require 'bindat)
 (require 'cl-lib)
+(require 'pcase)
 
 (declare-function speedbar-change-initial-expansion-list
                   "speedbar" (new-default))
@@ -4609,6 +4610,131 @@ 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
+    (when (or (derived-mode-p 'gdb-parent-mode)
+              (derived-mode-p 'gdb-inferior-io-mode)) t)))
+
+(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)))
+
+(defmacro gdb--inhibit-window-dedicated (&rest body)
+  "Run BODY with window-dedicated temporarily disabled."
+  ;; switch-to-buffer-in-dedicated-window
+  ;; doesn't work in non-interactive case
+  `(let ((window-dedicated (window-dedicated-p)))
+     (when window-dedicated
+       (set-window-dedicated-p nil nil))
+     ,@body
+     (when window-dedicated
+       (set-window-dedicated-p nil t))))
+
+(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 "F Save window configuration to file: ")
+  ;; 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
+          old-window-dedidated-value)
+      (dolist (win (window-list nil 'no-minibuffer))
+        (select-window win)
+        (setq old-window-dedidated-value (window-dedicated-p))
+        (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)))
+          (gdb--inhibit-window-dedicated
+           (set-window-buffer nil placeholder))))
+      ;; save the window configuration to FILE
+      (setq window-config (window-state-get nil t))
+      (let ((buffer (find-file file)))
+        (with-current-buffer buffer
+          (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 "F Restore window configuration from file: ")
+  ;; 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*")))
+    (progn ; don't leak buffer
+      (let ((window-config (with-current-buffer config-buffer
+                             (goto-char 1)
+                             (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))))
+                 (gdb--inhibit-window-dedicated
+                  (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