X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcode%2Ftarget-type.lisp;h=5bff4bd413353764657785ff4d4685d2ba36662d;hb=d90c8a75da90925a51a587f7bd4d9c494256f68a;hp=321d0a420ac8c9272b613a25ccce6a85a559e1f7;hpb=0aecc2b20142e08068c3434273500131cb13fe2d;p=sbcl.git

diff --git a/src/code/target-type.lisp b/src/code/target-type.lisp
index 321d0a4..5bff4bd 100644
--- a/src/code/target-type.lisp
+++ b/src/code/target-type.lisp
@@ -85,30 +85,11 @@
                 (values (not res) t)
                 (values nil nil))))
          (satisfies
-          (let ((predicate-name (second hairy-spec)))
-            (declare (type symbol predicate-name)) ; by ANSI spec of SATISFIES
-            (if (fboundp predicate-name)
-                (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)))))))))
+          ;; If the SATISFIES function is not foldable, we cannot answer!
+          (let* ((form `(,(second hairy-spec) ',obj)))
+            (multiple-value-bind (ok result)
+                (sb!c::constant-function-call-p form nil nil)
+              (values (not (null result)) ok)))))))))
 
 ;;; Return the layout for an object. This is the basic operation for
 ;;; finding out the "type" of an object, and is used for generic
@@ -125,13 +106,16 @@
          ;; Note: was #.((CLASS-LAYOUT (SB!XC:FIND-CLASS 'NULL))).
          ;; I (WHN 19990209) replaced this with an expression evaluated at
          ;; run time in order to make it easier to build the cross-compiler.
-         ;; If it doesn't work, something else will be needed..
-         (locally
-           ;; KLUDGE: In order to really make this run at run time
-           ;; (instead of doing some weird broken thing at cold load
-           ;; time), we need to suppress a DEFTRANSFORM.. -- WHN 19991004
-           (declare (notinline find-classoid))
-           (classoid-layout (find-classoid 'null))))
+         ;;
+         ;; KLUDGE: Since there's a DEFTRANSFORM for FIND-CLASSOID on
+         ;; constant names which creates non-cold-loadable code, we
+         ;; can't just use (CLASSOID-LAYOUT (FIND-CLASSOID 'NULL))
+         ;; here. The original (WHN 19991004) solution was to locally
+         ;; notinline FIND-CLASSOID. However, the full call to
+         ;; FIND-CLASSOID caused suboptimal register allocation in PCL
+         ;; dfuns. So instead we now use a special variable which is
+         ;; initialized during cold init. -- JES, 2006-07-04
+         *null-classoid-layout*)
         (t (svref *built-in-class-codes* (widetag-of x)))))
 
 #!-sb-fluid (declaim (inline classoid-of))
@@ -140,29 +124,17 @@
   "Return the class of the supplied object, which may be any Lisp object, not
    just a CLOS STANDARD-OBJECT."
   (layout-classoid (layout-of object)))
-
-;;; Pull the type specifier out of a function object.
-(defun extract-fun-type (fun)
-  (specifier-type (%simple-fun-type (%closure-fun fun))))
 
 ;;;; miscellaneous interfaces
 
 ;;; Clear memoization of all type system operations that can be
 ;;; altered by type definition/redefinition.
 ;;;
-;;; FIXME: This should be autogenerated.
 (defun clear-type-caches ()
-  (declare (special *type-system-initialized*))
-  (when *type-system-initialized*
-    (dolist (sym '(values-specifier-type-cache-clear
-                   values-type-union-cache-clear
-                   type-union2-cache-clear
-                   values-subtypep-cache-clear
-                   csubtypep-cache-clear
-                   type-intersection2-cache-clear
-                   values-type-intersection-cache-clear
-                   type=-cache-clear))
-      (funcall (the function (symbol-function sym)))))
+  ;; FIXME: We would like to differentiate between different cache
+  ;; kinds, but at the moment all our caches pretty much are type
+  ;; caches.
+  (drop-all-hash-caches)
   (values))
 
 ;;; This is like TYPE-OF, only we return a CTYPE structure instead of
@@ -179,7 +151,7 @@
     (function
      (if (funcallable-instance-p x)
          (classoid-of x)
-         (extract-fun-type x)))
+         (specifier-type (sb!impl::%fun-type x))))
     (symbol
      (make-member-type :members (list x)))
     (number