1.0.11.1: Handle set-but-empty environment variables
[sbcl.git] / src / code / coerce.lisp
1 ;;;; COERCE and related code
2
3 ;;;; This software is part of the SBCL system. See the README file for
4 ;;;; more information.
5 ;;;;
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.
11
12 (in-package "SB!IMPL")
13
14 (macrolet ((def (name result access src-type &optional typep)
15              `(defun ,name (object ,@(if typep '(type) ()))
16                 (do* ((index 0 (1+ index))
17                       (length (length (the ,(ecase src-type
18                                               (:list 'list)
19                                               (:vector 'vector)
20                                               (:sequence 'sequence))
21                                            object)))
22                       (result ,result)
23                       (in-object object))
24                      ((= index length) result)
25                   (declare (fixnum length index))
26                   (setf (,access result index)
27                         ,(ecase src-type
28                            (:list '(pop in-object))
29                            (:vector '(aref in-object index))
30                            (:sequence '(elt in-object index))))))))
31
32   (def list-to-vector* (make-sequence type length)
33     aref :list t)
34
35   (def vector-to-vector* (make-sequence type length)
36     aref :vector t)
37
38   (def sequence-to-vector* (make-sequence type length)
39     aref :sequence t))
40
41 (defun vector-to-list* (object)
42   (let ((result (list nil))
43         (length (length object)))
44     (declare (fixnum length))
45     (do ((index 0 (1+ index))
46          (splice result (cdr splice)))
47         ((= index length) (cdr result))
48       (declare (fixnum index))
49       (rplacd splice (list (aref object index))))))
50
51 (defvar *offending-datum*); FIXME: Remove after debugging COERCE.
52
53 ;;; These are used both by the full DEFUN function and by various
54 ;;; optimization transforms in the constant-OUTPUT-TYPE-SPEC case.
55 ;;;
56 ;;; Most of them are INLINE so that they can be optimized when the
57 ;;; argument type is known. It might be better to do this with
58 ;;; DEFTRANSFORMs, though.
59 (declaim (inline coerce-to-list))
60 (declaim (inline coerce-to-vector))
61 (defun coerce-to-fun (object)
62   ;; (Unlike the other COERCE-TO-FOOs, this one isn't inline, because
63   ;; it's so big and because optimizing away the outer ETYPECASE
64   ;; doesn't seem to buy us that much anyway.)
65   (etypecase object
66     (symbol
67      ;; ANSI lets us return ordinary errors (non-TYPE-ERRORs) here.
68      (cond ((macro-function object)
69             (error "~S names a macro." object))
70            ((special-operator-p object)
71             (error "~S is a special operator." object))
72            (t (fdefinition object))))
73     (list
74      (case (first object)
75        ((setf)
76         (fdefinition object))
77        ((lambda)
78         ;; FIXME: If we go to a compiler-only implementation, this can
79         ;; become COMPILE instead of EVAL, which seems nicer to me.
80         (eval `(function ,object)))
81        ((instance-lambda)
82         (deprecation-warning 'instance-lambda 'lambda)
83         (eval `(function ,object)))
84        (t
85         (error 'simple-type-error
86                :datum object
87                :expected-type '(or symbol
88                                    ;; KLUDGE: ANSI wants us to
89                                    ;; return a TYPE-ERROR here, and
90                                    ;; a TYPE-ERROR is supposed to
91                                    ;; describe the expected type,
92                                    ;; but it's not obvious how to
93                                    ;; describe the coerceable cons
94                                    ;; types, so we punt and just say
95                                    ;; CONS. -- WHN 20000503
96                                    cons)
97                :format-control "~S can't be coerced to a function."
98                :format-arguments (list object)))))))
99
100 (defun coerce-to-list (object)
101   (etypecase object
102     (vector (vector-to-list* object))))
103
104 (defun coerce-to-vector (object output-type-spec)
105   (etypecase object
106     (list (list-to-vector* object output-type-spec))
107     (vector (vector-to-vector* object output-type-spec))))
108
109 ;;; old working version
110 (defun coerce (object output-type-spec)
111   #!+sb-doc
112   "Coerce the Object to an object of type Output-Type-Spec."
113   (flet ((coerce-error ()
114            (/show0 "entering COERCE-ERROR")
115            (error 'simple-type-error
116                   :format-control "~S can't be converted to type ~S."
117                   :format-arguments (list object output-type-spec)
118                   :datum object
119                   :expected-type output-type-spec)))
120     (let ((type (specifier-type output-type-spec)))
121       (cond
122         ((%typep object output-type-spec)
123          object)
124         ((eq type *empty-type*)
125          (coerce-error))
126         ((csubtypep type (specifier-type 'character))
127          (character object))
128         ((numberp object)
129          (cond
130            ((csubtypep type (specifier-type 'single-float))
131             (let ((res (%single-float object)))
132               (unless (typep res output-type-spec)
133                 (coerce-error))
134               res))
135            ((csubtypep type (specifier-type 'double-float))
136             (let ((res (%double-float object)))
137               (unless (typep res output-type-spec)
138                 (coerce-error))
139               res))
140            #!+long-float
141            ((csubtypep type (specifier-type 'long-float))
142             (let ((res (%long-float object)))
143               (unless (typep res output-type-spec)
144                 (coerce-error))
145               res))
146            ((csubtypep type (specifier-type 'float))
147             (let ((res (%single-float object)))
148               (unless (typep res output-type-spec)
149                 (coerce-error))
150               res))
151            (t
152             (let ((res
153                    (cond
154                      ((csubtypep type (specifier-type '(complex single-float)))
155                       (complex (%single-float (realpart object))
156                                (%single-float (imagpart object))))
157                      ((csubtypep type (specifier-type '(complex double-float)))
158                       (complex (%double-float (realpart object))
159                                (%double-float (imagpart object))))
160                      #!+long-float
161                      ((csubtypep type (specifier-type '(complex long-float)))
162                       (complex (%long-float (realpart object))
163                                (%long-float (imagpart object))))
164                      ((csubtypep type (specifier-type '(complex float)))
165                       (complex (%single-float (realpart object))
166                                (%single-float (imagpart object))))
167                      ((and (typep object 'rational)
168                            (csubtypep type (specifier-type '(complex float))))
169                       ;; Perhaps somewhat surprisingly, ANSI specifies
170                       ;; that (COERCE FOO 'FLOAT) is a SINGLE-FLOAT,
171                       ;; not dispatching on
172                       ;; *READ-DEFAULT-FLOAT-FORMAT*.  By analogy, we
173                       ;; do the same for complex numbers. -- CSR,
174                       ;; 2002-08-06
175                       (complex (%single-float object)))
176                      ((csubtypep type (specifier-type 'complex))
177                       (complex object))
178                      (t
179                       (coerce-error)))))
180               ;; If RES has the wrong type, that means that rule of
181               ;; canonical representation for complex rationals was
182               ;; invoked. According to the Hyperspec, (coerce 7/2
183               ;; 'complex) returns 7/2. Thus, if the object was a
184               ;; rational, there is no error here.
185               (unless (or (typep res output-type-spec)
186                           (rationalp object))
187                 (coerce-error))
188               res))))
189         ((csubtypep type (specifier-type 'list))
190          (if (vectorp object)
191              (cond
192                ((type= type (specifier-type 'list))
193                 (vector-to-list* object))
194                ((type= type (specifier-type 'null))
195                 (if (= (length object) 0)
196                     'nil
197                     (sequence-type-length-mismatch-error type
198                                                          (length object))))
199                ((cons-type-p type)
200                 (multiple-value-bind (min exactp)
201                     (sb!kernel::cons-type-length-info type)
202                   (let ((length (length object)))
203                     (if exactp
204                         (unless (= length min)
205                           (sequence-type-length-mismatch-error type length))
206                         (unless (>= length min)
207                           (sequence-type-length-mismatch-error type length)))
208                     (vector-to-list* object))))
209                (t (sequence-type-too-hairy (type-specifier type))))
210              (if (sequencep object)
211                  (cond
212                    ((type= type (specifier-type 'list))
213                     (sb!sequence:make-sequence-like
214                      nil (length object) :initial-contents object))
215                    ((type= type (specifier-type 'null))
216                     (if (= (length object) 0)
217                         'nil
218                         (sequence-type-length-mismatch-error type
219                                                              (length object))))
220                    ((cons-type-p type)
221                     (multiple-value-bind (min exactp)
222                         (sb!kernel::cons-type-length-info type)
223                       (let ((length (length object)))
224                         (if exactp
225                             (unless (= length min)
226                               (sequence-type-length-mismatch-error type length))
227                             (unless (>= length min)
228                               (sequence-type-length-mismatch-error type length)))
229                         (sb!sequence:make-sequence-like
230                          nil length :initial-contents object))))
231                    (t (sequence-type-too-hairy (type-specifier type))))
232                  (coerce-error))))
233         ((csubtypep type (specifier-type 'vector))
234          (typecase object
235            ;; FOO-TO-VECTOR* go through MAKE-SEQUENCE, so length
236            ;; errors are caught there. -- CSR, 2002-10-18
237            (list (list-to-vector* object output-type-spec))
238            (vector (vector-to-vector* object output-type-spec))
239            (sequence (sequence-to-vector* object output-type-spec))
240            (t
241             (coerce-error))))
242         ((and (csubtypep type (specifier-type 'sequence))
243               (find-class output-type-spec nil))
244          (let ((class (find-class output-type-spec)))
245            (sb!sequence:make-sequence-like
246             (sb!mop:class-prototype class)
247             (length object) :initial-contents object)))
248         ((csubtypep type (specifier-type 'function))
249          (when (and (legal-fun-name-p object)
250                     (not (fboundp object)))
251            (error 'simple-type-error
252                   :datum object
253                   ;; FIXME: SATISFIES FBOUNDP is a kinda bizarre broken
254                   ;; type specifier, since the set of values it describes
255                   ;; isn't in general constant in time. Maybe we could
256                   ;; find a better way of expressing this error? (Maybe
257                   ;; with the UNDEFINED-FUNCTION condition?)
258                   :expected-type '(satisfies fboundp)
259                :format-control "~S isn't fbound."
260                :format-arguments (list object)))
261          (when (and (symbolp object)
262                     (sb!xc:macro-function object))
263            (error 'simple-type-error
264                   :datum object
265                   :expected-type '(not (satisfies sb!xc:macro-function))
266                   :format-control "~S is a macro."
267                   :format-arguments (list object)))
268          (when (and (symbolp object)
269                     (special-operator-p object))
270            (error 'simple-type-error
271                   :datum object
272                   :expected-type '(not (satisfies special-operator-p))
273                   :format-control "~S is a special operator."
274                   :format-arguments (list object)))
275          (eval `#',object))
276         (t
277          (coerce-error))))))
278
279 ;;; new version, which seems as though it should be better, but which
280 ;;; does not yet work
281 #+nil
282 (defun coerce (object output-type-spec)
283   #!+sb-doc
284   "Coerces the Object to an object of type Output-Type-Spec."
285   (flet ((coerce-error ()
286            (error 'simple-type-error
287                   :format-control "~S can't be converted to type ~S."
288                   :format-arguments (list object output-type-spec)))
289          (check-result (result)
290            #!+high-security (aver (typep result output-type-spec))
291            result))
292     (let ((type (specifier-type output-type-spec)))
293       (cond
294         ((%typep object output-type-spec)
295          object)
296         ((eq type *empty-type*)
297          (coerce-error))
298         ((csubtypep type (specifier-type 'character))
299          (character object))
300         ((csubtypep type (specifier-type 'function))
301          (coerce-to-fun object))
302         ((numberp object)
303          (let ((res
304                 (cond
305                   ((csubtypep type (specifier-type 'single-float))
306                    (%single-float object))
307                   ((csubtypep type (specifier-type 'double-float))
308                    (%double-float object))
309                   #!+long-float
310                   ((csubtypep type (specifier-type 'long-float))
311                    (%long-float object))
312                   ((csubtypep type (specifier-type 'float))
313                    (%single-float object))
314                   ((csubtypep type (specifier-type '(complex single-float)))
315                    (complex (%single-float (realpart object))
316                             (%single-float (imagpart object))))
317                   ((csubtypep type (specifier-type '(complex double-float)))
318                    (complex (%double-float (realpart object))
319                             (%double-float (imagpart object))))
320                   #!+long-float
321                   ((csubtypep type (specifier-type '(complex long-float)))
322                    (complex (%long-float (realpart object))
323                             (%long-float (imagpart object))))
324                   ((csubtypep type (specifier-type 'complex))
325                    (complex object))
326                   (t
327                    (coerce-error)))))
328            ;; If RES has the wrong type, that means that rule of
329            ;; canonical representation for complex rationals was
330            ;; invoked. According to the ANSI spec, (COERCE 7/2
331            ;; 'COMPLEX) returns 7/2. Thus, if the object was a
332            ;; rational, there is no error here.
333            (unless (or (typep res output-type-spec) (rationalp object))
334              (coerce-error))
335            res))
336         ((csubtypep type (specifier-type 'list))
337          (coerce-to-list object))
338         ((csubtypep type (specifier-type 'string))
339          (check-result (coerce-to-simple-string object)))
340         ((csubtypep type (specifier-type 'bit-vector))
341          (check-result (coerce-to-bit-vector object)))
342         ((csubtypep type (specifier-type 'vector))
343          (check-result (coerce-to-vector object output-type-spec)))
344         (t
345          (coerce-error))))))