X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcode%2Fdescribe.lisp;h=35971bc5bd863b5282ee8b6b25dcb56bfcc334ce;hb=d40a76606c86722b0aef8179155f9f2840739b72;hp=d6098e44231696baf891d1313cbb6e57332f9c9a;hpb=be9eb6c67b5f43a095c3de17bea945c309d662e4;p=sbcl.git

diff --git a/src/code/describe.lisp b/src/code/describe.lisp
index d6098e4..35971bc 100644
--- a/src/code/describe.lisp
+++ b/src/code/describe.lisp
@@ -36,9 +36,9 @@
 
 (defmethod describe-object ((x cons) s)
   (call-next-method)
-  (when (and (legal-function-name-p x)
+  (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
@@ -110,8 +110,8 @@
 ;;; up as a name. (In the case of anonymous closures and other
 ;;; things, it might not be.) TYPE-SPEC is the function type specifier
 ;;; extracted from the definition, or NIL if none.
-(declaim (ftype (function (t stream t)) %describe-function-name))
-(defun %describe-function-name (name s type-spec) 
+(declaim (ftype (function (t stream t)) %describe-fun-name))
+(defun %describe-fun-name (name s type-spec) 
   (when (and name (typep name '(or symbol cons)))
     (multiple-value-bind (type where)
 	(if (or (symbolp name) (and (listp name) (eq (car name) 'setf)))
@@ -127,7 +127,7 @@
 	(format s
 		"~@:_It is currently declared ~(~A~);~
 		 ~:[no~;~] expansion is available."
-		inlinep (info :function :inline-expansion name))))))
+		inlinep (info :function :inline-expansion-designator name))))))
 
 ;;; Print information from the debug-info about where CODE-OBJ was
 ;;; compiled from.
@@ -156,16 +156,16 @@
 
 ;;; 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 %FUNCTION-ARGLIST results, and the
+  ;; 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 %FUNCTION-ARGLIST a string instead of a
+  ;; arguments." (And why is %SIMPLE-FUN-ARGLIST a string instead of a
   ;; list of symbols anyway?)
-  (let ((args (%function-arglist x)))
+  (let ((args (%simple-fun-arglist x)))
     (format s "~@:_~@(~@[~A ~]arguments:~@:_~)" kind)
     (cond ((not args)
 	   (format s "  There is no argument information available."))
@@ -176,16 +176,16 @@
 	   (pprint-logical-block (s nil)
 	     (pprint-indent :current 2)
 	     (write-string args s)))))
-  (let ((name (or name (%function-name x))))
+  (let ((name (or name (%simple-fun-name x))))
     (%describe-doc name s 'function kind)
     (unless (eq kind :macro)
-      (%describe-function-name name s (%fun-type x))))
-  (%describe-compiled-from (sb-kernel:function-code-header x) s))
+      (%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)
+(defun %describe-fun (x s &optional (kind nil) name)
   (declare (type function x))
   (declare (type stream s))
   (declare (type (member :macro :function nil) kind))
@@ -194,17 +194,20 @@
     (:macro (format s "Macro-function: ~S" x))
     (:function (format s "Function: ~S" x))
     ((nil) (format s "~S is a function." x)))
-  (case (get-type x)
-    (#.sb-vm:closure-header-type
-     (%describe-function-compiled (%closure-function x) s kind name)
+  (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-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:function-header-type #.sb-vm:closure-function-header-type)
-     (%describe-function-compiled x s kind name))
-    (#.sb-vm:funcallable-instance-header-type
+    ((#.sb-vm:simple-fun-header-widetag #.sb-vm:closure-fun-header-widetag)
+     (%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
@@ -216,7 +219,7 @@
      (format s "~@:_It is an unknown type of function."))))
 
 (defmethod describe-object ((x function) s)
-  (%describe-function x s))
+  (%describe-fun x s))
   
 (defmethod describe-object ((x symbol) s)
   (declare (type stream s))
@@ -267,11 +270,11 @@
 
   ;; 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"))
 	((fboundp x)
-	 (%describe-function (fdefinition x) s :function x)))
+	 (%describe-fun (fdefinition x) s :function x)))
 
   ;; FIXME: Print out other stuff from the INFO database:
   ;;   * Does it name a type?