0.pre8.4
[sbcl.git] / src / code / target-defstruct.lisp
1 ;;;; This software is part of the SBCL system. See the README file for
2 ;;;; more information.
3 ;;;;
4 ;;;; This software is derived from the CMU CL system, which was
5 ;;;; written at Carnegie Mellon University and released into the
6 ;;;; public domain. The software is in the public domain and is
7 ;;;; provided with absolutely no warranty. See the COPYING and CREDITS
8 ;;;; files for more information.
9
10 (in-package "SB!KERNEL")
11
12 (/show0 "target-defstruct.lisp 12")
13 \f
14 ;;;; structure frobbing primitives
15
16 ;;; Allocate a new instance with LENGTH data slots.
17 (defun %make-instance (length)
18   (declare (type index length))
19   (%make-instance length))
20
21 ;;; Given an instance, return its length.
22 (defun %instance-length (instance)
23   (declare (type instance instance))
24   (%instance-length instance))
25
26 ;;; Return the value from the INDEXth slot of INSTANCE. This is SETFable.
27 (defun %instance-ref (instance index)
28   (%instance-ref instance index))
29
30 ;;; Set the INDEXth slot of INSTANCE to NEW-VALUE.
31 (defun %instance-set (instance index new-value)
32   (setf (%instance-ref instance index) new-value))
33
34 (defun %raw-ref-single (vec index)
35   (declare (type index index))
36   (%raw-ref-single vec index))
37
38 (defun %raw-ref-double (vec index)
39   (declare (type index index))
40   (%raw-ref-double vec index))
41
42 #!+long-float
43 (defun %raw-ref-long (vec index)
44   (declare (type index index))
45   (%raw-ref-long vec index))
46
47 (defun %raw-set-single (vec index val)
48   (declare (type index index))
49   (%raw-set-single vec index val))
50
51 (defun %raw-set-double (vec index val)
52   (declare (type index index))
53   (%raw-set-double vec index val))
54
55 #!+long-float
56 (defun %raw-set-long (vec index val)
57   (declare (type index index))
58   (%raw-set-long vec index val))
59
60 (defun %raw-ref-complex-single (vec index)
61   (declare (type index index))
62   (%raw-ref-complex-single vec index))
63
64 (defun %raw-ref-complex-double (vec index)
65   (declare (type index index))
66   (%raw-ref-complex-double vec index))
67
68 #!+long-float
69 (defun %raw-ref-complex-long (vec index)
70   (declare (type index index))
71   (%raw-ref-complex-long vec index))
72
73 (defun %raw-set-complex-single (vec index val)
74   (declare (type index index))
75   (%raw-set-complex-single vec index val))
76
77 (defun %raw-set-complex-double (vec index val)
78   (declare (type index index))
79   (%raw-set-complex-double vec index val))
80
81 #!+long-float
82 (defun %raw-set-complex-long (vec index val)
83   (declare (type index index))
84   (%raw-set-complex-long vec index val))
85
86 (defun %instance-layout (instance)
87   (%instance-layout instance))
88
89 (defun %set-instance-layout (instance new-value)
90   (%set-instance-layout instance new-value))
91
92 (defun %make-funcallable-instance (len layout)
93    (%make-funcallable-instance len layout))
94
95 (defun funcallable-instance-p (x) (funcallable-instance-p x))
96
97 (defun %funcallable-instance-info (fin i)
98   (%funcallable-instance-info fin i))
99
100 (defun %set-funcallable-instance-info (fin i new-value)
101   (%set-funcallable-instance-info fin i new-value))
102
103 (defun funcallable-instance-fun (fin)
104   (%funcallable-instance-lexenv fin))
105
106 ;;; The heart of the magic of funcallable instances ("FINs"). The
107 ;;; function for a FIN must be a magical INSTANCE-LAMBDA form. When
108 ;;; called (as with any other function), we grab the code pointer, and
109 ;;; call it, leaving the original function object in LEXENV (in case
110 ;;; it was a closure). If it is actually a FIN, then we need to do an
111 ;;; extra indirection with funcallable-instance-lexenv to get at any
112 ;;; closure environment. This extra indirection is set up when
113 ;;; accessing the closure environment of an INSTANCE-LAMBDA. Note that
114 ;;; the original FIN pointer is lost, so if the called function wants
115 ;;; to get at the original object to do some slot accesses, it must
116 ;;; close over the FIN object.
117 ;;;
118 ;;; If we set the FIN function to be a FIN, we directly copy across
119 ;;; both the code pointer and the lexenv, since that code pointer (for
120 ;;; an instance-lambda) is expecting that lexenv to be accessed. This
121 ;;; effectively pre-flattens what would otherwise be a chain of
122 ;;; indirections. (That used to happen when PCL dispatch functions
123 ;;; were byte-compiled; now that the byte compiler is gone, I can't
124 ;;; think of another example offhand. -- WHN 2001-10-06)
125 ;;;
126 ;;; The only loss is that if someone accesses the
127 ;;; FUNCALLABLE-INSTANCE-FUN, then won't get a FIN back. This probably
128 ;;; doesn't matter, since PCL only sets the FIN function.
129 (defun (setf funcallable-instance-fun) (new-value fin)
130   (setf (%funcallable-instance-fun fin)
131         (%closure-fun new-value))
132   (setf (%funcallable-instance-lexenv fin)
133         (if (funcallable-instance-p new-value)
134             (%funcallable-instance-lexenv new-value)
135             new-value)))
136
137 ;;; service function for structure constructors
138 (defun %make-instance-with-layout (layout)
139   (let ((result (%make-instance (layout-length layout))))
140     (setf (%instance-layout result) layout)
141     result))
142 \f
143 ;;;; target-only parts of the DEFSTRUCT top level code
144
145 ;;; Catch attempts to mess up definitions of symbols in the CL package.
146 (defun protect-cl (symbol)
147   (/show0 "entering PROTECT-CL, SYMBOL=..")
148   (/hexstr symbol)
149   (when (and *cold-init-complete-p*
150              (eq (symbol-package symbol) *cl-package*))
151     (cerror "Go ahead and patch the system."
152             "attempting to modify a symbol in the COMMON-LISP package: ~S"
153             symbol))
154   (/show0 "leaving PROTECT-CL")
155   (values))
156
157 ;;; the part of %DEFSTRUCT which makes sense only on the target SBCL
158 ;;;
159 ;;; (The "static" in the name is because it needs to be done not only
160 ;;; in ordinary toplevel %DEFSTRUCT, but also in cold init as early as
161 ;;; possible, to simulate static linking of structure functions as
162 ;;; nearly as possible.)
163 (defun %target-defstruct (dd layout)
164   (declare (type defstruct-description dd))
165   (declare (type layout layout))
166
167   (/show0 "entering %TARGET-DEFSTRUCT")
168
169   (remhash (dd-name dd) *typecheckfuns*)
170
171   ;; (Constructors aren't set up here, because constructors are
172   ;; varied enough (possibly parsing any specified argument list)
173   ;; that we can't reasonably implement them as closures, so we
174   ;; implement them with DEFUN instead.)
175
176   ;; Set FDEFINITIONs for slot accessors.
177   (dolist (dsd (dd-slots dd))
178     (/show0 "doing FDEFINITION for slot accessor")
179     (let ((accessor-name (dsd-accessor-name dsd)))
180       ;; We mustn't step on any inherited accessors
181       (unless (accessor-inherited-data accessor-name dd)
182         (/show0 "ACCESSOR-NAME=..")
183         (/hexstr accessor-name)
184         (protect-cl accessor-name)
185         (/hexstr "getting READER-FUN and WRITER-FUN")
186         (multiple-value-bind (reader-fun writer-fun)
187             (slot-accessor-funs dd dsd)
188           (declare (type function reader-fun writer-fun))
189           (/show0 "got READER-FUN and WRITER-FUN=..")
190           (/hexstr reader-fun)
191           (setf (symbol-function accessor-name) reader-fun)
192           (unless (dsd-read-only dsd)
193             (/show0 "setting FDEFINITION for WRITER-FUN=..")
194             (/hexstr writer-fun)
195             (setf (fdefinition `(setf ,accessor-name)) writer-fun))))))
196
197   ;; Set FDEFINITION for copier.
198   (when (dd-copier-name dd)
199     (/show0 "doing FDEFINITION for copier")
200     (protect-cl (dd-copier-name dd))
201     ;; We can't use COPY-STRUCTURE for other kinds of objects, notably
202     ;; funcallable structures, since it returns a STRUCTURE-OBJECT.
203     ;; (And funcallable instances don't need copiers anyway.)
204     (aver (eql (dd-type dd) 'structure))
205     (setf (symbol-function (dd-copier-name dd))
206           ;; FIXME: should use a closure which checks arg type before copying
207           #'copy-structure))
208
209   ;; Set FDEFINITION for predicate.
210   (when (dd-predicate-name dd)
211     (/show0 "doing FDEFINITION for predicate")
212     (protect-cl (dd-predicate-name dd))
213     (setf (symbol-function (dd-predicate-name dd))
214           (ecase (dd-type dd)
215             ;; structures with LAYOUTs
216             ((structure funcallable-structure)
217              (/show0 "with-LAYOUT case")
218              (lambda (object)
219                (locally ; <- to keep SAFETY 0 from affecting arg count checking
220                  (declare (optimize (speed 3) (safety 0)))
221                  (/noshow0 "in with-LAYOUT structure predicate closure, OBJECT,LAYOUT=..")
222                  (/nohexstr object)
223                  (/nohexstr layout)
224                  (typep-to-layout object layout))))
225             ;; structures with no LAYOUT (i.e. :TYPE VECTOR or :TYPE LIST)
226             ;;
227             ;; FIXME: should handle the :NAMED T case in these cases
228             (vector
229              (/show0 ":TYPE VECTOR case")
230              #'vectorp)
231             (list
232              (/show0 ":TYPE LIST case")
233              #'listp))))
234
235   (when (dd-doc dd)
236     (setf (fdocumentation (dd-name dd) 'type)
237           (dd-doc dd)))
238
239   (/show0 "leaving %TARGET-DEFSTRUCT")
240   (values))
241 \f
242 ;;;; generating out-of-line slot accessor functions
243
244 ;;; FIXME: Ideally, the presence of the type checks in the functions
245 ;;; here would be conditional on the optimization policy at the point
246 ;;; of expansion of DEFSTRUCT. (For now we're just doing the simpler
247 ;;; thing, putting in the type checks unconditionally.)
248
249 ;;; Return (VALUES SLOT-READER-FUN SLOT-WRITER-FUN).
250 (defun slot-accessor-funs (dd dsd)
251
252   #+sb-xc (/show0 "entering SLOT-ACCESSOR-FUNS")
253
254   ;; various code generators
255   ;;
256   ;; Note: They're only minimally parameterized, and cavalierly grab
257   ;; things like INSTANCE and DSD-INDEX from the namespace they're
258   ;; expanded in.
259   (macrolet (;; code shared between funcallable instance case and the
260              ;; ordinary STRUCTURE-OBJECT case: Handle native
261              ;; structures with LAYOUTs and (possibly) raw slots.
262              (%native-slot-accessor-funs (dd-ref-fun-name)
263                (let ((instance-type-check-form
264                       '(%check-structure-type-from-layout instance layout)))
265                  (/show "macroexpanding %NATIVE-SLOT-ACCESSOR-FUNS" dd-ref-fun-name instance-type-check-form)
266                  `(let ((layout (dd-layout-or-lose dd))
267                         (dsd-raw-type (dsd-raw-type dsd)))
268                     #+sb-xc (/show0 "in %NATIVE-SLOT-ACCESSOR-FUNS macroexpanded code")
269                     ;; Map over all the possible RAW-TYPEs, compiling
270                     ;; a different closure function for each one, so
271                     ;; that once the COND over RAW-TYPEs happens (at
272                     ;; the time closure is allocated) there are no
273                     ;; more decisions to be made and things execute
274                     ;; reasonably efficiently.
275                     (cond
276                      ;; nonraw slot case
277                      ((eql dsd-raw-type t)
278                       #+sb-xc (/show0 "in nonraw slot case")
279                       (%slotplace-accessor-funs
280                        (,dd-ref-fun-name instance dsd-index)
281                        ,instance-type-check-form))
282                      ;; raw slot cases
283                      ,@(mapcar (lambda (rtd)
284                                  (let ((raw-type (raw-slot-data-raw-type rtd))
285                                        (accessor-name
286                                         (raw-slot-data-accessor-name rtd))
287                                        (n-words (raw-slot-data-n-words rtd)))
288                                    `((equal dsd-raw-type ',raw-type)
289                                      #+sb-xc (/show0 "in raw slot case")
290                                      (let ((raw-index (dd-raw-index dd)))
291                                        (multiple-value-bind (scaled-dsd-index
292                                                              misalignment)
293                                            (floor dsd-index ,n-words)
294                                          (aver (zerop misalignment))
295                                          (%slotplace-accessor-funs
296                                           (,accessor-name (,dd-ref-fun-name
297                                                            instance
298                                                            raw-index)
299                                                           scaled-dsd-index)
300                                           ,instance-type-check-form))))))
301                                *raw-slot-data-list*)
302                      ;; oops
303                      (t
304                       (bug "unexpected DSD-RAW-TYPE ~S" dsd-raw-type))))))
305              ;; code shared between DEFSTRUCT :TYPE LIST and
306              ;; DEFSTRUCT :TYPE VECTOR cases: Handle the "typed
307              ;; structure" case, with no LAYOUTs and no raw slots.
308              (%colontyped-slot-accessor-funs () (error "stub")) 
309              ;; the common structure of the raw-slot and not-raw-slot
310              ;; cases, defined in terms of the writable SLOTPLACE. All
311              ;; possible flavors of slot access should be able to pass
312              ;; through here.
313              (%slotplace-accessor-funs (slotplace instance-type-check-form)
314                (/show "macroexpanding %SLOTPLACE-ACCESSOR-FUNS" slotplace instance-type-check-form)
315                `(values (lambda (instance)
316                           (/noshow0 "in %SLOTPLACE-ACCESSOR-FUNS-defined reader")
317                           ,instance-type-check-form
318                           (/noshow0 "back from INSTANCE-TYPE-CHECK-FORM")
319                           ,slotplace)
320                         (let ((typecheckfun (typespec-typecheckfun dsd-type)))
321                           (lambda (new-value instance)
322                             (/noshow0 "in %SLOTPLACE-ACCESSOR-FUNS-defined writer")
323                             ,instance-type-check-form
324                             (/noshow0 "back from INSTANCE-TYPE-CHECK-FORM")
325                             (funcall typecheckfun new-value)
326                             (/noshow0 "back from TYPECHECKFUN")
327                             (setf ,slotplace new-value))))))
328
329     (let ((dsd-index (dsd-index dsd))
330           (dsd-type (dsd-type dsd)))
331             
332       #+sb-xc (/show0 "got DSD-TYPE=..")
333       #+sb-xc (/hexstr dsd-type)
334       (ecase (dd-type dd)
335
336         ;; native structures
337         (structure
338          #+sb-xc (/show0 "case of DSD-TYPE = STRUCTURE")
339          (%native-slot-accessor-funs %instance-ref))
340                                      
341         ;; structures with the :TYPE option
342
343         ;; FIXME: Worry about these later..
344         #|
345         ;; In :TYPE LIST and :TYPE VECTOR structures, ANSI specifies the
346         ;; layout completely, so that raw slots are impossible.
347         (list
348          (dd-type-slot-accessor-funs nth-but-with-sane-arg-order
349                                  `(%check-structure-type-from-dd
350                                  :maybe-raw-p nil))
351         (vector
352          (dd-type-slot-accessor-funs aref
353                                  :maybe-raw-p nil)))
354         |#
355         ))))
356 \f
357 ;;; Copy any old kind of structure.
358 (defun copy-structure (structure)
359   #!+sb-doc
360   "Return a copy of STRUCTURE with the same (EQL) slot values."
361   (declare (type structure-object structure))
362   (let* ((len (%instance-length structure))
363          (res (%make-instance len))
364          (layout (%instance-layout structure)))
365
366     (declare (type index len))
367     (when (layout-invalid layout)
368       (error "attempt to copy an obsolete structure:~%  ~S" structure))
369
370     ;; Copy ordinary slots.
371     (dotimes (i len)
372       (declare (type index i))
373       (setf (%instance-ref res i)
374             (%instance-ref structure i)))
375
376     ;; Copy raw slots.
377     (let ((raw-index (dd-raw-index (layout-info layout))))
378       (when raw-index
379         (let* ((data (%instance-ref structure raw-index))
380                (raw-len (length data))
381                (new (make-array raw-len :element-type '(unsigned-byte 32))))
382           (declare (type (simple-array (unsigned-byte 32) (*)) data))
383           (setf (%instance-ref res raw-index) new)
384           (dotimes (i raw-len)
385             (setf (aref new i) (aref data i))))))
386
387     res))
388 \f
389 ;;; default PRINT-OBJECT and MAKE-LOAD-FORM methods
390
391 (defun %default-structure-pretty-print (structure stream)
392   (let* ((layout (%instance-layout structure))
393          (name (classoid-name (layout-classoid layout)))
394          (dd (layout-info layout)))
395     (pprint-logical-block (stream nil :prefix "#S(" :suffix ")")
396       (prin1 name stream)
397       (let ((remaining-slots (dd-slots dd)))
398         (when remaining-slots
399           (write-char #\space stream)
400           ;; CMU CL had (PPRINT-INDENT :BLOCK 2 STREAM) here,
401           ;; but I can't see why. -- WHN 20000205
402           (pprint-newline :linear stream)
403           (loop
404            (pprint-pop)
405            (let ((slot (pop remaining-slots)))
406              (write-char #\: stream)
407              (output-symbol-name (dsd-%name slot) stream)
408              (write-char #\space stream)
409              (pprint-newline :miser stream)
410              (output-object (funcall (fdefinition (dsd-accessor-name slot))
411                                      structure)
412                             stream)
413              (when (null remaining-slots)
414                (return))
415              (write-char #\space stream)
416              (pprint-newline :linear stream))))))))
417 (defun %default-structure-ugly-print (structure stream)
418   (let* ((layout (%instance-layout structure))
419          (name (classoid-name (layout-classoid layout)))
420          (dd (layout-info layout)))
421     (descend-into (stream)
422       (write-string "#S(" stream)
423       (prin1 name stream)
424       (do ((index 0 (1+ index))
425            (remaining-slots (dd-slots dd) (cdr remaining-slots)))
426           ((or (null remaining-slots)
427                (and (not *print-readably*)
428                     *print-length*
429                     (>= index *print-length*)))
430            (if (null remaining-slots)
431                (write-string ")" stream)
432                (write-string " ...)" stream)))
433         (declare (type index index))
434         (write-char #\space stream)
435         (write-char #\: stream)
436         (let ((slot (first remaining-slots)))
437           (output-symbol-name (dsd-%name slot) stream)
438           (write-char #\space stream)
439           (output-object
440            (funcall (fdefinition (dsd-accessor-name slot))
441                     structure)
442            stream))))))
443 (defun default-structure-print (structure stream depth)
444   (declare (ignore depth))
445   (cond ((funcallable-instance-p structure)
446          (print-unreadable-object (structure stream :identity t :type t)))
447         (*print-pretty*
448          (%default-structure-pretty-print structure stream))
449         (t
450          (%default-structure-ugly-print structure stream))))
451 (def!method print-object ((x structure-object) stream)
452   (default-structure-print x stream *current-level-in-print*))
453
454 (defun make-load-form-saving-slots (object &key slot-names environment)
455   (declare (ignore object environment))
456   (if slot-names
457       (error "stub: MAKE-LOAD-FORM-SAVING-SLOTS :SLOT-NAMES not implemented") ; KLUDGE
458       :sb-just-dump-it-normally))
459 \f
460 ;;;; testing structure types
461
462 ;;; Return true if OBJ is an object of the structure type
463 ;;; corresponding to LAYOUT. This is called by the accessor closures,
464 ;;; which have a handle on the type's LAYOUT.
465 ;;;
466 ;;; FIXME: This is fairly big, so it should probably become
467 ;;; MAYBE-INLINE instead of INLINE, or its inlineness should become
468 ;;; conditional (probably through DEFTRANSFORM) on (> SPEED SPACE). Or
469 ;;; else we could fix things up so that the things which call it are
470 ;;; all closures, so that it's expanded only in a small number of
471 ;;; places.
472 #!-sb-fluid (declaim (inline typep-to-layout))
473 (defun typep-to-layout (obj layout)
474   (declare (type layout layout) (optimize (speed 3) (safety 0)))
475   (/noshow0 "entering TYPEP-TO-LAYOUT, OBJ,LAYOUT=..")
476   (/nohexstr obj)
477   (/nohexstr layout)
478   (when (layout-invalid layout)
479     (error "An obsolete structure accessor function was called."))
480   (/noshow0 "back from testing LAYOUT-INVALID LAYOUT")
481   ;; FIXME: CMU CL used (%INSTANCEP OBJ) here. Check that
482   ;; (TYPEP OBJ 'INSTANCE) is optimized to equally efficient code.
483   (and (typep obj 'instance)
484        (let ((obj-layout (%instance-layout obj)))
485          (cond ((eq obj-layout layout)
486                 ;; (In this case OBJ-LAYOUT can't be invalid, because
487                 ;; we determined LAYOUT is valid in the test above.)
488                 (/noshow0 "EQ case")
489                 t)
490                ((layout-invalid obj-layout)
491                 (/noshow0 "LAYOUT-INVALID case")
492                 (error 'layout-invalid
493                        :expected-type (layout-classoid obj-layout)
494                        :datum obj))
495                (t
496                 (let ((depthoid (layout-depthoid layout)))
497                   (/noshow0 "DEPTHOID case, DEPTHOID,LAYOUT-INHERITS=..")
498                   (/nohexstr depthoid)
499                   (/nohexstr layout-inherits)
500                   (and (> (layout-depthoid obj-layout) depthoid)
501                        (eq (svref (layout-inherits obj-layout) depthoid)
502                            layout))))))))
503 \f
504 ;;;; checking structure types
505
506 ;;; Check that X is an instance of the named structure type.
507 (defmacro %check-structure-type-from-name (x name)
508   `(%check-structure-type-from-layout ,x ,(compiler-layout-or-lose name)))
509
510 ;;; Check that X is a structure of the type described by DD.
511 (defmacro %check-structure-type-from-dd (x dd)
512   (declare (type defstruct-description dd))
513   (let ((class-name (dd-name dd)))
514     (ecase (dd-type dd)
515       ((structure funcallable-instance)
516        `(%check-structure-type-from-layout
517          ,x
518          ,(compiler-layout-or-lose class-name)))
519       ((vector)
520        (let ((xx (gensym "X")))
521          `(let ((,xx ,x))
522             (declare (type vector ,xx))
523             ,@(when (dd-named dd)
524                 `((unless (eql (aref ,xx 0) ',class-name)
525                     (error
526                      'simple-type-error
527                      :datum (aref ,xx 0)
528                      :expected-type `(member ,class-name)
529                      :format-control
530                      "~@<missing name in instance of ~
531                       VECTOR-typed structure ~S: ~2I~_S~:>"
532                      :format-arguments (list ',class-name ,xx)))))
533             (values))))
534       ((list)
535        (let ((xx (gensym "X")))
536          `(let ((,xx ,x))
537             (declare (type list ,xx))
538             ,@(when (dd-named dd)
539                 `((unless (eql (first ,xx) ',class-name)
540                     (error
541                      'simple-type-error
542                      :datum (aref ,xx 0)
543                      :expected-type `(member ,class-name)
544                      :format-control
545                      "~@<missing name in instance of LIST-typed structure ~S: ~
546                       ~2I~_S~:>"
547                      :format-arguments (list ',class-name ,xx)))))
548             (values)))))))
549
550 ;;; Check that X is an instance of the structure class with layout LAYOUT.
551 (defun %check-structure-type-from-layout (x layout)
552   (unless (typep-to-layout x layout)
553     (error 'type-error
554            :datum x
555            :expected-type (classoid-name (layout-classoid layout))))
556   (values))
557 \f
558 (/show0 "target-defstruct.lisp end of file")