(in-package "SB-IMPL") ;(SB-IMPL, not SB!IMPL, since we're built in warm load.)
\f
-(defvar *describe-indentation-step* 3
- #+sb-doc
- "the number of spaces that sets off each line of a recursive description")
-
(declaim (ftype (function (t stream)) describe-object))
(defgeneric describe-object ((x t) stream))
#+sb-doc
"Print a description of the object X."
(let ((stream (out-synonym-of stream-designator)))
+ (fresh-line stream)
(pprint-logical-block (stream nil)
- (fresh-line stream)
(describe-object x stream)
- (fresh-line stream)))
+ (pprint-newline :mandatory stream)))
(values))
\f
;;;; miscellaneous DESCRIBE-OBJECT methods
(call-next-method)
(when (and (legal-fun-name-p x)
(fboundp x))
- (%describe-function (fdefinition x) s :function x)
+ (%describe-fun (fdefinition x) s :function x)
;;was: (format s "~@:_Its FDEFINITION is ~S.~@:_" (fdefinition x))
;; TO DO: should check for SETF documentation.
;; TO DO: should make it clear whether the definition is a
;;; Describe a compiled function. The closure case calls us to print
;;; the guts.
-(defun %describe-function-compiled (x s kind name)
+(defun %describe-fun-compiled (x s kind name)
(declare (type stream s))
- ;; FIXME: The lowercaseness of %SIMPLE-FUN-ARGLIST results, and the
- ;; non-sentenceness of the "Arguments" label, makes awkward output.
- ;; Better would be "Its arguments are: ~S" (with uppercase argument
- ;; names) when arguments are known, and otherwise "There is no
- ;; information available about its arguments." or "It has no
- ;; arguments." (And why is %SIMPLE-FUN-ARGLIST a string instead of a
- ;; list of symbols anyway?)
(let ((args (%simple-fun-arglist x)))
- (format s "~@:_~@(~@[~A ~]arguments:~@:_~)" kind)
(cond ((not args)
- (format s " There is no argument information available."))
- ((string= args "()")
(write-string " There are no arguments." s))
(t
+ (format s "~@:_~@(The ~@[~A's ~]arguments are:~@:_~)" kind)
(write-string " " s)
- (pprint-logical-block (s nil)
- (pprint-indent :current 2)
- (write-string args s)))))
+ (let ((*print-pretty* t)
+ (*print-escape* t)
+ (*print-base* 10)
+ (*print-radix* nil))
+ (pprint-logical-block (s nil)
+ (pprint-indent :current 2)
+ (format s "~A" args))))))
(let ((name (or name (%simple-fun-name x))))
(%describe-doc name s 'function kind)
(unless (eq kind :macro)
(%describe-fun-name name s (%simple-fun-type x))))
(%describe-compiled-from (sb-kernel:fun-code-header x) s))
-;;; Describe a function with the specified kind and name. The latter
-;;; arguments provide some information about where the function came
-;;; from. KIND=NIL means not from a name.
-(defun %describe-function (x s &optional (kind nil) name)
+;;; Describe a function object. KIND and NAME provide some information
+;;; about where the function came from.
+(defun %describe-fun (x s &optional (kind :function) (name nil))
(declare (type function x))
(declare (type stream s))
- (declare (type (member :macro :function nil) kind))
+ (declare (type (member :macro :function) kind))
(fresh-line s)
(ecase kind
(:macro (format s "Macro-function: ~S" x))
- (:function (format s "Function: ~S" x))
- ((nil) (format s "~S is a function." x)))
+ (:function (if name
+ (format s "Function: ~S" x)
+ (format s "~S is a function." x))))
+ (format s "~@:_Its associated name (as in ~S) is ~S."
+ 'function-lambda-expression
+ (%fun-name x))
(case (widetag-of x)
(#.sb-vm:closure-header-widetag
- (%describe-function-compiled (%closure-fun x) s kind name)
+ (%describe-fun-compiled (%closure-fun x) s kind name)
(format s "~@:_Its closure environment is:")
(pprint-logical-block (s nil)
(pprint-indent :current 8)
(dotimes (i (- (get-closure-length x) (1- sb-vm:closure-info-offset)))
(format s "~@:_~S: ~S" i (%closure-index-ref x i)))))
((#.sb-vm:simple-fun-header-widetag #.sb-vm:closure-fun-header-widetag)
- (%describe-function-compiled x s kind name))
+ (%describe-fun-compiled x s kind name))
(#.sb-vm:funcallable-instance-header-widetag
- (typecase x
- (standard-generic-function
- ;; There should be a special method for this case; we'll
- ;; delegate to that.
- (describe-object x s))
- (t
- (format s "~@:_It is an unknown type of funcallable instance."))))
+ ;; Only STANDARD-GENERIC-FUNCTION would be handled here, but
+ ;; since it has its own DESCRIBE-OBJECT method, it should've been
+ ;; picked off before getting here. So hopefully we never get here.
+ (format s "~@:_It is an unknown type of funcallable instance."))
(t
(format s "~@:_It is an unknown type of function."))))
(defmethod describe-object ((x function) s)
- (%describe-function x s))
-
+ (%describe-fun x s :function))
+
+(defgeneric describe-symbol-fdefinition (function stream &key (name nil) ))
+
+(defmethod describe-symbol-fdefinition ((fun function) stream &key name)
+ (%describe-fun fun stream :function name))
+
+(defmethod describe-symbol-fdefinition ((fun standard-generic-function) stream
+ &key name)
+ (declare (ignore name))
+ ;; just delegate
+ (describe-object fun stream))
+
(defmethod describe-object ((x symbol) s)
(declare (type stream s))
(multiple-value-bind (symbol status)
(find-symbol (symbol-name x) package)
(declare (ignore symbol))
- (format s "~S is ~_an ~(~A~) symbol ~_in ~S."
+ (format s "~@<~S is ~_an ~(~A~) symbol ~_in ~S.~:>"
x status (symbol-package x)))
- (format s "~S is ~_an uninterned symbol." x)))
+ (format s "~@<~S is ~_an uninterned symbol.~:>" x)))
;; TO DO: We could grovel over all packages looking for and
;; reporting other phenomena, e.g. IMPORT and SHADOW, or
;; availability in some package even after (SYMBOL-PACKAGE X) has
(let* ((kind (info :variable :kind x))
(wot (ecase kind
(:special "special variable")
+ (:macro "symbol macro")
(:constant "constant")
(:global "undefined variable")
(:alien nil))))
(sb-alien::heap-alien-info-type info)))
(format s "~@<Its current value is ~3I~:_~S.~:>"
(eval x))))
+ ((eq kind :macro)
+ (let ((expansion (info :variable :macro-expansion x)))
+ (format s "~@:_It is a ~A with expansion ~S." wot expansion)))
((boundp x)
- (format s "~@:_It is a ~A; its ~_value is ~S." wot (symbol-value x)))
+ (format s "~@:_~@<It is a ~A; its ~_value is ~S.~:>"
+ wot (symbol-value x)))
((not (eq kind :global))
- (format s "~@:_It is a ~A; no current value." wot)))
+ (format s "~@:_~@<It is a ~A; no current value.~:>" wot)))
(when (eq (info :variable :where-from x) :declared)
- (format s "~@:_Its declared type ~_is ~S."
+ (format s "~@:_~@<Its declared type ~_is ~S.~:>"
(type-specifier (info :variable :type x))))
(%describe-doc x s 'variable kind))
;; Describe the function cell.
(cond ((macro-function x)
- (%describe-function (macro-function x) s :macro x))
+ (%describe-fun (macro-function x) s :macro x))
((special-operator-p x)
- (%describe-doc x s 'function "Special form"))
+ (%describe-doc x s :function "Special form"))
((fboundp x)
- (%describe-function (fdefinition x) s :function x)))
-
- ;; FIXME: Print out other stuff from the INFO database:
- ;; * Does it name a type?
- ;; * Is it a structure accessor? (This is important since those are
- ;; magical in some ways, e.g. blasting the structure if you
- ;; redefine them.)
+ (describe-symbol-fdefinition (fdefinition x) s :name x)))
;; Print other documentation.
(%describe-doc x s 'structure "Structure")
(%describe-doc x s 'type "Type")
(%describe-doc x s 'setf "Setf macro")
-
(dolist (assoc (info :random-documentation :stuff x))
(format s
"~@:_Documentation on the ~(~A~):~@:_~A"
(car assoc)
(cdr assoc)))
- ;; Describe the associated class, if any.
+ ;; Mention the associated type information, if any.
+ ;;
+ ;; As of sbcl-0.7.2, (INFO :TYPE :KIND X) might be
+ ;; * :PRIMITIVE, which is handled by the FIND-CLASS case.
+ ;; * :DEFINED, which is handled specially.
+ ;; * :INSTANCE, which is handled by the FIND-CLASS case.
+ ;; * :FORTHCOMING-DEFCLASS-TYPE, which is an internal-to-the-compiler
+ ;; note that we don't try to report.
+ ;; * NIL, in which case there's nothing to see here, move along.
+ (when (eq (info :type :kind x) :defined)
+ (format s "~@:_It names a type specifier."))
(let ((symbol-named-class (cl:find-class x nil)))
(when symbol-named-class
- (format t "~&It names a class ~A." symbol-named-class)
- (describe symbol-named-class))))
+ (format s "~@:_It names a class ~A." symbol-named-class)
+ (describe symbol-named-class s))))