array-type
character-set-type
built-in-classoid
- cons-type)
+ cons-type
+ #!+sb-simd-pack simd-pack-type)
(values (%typep obj type) t))
(classoid
(if (if (csubtypep type (specifier-type 'function))
(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)))))))))
\f
;;; Return the layout for an object. This is the basic operation for
;;; finding out the "type" of an object, and is used for generic
"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))))
\f
;;;; 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
(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
(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
(classoid-of x))))
\f