1 ;;;; cross-compiler-only versions of TYPEP, TYPE-OF, and related functions
3 ;;;; This software is part of the SBCL system. See the README file for
6 ;;;; This software is derived from the CMU CL system, which was
7 ;;;; written at Carnegie Mellon University and released into the
8 ;;;; public domain. The software is in the public domain and is
9 ;;;; provided with absolutely no warranty. See the COPYING and CREDITS
10 ;;;; files for more information.
12 (in-package "SB!KERNEL")
14 ;;; Is X a fixnum in the target Lisp?
17 (<= sb!xc:most-negative-fixnum x sb!xc:most-positive-fixnum)))
19 ;;; (This was a useful warning when trying to get bootstrapping
20 ;;; to work, but it's mostly irrelevant noise now that the system
22 (define-condition cross-type-style-warning (style-warning)
24 :reader cross-type-style-warning-call)
25 (message :reader cross-type-style-warning-message
26 #+cmu :initarg #+cmu :message ; (to stop bogus non-STYLE WARNING)
28 (:report (lambda (c s)
31 "cross-compilation-time type ambiguity (should be OK) in ~S:~%~A"
32 (cross-type-style-warning-call c)
33 (cross-type-style-warning-message c)))))
35 ;;; This warning is issued when giving up on a type calculation where a
36 ;;; conservative answer is acceptable. Since a conservative answer is
37 ;;; acceptable, the only downside is lost optimization opportunities.
38 (define-condition cross-type-giving-up-conservatively
39 (cross-type-style-warning)
40 ((message :initform "giving up conservatively"
41 #+cmu :reader #+cmu #.(gensym) ; (to stop bogus non-STYLE WARNING)
44 ;;; This warning refers to the flexibility in the ANSI spec with
45 ;;; regard to run-time distinctions between floating point types.
46 ;;; (E.g. the cross-compilation host might not even distinguish
47 ;;; between SINGLE-FLOAT and DOUBLE-FLOAT, so a DOUBLE-FLOAT number
48 ;;; would test positive as SINGLE-FLOAT.) If the target SBCL does make
49 ;;; this distinction, then information is lost. It's not too hard to
50 ;;; contrive situations where this would be a problem. In practice we
51 ;;; don't tend to run into them because all widely used Common Lisp
52 ;;; environments do recognize the distinction between SINGLE-FLOAT and
53 ;;; DOUBLE-FLOAT, and we don't really need the other distinctions
54 ;;; (e.g. between SHORT-FLOAT and SINGLE-FLOAT), so we call
55 ;;; WARN-POSSIBLE-CROSS-TYPE-FLOAT-INFO-LOSS to test at runtime
56 ;;; whether we need to worry about this at all, and not warn unless we
57 ;;; do. If we *do* have to worry about this at runtime, my (WHN
58 ;;; 19990808) guess is that the system will break in multiple places,
59 ;;; so this is a real WARNING, not just a STYLE-WARNING.
61 ;;; KLUDGE: If we ever try to support LONG-FLOAT or SHORT-FLOAT, this
62 ;;; situation will get a lot more complicated.
63 (defun warn-possible-cross-type-float-info-loss (call)
64 (when (or (subtypep 'single-float 'double-float)
65 (subtypep 'double-float 'single-float))
66 (warn "possible floating point information loss in ~S" call)))
68 (defun sb!xc:type-of (object)
69 (let ((raw-result (type-of object)))
70 (cond ((or (subtypep raw-result 'float)
71 (subtypep raw-result 'complex))
72 (warn-possible-cross-type-float-info-loss
73 `(sb!xc:type-of ,object))
75 ((subtypep raw-result 'integer)
76 (cond ((<= 0 object 1)
78 (;; We can't rely on the host's opinion of whether
79 ;; it's a FIXNUM, but instead test against target
80 ;; MOST-fooITIVE-FIXNUM limits.
85 ((subtypep raw-result 'simple-string)
86 `(simple-base-string ,(length object)))
87 ((subtypep raw-result 'string) 'base-string)
88 ((some (lambda (type) (subtypep raw-result type))
89 '(array character list symbol))
92 (error "can't handle TYPE-OF ~S in cross-compilation" object)))))
94 ;;; Is SYMBOL in the CL package? Note that we're testing this on the
95 ;;; cross-compilation host, which could do things any old way. In
96 ;;; particular, it might be in the CL package even though
97 ;;; SYMBOL-PACKAGE is not (FIND-PACKAGE :CL). So we test things
99 (defun in-cl-package-p (symbol)
100 (eql (find-symbol (symbol-name symbol) :cl)
103 ;;; This is like TYPEP, except that it asks whether HOST-OBJECT would
104 ;;; be of TARGET-TYPE when instantiated on the target SBCL. Since this
105 ;;; is hard to determine in some cases, and since in other cases we
106 ;;; just haven't bothered to try, it needs to return two values, just
107 ;;; like SUBTYPEP: the first value for its conservative opinion (never
108 ;;; T unless it's certain) and the second value to tell whether it's
110 (defun cross-typep (host-object raw-target-type)
111 (let ((target-type (typexpand raw-target-type)))
112 (flet ((warn-and-give-up ()
113 ;; We don't have to keep track of this as long as system
114 ;; performance is acceptable, since giving up
115 ;; conservatively is a safe way out.
117 (warn 'cross-type-giving-up-conservatively
118 :call `(cross-typep ,host-object ,raw-target-type))
120 (warn-about-possible-float-info-loss ()
121 (warn-possible-cross-type-float-info-loss
122 `(cross-typep ,host-object ,raw-target-type)))
123 ;; a convenient idiom for making more matches to special cases:
124 ;; Test both forms of target type for membership in LIST.
126 ;; (In order to avoid having to use too much deep knowledge
127 ;; of types, it's sometimes convenient to test RAW-TARGET-TYPE
128 ;; as well as the expanded type, since we can get matches with
129 ;; just EQL. E.g. SIMPLE-STRING can be matched with EQL, while
130 ;; safely matching its expansion,
131 ;; (OR (SIMPLE-ARRAY CHARACTER (*)) (SIMPLE-BASE-STRING *))
132 ;; would require logic clever enough to know that, e.g., OR is
134 (target-type-is-in (list)
135 (or (member raw-target-type list)
136 (member target-type list))))
137 (cond (;; Handle various SBCL-specific types which can't exist on
138 ;; the ANSI cross-compilation host. KLUDGE: This code will
139 ;; need to be tweaked by hand if the names of these types
141 (if (consp target-type)
142 (member (car target-type)
145 '(system-area-pointer
146 sb!alien-internals:alien-value)))
148 (;; special case when TARGET-TYPE isn't a type spec, but
149 ;; instead a CLASS object.
150 (typep target-type 'class)
151 (bug "We don't support CROSS-TYPEP of CLASS type specifiers"))
152 ((and (symbolp target-type)
153 (find-classoid target-type nil)
154 (sb!xc:subtypep target-type 'cl:structure-object)
155 (typep host-object '(or symbol number list character)))
157 ((and (symbolp target-type)
158 (find-class target-type nil)
159 (subtypep target-type 'sb!kernel::structure!object))
160 (values (typep host-object target-type) t))
161 (;; easy cases of arrays and vectors
163 '(array simple-string simple-vector string vector))
164 (values (typep host-object target-type) t))
165 (;; sequence is not guaranteed to be an exhaustive
166 ;; partition, but it includes at least lists and vectors.
167 (target-type-is-in '(sequence))
168 (if (or (vectorp host-object) (listp host-object))
170 (if (typep host-object target-type)
173 (;; general cases of vectors
174 (and (not (hairy-type-p (values-specifier-type target-type)))
175 (sb!xc:subtypep target-type 'cl:vector))
176 (if (vectorp host-object)
177 (warn-and-give-up) ; general-case vectors being way too hard
178 (values nil t))) ; but "obviously not a vector" being easy
179 (;; general cases of arrays
180 (and (not (hairy-type-p (values-specifier-type target-type)))
181 (sb!xc:subtypep target-type 'cl:array))
182 (if (arrayp host-object)
183 (warn-and-give-up) ; general-case arrays being way too hard
184 (values nil t))) ; but "obviously not an array" being easy
185 ((target-type-is-in '(*))
186 ;; KLUDGE: SBCL has * as an explicit wild type. While
187 ;; this is sort of logical (because (e.g. (ARRAY * 1)) is
188 ;; a valid type) it's not ANSI: looking at the ANSI
189 ;; definitions of complex types like like ARRAY shows
190 ;; that they consider * different from other type names.
191 ;; Someday we should probably get rid of this non-ANSIism
192 ;; in base SBCL, but until we do, we might as well here
193 ;; in the cross compiler. And in order to make sure that
194 ;; we don't continue doing it after we someday patch
195 ;; SBCL's type system so that * is no longer a type, we
196 ;; make this assertion. -- WHN 2001-08-08
197 (aver (typep (values-specifier-type '*) 'named-type))
199 (;; Many simple types are guaranteed to correspond exactly
200 ;; between any host ANSI Common Lisp and the target
201 ;; Common Lisp. (Some array types are too, but they
202 ;; were picked off earlier.)
204 '(atom bit character complex cons float function integer keyword
205 list nil null number rational real signed-byte symbol t
207 (values (typep host-object target-type) t))
208 (;; Floating point types are guaranteed to correspond,
209 ;; too, but less exactly.
211 '(single-float double-float))
212 (cond ((floatp host-object)
213 (warn-about-possible-float-info-loss)
214 (values (typep host-object target-type) t))
217 (;; Complexes suffer the same kind of problems as arrays.
218 ;; Our dumping logic is based on contents, however, so
219 ;; reasoning about them should be safe
220 (and (not (hairy-type-p (values-specifier-type target-type)))
221 (sb!xc:subtypep target-type 'cl:complex))
222 (if (complexp host-object)
223 (let ((re (realpart host-object))
224 (im (imagpart host-object)))
225 (if (or (and (eq target-type 'complex)
226 (typep re 'rational) (typep im 'rational))
227 (and (equal target-type '(cl:complex single-float))
228 (typep re 'single-float) (typep im 'single-float))
229 (and (equal target-type '(cl:complex double-float))
230 (typep re 'double-float) (typep im 'double-float)))
233 ;; We won't know how to dump it either.
234 (warn "Host complex too complex: ~S" host-object)
235 (warn-and-give-up))))
237 ;; Some types require translation between the cross-compilation
238 ;; host Common Lisp and the target SBCL.
239 ((target-type-is-in '(classoid))
240 (values (typep host-object 'classoid) t))
241 ((target-type-is-in '(fixnum))
242 (values (fixnump host-object) t))
243 ;; Some types are too hard to handle in the positive
244 ;; case, but at least we can be confident in a large
245 ;; fraction of the negative cases..
247 '(base-string simple-base-string simple-string))
248 (if (stringp host-object)
251 ((target-type-is-in '(character base-char standard-char))
252 (cond ((typep host-object 'standard-char)
254 ((not (characterp host-object))
257 (warn-and-give-up))))
258 ((target-type-is-in '(stream instance))
259 ;; Neither target CL:STREAM nor target SB!KERNEL:INSTANCE
260 ;; is implemented as a STRUCTURE-OBJECT, so they'll fall
261 ;; through the tests above. We don't want to assume too
262 ;; much about them here, but at least we know enough
263 ;; about them to say that neither T nor NIL nor indeed
264 ;; any other symbol in the cross-compilation host is one.
265 ;; That knowledge suffices to answer so many of the
266 ;; questions that the cross-compiler asks that it's well
267 ;; worth special-casing it here.
268 (if (symbolp host-object)
271 ;; various hacks for composite types..
273 (let ((first (first target-type))
274 (rest (rest target-type)))
276 ;; Many complex types are guaranteed to correspond exactly
277 ;; between any host ANSI Common Lisp and the target SBCL.
278 ((integer member mod rational real signed-byte unsigned-byte)
279 (values (typep host-object target-type) t))
280 ;; Floating point types are guaranteed to correspond,
281 ;; too, but less exactly.
282 ((single-float double-float)
283 (cond ((floatp host-object)
284 (warn-about-possible-float-info-loss)
285 (values (typep host-object target-type) t))
288 ;; Some complex types have translations that are less
290 (and (every/type #'cross-typep host-object rest))
291 (or (any/type #'cross-typep host-object rest))
293 (multiple-value-bind (value surep)
294 (cross-typep host-object (car rest))
296 (values (not value) t)
297 (warn-and-give-up))))
298 ;; If we want to work with the KEYWORD type, we need
299 ;; to grok (SATISFIES KEYWORDP).
301 (destructuring-bind (predicate-name) rest
302 (if (and (in-cl-package-p predicate-name)
303 (fboundp predicate-name))
304 ;; Many predicates like KEYWORDP, ODDP, PACKAGEP,
305 ;; and NULL correspond between host and target.
306 ;; But we still need to handle errors, because
307 ;; the code which calls us may not understand
308 ;; that a type is unreachable. (E.g. when compiling
309 ;; (AND STRING (SATISFIES ARRAY-HAS-FILL-POINTER-P))
310 ;; CTYPEP may be called on the SATISFIES expression
311 ;; even for non-STRINGs.)
312 (multiple-value-bind (result error?)
313 (ignore-errors (funcall predicate-name
318 ;; For symbols not in the CL package, it's not
319 ;; in general clear how things correspond
320 ;; between host and target, so we punt.
321 (warn-and-give-up))))
322 ;; Some complex types are too hard to handle in the
323 ;; positive case, but at least we can be confident in
324 ;; a large fraction of the negative cases..
325 ((base-string simple-base-string simple-string)
326 (if (stringp host-object)
329 ((vector simple-vector)
330 (if (vectorp host-object)
333 ((array simple-array)
334 (if (arrayp host-object)
338 (if (functionp host-object)
341 ;; And the Common Lisp type system is complicated,
342 ;; and we don't try to implement everything.
343 (otherwise (warn-and-give-up)))))
344 ;; And the Common Lisp type system is complicated, and
345 ;; we don't try to implement everything.
347 (warn-and-give-up))))))
349 ;;; This is an incomplete TYPEP which runs at cross-compile time to
350 ;;; tell whether OBJECT is the host Lisp representation of a target
351 ;;; SBCL type specified by TARGET-TYPE-SPEC. It need make no pretense
352 ;;; to completeness, since it need only handle the cases which arise
353 ;;; when building SBCL itself, e.g. testing that range limits FOO and
354 ;;; BAR in (INTEGER FOO BAR) are INTEGERs.
355 (defun sb!xc:typep (host-object target-type-spec &optional (env nil env-p))
356 (declare (ignore env))
357 (aver (null env-p)) ; 'cause we're too lazy to think about it
358 (multiple-value-bind (opinion certain-p)
359 (cross-typep host-object target-type-spec)
360 ;; A program that calls TYPEP doesn't want uncertainty and
361 ;; probably can't handle it.
364 (error "uncertain in SB!XC:TYPEP ~S ~S"
368 ;;; This is an incomplete, portable implementation for use at
369 ;;; cross-compile time only.
370 (defun ctypep (obj ctype)
371 (check-type ctype ctype)
372 ;; There is at least one possible endless recursion in the
373 ;; cross-compiler type system: (SUBTYPEP NULL (OR UNKOWN0 UNKNOWN1)
374 ;; runs out of stack. The right way would probably be to not
375 ;; implement CTYPEP in terms of TYPE-SPECIFIER (:UNPARSE, that may
376 ;; call TYPE=, that in turn may call CTYPEP). Until then, pick a few
378 (cond ((member-type-p ctype)
379 (if (member-type-member-p obj ctype)
382 ((union-type-p ctype)
383 (any/type #'ctypep obj (union-type-types ctype)))
385 (let ( ;; the Common Lisp type specifier corresponding to CTYPE
386 (type (type-specifier ctype)))
387 (check-type type (or symbol cons))
388 (cross-typep obj type)))))
393 (if (typep x 'generic-function)
394 ;; Since at cross-compile time we build a CLOS-free bootstrap
395 ;; version of SBCL, it's unclear how to explain to it what a
396 ;; generic function is.
397 (error "not implemented: cross CTYPE-OF generic function")
398 ;; There's no ANSI way to find out what the function is
399 ;; declared to be, so we just return the CTYPE for the
400 ;; most-general function.
401 *universal-fun-type*))
403 (make-member-type :members (list x)))
407 (make-array-type :dimensions (array-dimensions x)
408 :complexp (not (typep x 'simple-array))
409 :element-type (specifier-type 'base-char)
410 :specialized-element-type (specifier-type 'base-char)))
412 (let ((etype (specifier-type (array-element-type x))))
413 (make-array-type :dimensions (array-dimensions x)
414 :complexp (not (typep x 'simple-array))
416 :specialized-element-type etype)))
417 (cons (specifier-type 'cons))
419 (cond ((typep x 'standard-char)
420 ;; (Note that SBCL doesn't distinguish between BASE-CHAR and
422 (specifier-type 'base-char))
423 ((not (characterp x))
426 ;; Beyond this, there seems to be no portable correspondence.
427 (error "can't map host Lisp CHARACTER ~S to target Lisp" x))))
429 (find-classoid (uncross (class-name (class-of x)))))
431 ;; There might be more cases which we could handle with
432 ;; sufficient effort; since all we *need* to handle are enough
433 ;; cases for bootstrapping, we don't try to be complete here,. If
434 ;; future maintainers make the bootstrap code more complicated,
435 ;; they can also add new cases here to handle it. -- WHN 2000-11-11
436 (error "can't handle ~S in cross CTYPE-OF" x))))