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