From mboxrd@z Thu Jan 1 00:00:00 1970 Path: news.gmane.org!not-for-mail From: Helmut Eller Newsgroups: gmane.emacs.devel Subject: debugger-toggle-locals Date: Sat, 23 Nov 2013 09:57:17 +0100 Message-ID: NNTP-Posting-Host: plane.gmane.org Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="=-=-=" X-Trace: ger.gmane.org 1385197066 6798 80.91.229.3 (23 Nov 2013 08:57:46 GMT) X-Complaints-To: usenet@ger.gmane.org NNTP-Posting-Date: Sat, 23 Nov 2013 08:57:46 +0000 (UTC) To: emacs-devel@gnu.org Original-X-From: emacs-devel-bounces+ged-emacs-devel=m.gmane.org@gnu.org Sat Nov 23 09:57:51 2013 Return-path: Envelope-to: ged-emacs-devel@m.gmane.org Original-Received: from lists.gnu.org ([208.118.235.17]) by plane.gmane.org with esmtp (Exim 4.69) (envelope-from ) id 1Vk92F-0002vV-61 for ged-emacs-devel@m.gmane.org; Sat, 23 Nov 2013 09:57:51 +0100 Original-Received: from localhost ([::1]:42826 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1Vk92E-00081C-Qt for ged-emacs-devel@m.gmane.org; Sat, 23 Nov 2013 03:57:50 -0500 Original-Received: from eggs.gnu.org ([2001:4830:134:3::10]:50998) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1Vk925-000811-ER for emacs-devel@gnu.org; Sat, 23 Nov 2013 03:57:48 -0500 Original-Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1Vk91v-0000xW-2H for emacs-devel@gnu.org; Sat, 23 Nov 2013 03:57:41 -0500 Original-Received: from plane.gmane.org ([80.91.229.3]:44682) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1Vk91u-0000xK-NO for emacs-devel@gnu.org; Sat, 23 Nov 2013 03:57:30 -0500 Original-Received: from list by plane.gmane.org with local (Exim 4.69) (envelope-from ) id 1Vk91t-0002ll-3i for emacs-devel@gnu.org; Sat, 23 Nov 2013 09:57:29 +0100 Original-Received: from dial-188058.pool.broadband44.net ([212.46.188.58]) by main.gmane.org with esmtp (Gmexim 0.1 (Debian)) id 1AlnuQ-0007hv-00 for ; Sat, 23 Nov 2013 09:57:29 +0100 Original-Received: from eller.helmut by dial-188058.pool.broadband44.net with local (Gmexim 0.1 (Debian)) id 1AlnuQ-0007hv-00 for ; Sat, 23 Nov 2013 09:57:29 +0100 X-Injected-Via-Gmane: http://gmane.org/ Original-Lines: 219 Original-X-Complaints-To: usenet@ger.gmane.org X-Gmane-NNTP-Posting-Host: dial-188058.pool.broadband44.net User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/24.3.50 (gnu/linux) Cancel-Lock: sha1:YFcX+Ljnc8A8DOOfoUQhcmNabuk= X-detected-operating-system: by eggs.gnu.org: Genre and OS details not recognized. X-Received-From: 80.91.229.3 X-BeenThere: emacs-devel@gnu.org X-Mailman-Version: 2.1.14 Precedence: list List-Id: "Emacs development discussions." List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: emacs-devel-bounces+ged-emacs-devel=m.gmane.org@gnu.org Original-Sender: emacs-devel-bounces+ged-emacs-devel=m.gmane.org@gnu.org Xref: news.gmane.org gmane.emacs.devel:165607 Archived-At: --=-=-= Content-Type: text/plain I'd like to add a new debugger command `debugger-toggle-locals', that displays the names and values of local variables of a stack frame. This looks like so: Debugger entered--Lisp error: (void-variable d) foo(10 113) foo(9 114) x: 9 y: 114 z: (9 . 114) foo(8 115) The command inserts the lines with x:, y: and z:. Pressing t a second time deletes those lines again. To do this I needed a new primitive `backtrace-locals' which extracts the names and values from the specpdl, similar to backtrace-eval. This works for interpreted functions and compiled non-lexically-scoped functions. Compiled lexically scoped functions would need compiler support, in the form of stackmaps. Until somebody implements that, the command only displays "no locals". Helmut --=-=-= Content-Type: text/x-diff Content-Disposition: inline; filename=toggle-locals.patch diff --git a/lisp/emacs-lisp/debug.el b/lisp/emacs-lisp/debug.el index 6c7a0d2..d8596aa 100644 --- a/lisp/emacs-lisp/debug.el +++ b/lisp/emacs-lisp/debug.el @@ -494,9 +494,13 @@ removes itself from that hook." (forward-line 1) (while (progn (forward-char 2) - (if (= (following-char) ?\() - (forward-sexp 1) - (forward-sexp 2)) + (cond ((debugger--locals-visible-p) + (goto-char (next-single-char-property-change + (1+ (point)) 'debugger-locals-visible-p))) + ((= (following-char) ?\() + (forward-sexp 1)) + (t + (forward-sexp 2))) (forward-line 1) (<= (point) opoint)) (if (looking-at " *;;;") @@ -558,6 +562,89 @@ The environment used is the one when entering the activation frame at point." (prin1 val t) (let ((str (eval-expression-print-format val))) (if str (princ str t)))))))) + +(defun debugger--backtrace-base () + "Return the function name that marks the top of the backtrace. +See `backtrace-frame'." + (cond ((eq 'debug--implement-debug-on-entry + (cadr (backtrace-frame 1 'debug))) + 'debug--implement-debug-on-entry) + (t 'debug))) + +(defun debugger--locals-visible-p () + "Are the local variables of the current stack frame visible?" + (save-excursion + (move-to-column 2) + (get-text-property (point) 'debugger-locals-visible-p))) + +(defun debugger--insert-locals (locals) + "Insert the local variables LOCALS at point." + ;; A bit messy because we need to deal with lexical frames, i.e. + ;; the ones with the magic symbol 'internal-interpreter-environment. + (when (null locals) + (insert "\n [no locals]")) + (dolist (s+v locals) + (let ((symbol (car s+v)) + (value (cdr s+v)) + (print-escape-newlines t) + (insert (lambda (s v) + (insert "\n ") + (prin1 s (current-buffer)) + (insert ": ") + (prin1 v (current-buffer))))) + (cond ((string= (symbol-name symbol) "internal-interpreter-environment") + (cond ((or (null value) + (and (null (cdr value)) + (symbol (car value)))) + (insert "\n [no locals]")) + (t + (dolist (s+v value) + (unless (symbolp s+v) + (let ((symbol (car s+v)) + (value (cdr s+v))) + (funcall insert symbol value))))))) + (t + (funcall insert symbol value)))))) + +(defun debugger--show-locals () + "For the frame at point, insert locals and add text properties." + (let* ((nframe (debugger-frame-number 'skip-base)) + (base (debugger--backtrace-base)) + (locals (backtrace-locals nframe base)) + (inhibit-read-only t)) + (save-excursion + (let ((start (progn + (beginning-of-line) + (skip-chars-forward " ") + (point)))) + (end-of-line) + (debugger--insert-locals locals) + (add-text-properties start (point) '(debugger-locals-visible-p t)))))) + +(defun debugger--hide-locals () + "Delete local variables and remove the text property." + (let* ((col (current-column)) + (end (progn + (move-to-column 2) + (next-single-char-property-change + (point) 'debugger-locals-visible-p))) + (start (previous-single-char-property-change + end 'debugger-locals-visible-p)) + (inhibit-read-only t)) + (goto-char start) + (end-of-line) + (remove-text-properties start end '(debugger-locals-visible-p)) + (delete-region (point) end) + (move-to-column col))) + +(defun debugger-toggle-locals () + "Show or hide local variables of the current stack frame." + (interactive) + (cond ((debugger--locals-visible-p) + (debugger--hide-locals)) + (t + (debugger--show-locals)))) + (defvar debugger-mode-map (let ((map (make-keymap)) @@ -575,6 +662,7 @@ The environment used is the one when entering the activation frame at point." (define-key map "h" 'describe-mode) (define-key map "q" 'top-level) (define-key map "e" 'debugger-eval-expression) + (define-key map "t" 'debugger-toggle-locals) (define-key map " " 'next-line) (define-key map "R" 'debugger-record-expression) (define-key map "\C-m" 'debug-help-follow) diff --git a/src/eval.c b/src/eval.c index d3fcec5..a455d95 100644 --- a/src/eval.c +++ b/src/eval.c @@ -3576,6 +3576,53 @@ NFRAMES and BASE specify the activation frame to use, as in `backtrace-frame'. from the debugger. */ return unbind_to (count, eval_sub (exp)); } + +DEFUN ("backtrace-locals", Fbacktrace_locals, Sbacktrace_locals, 1, 2, NULL, + doc: /* Return names and values of local variables of a stack frame. +NFRAMES and BASE specify the activation frame to use, as in `backtrace-frame'. +The result is an alist. */) + (Lisp_Object nframes, Lisp_Object base) +{ + union specbinding *frame = get_backtrace_frame (nframes, base); + union specbinding *olderframe = + get_backtrace_frame (make_number (XFASTINT (nframes) + 1), base); + ptrdiff_t distance = specpdl_ptr - olderframe; + Lisp_Object result = Qnil; + eassert (distance >= 0); + + if (!backtrace_p (frame)) + error ("Activation frame not found!"); + if (!backtrace_p (olderframe)) + error ("Activation frame not found!"); + + /* move values to specpdl */ + backtrace_eval_unrewind (distance); + + /* grab values */ + { + union specbinding *tmp = frame; + for (; tmp > olderframe; tmp--) + { + switch (tmp->kind) + { + case SPECPDL_LET: + case SPECPDL_LET_DEFAULT: + case SPECPDL_LET_LOCAL: + { + Lisp_Object sym = specpdl_symbol (tmp); + Lisp_Object val = specpdl_old_value (tmp); + result = Fcons (Fcons (sym, val), result); + } + } + } + } + + /* restore values from specpdl to orignal place */ + backtrace_eval_unrewind (-distance); + + return result; +} + void mark_specpdl (void) @@ -3824,6 +3871,7 @@ alist of active lexical bindings. */); defsubr (&Sbacktrace); defsubr (&Sbacktrace_frame); defsubr (&Sbacktrace_eval); + defsubr (&Sbacktrace_locals); defsubr (&Sspecial_variable_p); defsubr (&Sfunctionp); } --=-=-=--