;;; Walking the layout tree.
(defmethod hook-output :after ((class sod-class) reason sequencer)
+ "Register hooks for the class layout, direct methods, effective methods,
+ and vtables."
(with-slots ((ilayout %ilayout) vtables methods effective-methods) class
(hook-output ilayout reason sequencer)
(dolist (method methods) (hook-output method reason sequencer))
(dolist (vtable vtables) (hook-output vtable reason sequencer))))
(defmethod hook-output :after ((ilayout ilayout) reason sequencer)
+ "Register hooks for the layout's ichains."
(with-slots (ichains) ilayout
(dolist (ichain ichains) (hook-output ichain reason sequencer))))
(defmethod hook-output :after ((ichain ichain) reason sequencer)
+ "Register hooks for the ichain body's items."
(dolist (item (ichain-body ichain)) (hook-output item reason sequencer)))
(defmethod hook-output :after ((islots islots) reason sequencer)
+ "Register hooks for the islots structure's individual slots."
(dolist (slot (islots-slots islots)) (hook-output slot reason sequencer)))
(defmethod hook-output :after ((vtable vtable) reason sequencer)
+ "Register hooks for the vtable body's items."
(with-slots (body) vtable
(dolist (item body) (hook-output item reason sequencer))))
(defmethod hook-output :after ((vtmsgs vtmsgs) reason sequencer)
+ "Register hooks for the vtmsgs structure's individual method entries."
(with-slots (entries) vtmsgs
(dolist (entry entries) (hook-output entry reason sequencer))))
(when varargsp (format stream "#endif~%"))))
(defmethod hook-output ((class sod-class) (reason (eql :h)) sequencer)
+ "Write the skeleton of a class declaration.
+
+ Most of the work is done by other functions.
+
+ * The class type is defined by `emit-class-typedef'.
+
+ * The class object is declared by `emit-class-object-decl'.
+
+ * The upcast conversion macros are defined by `emit-class-conversion-
+ macro'.
+
+ * The message invocation macros are defined by `emit-message-macro'.
+
+ * The class instance structure itself is constructed by the `ilayout'
+ object.
+
+ * The various vtable structures are constructed by the `vtable'
+ objects."
;; Main output sequencing.
(sequence-output (stream sequencer)
(terpri stream))))))
(defmethod hook-output :after ((class sod-class) (reason (eql :h)) sequencer)
+ "Register hooks to output CLASS's direct slots and messages."
;; Output a structure member definition for each instance slot.
(dolist (slot (sod-class-slots class))
;;; Instance structure.
(defmethod hook-output ((slot sod-slot) (reason (eql 'islots)) sequencer)
+ "Declare the member for an individual slot within an `islots' structure."
(sequence-output (stream sequencer)
(((sod-slot-class slot) :islots :slots)
(pprint-logical-block (stream nil :prefix " " :suffix ";")
(terpri stream))))
(defmethod hook-output ((ilayout ilayout) (reason (eql :h)) sequencer)
- (with-slots ((class %class)) ilayout
+ "Define the structure for a class layout.
+
+ Here we just provide the outermost structure. It gets filled in by
+ the `ichains' objects and their body items."
+ (with-slots ((class %class) ichains) ilayout
(sequence-output (stream sequencer)
((class :ilayout :start)
(format stream "/* Instance layout. */~@
(format stream "};~2%")))))
(defmethod hook-output :after ((ilayout ilayout) (reason (eql :h)) sequencer)
+ "Register hooks to write chain members into the overall class layout."
(dolist (ichain (ilayout-ichains ilayout))
(hook-output ichain 'ilayout sequencer)))
(defmethod hook-output ((ichain ichain) (reason (eql :h)) sequencer)
+ "Define the layout structure for a particular chain of a class.
+
+ A member of this class is dropped into the `ilayout' structure by the
+ corresponding method for the `ilayout' reason.
+
+ We define both the chain structure of the class, and a union of it with
+ all of its in-chain superclasses (so as to invoke the common-prefix
+ rule)."
(with-slots ((class %class) chain-head chain-tail) ichain
(when (eq class chain-tail)
(sequence-output (stream sequencer)
(sod-class-chain chain-tail))))))))
(defmethod hook-output ((ichain ichain) (reason (eql 'ilayout)) sequencer)
+ "Declare the member for a class chain within the class layout."
(with-slots ((class %class) chain-head chain-tail) ichain
(sequence-output (stream sequencer)
((class :ilayout :slots)
(sod-class-nickname chain-head))))))
(defmethod hook-output ((vtptr vtable-pointer) (reason (eql :h)) sequencer)
+ "Declare the member for a vtable pointer within an `ichain' structure."
(with-slots ((class %class) chain-head chain-tail) vtptr
(when (eq class chain-tail)
(sequence-output (stream sequencer)
(vtable-struct-tag chain-tail chain-head)))))))
(defmethod hook-output ((islots islots) (reason (eql :h)) sequencer)
+ "Declare the member for a class's `islots' within an `ichain' structure."
(with-slots ((class %class) subclass slots) islots
(let ((head (sod-class-chain-head class)))
(when (eq head (sod-class-chain-head subclass))
;;; Vtable structure.
(defmethod hook-output ((method sod-method) (reason (eql :h)) sequencer)
+ "Emit declarations for a direct method.
+
+ We declare the direct method function, and, if necessary, the `suppliedp'
+ structure for its keyword arguments."
+
(with-slots ((class %class)) method
(sequence-output (stream sequencer)
((class :methods)
(mapcar #'argument-name keys))))))))
(defmethod hook-output ((vtable vtable) (reason (eql :h)) sequencer)
+ "Define the structure for a vtable.
+
+ We define the vtable structure of the class, and a union of it with all of
+ its in-chain superclasses (so as to invoke the common-prefix rule). We
+ also declare the vtable object, defined by the corresponding `:c' method."
(with-slots ((class %class) chain-head chain-tail) vtable
(when (eq class chain-tail)
(sequence-output (stream sequencer)
(vtable-name class chain-head))))))
(defmethod hook-output ((vtmsgs vtmsgs) (reason (eql :h)) sequencer)
+ "Declare the member for a class's `vtmsgs' within a `vtable' structure."
(with-slots ((class %class) subclass chain-head chain-tail) vtmsgs
(when (eq subclass chain-tail)
(sequence-output (stream sequencer)
(sod-class-nickname class)))))))
(defmethod hook-output ((vtmsgs vtmsgs) (reason (eql 'vtmsgs)) sequencer)
+ "Define the `vtmsgs' structure for a class's method entry functions."
(when (vtmsgs-entries vtmsgs)
(with-slots ((class %class) subclass) vtmsgs
(sequence-output (stream sequencer)
(defmethod hook-output ((entry method-entry)
(reason (eql 'vtmsgs)) sequencer)
+ "Declare the member for a method entry within a `vtmsgs' structure."
(let* ((method (method-entry-effective-method entry))
(message (effective-method-message method))
(class (effective-method-class method))
(terpri stream)))))
(defmethod hook-output ((cptr class-pointer) (reason (eql :h)) sequencer)
+ "Declare the member for a class-chain pointer within a `vtmsgs' structure."
(with-slots ((class %class) chain-head metaclass meta-chain-head) cptr
(when (eq chain-head (sod-class-chain-head class))
(sequence-output (stream sequencer)
(sod-class-nickname meta-chain-head))))))))
(defmethod hook-output ((boff base-offset) (reason (eql :h)) sequencer)
+ "Declare the member for the base offset within a `vtmsgs' structure."
(with-slots ((class %class) chain-head) boff
(when (eq chain-head (sod-class-chain-head class))
(sequence-output (stream sequencer)
(write-line " size_t _base;" stream))))))
(defmethod hook-output ((choff chain-offset) (reason (eql :h)) sequencer)
+ "Declare the member for a cross-chain offset within a `vtmsgs' structure."
(with-slots ((class %class) chain-head target-head) choff
(when (eq chain-head (sod-class-chain-head class))
(sequence-output (stream sequencer)
It may be bound at other times.")
(defmethod hook-output ((class sod-class) (reason (eql :c)) sequencer)
+ "Write the skeleton of a class definition.
+
+ Most of the work is done by other methods.
+
+ * The direct methods are defined by the `sod-method' objects.
+
+ * The effective method functions and related structures are defined by
+ the effective method objects.
+
+ * The vtable structures are initialized by the vtable objects and their
+ component items.
+
+ * The class structure and its associated tables are initialized by the
+ metaclass's layout objects."
+
(sequence-output (stream sequencer)
:constraint
(format stream "};~2%"))))
(defmethod hook-output :after ((class sod-class) (reason (eql :c)) sequencer)
+ "Register hooks to initialize the class object structure."
(let ((*instance-class* class))
(hook-output (sod-class-ilayout (sod-class-metaclass class))
'class sequencer)))
(defmethod hook-output ((method delegating-direct-method)
(reason (eql :c)) sequencer)
+ "Define the `CALL_NEXT_METHOD' macro around a `delegating-direct-method'."
(with-slots ((class %class) body) method
(unless body
(return-from hook-output))
(call-next-method))
(defmethod hook-output ((method sod-method) (reason (eql :c)) sequencer)
+ "Define a direct method function."
(with-slots ((class %class) role body message) method
(unless body
(return-from hook-output))
(defmethod hook-output ((method basic-effective-method)
(reason (eql :c)) sequencer)
+ "Define an effective method's functions.
+
+ Specifically, the method-entry functions and any auxiliary functions
+ needed to stitch everything together."
(with-slots ((class %class) functions) method
(sequence-output (stream sequencer)
((class :effective-methods)
;;; Vtables.
(defmethod hook-output ((vtable vtable) (reason (eql :c)) sequencer)
+ "Define a vtable structure.
+
+ Here we just provide the outermost structure. It gets filled in by the
+ vtable object's body items."
(with-slots ((class %class) chain-head chain-tail) vtable
(sequence-output (stream sequencer)
:constraint ((class :vtables :start)
(format stream "} };~2%")))))
(defmethod hook-output ((cptr class-pointer) (reason (eql :c)) sequencer)
+ "Drop a class pointer into a vtable definition."
(with-slots ((class %class) chain-head metaclass meta-chain-head) cptr
(sequence-output (stream sequencer)
:constraint ((class :vtable chain-head :start)
(sod-class-nickname metaclass))))))
(defmethod hook-output ((boff base-offset) (reason (eql :c)) sequencer)
+ "Drop a base offset into a vtable definition."
(with-slots ((class %class) chain-head) boff
(sequence-output (stream sequencer)
:constraint ((class :vtable chain-head :start)
(sod-class-nickname chain-head))))))
(defmethod hook-output ((choff chain-offset) (reason (eql :c)) sequencer)
+ "Drop a cross-chain offset into a vtable definition."
(with-slots ((class %class) chain-head target-head) choff
(sequence-output (stream sequencer)
:constraint ((class :vtable chain-head :start)
(sod-class-nickname target-head))))))
(defmethod hook-output ((vtmsgs vtmsgs) (reason (eql :c)) sequencer)
+ "Define the method entry pointers for a superclass's messages.
+
+ We only provide the outer structure. It gets filled in by the
+ `method-entry' objects."
(with-slots ((class %class) subclass chain-head) vtmsgs
(sequence-output (stream sequencer)
:constraint ((subclass :vtable chain-head :start)
(format stream " },~%")))))
(defmethod hook-output ((entry method-entry) (reason (eql :c)) sequencer)
+ "Define a method-entry pointer in a vtable."
(with-slots ((method %method) chain-head chain-tail role) entry
(let* ((message (effective-method-message method))
(class (effective-method-class method))
;;; Filling in the class object.
(defmethod hook-output ((ichain ichain) (reason (eql 'class)) sequencer)
+ "Define an instance chain of a class object.
+
+ Here we only provide the outer structure. It gets filled in by the
+ `ichain' object's body items."
(with-slots ((class %class) chain-head) ichain
(sequence-output (stream sequencer)
:constraint ((*instance-class* :object :start)
(format stream " } },~%")))))
(defmethod hook-output ((islots islots) (reason (eql 'class)) sequencer)
+ "Define an instance's slots in a class object.
+
+ Here we only provide the outer structure. It gets filled in by the
+ individual slot objects."
(with-slots ((class %class)) islots
(let ((chain-head (sod-class-chain-head class)))
(sequence-output (stream sequencer)
(defmethod hook-output ((vtptr vtable-pointer)
(reason (eql 'class)) sequencer)
+ "Define a vtable pointer in a class object."
(with-slots ((class %class) chain-head chain-tail) vtptr
(sequence-output (stream sequencer)
:constraint ((*instance-class* :object chain-head :ichain :start)
(sod-class-nickname chain-tail))))))
(defgeneric output-class-initializer (slot instance stream)
+ (:documentation
+ "Define an individual slot in a class object.")
(:method ((slot sod-class-effective-slot) (instance sod-class) stream)
+ "If this slot has an initializer function, then call it; otherwise try to
+ find an initializer as usual."
(let ((func (effective-slot-initializer-function slot))
(direct-slot (effective-slot-direct-slot slot)))
(if func
(funcall func instance))
(call-next-method))))
(:method ((slot effective-slot) (instance sod-class) stream)
+ "Initialize a class slot by looking up an applicable initializer."
(let ((init (find-class-initializer slot instance))
(direct-slot (effective-slot-direct-slot slot)))
(format stream " /* ~15@A = */ ~A,~%"
(defmethod hook-output ((slot sod-class-effective-slot)
(reason (eql 'class)) sequencer)
+ "Write any necessary preparatory definitions for a class slot with a
+ computed initializer."
(let ((instance *instance-class*)
(func (effective-slot-prepare-function slot)))
(when func
(defmethod hook-output ((slot effective-slot)
(reason (eql 'class)) sequencer)
+ "Define a slot in a class object."
(with-slots ((class %class) (dslot slot)) slot
(let ((instance *instance-class*)
(super (sod-slot-class dslot)))
~mdw / sod / commitdiff