chiark - git - mdw - sod/blob - src/class-output.lisp

   1 ;;; -*-lisp-*-
   2 ;;;
   3 ;;; Output for classes
   4 ;;;
   5 ;;; (c) 2009 Straylight/Edgeware
   6 ;;;
   7
   8 ;;;----- Licensing notice ---------------------------------------------------
   9 ;;;
  10 ;;; This file is part of the Sensble Object Design, an object system for C.
  11 ;;;
  12 ;;; SOD is free software; you can redistribute it and/or modify
  13 ;;; it under the terms of the GNU General Public License as published by
  14 ;;; the Free Software Foundation; either version 2 of the License, or
  15 ;;; (at your option) any later version.
  16 ;;;
  17 ;;; SOD is distributed in the hope that it will be useful,
  18 ;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 ;;; GNU General Public License for more details.
  21 ;;;
  22 ;;; You should have received a copy of the GNU General Public License
  23 ;;; along with SOD; if not, write to the Free Software Foundation,
  24 ;;; Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  25
  26 (cl:in-package #:sod)
  27
  28 ;;;--------------------------------------------------------------------------
  29 ;;; Classes.
  30
  31 (defmethod hook-output progn ((class sod-class) (reason (eql :h)) sequencer)
  32
  33   ;; Main output sequencing.
  34   (sequence-output (stream sequencer)
  35
  36     :constraint
  37     ((:classes :start)
  38      (class :banner)
  39      (class :islots :start) (class :islots :slots) (class :islots :end)
  40      (class :vtmsgs :start) (class :vtmsgs :end)
  41      (class :vtables :start) (class :vtables :end)
  42      (class :vtable-externs) (class :vtable-externs-after)
  43      (class :methods :start) (class :methods) (class :methods :end)
  44      (class :ichains :start) (class :ichains :end)
  45      (class :ilayout :start) (class :ilayout :slots) (class :ilayout :end)
  46      (class :conversions)
  47      (class :object)
  48      (:classes :end))
  49
  50     (:typedefs
  51      (format stream "typedef struct ~A ~A;~%"
  52              (ichain-struct-tag class (sod-class-chain-head class)) class))
  53
  54     ((class :banner)
  55      (banner (format nil "Class ~A" class) stream))
  56     ((class :vtable-externs-after)
  57      (terpri stream))
  58
  59     ((class :vtable-externs)
  60      (format stream "/* Vtable structures. */~%"))
  61
  62     ((class :object)
  63      (let ((metaclass (sod-class-metaclass class))
  64            (metaroot (find-root-metaclass class)))
  65        (format stream "/* The class object. */~@
  66                        extern const struct ~A ~A__classobj;~@
  67                        #define ~:*~A__class (&~:*~A__classobj.~A.~A)~2%"
  68                (ilayout-struct-tag metaclass) class
  69                (sod-class-nickname (sod-class-chain-head metaroot))
  70                (sod-class-nickname metaroot)))))
  71
  72   ;; Maybe generate an islots structure.
  73   (when (sod-class-slots class)
  74     (dolist (slot (sod-class-slots class))
  75       (hook-output slot 'islots sequencer))
  76     (sequence-output (stream sequencer)
  77       ((class :islots :start)
  78        (format stream "/* Instance slots. */~@
  79                        struct ~A {~%"
  80                (islots-struct-tag class)))
  81       ((class :islots :end)
  82        (format stream "};~2%"))))
  83
  84   ;; Declare the direct methods.
  85   (when (sod-class-methods class)
  86     (sequence-output (stream sequencer)
  87       ((class :methods :start)
  88        (format stream "/* Direct methods. */~%"))
  89       ((class :methods :end)
  90        (terpri stream))))
  91
  92   ;; Provide upcast macros which do the right thing.
  93   (when (sod-class-direct-superclasses class)
  94     (sequence-output (stream sequencer)
  95       ((class :conversions)
  96        (let ((chain-head (sod-class-chain-head class)))
  97          (format stream "/* Conversion macros. */~%")
  98          (dolist (super (cdr (sod-class-precedence-list class)))
  99            (let ((super-head (sod-class-chain-head super)))
 100              (format stream "#define ~:@(~A__CONV_~A~)(p) ((~A *)~
 101                                      ~:[SOD_XCHAIN(~A, (p))~;(p)~])~%"
 102                      class (sod-class-nickname super) super
 103                      (eq chain-head super-head)
 104                      (sod-class-nickname super-head))))
 105          (terpri stream)))))
 106
 107   ;; Generate vtmsgs structure for all superclasses.
 108   (hook-output (car (sod-class-vtables class))
 109                     'vtmsgs
 110                     sequencer))
 111
 112 (defmethod hook-output progn ((class sod-class) reason sequencer)
 113   (with-slots (ilayout vtables methods) class
 114     (hook-output ilayout reason sequencer)
 115     (dolist (method methods) (hook-output method reason sequencer))
 116     (dolist (vtable vtables) (hook-output vtable reason sequencer))))
 117
 118 ;;;--------------------------------------------------------------------------
 119 ;;; Instance structure.
 120
 121 (defmethod hook-output progn ((slot sod-slot)
 122                               (reason (eql 'islots))
 123                               sequencer)
 124   (sequence-output (stream sequencer)
 125     (((sod-slot-class slot) :islots :slots)
 126      (pprint-logical-block (stream nil :prefix "  " :suffix ";")
 127        (pprint-c-type (sod-slot-type slot) stream (sod-slot-name slot)))
 128      (terpri stream))))
 129
 130 (defmethod hook-output progn ((ilayout ilayout) reason sequencer)
 131   (with-slots (ichains) ilayout
 132     (dolist (ichain ichains) (hook-output ichain reason sequencer))))
 133
 134 (defmethod hook-output progn ((ichain ichain) reason sequencer)
 135   (dolist (item (ichain-body ichain))
 136     (hook-output item reason sequencer)))
 137
 138 (defmethod hook-output progn ((ilayout ilayout) (reason (eql :h)) sequencer)
 139   (with-slots (class ichains) ilayout
 140     (sequence-output (stream sequencer)
 141       ((class :ilayout :start)
 142        (format stream "/* Instance layout. */~@
 143                        struct ~A {~%"
 144                (ilayout-struct-tag class)))
 145       ((class :ilayout :end)
 146        (format stream "};~2%")))
 147     (dolist (ichain ichains)
 148       (hook-output ichain 'ilayout sequencer))))
 149
 150 (defmethod hook-output progn ((ichain ichain) (reason (eql :h)) sequencer)
 151   (with-slots (class chain-head chain-tail) ichain
 152     (when (eq class chain-tail)
 153       (sequence-output (stream sequencer)
 154         :constraint ((class :ichains :start)
 155                      (class :ichain chain-head :start)
 156                      (class :ichain chain-head :slots)
 157                      (class :ichain chain-head :end)
 158                      (class :ichains :end))
 159         ((class :ichain chain-head :start)
 160          (format stream "/* Instance chain structure. */~@
 161                          struct ~A {~%"
 162                  (ichain-struct-tag chain-tail chain-head)))
 163         ((class :ichain chain-head :end)
 164          (format stream "};~2%")
 165          (format stream "/* Union of equivalent superclass chains. */~@
 166                          union ~A {~@
 167                          ~:{  struct ~A ~A;~%~}~
 168                          };~2%"
 169                  (ichain-union-tag chain-tail chain-head)
 170
 171                  ;; Make sure the most specific class is first: only the
 172                  ;; first element of a union can be statically initialized in
 173                  ;; C90.
 174                  (mapcar (lambda (super)
 175                            (list (ichain-struct-tag super chain-head)
 176                                  (sod-class-nickname super)))
 177                          (sod-class-chain chain-tail))))))))
 178
 179 (defmethod hook-output progn ((ichain ichain)
 180                               (reason (eql 'ilayout))
 181                               sequencer)
 182   (with-slots (class chain-head chain-tail) ichain
 183     (sequence-output (stream sequencer)
 184       ((class :ilayout :slots)
 185        (format stream "  union ~A ~A;~%"
 186                (ichain-union-tag chain-tail chain-head)
 187                (sod-class-nickname chain-head))))))
 188
 189 (defmethod hook-output progn ((vtptr vtable-pointer)
 190                               (reason (eql :h))
 191                               sequencer)
 192   (with-slots (class chain-head chain-tail) vtptr
 193     (sequence-output (stream sequencer)
 194       ((class :ichain chain-head :slots)
 195        (format stream "  const struct ~A *_vt;~%"
 196                (vtable-struct-tag chain-tail chain-head))))))
 197
 198 (defmethod hook-output progn ((islots islots) reason sequencer)
 199   (dolist (slot (islots-slots islots))
 200     (hook-output slot reason sequencer)))
 201
 202 (defmethod hook-output progn ((islots islots) (reason (eql :h)) sequencer)
 203   (with-slots (class subclass slots) islots
 204     (sequence-output (stream sequencer)
 205       ((subclass :ichain (sod-class-chain-head class) :slots)
 206        (format stream "  struct ~A ~A;~%"
 207                (islots-struct-tag class)
 208                (sod-class-nickname class))))))
 209
 210 ;;;--------------------------------------------------------------------------
 211 ;;; Vtable structure.
 212
 213 (defmethod hook-output progn ((vtable vtable) reason sequencer)
 214   (with-slots (body) vtable
 215     (dolist (item body) (hook-output item reason sequencer))))
 216
 217 (defmethod hook-output progn ((method sod-method)
 218                               (reason (eql :h))
 219                               sequencer)
 220   (with-slots (class) method
 221     (sequence-output (stream sequencer)
 222       ((class :methods)
 223        (let ((type (sod-method-function-type method)))
 224          (princ "extern " stream)
 225          (pprint-c-type (commentify-function-type type) stream
 226                         (sod-method-function-name method))
 227          (format stream ";~%"))))))
 228
 229 (defmethod hook-output progn ((vtable vtable) (reason (eql :h)) sequencer)
 230   (with-slots (class chain-head chain-tail) vtable
 231     (when (eq class chain-tail)
 232       (sequence-output (stream sequencer)
 233         :constraint ((class :vtables :start)
 234                      (class :vtable chain-head :start)
 235                      (class :vtable chain-head :slots)
 236                      (class :vtable chain-head :end)
 237                      (class :vtables :end))
 238         ((class :vtable chain-head :start)
 239          (format stream "/* Vtable structure. */~@
 240                          struct ~A {~%"
 241                  (vtable-struct-tag chain-tail chain-head)))
 242         ((class :vtable chain-head :end)
 243          (format stream "};~2%"))))
 244     (sequence-output (stream sequencer)
 245       ((class :vtable-externs)
 246        (format stream "~@<extern const struct ~A ~2I~_~A__vtable_~A;~:>~%"
 247                (vtable-struct-tag chain-tail chain-head)
 248                class (sod-class-nickname chain-head))))))
 249
 250 (defmethod hook-output progn ((vtmsgs vtmsgs) (reason (eql :h)) sequencer)
 251   (with-slots (class subclass chain-head chain-tail) vtmsgs
 252     (sequence-output (stream sequencer)
 253       ((subclass :vtable chain-head :slots)
 254        (format stream "  struct ~A ~A;~%"
 255                (vtmsgs-struct-tag subclass class)
 256                (sod-class-nickname class))))))
 257
 258 (defmethod hook-output progn ((vtmsgs vtmsgs)
 259                               (reason (eql 'vtmsgs))
 260                               sequencer)
 261   (when (vtmsgs-entries vtmsgs)
 262     (with-slots (class subclass) vtmsgs
 263       (sequence-output (stream sequencer)
 264         :constraint ((subclass :vtmsgs :start)
 265                      (subclass :vtmsgs class :start)
 266                      (subclass :vtmsgs class :slots)
 267                      (subclass :vtmsgs class :end)
 268                      (subclass :vtmsgs :end))
 269         ((subclass :vtmsgs class :start)
 270          (format stream "/* Messages protocol from class ~A */~@
 271                          struct ~A {~%"
 272                  class
 273                  (vtmsgs-struct-tag subclass class)))
 274         ((subclass :vtmsgs class :end)
 275          (format stream "};~2%"))))))
 276
 277 (defmethod hook-output progn ((vtmsgs vtmsgs) reason sequencer)
 278   (with-slots (entries) vtmsgs
 279     (dolist (entry entries) (hook-output entry reason sequencer))))
 280
 281 (defmethod hook-output progn ((entry method-entry) reason sequencer)
 282   (with-slots (method) entry
 283     (hook-output method reason sequencer)))
 284
 285 (defmethod hook-output progn ((entry method-entry)
 286                               (reason (eql 'vtmsgs))
 287                               sequencer)
 288   (let* ((method (method-entry-effective-method entry))
 289          (message (effective-method-message method))
 290          (class (effective-method-class method))
 291          (function-type (method-entry-function-type entry))
 292          (commented-type (commentify-function-type function-type))
 293          (pointer-type (make-pointer-type commented-type)))
 294     (sequence-output (stream sequencer)
 295       ((class :vtmsgs (sod-message-class message) :slots)
 296        (pprint-logical-block (stream nil :prefix "  " :suffix ";")
 297          (pprint-c-type pointer-type stream (sod-message-name message)))
 298        (terpri stream)))))
 299
 300 (defmethod hook-output progn ((cptr class-pointer)
 301                               (reason (eql :h))
 302                               sequencer)
 303   (with-slots (class chain-head metaclass meta-chain-head) cptr
 304     (sequence-output (stream sequencer)
 305       ((class :vtable chain-head :slots)
 306        (format stream "  const ~A *~:[_class~;~:*_cls_~A~];~%"
 307                metaclass
 308                (and (sod-class-direct-superclasses meta-chain-head)
 309                     (sod-class-nickname meta-chain-head)))))))
 310
 311 (defmethod hook-output progn ((boff base-offset) (reason (eql :h)) sequencer)
 312   (with-slots (class chain-head) boff
 313     (sequence-output (stream sequencer)
 314       ((class :vtable chain-head :slots)
 315        (write-line "  size_t _base;" stream)))))
 316
 317 (defmethod hook-output progn ((choff chain-offset)
 318                               (reason (eql :h))
 319                               sequencer)
 320   (with-slots (class chain-head target-head) choff
 321     (sequence-output (stream sequencer)
 322       ((class :vtable chain-head :slots)
 323        (format stream "  ptrdiff_t _off_~A;~%"
 324                (sod-class-nickname target-head))))))
 325
 326 ;;;--------------------------------------------------------------------------
 327 ;;; Implementation output.
 328
 329 (defvar *instance-class*)
 330
 331 (defmethod hook-output progn ((class sod-class) (reason (eql :c)) sequencer)
 332   (sequence-output (stream sequencer)
 333
 334     :constraint
 335     ((:classes :start)
 336      (class :banner)
 337      (class :direct-methods :start) (class :direct-methods :end)
 338      (class :effective-methods)
 339      (class :vtables :start) (class :vtables :end)
 340      (class :object :prepare) (class :object :start) (class :object :end)
 341      (:classes :end))
 342
 343     ((class :banner)
 344      (banner (format nil "Class ~A" class) stream))
 345
 346     ((class :object :start)
 347      (format stream "~
 348 /* The class object. */
 349 const struct ~A ~A__classobj = {~%"
 350              (ilayout-struct-tag (sod-class-metaclass class))
 351              class))
 352     ((class :object :end)
 353      (format stream "};~2%")))
 354
 355   (let ((*instance-class* class))
 356     (hook-output (sod-class-ilayout (sod-class-metaclass class))
 357                       'class
 358                       sequencer)))
 359
 360 ;;;--------------------------------------------------------------------------
 361 ;;; Direct and effective methods.
 362
 363 (defmethod hook-output progn ((method delegating-direct-method)
 364                               (reason (eql :c))
 365                               sequencer)
 366   (with-slots (class body) method
 367     (unless body
 368       (return-from hook-output))
 369     (sequence-output (stream sequencer)
 370       ((class :direct-method method :start)
 371        (format stream "#define CALL_NEXT_METHOD (next_method(~{~A~^, ~}))~%"
 372                (mapcar #'argument-name
 373                        (c-function-arguments (sod-method-next-method-type
 374                                               method)))))
 375       ((class :direct-method method :end)
 376        (format stream "#undef CALL_NEXT_METHOD~%")))))
 377
 378 (defmethod hook-output progn ((method sod-method)
 379                               (reason (eql :c))
 380                               sequencer)
 381   (with-slots (class body) method
 382     (unless body
 383       (return-from hook-output))
 384     (sequence-output (stream sequencer)
 385       :constraint ((class :direct-methods :start)
 386                    (class :direct-method method :start)
 387                    (class :direct-method method :body)
 388                    (class :direct-method method :end)
 389                    (class :direct-methods :end))
 390       ((class :direct-method method :body)
 391        (pprint-c-type (sod-method-function-type method)
 392                       stream
 393                       (sod-method-function-name method))
 394        (format stream "~&{~%")
 395        (write body :stream stream :pretty nil :escape nil)
 396        (format stream "~&}~%"))
 397       ((class :direct-method method :end)
 398        (terpri stream)))))
 399
 400 (defmethod hook-output progn ((method basic-effective-method)
 401                               (reason (eql :c))
 402                               sequencer)
 403   (with-slots (class functions) method
 404     (sequence-output (stream sequencer)
 405       ((class :effective-methods)
 406        (dolist (func functions)
 407          (write func :stream stream :escape nil :circle nil))))))
 408
 409 ;;;--------------------------------------------------------------------------
 410 ;;; Vtables.
 411
 412 (defmethod hook-output progn ((vtable vtable) (reason (eql :c)) sequencer)
 413   (with-slots (class chain-head chain-tail) vtable
 414     (sequence-output (stream sequencer)
 415       :constraint ((class :vtables :start)
 416                    (class :vtable chain-head :start)
 417                    (class :vtable chain-head :end)
 418                    (class :vtables :end))
 419       ((class :vtable chain-head :start)
 420        (format stream "/* Vtable for ~A chain. */~@
 421                        const struct ~A ~A = {~%"
 422                chain-head
 423                (vtable-struct-tag chain-tail chain-head)
 424                (vtable-name class chain-head)))
 425       ((class :vtable chain-head :end)
 426        (format stream "};~2%")))))
 427
 428 (defmethod hook-output progn ((cptr class-pointer)
 429                               (reason (eql :c))
 430                               sequencer)
 431   (with-slots (class chain-head metaclass meta-chain-head) cptr
 432     (sequence-output (stream sequencer)
 433       :constraint ((class :vtable chain-head :start)
 434                    (class :vtable chain-head :class-pointer metaclass)
 435                    (class :vtable chain-head :end))
 436       ((class :vtable chain-head :class-pointer metaclass)
 437        (format stream "  /* ~21@A = */ &~A__classobj.~A.~A,~%"
 438                (if (sod-class-direct-superclasses meta-chain-head)
 439                    (format nil "_cls_~A"
 440                            (sod-class-nickname meta-chain-head))
 441                    "_class")
 442                (sod-class-metaclass class)
 443                (sod-class-nickname meta-chain-head)
 444                (sod-class-nickname metaclass))))))
 445
 446 (defmethod hook-output progn ((boff base-offset) (reason (eql :c)) sequencer)
 447   (with-slots (class chain-head) boff
 448     (sequence-output (stream sequencer)
 449       :constraint ((class :vtable chain-head :start)
 450                    (class :vtable chain-head :base-offset)
 451                    (class :vtable chain-head :end))
 452       ((class :vtable chain-head :base-offset)
 453        (format stream "  /* ~21@A = */ offsetof(struct ~A, ~A),~%"
 454                "_base"
 455                (ilayout-struct-tag class)
 456                (sod-class-nickname chain-head))))))
 457
 458 (defmethod hook-output progn ((choff chain-offset)
 459                               (reason (eql :c))
 460                               sequencer)
 461   (with-slots (class chain-head target-head) choff
 462     (sequence-output (stream sequencer)
 463       :constraint ((class :vtable chain-head :start)
 464                    (class :vtable chain-head :chain-offset target-head)
 465                    (class :vtable chain-head :end))
 466       ((class :vtable chain-head :chain-offset target-head)
 467        (format stream "  /* ~21@A = */ SOD_OFFSETDIFF(struct ~A, ~A, ~A),~%"
 468                (format nil "_off_~A" (sod-class-nickname target-head))
 469                (ilayout-struct-tag class)
 470                (sod-class-nickname chain-head)
 471                (sod-class-nickname target-head))))))
 472
 473 (defmethod hook-output progn ((vtmsgs vtmsgs) (reason (eql :c)) sequencer)
 474   (with-slots (class subclass chain-head) vtmsgs
 475     (sequence-output (stream sequencer)
 476       :constraint ((subclass :vtable chain-head :start)
 477                    (subclass :vtable chain-head :vtmsgs class :start)
 478                    (subclass :vtable chain-head :vtmsgs class :slots)
 479                    (subclass :vtable chain-head :vtmsgs class :end)
 480                    (subclass :vtable chain-head :end))
 481       ((subclass :vtable chain-head :vtmsgs class :start)
 482        (format stream "  { /* Method entries for ~A messages. */~%"
 483                class))
 484       ((subclass :vtable chain-head :vtmsgs class :end)
 485        (format stream "  },~%")))))
 486
 487 (defmethod hook-output progn ((entry method-entry)
 488                               (reason (eql :c))
 489                               sequencer)
 490   (with-slots (method chain-head chain-tail) entry
 491     (let* ((message (effective-method-message method))
 492            (class (effective-method-class method))
 493            (super (sod-message-class message)))
 494       (sequence-output (stream sequencer)
 495         ((class :vtable chain-head :vtmsgs super :slots)
 496          (format stream "    /* ~19@A = */ ~A,~%"
 497                  (sod-message-name message)
 498                  (method-entry-function-name method chain-head)))))))
 499
 500 ;;;--------------------------------------------------------------------------
 501 ;;; Filling in the class object.
 502
 503 (defmethod hook-output progn ((ichain ichain)
 504                               (reason (eql 'class))
 505                               sequencer)
 506   (with-slots (class chain-head) ichain
 507     (sequence-output (stream sequencer)
 508       :constraint ((*instance-class* :object :start)
 509                    (*instance-class* :object chain-head :ichain :start)
 510                    (*instance-class* :object chain-head :ichain :end)
 511                    (*instance-class* :object :end))
 512       ((*instance-class* :object chain-head :ichain :start)
 513        (format stream "  { { /* ~A ichain */~%"
 514                (sod-class-nickname chain-head)))
 515       ((*instance-class* :object chain-head :ichain :end)
 516        (format stream "  } },~%")))))
 517
 518 (defmethod hook-output progn ((islots islots)
 519                               (reason (eql 'class))
 520                               sequencer)
 521   (with-slots (class) islots
 522     (let ((chain-head (sod-class-chain-head class)))
 523       (sequence-output (stream sequencer)
 524         :constraint ((*instance-class* :object chain-head :ichain :start)
 525                      (*instance-class* :object class :slots :start)
 526                      (*instance-class* :object class :slots)
 527                      (*instance-class* :object class :slots :end)
 528                      (*instance-class* :object chain-head :ichain :end))
 529         ((*instance-class* :object class :slots :start)
 530          (format stream "      { /* Class ~A */~%" class))
 531         ((*instance-class* :object class :slots :end)
 532          (format stream "      },~%"))))))
 533
 534 (defmethod hook-output progn ((vtptr vtable-pointer)
 535                               (reason (eql 'class))
 536                               sequencer)
 537   (with-slots (class chain-head chain-tail) vtptr
 538     (sequence-output (stream sequencer)
 539       :constraint ((*instance-class* :object chain-head :ichain :start)
 540                    (*instance-class* :object chain-head :vtable)
 541                    (*instance-class* :object chain-head :ichain :end))
 542       ((*instance-class* :object chain-head :vtable)
 543        (format stream "      &~A__vtable_~A,~%"
 544                class (sod-class-nickname chain-head))))))
 545
 546 (defgeneric find-class-initializer (slot class)
 547   (:method ((slot effective-slot) (class sod-class))
 548     (let ((dslot (effective-slot-direct-slot slot)))
 549       (or (some (lambda (super)
 550                   (find dslot (sod-class-class-initializers super)
 551                         :test #'sod-initializer-slot))
 552                 (sod-class-precedence-list class))
 553           (effective-slot-initializer slot)))))
 554
 555 (defgeneric output-class-initializer (slot instance stream)
 556   (:method ((slot sod-class-effective-slot) (instance sod-class) stream)
 557     (let ((func (effective-slot-initializer-function slot))
 558           (direct-slot (effective-slot-direct-slot slot)))
 559       (if func
 560           (format stream "        /* ~15@A = */ ~A,~%"
 561                   (sod-slot-name direct-slot)
 562                   (funcall func instance))
 563           (call-next-method))))
 564   (:method ((slot effective-slot) (instance sod-class) stream)
 565     (let ((init (find-class-initializer slot instance))
 566           (direct-slot (effective-slot-direct-slot slot)))
 567       (ecase (sod-initializer-value-kind init)
 568         (:simple (format stream "        /* ~15@A = */ ~A,~%"
 569                          (sod-slot-name direct-slot)
 570                          (sod-initializer-value-form init)))
 571         (:compound (format stream "        /* ~15@A = */ ~@<{ ~;~A~; },~:>~%"
 572                            (sod-slot-name direct-slot)
 573                            (sod-initializer-value-form init)))))))
 574
 575 (defmethod hook-output progn ((slot sod-class-effective-slot)
 576                               (reason (eql 'class))
 577                               sequencer)
 578   (let ((instance *instance-class*)
 579         (func (effective-slot-prepare-function slot)))
 580     (when func
 581       (sequence-output (stream sequencer)
 582         ((instance :object :prepare)
 583          (funcall func instance stream))))))
 584
 585 (defmethod hook-output progn ((slot effective-slot)
 586                               (reason (eql 'class))
 587                               sequencer)
 588   (with-slots (class (dslot slot)) slot
 589     (let ((instance *instance-class*)
 590           (super (sod-slot-class dslot)))
 591       (sequence-output (stream sequencer)
 592         ((instance :object super :slots)
 593          (output-class-initializer slot instance stream))))))
 594
 595 ;;;----- That's all, folks --------------------------------------------------