X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcode%2Ftarget-type.lisp;h=bae3258de5880a65a3ab6c1d8dd649319b26bf36;hb=58ff25d134554f86b15d1978ae21861ccbe70f3d;hp=0a9e0680e4fef14fab95f94a6641155a9a99ac5d;hpb=334af30b26555f0bf706f7157b399bdbd4fad548;p=sbcl.git

diff --git a/src/code/target-type.lisp b/src/code/target-type.lisp
index 0a9e068..bae3258 100644
--- a/src/code/target-type.lisp
+++ b/src/code/target-type.lisp
@@ -13,17 +13,6 @@
 
 (!begin-collecting-cold-init-forms)
 
-;;; Just call %TYPEP.
-;;;
-;;; Note that when cross-compiling, SB!XC:TYPEP is interpreted as
-;;; a test that the host Lisp object OBJECT translates to a target SBCL
-;;; type TYPE. (This behavior is needed e.g. to test for the validity of
-;;; numeric subtype bounds read when cross-compiling.)
-(defun typep (object type)
-  #!+sb-doc
-  "Return T iff OBJECT is of type TYPE."
-  (%typep object type))
-
 ;;; If TYPE is a type that we can do a compile-time test on, then
 ;;; return whether the object is of that type as the first value and
 ;;; second value true. Otherwise return NIL, NIL.
@@ -63,12 +52,18 @@
 	      #'ctypep
 	      obj
 	      (compound-type-types type)))
-    (function-type
+    (fun-type
      (values (functionp obj) t))
     (unknown-type
      (values nil nil))
     (alien-type-type
      (values (alien-typep obj (alien-type-type-alien-type type)) t))
+    (negation-type
+     (multiple-value-bind (res win)
+	 (ctypep obj (negation-type-type type))
+       (if win
+	   (values (not res) t)
+	   (values nil nil))))
     (hairy-type
      ;; Now the tricky stuff.
      (let* ((hairy-spec (hairy-type-specifier type))
@@ -92,7 +87,26 @@
 	  (let ((predicate-name (second hairy-spec)))
 	    (declare (type symbol predicate-name)) ; by ANSI spec of SATISFIES
 	    (if (fboundp predicate-name)
-		(values (not (null (funcall predicate-name obj))) t)
+		(let* (;; "Is OBJ of the SATISFIES type?" represented
+		       ;; as a generalized boolean.
+		       ;;
+		       ;; (Why IGNORE-ERRORS? This code is used to try to
+		       ;; check type relationships at compile time. 
+		       ;; Passing only-slightly-twisted types like
+		       ;; (AND INTEGER (SATISFIES ODDP)) into the
+		       ;; rather-significantly-twisted type dispatch
+		       ;; system can easily give rise to oddities like
+		       ;; calling predicates like ODDP on values they
+		       ;; don't like. (E.g. on OBJ=#\NEWLINE when the
+		       ;; above type is tested for TYPE= against
+		       ;; STANDARD-CHAR, represented as a
+		       ;; MEMBER-TYPE.) In such cases, NIL seems to be
+		       ;; an appropriate answer to "is OBJ of the
+		       ;; SATISFIES type?")
+		       (gbool (ignore-errors (funcall predicate-name obj)))
+		       ;; RAW coerced to a pure BOOLEAN value
+		       (bool (not (not gbool))))
+		  (values bool t))
 		(values nil nil)))))))))
 
 ;;; Return the layout for an object. This is the basic operation for
@@ -117,7 +131,7 @@
 	   ;; time), we need to suppress a DEFTRANSFORM.. -- WHN 19991004
 	   (declare (notinline sb!xc:find-class))
 	   (class-layout (sb!xc:find-class 'null))))
-	(t (svref *built-in-class-codes* (get-type x)))))
+	(t (svref *built-in-class-codes* (widetag-of x)))))
 
 #!-sb-fluid (declaim (inline sb!xc:class-of))
 (defun sb!xc:class-of (object)
@@ -127,14 +141,8 @@
   (layout-class (layout-of object)))
 
 ;;; Pull the type specifier out of a function object.
-(defun extract-function-type (fun)
-  (if (sb!eval:interpreted-function-p fun)
-      (sb!eval:interpreted-function-type fun)
-      (typecase fun
-	(byte-function (byte-function-type fun))
-	(byte-closure (byte-function-type (byte-closure-function fun)))
-	(t
-	 (specifier-type (%function-type (%closure-function fun)))))))
+(defun extract-fun-type (fun)
+  (specifier-type (%simple-fun-type (%closure-fun fun))))
 
 ;;;; miscellaneous interfaces
 
@@ -149,13 +157,13 @@
 		   csubtypep-cache-clear
 		   type-intersection2-cache-clear
 		   values-type-intersection-cache-clear))
-      (funcall (symbol-function sym))))
+      (funcall (the function (symbol-function sym)))))
   (values))
 
-;;; Like TYPE-OF, only we return a CTYPE structure instead of a type
-;;; specifier, and we try to return the type most useful for type
-;;; checking, rather than trying to come up with the one that the user
-;;; might find most informative.
+;;; This is like TYPE-OF, only we return a CTYPE structure instead of
+;;; a type specifier, and we try to return the type most useful for
+;;; type checking, rather than trying to come up with the one that the
+;;; user might find most informative.
 (declaim (ftype (function (t) ctype) ctype-of))
 (defun-cached (ctype-of
 	       :hash-function (lambda (x) (logand (sxhash x) #x1FF))
@@ -166,7 +174,7 @@
     (function
      (if (funcallable-instance-p x)
 	 (sb!xc:class-of x)
-	 (extract-function-type x)))
+	 (extract-fun-type x)))
     (symbol
      (make-member-type :members (list x)))
     (number