X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcode%2Fdebug.lisp;h=faa5279f6a593644e47cb8a58d5425bfc0becd17;hb=422b88abf96f4842a3d0999cd3b80d96f5a153d6;hp=535b4298519a86e644d6f9aa5279b92d0890bfad;hpb=74a48d09e08aead6f67204878bdf9be4f448e1e8;p=sbcl.git diff --git a/src/code/debug.lisp b/src/code/debug.lisp index 535b429..faa5279 100644 --- a/src/code/debug.lisp +++ b/src/code/debug.lisp @@ -13,11 +13,28 @@ ;;;; variables and constants -(defvar *debug-print-level* 3 +;;; things to consider when tweaking these values: +;;; * We're afraid to just default them to NIL and NIL, in case the +;;; user inadvertently causes a hairy data structure to be printed +;;; when he inadvertently enters the debugger. +;;; * We don't want to truncate output too much. These days anyone +;;; can easily run their Lisp in a windowing system or under Emacs, +;;; so it's not the end of the world even if the worst case is a +;;; few thousand lines of output. +;;; * As condition :REPORT methods are converted to use the pretty +;;; printer, they acquire *PRINT-LEVEL* constraints, so e.g. under +;;; sbcl-0.7.1.28's old value of *DEBUG-PRINT-LEVEL*=3, an +;;; ARG-COUNT-ERROR printed as +;;; error while parsing arguments to DESTRUCTURING-BIND: +;;; invalid number of elements in +;;; # +;;; to satisfy lambda list +;;; #: +;;; exactly 2 expected, but 5 found +(defvar *debug-print-level* 5 #!+sb-doc "*PRINT-LEVEL* for the debugger") - -(defvar *debug-print-length* 5 +(defvar *debug-print-length* 7 #!+sb-doc "*PRINT-LENGTH* for the debugger") @@ -108,7 +125,12 @@ Function and macro commands: (SB-DEBUG:ARG n) Return the n'th argument in the current frame. (SB-DEBUG:VAR string-or-symbol [id]) - Returns the value of the specified variable in the current frame.") + Returns the value of the specified variable in the current frame. + +Other commands: + SLURP Discard all pending input on *STANDARD-INPUT*. (This can be + useful when the debugger was invoked to handle an error in + deeply nested input syntax, and now the reader is confused.)") ;;; This is used to communicate to DEBUG-LOOP that we are at a step breakpoint. (define-condition step-condition (simple-condition) ()) @@ -305,12 +327,12 @@ Function and macro commands: (format t "~&~S: FUN-END in ~S" bp-number (sb!di:debug-fun-name place)))))) -;;;; MAIN-HOOK-FUNCTION for steps and breakpoints +;;;; MAIN-HOOK-FUN for steps and breakpoints ;;; This must be passed as the hook function. It keeps track of where ;;; STEP breakpoints are. -(defun main-hook-function (current-frame breakpoint &optional return-vals - fun-end-cookie) +(defun main-hook-fun (current-frame breakpoint &optional return-vals + fun-end-cookie) (setf *default-breakpoint-debug-fun* (sb!di:frame-debug-fun current-frame)) (dolist (step-info *step-breakpoints*) @@ -377,7 +399,7 @@ Function and macro commands: (break string) (format t "~A" string))) (t - (break "error in main-hook-function: unknown breakpoint")))))) + (break "unknown breakpoint")))))) ;;; Set breakpoints at the next possible code-locations. After calling ;;; this, either (CONTINUE) if in the debugger or just let program flow @@ -399,14 +421,14 @@ Function and macro commands: (when bp-info (sb!di:deactivate-breakpoint (breakpoint-info-breakpoint bp-info)))) - (let ((bp (sb!di:make-breakpoint #'main-hook-function code-location + (let ((bp (sb!di:make-breakpoint #'main-hook-fun code-location :kind :code-location))) (sb!di:activate-breakpoint bp) (push (create-breakpoint-info code-location bp 0) *step-breakpoints*)))) (t (let* ((debug-fun (sb!di:frame-debug-fun *current-frame*)) - (bp (sb!di:make-breakpoint #'main-hook-function debug-fun + (bp (sb!di:make-breakpoint #'main-hook-fun debug-fun :kind :fun-end))) (sb!di:activate-breakpoint bp) (push (create-breakpoint-info debug-fun bp 0) @@ -475,12 +497,11 @@ Function and macro commands: ) ; EVAL-WHEN ;;; This is used in constructing arg lists for debugger printing when -;;; the arg list is unavailable, some arg is unavailable or unused, -;;; etc. +;;; the arg list is unavailable, some arg is unavailable or unused, etc. (defstruct (unprintable-object (:constructor make-unprintable-object (string)) (:print-object (lambda (x s) - (print-unreadable-object (x s :type t) + (print-unreadable-object (x s) (write-string (unprintable-object-string x) s)))) (:copier nil)) @@ -491,37 +512,51 @@ Function and macro commands: ;;; lambda-list variables since any other arguments will be in the ;;; &REST arg's list of values. (defun print-frame-call-1 (frame) - (let* ((d-fun (sb!di:frame-debug-fun frame)) - (loc (sb!di:frame-code-location frame)) - (results (list (sb!di:debug-fun-name d-fun)))) + (let ((debug-fun (sb!di:frame-debug-fun frame)) + (loc (sb!di:frame-code-location frame)) + (reversed-args nil)) + + ;; Construct function arguments in REVERSED-ARGS. (handler-case - (dolist (ele (sb!di:debug-fun-lambda-list d-fun)) + (dolist (ele (sb!di:debug-fun-lambda-list debug-fun)) (lambda-list-element-dispatch ele - :required ((push (frame-call-arg ele loc frame) results)) - :optional ((push (frame-call-arg (second ele) loc frame) results)) - :keyword ((push (second ele) results) - (push (frame-call-arg (third ele) loc frame) results)) - :deleted ((push (frame-call-arg ele loc frame) results)) + :required ((push (frame-call-arg ele loc frame) reversed-args)) + :optional ((push (frame-call-arg (second ele) loc frame) + reversed-args)) + :keyword ((push (second ele) reversed-args) + (push (frame-call-arg (third ele) loc frame) + reversed-args)) + :deleted ((push (frame-call-arg ele loc frame) reversed-args)) :rest ((lambda-var-dispatch (second ele) loc nil (progn - (setf results + (setf reversed-args (append (reverse (sb!di:debug-var-value (second ele) frame)) - results)) + reversed-args)) (return)) (push (make-unprintable-object "unavailable &REST argument") - results))))) + reversed-args))))) (sb!di:lambda-list-unavailable () - (push (make-unprintable-object "lambda list unavailable") results))) - (pprint-logical-block (*standard-output* nil) - (let ((x (nreverse (mapcar #'ensure-printable-object results)))) - (format t "(~@<~S~{ ~_~S~}~:>)" (first x) (rest x)))) - (when (sb!di:debug-fun-kind d-fun) + (push (make-unprintable-object "lambda list unavailable") + reversed-args))) + + (pprint-logical-block (*standard-output* nil :prefix "(" :suffix ")") + (let ((args (nreverse (mapcar #'ensure-printable-object reversed-args)))) + ;; Since we go to some trouble to make nice informative function + ;; names like (PRINT-OBJECT :AROUND (CLOWN T)), let's make sure + ;; that they aren't truncated by *PRINT-LENGTH* and *PRINT-LEVEL*. + (let ((*print-length* nil) + (*print-level* nil)) + (prin1 (ensure-printable-object (sb!di:debug-fun-name debug-fun)))) + ;; For the function arguments, we can just print normally. + (format t "~{ ~_~S~}" args))) + + (when (sb!di:debug-fun-kind debug-fun) (write-char #\[) - (prin1 (sb!di:debug-fun-kind d-fun)) + (prin1 (sb!di:debug-fun-kind debug-fun)) (write-char #\])))) (defun ensure-printable-object (object) @@ -577,6 +612,7 @@ Function and macro commands: ;;; These are bound on each invocation of INVOKE-DEBUGGER. (defvar *debug-restarts*) (defvar *debug-condition*) +(defvar *nested-debug-condition*) (defun invoke-debugger (condition) #!+sb-doc @@ -585,7 +621,9 @@ Function and macro commands: (when old-hook (let ((*debugger-hook* nil)) (funcall old-hook condition old-hook)))) - (sb!unix:unix-sigsetmask 0) + ;; FIXME: No-one seems to know what this is for. Nothing is noticeably + ;; broken on sunos... + #!-sunos (sb!unix:unix-sigsetmask 0) ;; Elsewhere in the system, we use the SANE-PACKAGE function for ;; this, but here causing an exception just as we're trying to handle @@ -607,7 +645,7 @@ reset to ~S." ;; the program. WITH-STANDARD-IO-SYNTAX does some of that, ;; but ;; 1. It doesn't affect our internal special variables - ;; like *CURRENT-LEVEL*. + ;; like *CURRENT-LEVEL-IN-PRINT*. ;; 2. It isn't customizable. ;; 3. It doesn't set *PRINT-READABLY* or *PRINT-PRETTY* ;; to the same value as the toplevel default. @@ -615,13 +653,14 @@ reset to ~S." ;; helpful behavior for a debugger. ;; We try to remedy all these problems with explicit ;; rebindings here. - (sb!kernel:*current-level* 0) + (sb!kernel:*current-level-in-print* 0) (*print-length* *debug-print-length*) (*print-level* *debug-print-level*) (*readtable* *debug-readtable*) (*print-readably* nil) (*print-pretty* t) - (*package* original-package)) + (*package* original-package) + (*nested-debug-condition* nil)) ;; Before we start our own output, finish any pending output. ;; Otherwise, if the user tried to track the progress of @@ -641,10 +680,22 @@ reset to ~S." (type-of *debug-condition*) *debug-condition*) (error (condition) - (format *error-output* - "~&(caught ~S trying to print ~S when entering debugger)~%" - (type-of condition) - '*debug-condition*))) + (setf *nested-debug-condition* condition) + (let ((ndc-type (type-of *nested-debug-condition*))) + (format *error-output* + "~&~@<(A ~S was caught when trying to print ~S when ~ + entering the debugger. Printing was aborted and the ~ + ~S was stored in ~S.)~@:>~%" + ndc-type + '*debug-condition* + ndc-type + '*nested-debug-condition*)) + (when (typep condition 'cell-error) + ;; what we really want to know when it's e.g. an UNBOUND-VARIABLE: + (format *error-output* + "~&(CELL-ERROR-NAME ~S) = ~S~%" + '*debug-condition* + (cell-error-name *debug-condition*))))) ;; After the initial error/condition/whatever announcement to ;; *ERROR-OUTPUT*, we become interactive, and should talk on @@ -653,15 +704,14 @@ reset to ~S." ;; older debugger code which was written to do i/o on whatever ;; stream was in fashion at the time, and not all of it has ;; been converted to behave this way. -- WHN 2000-11-16) - (let (;; FIXME: The first two bindings here seem wrong, + (let (;; FIXME: Rebinding *STANDARD-OUTPUT* here seems wrong, ;; violating the principle of least surprise, and making ;; it impossible for the user to do reasonable things ;; like using PRINT at the debugger prompt to send output ;; to the program's ordinary (possibly - ;; redirected-to-a-file) *STANDARD-OUTPUT*, or using - ;; PEEK-CHAR or some such thing on the program's ordinary - ;; (possibly also redirected) *STANDARD-INPUT*. - (*standard-input* *debug-io*) + ;; redirected-to-a-file) *STANDARD-OUTPUT*. (CMU CL + ;; used to rebind *STANDARD-INPUT* here too, but that's + ;; been fixed already.) (*standard-output* *debug-io*) ;; This seems reasonable: e.g. if the user has redirected ;; *ERROR-OUTPUT* to some log file, it's probably wrong @@ -703,7 +753,7 @@ reset to ~S." (dolist (restart restarts) (let ((name (restart-name restart))) (cond ((member name names-used) - (format s "~& ~2D: ~@VT~A~%" count max-name-len restart)) + (format s "~& ~2D: ~V@T~A~%" count max-name-len restart)) (t (format s "~& ~2D: [~VA] ~A~%" count (- max-name-len 3) name restart) @@ -760,7 +810,7 @@ reset to ~S." '*flush-debug-errors*) (/show0 "throwing DEBUG-LOOP-CATCHER") (throw 'debug-loop-catcher nil))))) - ;; We have to bind level for the restart function created by + ;; We have to bind LEVEL for the restart function created by ;; WITH-SIMPLE-RESTART. (let ((level *debug-command-level*) (restart-commands (make-restart-commands))) @@ -783,7 +833,7 @@ reset to ~S." (apply cmd-fun (sb!int:stream-command-args input)))))) (t - (let* ((exp (read)) + (let* ((exp (read *debug-io*)) (cmd-fun (debug-command-p exp restart-commands))) (cond ((not cmd-fun) @@ -828,7 +878,7 @@ reset to ~S." (sb!xc:defmacro define-var-operation (ref-or-set &optional value-var) `(let* ((temp (etypecase name - (symbol (sb!di:debug-fun-symbol-variables + (symbol (sb!di:debug-fun-symbol-vars (sb!di:frame-debug-fun *current-frame*) name)) (simple-string (sb!di:ambiguous-debug-vars @@ -1160,7 +1210,7 @@ argument") (show-restarts *debug-restarts* *debug-io*) (write-string "restart: ") (force-output) - (setf num (read *standard-input*))) + (setf num (read *debug-io*))) (let ((restart (typecase num (unsigned-byte (nth num *debug-restarts*)) @@ -1473,7 +1523,7 @@ argument") *default-breakpoint-debug-fun*)))))) (setup-fun-start () (let ((code-loc (sb!di:debug-fun-start-location place))) - (setf bp (sb!di:make-breakpoint #'main-hook-function + (setf bp (sb!di:make-breakpoint #'main-hook-fun place :kind :fun-start)) (setf break (sb!di:preprocess-for-eval break code-loc)) @@ -1483,7 +1533,7 @@ argument") print-functions)))) (setup-fun-end () (setf bp - (sb!di:make-breakpoint #'main-hook-function + (sb!di:make-breakpoint #'main-hook-fun place :kind :fun-end)) (setf break @@ -1504,8 +1554,7 @@ argument") print-functions))) (setup-code-location () (setf place (nth index *possible-breakpoints*)) - (setf bp (sb!di:make-breakpoint #'main-hook-function - place + (setf bp (sb!di:make-breakpoint #'main-hook-fun place :kind :code-location)) (dolist (form print) (push (cons @@ -1576,17 +1625,19 @@ argument") (if function (describe function) (format t "can't figure out the function for this frame")))) + +(!def-debug-command "SLURP" () + (loop while (read-char-no-hang *standard-input*))) ;;;; debug loop command utilities -(defun read-prompting-maybe (prompt &optional (in *standard-input*) - (out *standard-output*)) - (unless (sb!int:listen-skip-whitespace in) - (princ prompt out) - (force-output out)) - (read in)) +(defun read-prompting-maybe (prompt) + (unless (sb!int:listen-skip-whitespace *debug-io*) + (princ prompt) + (force-output)) + (read *debug-io*)) -(defun read-if-available (default &optional (stream *standard-input*)) - (if (sb!int:listen-skip-whitespace stream) - (read stream) +(defun read-if-available (default) + (if (sb!int:listen-skip-whitespace *debug-io*) + (read *debug-io*) default))