X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2Fcode%2Ftarget-type.lisp;h=7ebfccf60fdd2f34a0efab47e6f467167b9dac90;hb=ce02ab2ecd9c6ae2e570abd8c93ebf3be55bbdad;hp=1e240305ca1850fd47382cf6098e0d31f0949389;hpb=3aff5655417da74a19ce576f55b2cb6999cda6c5;p=sbcl.git

diff --git a/src/code/target-type.lisp b/src/code/target-type.lisp
index 1e24030..7ebfccf 100644
--- a/src/code/target-type.lisp
+++ b/src/code/target-type.lisp
@@ -19,11 +19,6 @@
 ;;; 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.)
-;;;
-;;; KLUDGE: In classic CMU CL this was wrapped in a (DECLAIM (START-BLOCK
-;;; TYPEP %TYPEP CLASS-CELL-TYPEP)) to make calls efficient. Once I straighten
-;;; out bootstrapping and cross-compiling issues it'd likely be a good idea to
-;;; do this again. -- WHN 19990413
 (defun typep (object type)
   #!+sb-doc
   "Return T iff OBJECT is of type TYPE."
@@ -33,10 +28,10 @@
 ;;; return whether the object is of that type as the first value and
 ;;; second value true. Otherwise return NIL, NIL.
 ;;;
-;;; We give up on unknown types and pick off FUNCTION and UNION types.
-;;; For structure types, we require that the type be defined in both
-;;; the current and compiler environments, and that the INCLUDES be
-;;; the same.
+;;; We give up on unknown types and pick off FUNCTION- and COMPOUND-
+;;; types. For STRUCTURE- types, we require that the type be defined
+;;; in both the current and compiler environments, and that the
+;;; INCLUDES be the same.
 (defun ctypep (obj type)
   (declare (type ctype type))
   (etypecase type
@@ -44,7 +39,8 @@
 	 named-type
 	 member-type
 	 array-type
-	 sb!xc:built-in-class)
+	 sb!xc:built-in-class
+	 cons-type)
      (values (%typep obj type) t))
     (sb!xc:class
      (if (if (csubtypep type (specifier-type 'funcallable-instance))
@@ -55,11 +51,30 @@
 	     (values (sb!xc:typep obj type) t)
 	     (values nil nil))
 	 (values nil t)))
-    (union-type
-     (dolist (mem (union-type-types type) (values nil t))
-       (multiple-value-bind (val win) (ctypep obj mem)
-	 (unless win (return (values nil nil)))
-	 (when val (return (values t t))))))
+    (compound-type
+     (let ((certain? t))
+       (etypecase type
+	 ;; FIXME: The cases here are very similar to #'EVERY/TYPE and
+	 ;; #'ANY/TYPE. It would be good to fix them so that they
+	 ;; share the same code. (That will require making sure that
+	 ;; the two-value return convention for CTYPEP really is
+	 ;; exactly compatible with the two-value convention the
+	 ;; quantifier/TYPE functions operate on, and probably also
+	 ;; making sure that things are inlined and defined early
+	 ;; enough that consing can be avoided.)
+	 (union-type
+	  (dolist (mem (union-type-types type) (values nil certain?))
+	    (multiple-value-bind (val win) (ctypep obj mem)
+	      (if win
+		  (when val (return (values t t)))
+		  (setf certain? nil)))))
+	 (intersection-type
+	  (dolist (mem (intersection-type-types type)
+		       (if certain? (values t t) (values nil nil)))
+	    (multiple-value-bind (val win) (ctypep obj mem)
+	      (if win
+		  (unless val (return (values nil t)))
+		  (setf certain? nil))))))))
     (function-type
      (values (functionp obj) t))
     (unknown-type
@@ -146,8 +161,8 @@
 
 ;;;; miscellaneous interfaces
 
-;;; Clear memoization of all type system operations that can be altered by
-;;; type definition/redefinition.
+;;; Clear memoization of all type system operations that can be
+;;; altered by type definition/redefinition.
 (defun clear-type-caches ()
   (when *type-system-initialized*
     (dolist (sym '(values-specifier-type-cache-clear
@@ -155,14 +170,15 @@
 		   type-union-cache-clear
 		   values-subtypep-cache-clear
 		   csubtypep-cache-clear
-		   type-intersection-cache-clear
+		   type-intersection2-cache-clear
 		   values-type-intersection-cache-clear))
       (funcall (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.
+;;; 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))
@@ -201,6 +217,8 @@
 			:complexp (not (typep x 'simple-array))
 			:element-type etype
 			:specialized-element-type etype)))
+    (cons
+     (make-cons-type *universal-type* *universal-type*))
     (t
      (sb!xc:class-of x))))