;;;; FIXME: I'm not sure where to put this. -- WHN 19990817
(def!type sb!vm:word () `(unsigned-byte ,sb!vm:n-word-bits))
+(def!type sb!vm:signed-word () `(signed-byte ,sb!vm:n-word-bits))
+
\f
;;;; implementation-dependent DEFTYPEs
(collect ((types (list 'or)))
(dolist (type *specialized-array-element-types*)
(when (subtypep type '(or integer character float (complex float)))
- (types `(array ,type ,dims))))
+ (types `(array ,type ,dims))))
(types)))
(sb!xc:deftype simple-unboxed-array (&optional dims)
(collect ((types (list 'or)))
(dolist (type *specialized-array-element-types*)
(when (subtypep type '(or integer character float (complex float)))
- (types `(simple-array ,type ,dims))))
+ (types `(simple-array ,type ,dims))))
(types)))
+(sb!xc:deftype complex-vector (&optional element-type length)
+ `(and (vector ,element-type ,length) (not simple-array)))
+
;;; Return the symbol that describes the format of FLOAT.
(declaim (ftype (function (float) symbol) float-format-name))
(defun float-format-name (x)
(defun specialize-array-type (type)
(let ((eltype (array-type-element-type type)))
(setf (array-type-specialized-element-type type)
- (if (or (eq eltype *wild-type*)
- ;; This is slightly dubious, but not as dubious as
- ;; assuming that the upgraded-element-type should be
- ;; equal to T, given the way that the AREF
- ;; DERIVE-TYPE optimizer works. -- CSR, 2002-08-19
- (unknown-type-p eltype))
- *wild-type*
- (dolist (stype-name *specialized-array-element-types*
- *universal-type*)
- ;; FIXME: Mightn't it be better to have
- ;; *SPECIALIZED-ARRAY-ELEMENT-TYPES* be stored as precalculated
- ;; SPECIFIER-TYPE results, instead of having to calculate
- ;; them on the fly this way? (Call the new array
- ;; *SPECIALIZED-ARRAY-ELEMENT-SPECIFIER-TYPES* or something..)
- (let ((stype (specifier-type stype-name)))
- (aver (not (unknown-type-p stype)))
- (when (csubtypep eltype stype)
- (return stype))))))
+ (if (or (eq eltype *wild-type*)
+ ;; This is slightly dubious, but not as dubious as
+ ;; assuming that the upgraded-element-type should be
+ ;; equal to T, given the way that the AREF
+ ;; DERIVE-TYPE optimizer works. -- CSR, 2002-08-19
+ (unknown-type-p eltype))
+ *wild-type*
+ (dolist (stype-name *specialized-array-element-types*
+ *universal-type*)
+ ;; FIXME: Mightn't it be better to have
+ ;; *SPECIALIZED-ARRAY-ELEMENT-TYPES* be stored as precalculated
+ ;; SPECIFIER-TYPE results, instead of having to calculate
+ ;; them on the fly this way? (Call the new array
+ ;; *SPECIALIZED-ARRAY-ELEMENT-SPECIFIER-TYPES* or something..)
+ (let ((stype (specifier-type stype-name)))
+ (aver (not (unknown-type-p stype)))
+ (when (csubtypep eltype stype)
+ (return stype))))))
type))
(defun sb!xc:upgraded-array-element-type (spec &optional environment)
(if (unknown-type-p (specifier-type spec))
(error "undefined type: ~S" spec)
(type-specifier (array-type-specialized-element-type
- (specifier-type `(array ,spec))))))
+ (specifier-type `(array ,spec))))))
(defun sb!xc:upgraded-complex-part-type (spec &optional environment)
#!+sb-doc
;;; includes the given type.
(defun containing-integer-type (subtype)
(dolist (type '(fixnum
- (signed-byte 32)
- (unsigned-byte 32)
- integer)
- (error "~S isn't an integer type?" subtype))
+ (signed-byte 32)
+ (unsigned-byte 32)
+ integer)
+ (error "~S isn't an integer type?" subtype))
(when (csubtypep subtype (specifier-type type))
(return type))))
(typecase type
(cons-type
(if (type= type (specifier-type 'cons))
- 'sb!c:check-cons
- nil))
+ 'sb!c:check-cons
+ nil))
(built-in-classoid
(if (type= type (specifier-type 'symbol))
- 'sb!c:check-symbol
- nil))
+ 'sb!c:check-symbol
+ nil))
(numeric-type
(cond ((type= type (specifier-type 'fixnum))
- 'sb!c:check-fixnum)
- ((type= type (specifier-type '(signed-byte 32)))
- 'sb!c:check-signed-byte-32)
- ((type= type (specifier-type '(unsigned-byte 32)))
- 'sb!c:check-unsigned-byte-32)
- (t nil)))
+ 'sb!c:check-fixnum)
+ #!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
+ ((type= type (specifier-type '(signed-byte 32)))
+ 'sb!c:check-signed-byte-32)
+ #!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
+ ((type= type (specifier-type '(unsigned-byte 32)))
+ 'sb!c:check-unsigned-byte-32)
+ #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
+ ((type= type (specifier-type '(signed-byte 64)))
+ 'sb!c:check-signed-byte-64)
+ #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
+ ((type= type (specifier-type '(unsigned-byte 64)))
+ 'sb!c:check-unsigned-byte-64)
+ (t nil)))
(fun-type
'sb!c:check-fun)
(t