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

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