(in-package "SB!KERNEL")
-(file-comment
- "$Header$")
+(/show0 "vm-type.lisp 17")
(!begin-collecting-cold-init-forms)
\f
;;;; FIXME: I'm not sure where to put this. -- WHN 19990817
-(deftype sb!vm:word () `(unsigned-byte ,sb!vm:word-bits))
+(deftype sb!vm:word () `(unsigned-byte ,sb!vm:n-word-bits))
\f
;;;; implementation-dependent DEFTYPEs
-;;; Make DOUBLE-FLOAT a synonym for LONG-FLOAT, SINGLE-FLOAT for SHORT-FLOAT.
-;;; This is expanded before the translator gets a chance, so we will get
-;;; precedence.
+;;; Make DOUBLE-FLOAT a synonym for LONG-FLOAT, SINGLE-FLOAT for
+;;; SHORT-FLOAT. This is expanded before the translator gets a chance,
+;;; so we will get precedence.
#!-long-float
(setf (info :type :kind 'long-float) :defined)
#!-long-float
;;; internal time format. (Note: not a FIXNUM, ouch..)
(sb!xc:deftype internal-time () 'unsigned-byte)
-(sb!xc:deftype bignum-element-type () `(unsigned-byte ,sb!vm:word-bits))
+(sb!xc:deftype bignum-element-type () `(unsigned-byte ,sb!vm:n-word-bits))
(sb!xc:deftype bignum-type () 'bignum)
(sb!xc:deftype bignum-index () 'index)
\f
(defvar *specialized-array-element-types*)
(!cold-init-forms
(setf *specialized-array-element-types*
- '(bit
+ '(nil
+ bit
(unsigned-byte 2)
(unsigned-byte 4)
(unsigned-byte 8)
;;; This function is called when the type code wants to find out how
;;; an array will actually be implemented. We set the
-;;; Specialized-Element-Type to correspond to the actual
+;;; SPECIALIZED-ELEMENT-TYPE to correspond to the actual
;;; specialization used in this implementation.
(declaim (ftype (function (array-type) array-type) specialize-array-type))
(defun specialize-array-type (type)
(let ((eltype (array-type-element-type type)))
(setf (array-type-specialized-element-type type)
- (if (eq eltype *wild-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*
- ;; FIXME: Use *UNIVERSAL-TYPE* here?
- (specifier-type 't))
+ *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
(when (csubtypep subtype (specifier-type type))
(return type))))
-;;; If Type has a CHECK-xxx template, but doesn't have a corresponding
-;;; primitive-type, then return the template's name. Otherwise, return NIL.
+;;; If TYPE has a CHECK-xxx template, but doesn't have a corresponding
+;;; PRIMITIVE-TYPE, then return the template's name. Otherwise, return NIL.
(defun hairy-type-check-template-name (type)
(declare (type ctype type))
(typecase type
- (named-type
- (case (named-type-name type)
- (cons 'sb!c:check-cons)
- (symbol 'sb!c:check-symbol)
- (t nil)))
+ (cons-type
+ (if (type= type (specifier-type 'cons))
+ 'sb!c:check-cons
+ nil))
+ (built-in-classoid
+ (if (type= type (specifier-type 'symbol))
+ 'sb!c:check-symbol
+ nil))
(numeric-type
(cond ((type= type (specifier-type 'fixnum))
'sb!c:check-fixnum)
((type= type (specifier-type '(unsigned-byte 32)))
'sb!c:check-unsigned-byte-32)
(t nil)))
- (function-type
- 'sb!c:check-function)
+ (fun-type
+ 'sb!c:check-fun)
(t
nil)))
\f
(!defun-from-collected-cold-init-forms !vm-type-cold-init)
+
+(/show0 "vm-type.lisp end of file")