(!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.)
-(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.
#'ctypep
obj
(compound-type-types type)))
- (function-type
+ (fun-type
(values (functionp obj) t))
(unknown-type
(values nil nil))
(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)))))))))
\f
;;; Return the layout for an object. This is the basic operation for
;; 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)
(layout-class (layout-of object)))
;;; Pull the type specifier out of a function object.
-(defun extract-function-type (fun)
- (typecase fun
- ;; FIXME: byte compiler to be deleted completely
- #|
- (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))))
\f
;;;; miscellaneous interfaces
(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.
+;;; 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))
(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