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 (defun %make-instance (length)
  17   #!+sb-doc
  18   "Allocate a new instance with LENGTH data slots."
  19   (declare (type index length))
  20   (%make-instance length))
  21
  22 (defun %instance-length (instance)
  23   #!+sb-doc
  24   "Given an instance, return its length."
  25   (declare (type instance instance))
  26   (%instance-length instance))
  27
  28 (defun %instance-ref (instance index)
  29   #!+sb-doc
  30   "Return the value from the INDEXth slot of INSTANCE. This is SETFable."
  31   (%instance-ref instance index))
  32
  33 (defun %instance-set (instance index new-value)
  34   #!+sb-doc
  35   "Set the INDEXth slot of INSTANCE to NEW-VALUE."
  36   (setf (%instance-ref instance index) new-value))
  37
  38 (defun %raw-ref-single (vec index)
  39   (declare (type index index))
  40   (%raw-ref-single vec index))
  41
  42 (defun %raw-ref-double (vec index)
  43   (declare (type index index))
  44   (%raw-ref-double vec index))
  45
  46 #!+long-float
  47 (defun %raw-ref-long (vec index)
  48   (declare (type index index))
  49   (%raw-ref-long vec index))
  50
  51 (defun %raw-set-single (vec index val)
  52   (declare (type index index))
  53   (%raw-set-single vec index val))
  54
  55 (defun %raw-set-double (vec index val)
  56   (declare (type index index))
  57   (%raw-set-double vec index val))
  58
  59 #!+long-float
  60 (defun %raw-set-long (vec index val)
  61   (declare (type index index))
  62   (%raw-set-long vec index val))
  63
  64 (defun %raw-ref-complex-single (vec index)
  65   (declare (type index index))
  66   (%raw-ref-complex-single vec index))
  67
  68 (defun %raw-ref-complex-double (vec index)
  69   (declare (type index index))
  70   (%raw-ref-complex-double vec index))
  71
  72 #!+long-float
  73 (defun %raw-ref-complex-long (vec index)
  74   (declare (type index index))
  75   (%raw-ref-complex-long vec index))
  76
  77 (defun %raw-set-complex-single (vec index val)
  78   (declare (type index index))
  79   (%raw-set-complex-single vec index val))
  80
  81 (defun %raw-set-complex-double (vec index val)
  82   (declare (type index index))
  83   (%raw-set-complex-double vec index val))
  84
  85 #!+long-float
  86 (defun %raw-set-complex-long (vec index val)
  87   (declare (type index index))
  88   (%raw-set-complex-long vec index val))
  89
  90 (defun %instance-layout (instance)
  91   (%instance-layout instance))
  92
  93 (defun %set-instance-layout (instance new-value)
  94   (%set-instance-layout instance new-value))
  95
  96 (defun %make-funcallable-instance (len layout)
  97    (%make-funcallable-instance len layout))
  98
  99 (defun funcallable-instance-p (x) (funcallable-instance-p x))
 100
 101 (defun %funcallable-instance-info (fin i)
 102   (%funcallable-instance-info fin i))
 103
 104 (defun %set-funcallable-instance-info (fin i new-value)
 105   (%set-funcallable-instance-info fin i new-value))
 106
 107 (defun funcallable-instance-function (fin)
 108   (%funcallable-instance-lexenv fin))
 109
 110 ;;; The heart of the magic of funcallable instances ("FINs"). The
 111 ;;; function for a FIN must be a magical INSTANCE-LAMBDA form. When
 112 ;;; called (as with any other function), we grab the code pointer, and
 113 ;;; call it, leaving the original function object in LEXENV (in case
 114 ;;; it was a closure). If it is actually a FIN, then we need to do an
 115 ;;; extra indirection with funcallable-instance-lexenv to get at any
 116 ;;; closure environment. This extra indirection is set up when
 117 ;;; accessing the closure environment of an INSTANCE-LAMBDA. Note that
 118 ;;; the original FIN pointer is lost, so if the called function wants
 119 ;;; to get at the original object to do some slot accesses, it must
 120 ;;; close over the FIN object.
 121 ;;;
 122 ;;; If we set the FIN function to be a FIN, we directly copy across
 123 ;;; both the code pointer and the lexenv, since that code pointer (for
 124 ;;; an instance-lambda) is expecting that lexenv to be accessed. This
 125 ;;; effectively pre-flattens what would otherwise be a chain of
 126 ;;; indirections. (That used to happen when PCL dispatch functions
 127 ;;; were byte-compiled; now that the byte compiler is gone, I can't
 128 ;;; think of another example offhand. -- WHN 2001-10-06)
 129 ;;;
 130 ;;; The only loss is that if someone accesses the
 131 ;;; FUNCALLABLE-INSTANCE-FUNCTION, then won't get a FIN back. This
 132 ;;; probably doesn't matter, since PCL only sets the FIN function. And
 133 ;;; the only reason that interpreted functions are FINs instead of
 134 ;;; bare closures is for debuggability.
 135 (defun (setf funcallable-instance-function) (new-value fin)
 136   (setf (%funcallable-instance-function fin)
 137         (%closure-function new-value))
 138   (setf (%funcallable-instance-lexenv fin)
 139         (if (funcallable-instance-p new-value)
 140             (%funcallable-instance-lexenv new-value)
 141             new-value)))
 142 \f
 143 ;;; Copy any old kind of structure.
 144 (defun copy-structure (structure)
 145   #!+sb-doc
 146   "Return a copy of STRUCTURE with the same (EQL) slot values."
 147   (declare (type structure-object structure))
 148   (let* ((len (%instance-length structure))
 149          (res (%make-instance len))
 150          (layout (%instance-layout structure)))
 151
 152     (declare (type index len))
 153     (when (layout-invalid layout)
 154       (error "attempt to copy an obsolete structure:~%  ~S" structure))
 155
 156     ;; Copy ordinary slots.
 157     (dotimes (i len)
 158       (declare (type index i))
 159       (setf (%instance-ref res i)
 160             (%instance-ref structure i)))
 161
 162     ;; Copy raw slots.
 163     (let ((raw-index (dd-raw-index (layout-info layout))))
 164       (when raw-index
 165         (let* ((data (%instance-ref structure raw-index))
 166                (raw-len (length data))
 167                (new (make-array raw-len :element-type '(unsigned-byte 32))))
 168           (declare (type (simple-array (unsigned-byte 32) (*)) data))
 169           (setf (%instance-ref res raw-index) new)
 170           (dotimes (i raw-len)
 171             (setf (aref new i) (aref data i))))))
 172
 173     res))
 174 \f
 175 ;;; default PRINT and MAKE-LOAD-FORM methods
 176
 177 (defun default-structure-print (structure stream depth)
 178   (declare (ignore depth))
 179   (if (funcallable-instance-p structure)
 180       (print-unreadable-object (structure stream :identity t :type t))
 181       (let* ((type (%instance-layout structure))
 182              (name (sb!xc:class-name (layout-class type)))
 183              (dd (layout-info type)))
 184         (if *print-pretty*
 185             (pprint-logical-block (stream nil :prefix "#S(" :suffix ")")
 186               (prin1 name stream)
 187               (let ((slots (dd-slots dd)))
 188                 (when slots
 189                   (write-char #\space stream)
 190                   ;; CMU CL had (PPRINT-INDENT :BLOCK 2 STREAM) here,
 191                   ;; but I can't see why. -- WHN 20000205
 192                   (pprint-newline :linear stream)
 193                   (loop
 194                     (pprint-pop)
 195                     (let ((slot (pop slots)))
 196                       (write-char #\: stream)
 197                       (output-symbol-name (dsd-%name slot) stream)
 198                       (write-char #\space stream)
 199                       (pprint-newline :miser stream)
 200                       (output-object
 201                        (funcall (fdefinition (dsd-accessor-name slot))
 202                                 structure)
 203                        stream)
 204                       (when (null slots)
 205                         (return))
 206                       (write-char #\space stream)
 207                       (pprint-newline :linear stream))))))
 208             (descend-into (stream)
 209               (write-string "#S(" stream)
 210               (prin1 name stream)
 211               (do ((index 0 (1+ index))
 212                    (slots (dd-slots dd) (cdr slots)))
 213                   ((or (null slots)
 214                        (and (not *print-readably*)
 215                             *print-length*
 216                             (>= index *print-length*)))
 217                    (if (null slots)
 218                        (write-string ")" stream)
 219                        (write-string " ...)" stream)))
 220                 (declare (type index index))
 221                 (write-char #\space stream)
 222                 (write-char #\: stream)
 223                 (let ((slot (first slots)))
 224                   (output-symbol-name (dsd-%name slot) stream)
 225                   (write-char #\space stream)
 226                   (output-object
 227                    (funcall (fdefinition (dsd-accessor-name slot))
 228                             structure)
 229                    stream))))))))
 230 (def!method print-object ((x structure-object) stream)
 231   (default-structure-print x stream *current-level*))
 232
 233 (defun make-load-form-saving-slots (object &key slot-names environment)
 234   (declare (ignore object environment))
 235   (if slot-names
 236     (error "stub: MAKE-LOAD-FORM-SAVING-SLOTS :SLOT-NAMES not implemented") ; KLUDGE
 237     :just-dump-it-normally))
 238 \f
 239 ;;; Return true if OBJ is an object of the structure type
 240 ;;; corresponding to LAYOUT. This is called by the accessor closures,
 241 ;;; which have a handle on the type's layout.
 242 ;;;
 243 ;;; FIXME: This is fairly big, so it should probably become
 244 ;;; MAYBE-INLINE instead of INLINE. Or else we could fix things up so
 245 ;;; that the things which call it are all closures, so that it's
 246 ;;; expanded only in a small number of places.
 247 #!-sb-fluid (declaim (inline typep-to-layout))
 248 (defun typep-to-layout (obj layout)
 249   (declare (type layout layout) (optimize (speed 3) (safety 0)))
 250   (when (layout-invalid layout)
 251     (error "An obsolete structure accessor function was called."))
 252   ;; FIXME: CMU CL used (%INSTANCEP OBJ) here. Check that
 253   ;; (TYPEP OBJ 'INSTANCE) is optimized to equally efficient code.
 254   (and (typep obj 'instance)
 255        (let ((obj-layout (%instance-layout obj)))
 256          (cond ((eq obj-layout layout)
 257                 t)
 258                ;; FIXME: Does the test for LAYOUT-INVALID really belong
 259                ;; after the test for EQ LAYOUT? Either explain why this
 260                ;; is, or change the order.
 261                ((layout-invalid obj-layout)
 262                 (error 'layout-invalid
 263                        :expected-type (layout-class obj-layout)
 264                        :datum obj))
 265                (t
 266                  (let ((depthoid (layout-depthoid layout)))
 267                    (and (> (layout-depthoid obj-layout) depthoid)
 268                         (eq (svref (layout-inherits obj-layout) depthoid)
 269                             layout))))))))
 270 \f
 271 ;;;; implementing structure slot accessors as closures
 272
 273 ;;; In the normal case of structures that have a real type (i.e. no
 274 ;;; :TYPE option was specified), we want to optimize things for space
 275 ;;; as well as speed, since there can be thousands of defined slot
 276 ;;; accessors.
 277 ;;;
 278 ;;; What we do is define the accessors and copier as closures over
 279 ;;; general-case code. Since the compiler will normally open-code
 280 ;;; accessors, the (minor) extra speed penalty for full calls is not a
 281 ;;; concern.
 282 ;;;
 283 ;;; KLUDGE: This is a minor headache at cold init time, since genesis
 284 ;;; doesn't know how to create the closures in the cold image, so the
 285 ;;; function definitions aren't done until the appropriate top level
 286 ;;; forms are executed, so any forward references to structure slots
 287 ;;; (which are compiled into full calls) fail. The headache can be
 288 ;;; treated by using SB!XC:DEFSTRUCT on the relevant structure at
 289 ;;; build-the-cross-compiler time, so that the compiler is born
 290 ;;; knowing how to inline accesses to the relevant structure, so no
 291 ;;; full calls are made. This can be achieved by calling
 292 ;;; SB!XC:DEFSTRUCT directly, or by using DEF!STRUCT, which (among
 293 ;;; other things) calls SB!XC:DEFSTRUCT for you.
 294
 295 ;;; Return closures to do slot access according to Layout and DSD. We check
 296 ;;; types, then do the access. This is only used for normal slots, not raw
 297 ;;; slots.
 298 (defun structure-slot-getter (layout dsd)
 299   (let ((class (layout-class layout)))
 300     (if (typep class 'basic-structure-class)
 301         #'(lambda (structure)
 302             (declare (optimize (speed 3) (safety 0)))
 303             (flet ((structure-test (structure)
 304                      (typep-to-layout structure layout)))
 305               (unless (structure-test structure)
 306                 (error 'simple-type-error
 307                        :datum structure
 308                        :expected-type (class-name (layout-class layout))
 309                        :format-control
 310                        "Structure for accessor ~S is not a ~S:~% ~S"
 311                        :format-arguments
 312                        (list (dsd-accessor-name dsd)
 313                              (sb!xc:class-name (layout-class layout))
 314                              structure))))
 315             (%instance-ref structure (dsd-index dsd)))
 316         #'(lambda (structure)
 317             (declare (optimize (speed 3) (safety 0)))
 318             (unless (%typep structure class)
 319               (error 'simple-type-error
 320                      :datum structure
 321                      :expected-type 'class
 322                      :format-control
 323                      "The structure for accessor ~S is not a ~S:~% ~S"
 324                      :format-arguments
 325                      (list (dsd-accessor-name dsd) class
 326                            structure)))
 327             (%instance-ref structure (dsd-index dsd))))))
 328 (defun structure-slot-setter (layout dsd)
 329   (let ((class (layout-class layout)))
 330     (if (typep class 'basic-structure-class)
 331         #'(lambda (new-value structure)
 332             (declare (optimize (speed 3) (safety 0)))
 333             (flet ((structure-test (structure)
 334                      (typep-to-layout structure layout))
 335                    (typep-test (new-value)
 336                      (%typep new-value (dsd-type dsd))))
 337               (unless (structure-test structure)
 338                 (error 'simple-type-error
 339                        :datum structure
 340                        :expected-type (class-name (layout-class layout))
 341                        :format-control
 342                        "The structure for setter ~S is not a ~S:~% ~S"
 343                        :format-arguments
 344                        (list `(setf ,(dsd-accessor-name dsd))
 345                              (sb!xc:class-name (layout-class layout))
 346                              structure)))
 347               (unless  (typep-test new-value)
 348                 (error 'simple-type-error
 349                        :datum new-value
 350                        :expected-type (class-name (layout-class layout))
 351                        :format-control
 352                        "The new value for setter ~S is not a ~S:~% ~S"
 353                        :format-arguments
 354                        (list `(setf ,(dsd-accessor-name dsd))
 355                               (dsd-type dsd)
 356                               new-value))))
 357             (setf (%instance-ref structure (dsd-index dsd)) new-value))
 358         #'(lambda (new-value structure)
 359             (declare (optimize (speed 3) (safety 0)))
 360             (flet ((structure-test (structure)
 361                      (sb!xc:typep structure class))
 362                    (typep-test (new-value)
 363                      (%typep new-value (dsd-type dsd))))
 364               (unless (structure-test structure)
 365                 (error 'simple-type-error
 366                        :datum structure
 367                        :expected-type (class-name (layout-class layout))
 368                        :format-control
 369                        "The structure for setter ~S is not a ~S:~% ~S"
 370                        :format-arguments
 371                        (list `(setf ,(dsd-accessor-name dsd))
 372                              (sb!xc:class-name class)
 373                              structure)))
 374               (unless  (typep-test new-value)
 375                 (error 'simple-type-error
 376                        :datum new-value
 377                        :expected-type (class-name (layout-class layout))
 378                        :format-control
 379                        "The new value for setter ~S is not a ~S:~% ~S"
 380                        :format-arguments
 381                        (list `(setf ,(dsd-accessor-name dsd))
 382                              (dsd-type dsd)
 383                              new-value))))
 384             (setf (%instance-ref structure (dsd-index dsd)) new-value)))))
 385
 386 (/show0 "target-defstruct.lisp end of file")