0.8.20.1: fun-name fun, debugger debugged

[sbcl.git] / src / code / inspect.lisp

diff --git a/src/code/inspect.lisp b/src/code/inspect.lisp
index 2fe8ca2..603319c 100644 (file)
--- a/src/code/inspect.lisp
+++ b/src/code/inspect.lisp
@@ -17,15 +17,22 @@
 ;;; indicates that that a slot is unbound.
 (defvar *inspect-unbound-object-marker* (gensym "INSPECT-UNBOUND-OBJECT-"))
 
-(defun inspect (object)
+(defun inspector (object input-stream output-stream)
+  (declare (ignore input-stream))
   (catch 'quit-inspect
-    (%inspect object *standard-output*))
+    (%inspect object output-stream))
   (values))
 
+(defvar *inspect-fun* #'inspector
+  "a function of three arguments OBJECT, INPUT, and OUTPUT which starts an interactive inspector.")
+
 (defvar *inspected*)
 (setf (documentation '*inspected* 'variable)
       "the value currently being inspected in CL:INSPECT")
 
+(defun inspect (object)
+  (funcall *inspect-fun* object *standard-input* *standard-output*))
+
 (defvar *help-for-inspect*
   "
 help for INSPECT:
@@ -41,17 +48,18 @@ evaluated expressions.
 ")
 
 (defun %inspect (*inspected* s)
-  (named-let redisplay () ; "lambda, the ultimate GOTO":-|
+  (named-let redisplay () ; "LAMBDA, the ultimate GOTO":-|
     (multiple-value-bind (description named-p elements)
        (inspected-parts *inspected*)
       (tty-display-inspected-parts description named-p elements s)
       (named-let reread ()
        (format s "~&> ")
        (force-output)
-       (let (;; KMP idiom, using stream itself as EOF value
-             (command (read *standard-input* nil *standard-input*)))
-         (typecase command
-           (stream ; i.e. EOF
+       (let* (;; newly-consed object for hermetic protection against
+              ;; mischievous input like #.*EOF-OBJECT*:
+              (eof (cons *eof-object* nil))
+               (command (read *standard-input* nil eof)))
+          (when (eq command eof)
             ;; currently-undocumented feature: EOF is handled as Q.
             ;; If there's ever consensus that this is *the* right
             ;; thing to do (as opposed to e.g. handling it as U), we
@@ -59,6 +67,7 @@ evaluated expressions.
             ;; do this than to signal an error.
             (/show0 "THROWing QUIT-INSPECT for EOF")
             (throw 'quit-inspect nil))
+         (typecase command
            (integer
             (let ((elements-length (length elements)))
               (cond ((< -1 command elements-length)
@@ -146,7 +155,7 @@ evaluated expressions.
 (defgeneric inspected-parts (object))
 
 (defmethod inspected-parts ((object symbol))
-  (values (format nil "The object is a SYMBOL.~%" object)
+  (values (format nil "The object is a SYMBOL.~%")
          t
          (list (cons "Name" (symbol-name object))
                (cons "Package" (symbol-package object))
@@ -163,7 +172,7 @@ evaluated expressions.
         (info (layout-info (sb-kernel:layout-of object))))
     (when (sb-kernel::defstruct-description-p info)
       (dolist (dd-slot (dd-slots info) (nreverse parts-list))
-        (push (cons (dsd-%name dd-slot)
+        (push (cons (dsd-name dd-slot)
                     (funcall (dsd-accessor-name dd-slot) object))
               parts-list)))))
 
@@ -193,21 +202,28 @@ evaluated expressions.
   (values (format nil "The object is a FUNCALLABLE-INSTANCE of type ~S.~%"
                  (type-of object))
          t
-         (inspected-structure-elements object)))
+         (inspected-standard-object-elements object)))
+
+(defmethod inspected-parts ((object condition))
+  (values (format nil "The object is a CONDITION of type ~S.~%"
+                 (type-of object))
+         t
+         (inspected-standard-object-elements object)))
 
 (defmethod inspected-parts ((object function))
-  (let* ((type (sb-kernel:widetag-of object))
-        (object (if (= type sb-vm:closure-header-widetag)
-                    (sb-kernel:%closure-fun object)
-                    object)))
-    (values (format nil "FUNCTION ~S.~@[~%Argument List: ~A~]." object
-                   (sb-kernel:%simple-fun-arglist object)
-                   ;; Defined-from stuff used to be here. Someone took
-                   ;; it out. FIXME: We should make it easy to get
-                   ;; to DESCRIBE from the inspector.
-                   )
-           t
-           nil)))
+           (values (format nil "The object is a ~A named ~S.~%" 
+                           (if (closurep object) 'closure 'function)
+                           (%fun-name object))
+                   t
+                   ;; Defined-from stuff used to be here. Someone took
+                   ;; it out. FIXME: We should make it easy to get
+                   ;; to DESCRIBE from the inspector.
+                   (list*
+                    (cons "Lambda-list" (%fun-lambda-list object))
+                    (cons "Ftype" (%fun-type object))
+                    (when (closurep object)
+                      (list
+                       (cons "Closed over values" (%closure-values object)))))))
 
 (defmethod inspected-parts ((object vector))
   (values (format nil
@@ -232,7 +248,9 @@ evaluated expressions.
 
 (defmethod inspected-parts ((object array))
   (let* ((length (min (array-total-size object) *inspect-length*))
-        (reference-array (make-array length :displaced-to object))
+        (reference-array (make-array length 
+                                     :element-type (array-element-type object)
+                                     :displaced-to object))
         (dimensions (array-dimensions object))
         (reversed-elements nil))
     ;; FIXME: Should we respect *INSPECT-LENGTH* here? If not, what does