(!begin-collecting-cold-init-forms)
\f
-;;; 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.)
-;;;
-;;; 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."
- (%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.
;;;
-;;; 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.
+;;;
+;;; KLUDGE: This should probably be a type method instead of a big
+;;; ETYPECASE. But then the type method system should probably be CLOS
+;;; too, and until that happens wedging more stuff into it might be
+;;; messy. So I've left it a big ETYPECASE. -- 2001-03-16
(defun ctypep (obj type)
(declare (type ctype type))
(etypecase type
((or numeric-type
- named-type
- member-type
- array-type
- sb!xc:built-in-class
- cons-type)
+ named-type
+ member-type
+ array-type
+ character-set-type
+ built-in-classoid
+ cons-type
+ #!+sb-simd-pack simd-pack-type)
(values (%typep obj type) t))
- (sb!xc:class
- (if (if (csubtypep type (specifier-type 'funcallable-instance))
- (funcallable-instance-p obj)
- (typep obj 'instance))
- (if (eq (class-layout type)
- (info :type :compiler-layout (sb!xc:class-name type)))
- (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))))))
- (function-type
+ (classoid
+ (if (if (csubtypep type (specifier-type 'function))
+ (funcallable-instance-p obj)
+ (%instancep obj))
+ (if (eq (classoid-layout type)
+ (info :type :compiler-layout (classoid-name type)))
+ (values (sb!xc:typep obj type) t)
+ (values nil nil))
+ (values nil t)))
+ (compound-type
+ (funcall (etypecase type
+ (intersection-type #'every/type)
+ (union-type #'any/type))
+ #'ctypep
+ obj
+ (compound-type-types 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))
- (symbol (if (consp hairy-spec) (car hairy-spec) hairy-spec)))
+ (symbol (if (consp hairy-spec) (car hairy-spec) hairy-spec)))
(ecase symbol
- (and
- (if (atom hairy-spec)
- (values t t)
- (dolist (spec (cdr hairy-spec) (values t t))
- (multiple-value-bind (res win)
- (ctypep obj (specifier-type spec))
- (unless win (return (values nil nil)))
- (unless res (return (values nil t)))))))
- (not
- (multiple-value-bind (res win)
- (ctypep obj (specifier-type (cadr hairy-spec)))
- (if win
- (values (not res) t)
- (values nil nil))))
- (satisfies
- ;; KLUDGE: This stuff might well blow up if we tried to execute it
- ;; when cross-compiling. But since for the foreseeable future the
- ;; only code we'll try to cross-compile is SBCL itself, and SBCL is
- ;; built without using SATISFIES types, it's arguably not important
- ;; to worry about this. -- WHN 19990210.
- (let ((fun (second hairy-spec)))
- (cond ((and (consp fun)
- (eq (car fun) 'lambda))
- (values (not (null (funcall (coerce fun 'function) obj)))
- t))
- ((and (symbolp fun) (fboundp fun))
- (values (not (null (funcall fun obj))) t))
- (t
- (values nil nil))))))))))
+ (and
+ (if (atom hairy-spec)
+ (values t t)
+ (dolist (spec (cdr hairy-spec) (values t t))
+ (multiple-value-bind (res win)
+ (ctypep obj (specifier-type spec))
+ (unless win (return (values nil nil)))
+ (unless res (return (values nil t)))))))
+ (not
+ (multiple-value-bind (res win)
+ (ctypep obj (specifier-type (cadr hairy-spec)))
+ (if win
+ (values (not res) t)
+ (values nil nil))))
+ (satisfies
+ ;; 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)))))))))
\f
-;;; LAYOUT-OF -- Exported
-;;;
-;;; Return the layout for an object. This is the basic operation for
-;;; finding out the "type" of an object, and is used for generic function
-;;; dispatch. The standard doesn't seem to say as much as it should about what
-;;; this returns for built-in objects. For example, it seems that we must
-;;; return NULL rather than LIST when X is NIL so that GF's can specialize on
-;;; NULL.
+;;; Return the layout for an object. This is the basic operation for
+;;; finding out the "type" of an object, and is used for generic
+;;; function dispatch. The standard doesn't seem to say as much as it
+;;; should about what this returns for built-in objects. For example,
+;;; it seems that we must return NULL rather than LIST when X is NIL
+;;; so that GF's can specialize on NULL.
#!-sb-fluid (declaim (inline layout-of))
(defun layout-of (x)
(declare (optimize (speed 3) (safety 0)))
- (cond ((typep x 'instance) (%instance-layout x))
- ((funcallable-instance-p x) (%funcallable-instance-layout x))
- ((null x)
- ;; 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 it 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 sb!xc:find-class))
- (class-layout (sb!xc:find-class 'null))))
- (t (svref *built-in-class-codes* (get-type x)))))
+ (cond ((%instancep x) (%instance-layout x))
+ ((funcallable-instance-p x) (%funcallable-instance-layout x))
+ ((null x)
+ ;; 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.
+ ;;
+ ;; 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 sb!xc:class-of))
-(defun sb!xc:class-of (object)
+#!-sb-fluid (declaim (inline classoid-of))
+(defun classoid-of (object)
#!+sb-doc
"Return the class of the supplied object, which may be any Lisp object, not
just a CLOS STANDARD-OBJECT."
- (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)))))))
+ (layout-classoid (layout-of object)))
\f
;;;; miscellaneous interfaces
;;; 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
- values-type-union-cache-clear
- type-union-cache-clear
- values-subtypep-cache-clear
- csubtypep-cache-clear
- type-intersection-cache-clear
- values-type-intersection-cache-clear))
- (funcall (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))
-;;; 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))
- :hash-bits 9
- :init-wrapper !cold-init-forms)
- ((x eq))
+ :hash-function (lambda (x) (logand (sxhash x) #x1FF))
+ :hash-bits 9
+ :init-wrapper !cold-init-forms)
+ ((x eq))
(typecase x
(function
(if (funcallable-instance-p x)
- (sb!xc:class-of x)
- (extract-function-type x)))
+ (classoid-of x)
+ (specifier-type (sb!impl::%fun-type x))))
(symbol
(make-member-type :members (list x)))
(number
- (let* ((num (if (complexp x) (realpart x) x))
- (res (make-numeric-type
- :class (etypecase num
- (integer 'integer)
- (rational 'rational)
- (float 'float))
- :format (if (floatp num)
- (float-format-name num)
- nil))))
- (cond ((complexp x)
- (setf (numeric-type-complexp res) :complex)
- (let ((imag (imagpart x)))
- (setf (numeric-type-low res) (min num imag))
- (setf (numeric-type-high res) (max num imag))))
- (t
- (setf (numeric-type-low res) num)
- (setf (numeric-type-high res) num)))
- res))
+ (ctype-of-number x))
(array
(let ((etype (specifier-type (array-element-type x))))
(make-array-type :dimensions (array-dimensions x)
- :complexp (not (typep x 'simple-array))
- :element-type etype
- :specialized-element-type etype)))
+ :complexp (not (typep x 'simple-array))
+ :element-type etype
+ :specialized-element-type etype)))
(cons
(make-cons-type *universal-type* *universal-type*))
+ (character
+ (specifier-type 'character))
+ #!+sb-simd-pack
+ (simd-pack
+ (let ((type (nth (%simd-pack-tag x) *simd-pack-element-types*)))
+ (if type
+ (specifier-type `(simd-pack ,type))
+ (specifier-type 'simd-pack))))
(t
- (sb!xc:class-of x))))
-
-;;; Clear this cache on GC so that we don't hold onto too much garbage.
-(pushnew 'ctype-of-cache-clear *before-gc-hooks*)
+ (classoid-of x))))
\f
(!defun-from-collected-cold-init-forms !target-type-cold-init)
projects / sbcl.git / blobdiff