;;;
;;; RATIO and BIGNUM are not recognized as numeric types.
-;;; FIXME: It seems to me that this should be set to NIL by default,
-;;; and perhaps not even optionally set to T.
-(defvar *use-implementation-types* t
+;;; FIXME: This really should go away. Alas, it doesn't seem to be so
+;;; simple to make it go away.. (See bug 123 in BUGS file.)
+(defvar *use-implementation-types* t ; actually initialized in cold init
#!+sb-doc
"*USE-IMPLEMENTATION-TYPES* is a semi-public flag which determines how
restrictive we are in determining type membership. If two types are the
this switch is on. When it is off, we try to be as restrictive as the
language allows, allowing us to detect more errors. Currently, this only
affects array types.")
-
(!cold-init-forms (setq *use-implementation-types* t))
;;; These functions are used as method for types which need a complex
;;; a flag that we can bind to cause complex function types to be
;;; unparsed as FUNCTION. This is useful when we want a type that we
;;; can pass to TYPEP.
-(defvar *unparse-function-type-simplify*)
-(!cold-init-forms (setq *unparse-function-type-simplify* nil))
+(defvar *unparse-fun-type-simplify*)
+(!cold-init-forms (setq *unparse-fun-type-simplify* nil))
(!define-type-method (function :unparse) (type)
- (if *unparse-function-type-simplify*
+ (if *unparse-fun-type-simplify*
'function
(list 'function
- (if (function-type-wild-args type)
+ (if (fun-type-wild-args type)
'*
(unparse-args-types type))
(type-specifier
- (function-type-returns type)))))
+ (fun-type-returns type)))))
;;; Since all function types are equivalent to FUNCTION, they are all
;;; subtypes of each other.
(result)))
(!def-type-translator function (&optional (args '*) (result '*))
- (let ((res (make-function-type
- :returns (values-specifier-type result))))
+ (let ((res (make-fun-type :returns (values-specifier-type result))))
(if (eq args '*)
- (setf (function-type-wild-args res) t)
+ (setf (fun-type-wild-args res) t)
(parse-args-types args res))
res))
;;; Return the minimum number of arguments that a function can be
;;; called with, and the maximum number or NIL. If not a function
;;; type, return NIL, NIL.
-(defun function-type-nargs (type)
+(defun fun-type-nargs (type)
(declare (type ctype type))
- (if (function-type-p type)
+ (if (fun-type-p type)
(let ((fixed (length (args-type-required type))))
(if (or (args-type-rest type)
(args-type-keyp type)
(defvar *wild-type*)
(defvar *empty-type*)
(defvar *universal-type*)
-
+(defvar *universal-fun-type*)
(!cold-init-forms
(macrolet ((frob (name var)
`(progn
;; Ts and *UNIVERSAL-TYPE*s.
(frob * *wild-type*)
(frob nil *empty-type*)
- (frob t *universal-type*)))
+ (frob t *universal-type*))
+ (setf *universal-fun-type*
+ (make-fun-type :wild-args t
+ :returns *wild-type*)))
(!define-type-method (named :simple-=) (type1 type2)
;; FIXME: BUG 85: This assertion failed when I added it in
(type=-set (intersection-type-types type1)
(intersection-type-types type2)))
-(flet ((intersection-complex-subtypep-arg1 (type1 type2)
- (any/type (swapped-args-fun #'csubtypep)
- type2
- (intersection-type-types type1))))
- (!define-type-method (intersection :simple-subtypep) (type1 type2)
- (every/type #'intersection-complex-subtypep-arg1
- type1
- (intersection-type-types type2)))
- (!define-type-method (intersection :complex-subtypep-arg1) (type1 type2)
- (intersection-complex-subtypep-arg1 type1 type2)))
+(defun %intersection-complex-subtypep-arg1 (type1 type2)
+ (any/type (swapped-args-fun #'csubtypep)
+ type2
+ (intersection-type-types type1)))
+
+(!define-type-method (intersection :simple-subtypep) (type1 type2)
+ (every/type #'%intersection-complex-subtypep-arg1
+ type1
+ (intersection-type-types type2)))
+
+(!define-type-method (intersection :complex-subtypep-arg1) (type1 type2)
+ (%intersection-complex-subtypep-arg1 type1 type2))
(!define-type-method (intersection :complex-subtypep-arg2) (type1 type2)
(every/type #'csubtypep type1 (intersection-type-types type2)))
;; that an object of type FUNCTION doesn't satisfy it, so
;; we return success no matter what.
t)
- (;; Otherwise both of them must be FUNCTION-TYPE objects.
+ (;; Otherwise both of them must be FUN-TYPE objects.
t
;; FIXME: For now we only check compatibility of the return
;; type, not argument types, and we don't even check the
;; compatibility of the arguments, we should (1) redo
;; VALUES-TYPES-EQUAL-OR-INTERSECT as
;; ARGS-TYPES-EQUAL-OR-INTERSECT, and then (2) apply it to
- ;; the ARGS-TYPE slices of the FUNCTION-TYPEs. (ARGS-TYPE
- ;; is a base class both of VALUES-TYPE and of FUNCTION-TYPE.)
+ ;; the ARGS-TYPE slices of the FUN-TYPEs. (ARGS-TYPE
+ ;; is a base class both of VALUES-TYPE and of FUN-TYPE.)
(values-types-equal-or-intersect
- (function-type-returns defined-ftype)
- (function-type-returns declared-ftype))))))
+ (fun-type-returns defined-ftype)
+ (fun-type-returns declared-ftype))))))
;;; This messy case of CTYPE for NUMBER is shared between the
;;; cross-compiler and the target system.
:low low
:high high))))
\f
-(!defun-from-collected-cold-init-forms !late-type-cold-init)
+(locally
+ ;; Why SAFETY 0? To suppress the is-it-the-right-structure-type
+ ;; checking for declarations in structure accessors. Otherwise we
+ ;; can get caught in a chicken-and-egg bootstrapping problem, whose
+ ;; symptom on x86 OpenBSD sbcl-0.pre7.37.flaky5.22 is an illegal
+ ;; instruction trap. I haven't tracked it down, but I'm guessing it
+ ;; has to do with setting LAYOUTs when the LAYOUT hasn't been set
+ ;; yet. -- WHN
+ (declare (optimize (safety 0)))
+ (!defun-from-collected-cold-init-forms !late-type-cold-init))
(/show0 "late-type.lisp end of file")
projects / sbcl.git / blobdiff