(class :ichains :start) (class :ichains :end)
(class :ilayout :start) (class :ilayout :slots) (class :ilayout :end)
(class :conversions)
+ (class :message-macros)
(class :object)
(:classes :end))
(format stream "/* Conversion macros. */~%")
(dolist (super (cdr (sod-class-precedence-list class)))
(let ((super-head (sod-class-chain-head super)))
- (format stream "#define ~:@(~A__CONV_~A~)(p) ((~A *)~
- ~:[SOD_XCHAIN(~A, (p))~;(p)~])~%"
+ (format stream "#define ~:@(~A__CONV_~A~)(_obj) ((~A *)~
+ ~:[SOD_XCHAIN(~A, (_obj))~;(_obj)~])~%"
class (sod-class-nickname super) super
(eq chain-head super-head)
(sod-class-nickname super-head))))
(terpri stream)))))
+ ;; Provide convenience macros for sending the newly defined messages. (The
+ ;; macros work on all subclasses too.)
+ ;;
+ ;; We need each message's method entry type for this, so we need to dig it
+ ;; out of the vtmsgs structure. Indeed, the vtmsgs for this class contains
+ ;; entries for precisely the messages we want to make macros for.
+ (when (sod-class-messages class)
+ (sequence-output (stream sequencer)
+ ((class :message-macros)
+ (let* ((vtable (find (sod-class-chain-head class)
+ (sod-class-vtables class)
+ :key #'vtable-chain-head))
+ (vtmsgs (find-if (lambda (item)
+ (and (typep item 'vtmsgs)
+ (eql (vtmsgs-class item) class)))
+ (vtable-body vtable))))
+ (format stream "/* Message invocation macros. */~%")
+ (dolist (entry (vtmsgs-entries vtmsgs))
+ (let* ((type (method-entry-function-type entry))
+ (args (c-function-arguments type))
+ (in-names nil) (out-names nil) (varargsp nil) (me "me"))
+ (do ((args args (cdr args)))
+ ((endp args))
+ (let* ((raw-name (princ-to-string (argument-name (car args))))
+ (name (if (find raw-name
+ (list "_vt"
+ (sod-class-nickname class)
+ (method-entry-slot-name entry))
+ :test #'string=)
+ (format nil "sod__a_~A" raw-name)
+ raw-name)))
+ (cond ((and (cdr args) (eq (cadr args) :ellipsis))
+ (setf varargsp t)
+ (unless in-names (setf me "SOD_CAR(__VA_ARGS__)"))
+ (push (format nil "/*~A*/ ..." name) in-names)
+ (push "__VA_ARGS__" out-names)
+ (return))
+ (t
+ (push name in-names)
+ (push name out-names)))))
+ (when varargsp
+ (format stream "#if __STDC_VERSION__ >= 199901~%"))
+ (format stream "#define ~A(~{~A~^, ~}) ~
+ ~A->_vt->~A.~A(~{~A~^, ~})~%"
+ (message-macro-name class entry)
+ (nreverse in-names)
+ me
+ (sod-class-nickname class)
+ (method-entry-slot-name entry)
+ (nreverse out-names))
+ (when varargsp
+ (format stream "#endif~%"))))
+ (terpri stream)))))
+
;; Generate vtmsgs structure for all superclasses.
(hook-output (car (sod-class-vtables class))
'vtmsgs
struct ~A {~%"
(vtable-struct-tag chain-tail chain-head)))
((class :vtable chain-head :end)
- (format stream "};~2%"))))
+ (format stream "};~2%")
+ (format stream "/* Union of equivalent superclass vtables. */~@
+ union ~A {~@
+ ~:{ struct ~A ~A;~%~}~
+ };~2%"
+ (vtable-union-tag chain-tail chain-head)
+
+ ;; As for the ichain union, make sure the most specific
+ ;; class is first.
+ (mapcar (lambda (super)
+ (list (vtable-struct-tag super chain-head)
+ (sod-class-nickname super)))
+ (sod-class-chain chain-tail))))))
(sequence-output (stream sequencer)
((class :vtable-externs)
- (format stream "~@<extern const struct ~A ~2I~_~A__vtable_~A;~:>~%"
- (vtable-struct-tag chain-tail chain-head)
+ (format stream "~@<extern const union ~A ~2I~_~A__vtable_~A;~:>~%"
+ (vtable-union-tag chain-tail chain-head)
class (sod-class-nickname chain-head))))))
(defmethod hook-output progn ((vtmsgs vtmsgs) (reason (eql :h)) sequencer)
(sequence-output (stream sequencer)
((class :vtmsgs (sod-message-class message) :slots)
(pprint-logical-block (stream nil :prefix " " :suffix ";")
- (pprint-c-type pointer-type stream (sod-message-name message)))
+ (pprint-c-type pointer-type stream (method-entry-slot-name entry)))
(terpri stream)))))
(defmethod hook-output progn ((cptr class-pointer)
(class :vtables :end))
((class :vtable chain-head :start)
(format stream "/* Vtable for ~A chain. */~@
- const struct ~A ~A = {~%"
+ const union ~A ~A = { {~%"
chain-head
- (vtable-struct-tag chain-tail chain-head)
+ (vtable-union-tag chain-tail chain-head)
(vtable-name class chain-head)))
((class :vtable chain-head :end)
- (format stream "};~2%")))))
+ (format stream "} };~2%")))))
(defmethod hook-output progn ((cptr class-pointer)
(reason (eql :c))
(format nil "_cls_~A"
(sod-class-nickname meta-chain-head))
"_class")
- (sod-class-metaclass class)
+ class
(sod-class-nickname meta-chain-head)
(sod-class-nickname metaclass))))))
(defmethod hook-output progn ((entry method-entry)
(reason (eql :c))
sequencer)
- (with-slots (method chain-head chain-tail) entry
+ (with-slots (method chain-head chain-tail role) entry
(let* ((message (effective-method-message method))
(class (effective-method-class method))
(super (sod-message-class message)))
(sequence-output (stream sequencer)
((class :vtable chain-head :vtmsgs super :slots)
(format stream " /* ~19@A = */ ~A,~%"
- (sod-message-name message)
- (method-entry-function-name method chain-head)))))))
+ (method-entry-slot-name entry)
+ (method-entry-function-name method chain-head role)))))))
;;;--------------------------------------------------------------------------
;;; Filling in the class object.
(*instance-class* :object chain-head :vtable)
(*instance-class* :object chain-head :ichain :end))
((*instance-class* :object chain-head :vtable)
- (format stream " &~A__vtable_~A,~%"
- class (sod-class-nickname chain-head))))))
+ (format stream " /* ~17@A = */ &~A.~A,~%"
+ "_vt"
+ (vtable-name class chain-head)
+ (sod-class-nickname chain-tail))))))
(defgeneric find-class-initializer (slot class)
(:method ((slot effective-slot) (class sod-class))
~mdw / sod / blobdiff