Tighter floating-point type constraints in some cases
[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 ;;; Normally IR2 converted, definition needed for interpreted structure
35 ;;; constructors only.
36 #!+sb-eval
37 (defun %make-structure-instance (dd slot-specs &rest slot-values)
38   (let ((instance (%make-instance (dd-instance-length dd))))
39     (setf (%instance-layout instance) (dd-layout-or-lose dd))
40     (mapc (lambda (spec value)
41             (destructuring-bind (raw-type . index) (cdr spec)
42               (macrolet ((make-case ()
43                            `(ecase raw-type
44                               ((t)
45                                (setf (%instance-ref instance index) value))
46                               ,@(mapcar
47                                  (lambda (rsd)
48                                    `(,(raw-slot-data-raw-type rsd)
49                                       (setf (,(raw-slot-data-accessor-name rsd)
50                                               instance index)
51                                             value)))
52                                  *raw-slot-data-list*))))
53                 (make-case))))
54           slot-specs slot-values)
55     instance))
56
57 (defun %raw-instance-ref/word (instance index)
58   (declare (type index index))
59   (%raw-instance-ref/word instance index))
60 (defun %raw-instance-set/word (instance index new-value)
61   (declare (type index index)
62            (type sb!vm:word new-value))
63   (%raw-instance-set/word instance index new-value))
64
65 (defun %raw-instance-ref/single (instance index)
66   (declare (type index index))
67   (%raw-instance-ref/single instance index))
68 (defun %raw-instance-set/single (instance index new-value)
69   (declare (type index index)
70            (type single-float new-value))
71   (%raw-instance-set/single instance index new-value))
72
73 (defun %raw-instance-ref/double (instance index)
74   (declare (type index index))
75   (%raw-instance-ref/double instance index))
76 (defun %raw-instance-set/double (instance index new-value)
77   (declare (type index index)
78            (type double-float new-value))
79   (%raw-instance-set/double instance index new-value))
80
81 (defun %raw-instance-ref/complex-single (instance index)
82   (declare (type index index))
83   (%raw-instance-ref/complex-single instance index))
84 (defun %raw-instance-set/complex-single (instance index new-value)
85   (declare (type index index)
86            (type (complex single-float) new-value))
87   (%raw-instance-set/complex-single instance index new-value))
88
89 (defun %raw-instance-ref/complex-double (instance index)
90   (declare (type index index))
91   (%raw-instance-ref/complex-double instance index))
92 (defun %raw-instance-set/complex-double (instance index new-value)
93   (declare (type index index)
94            (type (complex double-float) new-value))
95   (%raw-instance-set/complex-double instance index new-value))
96
97 (defun %instance-layout (instance)
98   (%instance-layout instance))
99
100 (defun %set-instance-layout (instance new-value)
101   (%set-instance-layout instance new-value))
102
103 (defun %make-funcallable-instance (len)
104   (%make-funcallable-instance len))
105
106 (defun funcallable-instance-p (x)
107   (funcallable-instance-p x))
108
109 (deftype funcallable-instance ()
110   `(satisfies funcallable-instance-p))
111
112 (defun %funcallable-instance-info (fin i)
113   (%funcallable-instance-info fin i))
114
115 (defun %set-funcallable-instance-info (fin i new-value)
116   (%set-funcallable-instance-info fin i new-value))
117
118 (defun funcallable-instance-fun (fin)
119   (%funcallable-instance-function fin))
120
121 (defun (setf funcallable-instance-fun) (new-value fin)
122   (setf (%funcallable-instance-function fin) new-value))
123 \f
124 ;;;; target-only parts of the DEFSTRUCT top level code
125
126 ;;; A list of hooks designating functions of one argument, the
127 ;;; classoid, to be called when a defstruct is evaluated.
128 (defvar *defstruct-hooks* nil)
129
130 ;;; Catch attempts to mess up definitions of symbols in the CL package.
131 (defun protect-cl (symbol)
132   (/show0 "entering PROTECT-CL, SYMBOL=..")
133   (/hexstr symbol)
134   (when (and *cold-init-complete-p*
135              (eq (symbol-package symbol) *cl-package*))
136     (cerror "Go ahead and patch the system."
137             "attempting to modify a symbol in the COMMON-LISP package: ~S"
138             symbol))
139   (/show0 "leaving PROTECT-CL")
140   (values))
141
142 (defun make-defstruct-predicate (dd layout)
143   (ecase (dd-type dd)
144     ;; structures with LAYOUTs
145     ((structure funcallable-structure)
146      (/show0 "with-LAYOUT case")
147      #'(lambda (object)
148          (locally ; <- to keep SAFETY 0 from affecting arg count checking
149              (declare (optimize (speed 3) (safety 0)))
150            (/noshow0 "in with-LAYOUT structure predicate closure,")
151            (/noshow0 "  OBJECT,LAYOUT=..")
152            (/nohexstr object)
153            (/nohexstr layout)
154            (typep-to-layout object layout))))
155     ;; structures with no LAYOUT (i.e. :TYPE VECTOR or :TYPE LIST)
156     ;;
157     ;; FIXME: should handle the :NAMED T case in these cases
158     (vector
159      (/show0 ":TYPE VECTOR case")
160      #'vectorp)
161     (list
162      (/show0 ":TYPE LIST case")
163      #'listp)))
164
165 (defun make-defstruct-copier (dd layout)
166   (ecase (dd-type dd)
167     (structure
168      #'(lambda (instance)
169          (%check-structure-type-from-layout instance layout)
170          (copy-structure instance)))))
171
172 ;;; the part of %DEFSTRUCT which makes sense only on the target SBCL
173 ;;;
174 ;;; (The "static" in the name is because it needs to be done not only
175 ;;; in ordinary toplevel %DEFSTRUCT, but also in cold init as early as
176 ;;; possible, to simulate static linking of structure functions as
177 ;;; nearly as possible.)
178 (defun %target-defstruct (dd layout)
179   (declare (type defstruct-description dd))
180   (declare (type layout layout))
181
182   (/show0 "entering %TARGET-DEFSTRUCT")
183
184   (remhash (dd-name dd) *typecheckfuns*)
185
186   ;; (Constructors aren't set up here, because constructors are
187   ;; varied enough (possibly parsing any specified argument list)
188   ;; that we can't reasonably implement them as closures, so we
189   ;; implement them with DEFUN instead.)
190
191   ;; Set FDEFINITIONs for slot accessors.
192   (dolist (dsd (dd-slots dd))
193     (/show0 "doing FDEFINITION for slot accessor")
194     (let ((accessor-name (dsd-accessor-name dsd)))
195       ;; We mustn't step on any inherited accessors
196       (unless (accessor-inherited-data accessor-name dd)
197         (/show0 "ACCESSOR-NAME=..")
198         (/hexstr accessor-name)
199         (protect-cl accessor-name)
200         (/hexstr "getting READER-FUN and WRITER-FUN")
201         (multiple-value-bind (reader-fun writer-fun)
202             (slot-accessor-funs dd dsd)
203           (declare (type function reader-fun writer-fun))
204           (/show0 "got READER-FUN and WRITER-FUN=..")
205           (/hexstr reader-fun)
206           (setf (symbol-function accessor-name) reader-fun)
207           (unless (dsd-read-only dsd)
208             (/show0 "setting FDEFINITION for WRITER-FUN=..")
209             (/hexstr writer-fun)
210             (setf (fdefinition `(setf ,accessor-name)) writer-fun))))))
211
212   ;; Set FDEFINITION for copier.
213   (when (dd-copier-name dd)
214     (/show0 "doing FDEFINITION for copier")
215     (protect-cl (dd-copier-name dd))
216     ;; We can't use COPY-STRUCTURE for other kinds of objects, notably
217     ;; funcallable structures, since it returns a STRUCTURE-OBJECT.
218     ;; (And funcallable instances don't need copiers anyway.)
219     (aver (eql (dd-type dd) 'structure))
220     (setf (symbol-function (dd-copier-name dd))
221           (make-defstruct-copier dd layout)))
222
223   ;; Set FDEFINITION for predicate.
224   (when (dd-predicate-name dd)
225     (/show0 "doing FDEFINITION for predicate")
226     (protect-cl (dd-predicate-name dd))
227     (setf (symbol-function (dd-predicate-name dd))
228           (make-defstruct-predicate dd layout)))
229
230   (when (dd-doc dd)
231     (setf (fdocumentation (dd-name dd) 'structure)
232           (dd-doc dd)))
233
234   ;; the BOUNDP test here is to get past cold-init.
235   (when (boundp '*defstruct-hooks*)
236     (dolist (fun *defstruct-hooks*)
237       (funcall fun (find-classoid (dd-name 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 ;;; KLUDGE: Why use this closure approach at all?  The macrology in
250 ;;; SLOT-ACCESSOR-FUNS seems to be half stub, half OAOOM to me.  --DFL
251
252 ;;; Return (VALUES SLOT-READER-FUN SLOT-WRITER-FUN).
253 (defun slot-accessor-funs (dd dsd)
254
255   #+sb-xc (/show0 "entering SLOT-ACCESSOR-FUNS")
256
257   ;; various code generators
258   ;;
259   ;; Note: They're only minimally parameterized, and cavalierly grab
260   ;; things like INSTANCE and DSD-INDEX from the namespace they're
261   ;; expanded in.
262   (macrolet (;; code shared between funcallable instance case and the
263              ;; ordinary STRUCTURE-OBJECT case: Handle native
264              ;; structures with LAYOUTs and (possibly) raw slots.
265              (%native-slot-accessor-funs (dd-ref-fun-name)
266                (let ((instance-type-check-form
267                       '(%check-structure-type-from-layout instance layout)))
268                  (/show "macroexpanding %NATIVE-SLOT-ACCESSOR-FUNS" dd-ref-fun-name instance-type-check-form)
269                  `(let ((layout (dd-layout-or-lose dd))
270                         (dsd-raw-type (dsd-raw-type dsd)))
271                     #+sb-xc (/show0 "in %NATIVE-SLOT-ACCESSOR-FUNS macroexpanded code")
272                     ;; Map over all the possible RAW-TYPEs, compiling
273                     ;; a different closure function for each one, so
274                     ;; that once the COND over RAW-TYPEs happens (at
275                     ;; the time closure is allocated) there are no
276                     ;; more decisions to be made and things execute
277                     ;; reasonably efficiently.
278                     (cond
279                      ;; nonraw slot case
280                      ((eql dsd-raw-type t)
281                       #+sb-xc (/show0 "in nonraw slot case")
282                       (%slotplace-accessor-funs
283                        (,dd-ref-fun-name instance dsd-index)
284                        ,instance-type-check-form))
285                      ;; raw slot cases
286                      ,@(mapcar (lambda (rtd)
287                                  (let ((raw-type (raw-slot-data-raw-type rtd))
288                                        (accessor-name
289                                         (raw-slot-data-accessor-name rtd)))
290                                    `((equal dsd-raw-type ',raw-type)
291                                      #+sb-xc (/show0 "in raw slot case")
292                                      (%slotplace-accessor-funs
293                                       (,accessor-name instance dsd-index)
294                                       ,instance-type-check-form))))
295                                *raw-slot-data-list*)
296                      ;; oops
297                      (t
298                       (bug "unexpected DSD-RAW-TYPE ~S" dsd-raw-type))))))
299              ;; code shared between DEFSTRUCT :TYPE LIST and
300              ;; DEFSTRUCT :TYPE VECTOR cases: Handle the "typed
301              ;; structure" case, with no LAYOUTs and no raw slots.
302              (%colontyped-slot-accessor-funs () (error "stub"))
303              ;; the common structure of the raw-slot and not-raw-slot
304              ;; cases, defined in terms of the writable SLOTPLACE. All
305              ;; possible flavors of slot access should be able to pass
306              ;; through here.
307              (%slotplace-accessor-funs (slotplace instance-type-check-form)
308                (/show "macroexpanding %SLOTPLACE-ACCESSOR-FUNS" slotplace instance-type-check-form)
309                `(let ((typecheckfun (typespec-typecheckfun dsd-type)))
310                   (values (if (dsd-safe-p dsd)
311                               (lambda (instance)
312                                 (/noshow0 "in %SLOTPLACE-ACCESSOR-FUNS-defined reader")
313                                 ,instance-type-check-form
314                                 (/noshow0 "back from INSTANCE-TYPE-CHECK-FORM")
315                                 ,slotplace)
316                               (lambda (instance)
317                                 (/noshow0 "in %SLOTPLACE-ACCESSOR-FUNS-defined reader")
318                                 ,instance-type-check-form
319                                 (/noshow0 "back from INSTANCE-TYPE-CHECK-FORM")
320                                 (let ((value ,slotplace))
321                                   (funcall typecheckfun value)
322                                   value)))
323                           (lambda (new-value instance)
324                             (/noshow0 "in %SLOTPLACE-ACCESSOR-FUNS-defined writer")
325                             ,instance-type-check-form
326                             (/noshow0 "back from INSTANCE-TYPE-CHECK-FORM")
327                             (funcall typecheckfun new-value)
328                             (/noshow0 "back from TYPECHECKFUN")
329                             (setf ,slotplace new-value))))))
330
331     (let ((dsd-index (dsd-index dsd))
332           (dsd-type (dsd-type dsd)))
333
334       #+sb-xc (/show0 "got DSD-TYPE=..")
335       #+sb-xc (/hexstr dsd-type)
336       (ecase (dd-type dd)
337
338         ;; native structures
339         (structure
340          #+sb-xc (/show0 "case of DSD-TYPE = STRUCTURE")
341          (%native-slot-accessor-funs %instance-ref))
342
343         ;; structures with the :TYPE option
344
345         ;; FIXME: Worry about these later..
346         #|
347         ;; In :TYPE LIST and :TYPE VECTOR structures, ANSI specifies the
348         ;; layout completely, so that raw slots are impossible.
349         (list
350          (dd-type-slot-accessor-funs nth-but-with-sane-arg-order
351                                  `(%check-structure-type-from-dd
352                                  :maybe-raw-p nil))
353         (vector
354          (dd-type-slot-accessor-funs aref
355                                  :maybe-raw-p nil)))
356         |#
357         ))))
358 \f
359 ;;; Copy any old kind of structure.
360 (defun copy-structure (structure)
361   #!+sb-doc
362   "Return a copy of STRUCTURE with the same (EQL) slot values."
363   (declare (type structure-object structure))
364   (let* ((len (%instance-length structure))
365          (res (%make-instance len))
366          (layout (%instance-layout structure))
367          (nuntagged (layout-n-untagged-slots layout)))
368
369     (declare (type index len))
370     (when (layout-invalid layout)
371       (error "attempt to copy an obsolete structure:~%  ~S" structure))
372
373     ;; Copy ordinary slots and layout.
374     (dotimes (i (- len nuntagged))
375       (declare (type index i))
376       (setf (%instance-ref res i)
377             (%instance-ref structure i)))
378
379     ;; Copy raw slots.
380     (dotimes (i nuntagged)
381       (declare (type index i))
382       (setf (%raw-instance-ref/word res i)
383             (%raw-instance-ref/word structure i)))
384
385     res))
386
387 \f
388
389 ;; Do an EQUALP comparison on the raw slots (only, not the normal slots) of a
390 ;; structure.
391 (defun raw-instance-slots-equalp (layout x y)
392   ;; This implementation sucks, but hopefully EQUALP on raw structures
393   ;; won't be a major bottleneck for anyone. It'd be tempting to do
394   ;; all this with %RAW-INSTANCE-REF/WORD and bitwise comparisons, but
395   ;; that'll fail in some cases. For example -0.0 and 0.0 are EQUALP
396   ;; but have different bit patterns. -- JES, 2007-08-21
397   (loop with i = -1
398         for dsd in (dd-slots (layout-info layout))
399         for raw-type = (dsd-raw-type dsd)
400         for rsd = (when raw-type
401                     (find raw-type
402                           *raw-slot-data-list*
403                           :key 'raw-slot-data-raw-type))
404         for accessor = (when rsd
405                          (raw-slot-data-accessor-name rsd))
406         always (or (not accessor)
407                    (progn
408                      (incf i)
409                      (equalp (funcall accessor x i)
410                              (funcall accessor y i))))))
411 \f
412 ;;; default PRINT-OBJECT method
413
414 (defun %print-structure-sans-layout-info (name stream)
415   ;; KLUDGE: during PCL build debugging, we can sometimes
416   ;; attempt to print out a PCL object (with null LAYOUT-INFO).
417   (pprint-logical-block (stream nil :prefix "#<" :suffix ">")
418     (prin1 name stream)
419     (write-char #\space stream)
420     (write-string "(no LAYOUT-INFO)" stream)))
421
422 (defun %print-structure-sans-slots (name stream)
423   ;; the structure type doesn't count as a component for *PRINT-LEVEL*
424   ;; processing. We can likewise elide the logical block processing,
425   ;; since all we have to print is the type name. -- CSR, 2004-10-05
426   (write-string "#S(" stream)
427   (prin1 name stream)
428   (write-char #\) stream))
429
430 (defun %default-structure-pretty-print (structure stream)
431   (let* ((layout (%instance-layout structure))
432          (name (classoid-name (layout-classoid layout)))
433          (dd (layout-info layout)))
434     (cond ((not dd)
435            (%print-structure-sans-layout-info name stream))
436           ((not (dd-slots dd))
437            (%print-structure-sans-slots name stream))
438           (t
439            (pprint-logical-block (stream nil :prefix "#S(" :suffix ")")
440              (prin1 name stream)
441              (let ((remaining-slots (dd-slots dd)))
442                (when remaining-slots
443                  (write-char #\space stream)
444                  ;; CMU CL had (PPRINT-INDENT :BLOCK 2 STREAM) here,
445                  ;; but I can't see why. -- WHN 20000205
446                  (pprint-newline :linear stream)
447                  (loop
448                    (pprint-pop)
449                    (let ((slot (pop remaining-slots)))
450                      (write-char #\: stream)
451                      (output-symbol-name (symbol-name (dsd-name slot)) stream)
452                      (write-char #\space stream)
453                      (pprint-newline :miser stream)
454                      (output-object (funcall (fdefinition (dsd-accessor-name slot))
455                                              structure)
456                                     stream)
457                      (when (null remaining-slots)
458                        (return))
459                      (write-char #\space stream)
460                      (pprint-newline :linear stream))))))))))
461
462 (defun %default-structure-ugly-print (structure stream)
463   (let* ((layout (%instance-layout structure))
464          (name (classoid-name (layout-classoid layout)))
465          (dd (layout-info layout)))
466     (cond ((not dd)
467            (%print-structure-sans-layout-info name stream))
468           ((not (dd-slots dd))
469            (%print-structure-sans-slots name stream))
470           (t
471            (descend-into (stream)
472              (write-string "#S(" stream)
473              (prin1 name stream)
474              (do ((index 0 (1+ index))
475                   (remaining-slots (dd-slots dd) (cdr remaining-slots)))
476                  ((or (null remaining-slots)
477                       (and (not *print-readably*)
478                            *print-length*
479                            (>= index *print-length*)))
480                   (if (null remaining-slots)
481                       (write-string ")" stream)
482                       (write-string " ...)" stream)))
483                (declare (type index index))
484                (write-string " :" stream)
485                (let ((slot (first remaining-slots)))
486                  (output-symbol-name (symbol-name (dsd-name slot)) stream)
487                  (write-char #\space stream)
488                  (output-object
489                   (funcall (fdefinition (dsd-accessor-name slot))
490                            structure)
491                   stream))))))))
492
493 (defun default-structure-print (structure stream depth)
494   (declare (ignore depth))
495   (cond ((funcallable-instance-p structure)
496          (print-unreadable-object (structure stream :identity t :type t)))
497         (*print-pretty*
498          (%default-structure-pretty-print structure stream))
499         (t
500          (%default-structure-ugly-print structure stream))))
501
502 (def!method print-object ((x structure-object) stream)
503   (default-structure-print x stream *current-level-in-print*))
504 \f
505 ;;;; testing structure types
506
507 ;;; Return true if OBJ is an object of the structure type
508 ;;; corresponding to LAYOUT. This is called by the accessor closures,
509 ;;; which have a handle on the type's LAYOUT.
510 ;;;
511 ;;; FIXME: This is fairly big, so it should probably become
512 ;;; MAYBE-INLINE instead of INLINE, or its inlineness should become
513 ;;; conditional (probably through DEFTRANSFORM) on (> SPEED SPACE). Or
514 ;;; else we could fix things up so that the things which call it are
515 ;;; all closures, so that it's expanded only in a small number of
516 ;;; places.
517 #!-sb-fluid (declaim (inline typep-to-layout))
518 (defun typep-to-layout (obj layout)
519   (declare (type layout layout) (optimize (speed 3) (safety 0)))
520   (/noshow0 "entering TYPEP-TO-LAYOUT, OBJ,LAYOUT=..")
521   (/nohexstr obj)
522   (/nohexstr layout)
523   (when (layout-invalid layout)
524     (error "An obsolete structure typecheck function was called."))
525   (/noshow0 "back from testing LAYOUT-INVALID LAYOUT")
526   (and (%instancep obj)
527        (let ((obj-layout (%instance-layout obj)))
528          (when (eq obj-layout layout)
529            ;; (In this case OBJ-LAYOUT can't be invalid, because
530            ;; we determined LAYOUT is valid in the test above.)
531            (/noshow0 "EQ case")
532            (return-from typep-to-layout t))
533          (when (layout-invalid obj-layout)
534            (/noshow0 "LAYOUT-INVALID case")
535            (setf obj-layout (update-object-layout-or-invalid obj layout)))
536          (let ((depthoid (layout-depthoid layout)))
537            (/noshow0 "DEPTHOID case, DEPTHOID,LAYOUT-INHERITS=..")
538            (/nohexstr depthoid)
539            (/nohexstr layout-inherits)
540            (and (> (layout-depthoid obj-layout) depthoid)
541                 (eq (svref (layout-inherits obj-layout) depthoid)
542                     layout))))))
543 \f
544 ;;;; checking structure types
545
546 ;;; Check that X is an instance of the named structure type.
547 (defmacro %check-structure-type-from-name (x name)
548   `(%check-structure-type-from-layout ,x ,(compiler-layout-or-lose name)))
549
550 ;;; Check that X is a structure of the type described by DD.
551 (defmacro %check-structure-type-from-dd (x dd)
552   (declare (type defstruct-description dd))
553   (let ((class-name (dd-name dd)))
554     (ecase (dd-type dd)
555       ((structure funcallable-instance)
556        `(%check-structure-type-from-layout
557          ,x
558          ,(compiler-layout-or-lose class-name)))
559       ((vector)
560        (with-unique-names (xx)
561          `(let ((,xx ,x))
562             (declare (type vector ,xx))
563             ,@(when (dd-named dd)
564                 `((unless (eql (aref ,xx 0) ',class-name)
565                     (error
566                      'simple-type-error
567                      :datum (aref ,xx 0)
568                      :expected-type `(member ,class-name)
569                      :format-control
570                      "~@<missing name in instance of ~
571                       VECTOR-typed structure ~S: ~2I~_S~:>"
572                      :format-arguments (list ',class-name ,xx)))))
573             (values))))
574       ((list)
575        (with-unique-names (xx)
576          `(let ((,xx ,x))
577             (declare (type list ,xx))
578             ,@(when (dd-named dd)
579                 `((unless (eql (first ,xx) ',class-name)
580                     (error
581                      'simple-type-error
582                      :datum (aref ,xx 0)
583                      :expected-type `(member ,class-name)
584                      :format-control
585                      "~@<missing name in instance of LIST-typed structure ~S: ~
586                       ~2I~_S~:>"
587                      :format-arguments (list ',class-name ,xx)))))
588             (values)))))))
589
590 ;;; Check that X is an instance of the structure class with layout LAYOUT.
591 (defun %check-structure-type-from-layout (x layout)
592   (unless (typep-to-layout x layout)
593     (error 'type-error
594            :datum x
595            :expected-type (classoid-name (layout-classoid layout))))
596   (values))
597
598 \f
599 (/show0 "target-defstruct.lisp end of file")