;;;----- Licensing notice ---------------------------------------------------
;;;
-;;; This file is part of the Sensble Object Design, an object system for C.
+;;; This file is part of the Sensible Object Design, an object system for C.
;;;
;;; SOD is free software; you can redistribute it and/or modify
;;; it under the terms of the GNU General Public License as published by
(cl:in-package #:sod)
;;;--------------------------------------------------------------------------
+;;; Walking the layout tree.
+
+(defmethod hook-output progn ((class sod-class) reason sequencer)
+ (with-slots ((ilayout %ilayout) vtables methods effective-methods) class
+ (hook-output ilayout reason sequencer)
+ (dolist (method methods) (hook-output method reason sequencer))
+ (dolist (method effective-methods) (hook-output method reason sequencer))
+ (dolist (vtable vtables) (hook-output vtable reason sequencer))))
+
+(defmethod hook-output progn ((ilayout ilayout) reason sequencer)
+ (with-slots (ichains) ilayout
+ (dolist (ichain ichains) (hook-output ichain reason sequencer))))
+
+(defmethod hook-output progn ((ichain ichain) reason sequencer)
+ (dolist (item (ichain-body ichain)) (hook-output item reason sequencer)))
+
+(defmethod hook-output progn ((islots islots) reason sequencer)
+ (dolist (slot (islots-slots islots)) (hook-output slot reason sequencer)))
+
+(defmethod hook-output progn ((vtable vtable) reason sequencer)
+ (with-slots (body) vtable
+ (dolist (item body) (hook-output item reason sequencer))))
+
+(defmethod hook-output progn ((vtmsgs vtmsgs) reason sequencer)
+ (with-slots (entries) vtmsgs
+ (dolist (entry entries) (hook-output entry reason sequencer))))
+
+;;;--------------------------------------------------------------------------
;;; Classes.
(defmethod hook-output progn ((class sod-class) (reason (eql :h)) sequencer)
(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))))
(eql (vtmsgs-class item) class)))
(vtable-body vtable))))
(format stream "/* Message invocation macros. */~%")
- ;;(break)
(dolist (entry (vtmsgs-entries vtmsgs))
(let* ((type (method-entry-function-type entry))
(args (c-function-arguments type))
- (method (method-entry-effective-method entry))
- (message (effective-method-message method))
(in-names nil) (out-names nil) (varargsp nil) (me "me"))
(do ((args args (cdr args)))
((endp args))
- (let* ((raw-name (argument-name (car args)))
+ (let* ((raw-name (princ-to-string (argument-name (car args))))
(name (if (find raw-name
(list "_vt"
(sod-class-nickname class)
- (sod-message-name message))
+ (method-entry-slot-name entry))
:test #'string=)
(format nil "sod__a_~A" raw-name)
raw-name)))
(format stream "#if __STDC_VERSION__ >= 199901~%"))
(format stream "#define ~A(~{~A~^, ~}) ~
~A->_vt->~A.~A(~{~A~^, ~})~%"
- (message-macro-name class message)
+ (message-macro-name class entry)
(nreverse in-names)
me
(sod-class-nickname class)
- (sod-message-name message)
+ (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
- sequencer))
-
-(defmethod hook-output progn ((class sod-class) reason sequencer)
- (with-slots (ilayout vtables methods effective-methods) class
- (hook-output ilayout reason sequencer)
- (dolist (method methods) (hook-output method reason sequencer))
- (dolist (method effective-methods) (hook-output method reason sequencer))
- (dolist (vtable vtables) (hook-output vtable reason sequencer))))
+ (hook-output (car (sod-class-vtables class)) 'vtmsgs sequencer))
;;;--------------------------------------------------------------------------
;;; Instance structure.
-(defmethod hook-output progn ((slot sod-slot)
- (reason (eql 'islots))
- sequencer)
+(defmethod hook-output progn
+ ((slot sod-slot) (reason (eql 'islots)) sequencer)
(sequence-output (stream sequencer)
(((sod-slot-class slot) :islots :slots)
(pprint-logical-block (stream nil :prefix " " :suffix ";")
(pprint-c-type (sod-slot-type slot) stream (sod-slot-name slot)))
(terpri stream))))
-(defmethod hook-output progn ((ilayout ilayout) reason sequencer)
- (with-slots (ichains) ilayout
- (dolist (ichain ichains) (hook-output ichain reason sequencer))))
-
-(defmethod hook-output progn ((ichain ichain) reason sequencer)
- (dolist (item (ichain-body ichain))
- (hook-output item reason sequencer)))
-
(defmethod hook-output progn ((ilayout ilayout) (reason (eql :h)) sequencer)
- (with-slots (class ichains) ilayout
+ (with-slots ((class %class) ichains) ilayout
(sequence-output (stream sequencer)
((class :ilayout :start)
(format stream "/* Instance layout. */~@
(hook-output ichain 'ilayout sequencer))))
(defmethod hook-output progn ((ichain ichain) (reason (eql :h)) sequencer)
- (with-slots (class chain-head chain-tail) ichain
+ (with-slots ((class %class) chain-head chain-tail) ichain
(when (eq class chain-tail)
(sequence-output (stream sequencer)
:constraint ((class :ichains :start)
(sod-class-nickname super)))
(sod-class-chain chain-tail))))))))
-(defmethod hook-output progn ((ichain ichain)
- (reason (eql 'ilayout))
- sequencer)
- (with-slots (class chain-head chain-tail) ichain
+(defmethod hook-output progn
+ ((ichain ichain) (reason (eql 'ilayout)) sequencer)
+ (with-slots ((class %class) chain-head chain-tail) ichain
(sequence-output (stream sequencer)
((class :ilayout :slots)
(format stream " union ~A ~A;~%"
(defmethod hook-output progn ((vtptr vtable-pointer)
(reason (eql :h))
sequencer)
- (with-slots (class chain-head chain-tail) vtptr
+ (with-slots ((class %class) chain-head chain-tail) vtptr
(sequence-output (stream sequencer)
((class :ichain chain-head :slots)
(format stream " const struct ~A *_vt;~%"
(vtable-struct-tag chain-tail chain-head))))))
-(defmethod hook-output progn ((islots islots) reason sequencer)
- (dolist (slot (islots-slots islots))
- (hook-output slot reason sequencer)))
-
(defmethod hook-output progn ((islots islots) (reason (eql :h)) sequencer)
- (with-slots (class subclass slots) islots
+ (with-slots ((class %class) subclass slots) islots
(sequence-output (stream sequencer)
((subclass :ichain (sod-class-chain-head class) :slots)
(format stream " struct ~A ~A;~%"
;;;--------------------------------------------------------------------------
;;; Vtable structure.
-(defmethod hook-output progn ((vtable vtable) reason sequencer)
- (with-slots (body) vtable
- (dolist (item body) (hook-output item reason sequencer))))
-
-(defmethod hook-output progn ((method sod-method)
- (reason (eql :h))
- sequencer)
- (with-slots (class) method
+(defmethod hook-output progn
+ ((method sod-method) (reason (eql :h)) sequencer)
+ (with-slots ((class %class)) method
(sequence-output (stream sequencer)
((class :methods)
(let ((type (sod-method-function-type method)))
(format stream ";~%"))))))
(defmethod hook-output progn ((vtable vtable) (reason (eql :h)) sequencer)
- (with-slots (class chain-head chain-tail) vtable
+ (with-slots ((class %class) chain-head chain-tail) vtable
(when (eq class chain-tail)
(sequence-output (stream sequencer)
:constraint ((class :vtables :start)
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)
- class (sod-class-nickname chain-head))))))
+ (format stream "~@<extern const union ~A ~2I~_~A;~:>~%"
+ (vtable-union-tag chain-tail chain-head)
+ (vtable-name class chain-head))))))
(defmethod hook-output progn ((vtmsgs vtmsgs) (reason (eql :h)) sequencer)
- (with-slots (class subclass chain-head chain-tail) vtmsgs
+ (with-slots ((class %class) subclass chain-head chain-tail) vtmsgs
(sequence-output (stream sequencer)
((subclass :vtable chain-head :slots)
(format stream " struct ~A ~A;~%"
(vtmsgs-struct-tag subclass class)
(sod-class-nickname class))))))
-(defmethod hook-output progn ((vtmsgs vtmsgs)
- (reason (eql 'vtmsgs))
- sequencer)
+(defmethod hook-output progn
+ ((vtmsgs vtmsgs) (reason (eql 'vtmsgs)) sequencer)
(when (vtmsgs-entries vtmsgs)
- (with-slots (class subclass) vtmsgs
+ (with-slots ((class %class) subclass) vtmsgs
(sequence-output (stream sequencer)
:constraint ((subclass :vtmsgs :start)
(subclass :vtmsgs class :start)
((subclass :vtmsgs class :end)
(format stream "};~2%"))))))
-(defmethod hook-output progn ((vtmsgs vtmsgs) reason sequencer)
- (with-slots (entries) vtmsgs
- (dolist (entry entries) (hook-output entry reason sequencer))))
-
-(defmethod hook-output progn ((entry method-entry)
- (reason (eql 'vtmsgs))
- sequencer)
+(defmethod hook-output progn
+ ((entry method-entry) (reason (eql 'vtmsgs)) sequencer)
(let* ((method (method-entry-effective-method entry))
(message (effective-method-message method))
(class (effective-method-class method))
(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)
- (reason (eql :h))
- sequencer)
- (with-slots (class chain-head metaclass meta-chain-head) cptr
+(defmethod hook-output progn
+ ((cptr class-pointer) (reason (eql :h)) sequencer)
+ (with-slots ((class %class) chain-head metaclass meta-chain-head) cptr
(sequence-output (stream sequencer)
((class :vtable chain-head :slots)
(format stream " const ~A *~:[_class~;~:*_cls_~A~];~%"
(sod-class-nickname meta-chain-head)))))))
(defmethod hook-output progn ((boff base-offset) (reason (eql :h)) sequencer)
- (with-slots (class chain-head) boff
+ (with-slots ((class %class) chain-head) boff
(sequence-output (stream sequencer)
((class :vtable chain-head :slots)
(write-line " size_t _base;" stream)))))
-(defmethod hook-output progn ((choff chain-offset)
- (reason (eql :h))
- sequencer)
- (with-slots (class chain-head target-head) choff
+(defmethod hook-output progn
+ ((choff chain-offset) (reason (eql :h)) sequencer)
+ (with-slots ((class %class) chain-head target-head) choff
(sequence-output (stream sequencer)
((class :vtable chain-head :slots)
(format stream " ptrdiff_t _off_~A;~%"
;;;--------------------------------------------------------------------------
;;; Implementation output.
-(defvar *instance-class*)
+(export '*instance-class*)
+(defvar *instance-class* nil
+ "The class currently being output.
+
+ This is bound during the `hook-output' traversal of a class layout for
+ `:c' output, since some of the objects traversed actually `belong' to
+ superclasses and there's no other way to find out what the reference class
+ actually is.
+
+ It may be bound at other times.")
(defmethod hook-output progn ((class sod-class) (reason (eql :c)) sequencer)
(sequence-output (stream sequencer)
(let ((*instance-class* class))
(hook-output (sod-class-ilayout (sod-class-metaclass class))
- 'class
- sequencer)))
+ 'class sequencer)))
;;;--------------------------------------------------------------------------
;;; Direct and effective methods.
-(defmethod hook-output progn ((method delegating-direct-method)
- (reason (eql :c))
- sequencer)
- (with-slots (class body) method
+(defmethod hook-output progn
+ ((method delegating-direct-method) (reason (eql :c)) sequencer)
+ (with-slots ((class %class) body) method
(unless body
(return-from hook-output))
(sequence-output (stream sequencer)
((class :direct-method method :end)
(format stream "#undef CALL_NEXT_METHOD~%")))))
-(defmethod hook-output progn ((method sod-method)
- (reason (eql :c))
- sequencer)
- (with-slots (class body) method
+(defmethod hook-output progn
+ ((method sod-method) (reason (eql :c)) sequencer)
+ (with-slots ((class %class) body) method
(unless body
(return-from hook-output))
(sequence-output (stream sequencer)
((class :direct-method method :end)
(terpri stream)))))
-(defmethod hook-output progn ((method basic-effective-method)
- (reason (eql :c))
- sequencer)
- (with-slots (class functions) method
+(defmethod hook-output progn
+ ((method basic-effective-method) (reason (eql :c)) sequencer)
+ (with-slots ((class %class) functions) method
(sequence-output (stream sequencer)
((class :effective-methods)
(dolist (func functions)
;;; Vtables.
(defmethod hook-output progn ((vtable vtable) (reason (eql :c)) sequencer)
- (with-slots (class chain-head chain-tail) vtable
+ (with-slots ((class %class) chain-head chain-tail) vtable
(sequence-output (stream sequencer)
:constraint ((class :vtables :start)
(class :vtable chain-head :start)
(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))
- sequencer)
- (with-slots (class chain-head metaclass meta-chain-head) cptr
+(defmethod hook-output progn
+ ((cptr class-pointer) (reason (eql :c)) sequencer)
+ (with-slots ((class %class) chain-head metaclass meta-chain-head) cptr
(sequence-output (stream sequencer)
:constraint ((class :vtable chain-head :start)
(class :vtable chain-head :class-pointer metaclass)
(sod-class-nickname metaclass))))))
(defmethod hook-output progn ((boff base-offset) (reason (eql :c)) sequencer)
- (with-slots (class chain-head) boff
+ (with-slots ((class %class) chain-head) boff
(sequence-output (stream sequencer)
:constraint ((class :vtable chain-head :start)
(class :vtable chain-head :base-offset)
(ilayout-struct-tag class)
(sod-class-nickname chain-head))))))
-(defmethod hook-output progn ((choff chain-offset)
- (reason (eql :c))
- sequencer)
- (with-slots (class chain-head target-head) choff
+(defmethod hook-output progn
+ ((choff chain-offset) (reason (eql :c)) sequencer)
+ (with-slots ((class %class) chain-head target-head) choff
(sequence-output (stream sequencer)
:constraint ((class :vtable chain-head :start)
(class :vtable chain-head :chain-offset target-head)
(sod-class-nickname target-head))))))
(defmethod hook-output progn ((vtmsgs vtmsgs) (reason (eql :c)) sequencer)
- (with-slots (class subclass chain-head) vtmsgs
+ (with-slots ((class %class) subclass chain-head) vtmsgs
(sequence-output (stream sequencer)
:constraint ((subclass :vtable chain-head :start)
(subclass :vtable chain-head :vtmsgs class :start)
((subclass :vtable chain-head :vtmsgs class :end)
(format stream " },~%")))))
-(defmethod hook-output progn ((entry method-entry)
- (reason (eql :c))
- sequencer)
- (with-slots (method chain-head chain-tail) entry
+(defmethod hook-output progn
+ ((entry method-entry) (reason (eql :c)) sequencer)
+ (with-slots ((method %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.
-(defmethod hook-output progn ((ichain ichain)
- (reason (eql 'class))
- sequencer)
- (with-slots (class chain-head) ichain
+(defmethod hook-output progn
+ ((ichain ichain) (reason (eql 'class)) sequencer)
+ (with-slots ((class %class) chain-head) ichain
(sequence-output (stream sequencer)
:constraint ((*instance-class* :object :start)
(*instance-class* :object chain-head :ichain :start)
((*instance-class* :object chain-head :ichain :end)
(format stream " } },~%")))))
-(defmethod hook-output progn ((islots islots)
- (reason (eql 'class))
- sequencer)
- (with-slots (class) islots
+(defmethod hook-output progn
+ ((islots islots) (reason (eql 'class)) sequencer)
+ (with-slots ((class %class)) islots
(let ((chain-head (sod-class-chain-head class)))
(sequence-output (stream sequencer)
:constraint ((*instance-class* :object chain-head :ichain :start)
((*instance-class* :object class :slots :end)
(format stream " },~%"))))))
-(defmethod hook-output progn ((vtptr vtable-pointer)
- (reason (eql 'class))
- sequencer)
- (with-slots (class chain-head chain-tail) vtptr
+(defmethod hook-output progn
+ ((vtptr vtable-pointer) (reason (eql 'class)) sequencer)
+ (with-slots ((class %class) chain-head chain-tail) vtptr
(sequence-output (stream sequencer)
:constraint ((*instance-class* :object chain-head :ichain :start)
(*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))
(sod-slot-name direct-slot)
(sod-initializer-value-form init)))))))
-(defmethod hook-output progn ((slot sod-class-effective-slot)
- (reason (eql 'class))
- sequencer)
+(defmethod hook-output progn
+ ((slot sod-class-effective-slot) (reason (eql 'class)) sequencer)
(let ((instance *instance-class*)
(func (effective-slot-prepare-function slot)))
(when func
((instance :object :prepare)
(funcall func instance stream))))))
-(defmethod hook-output progn ((slot effective-slot)
- (reason (eql 'class))
- sequencer)
- (with-slots (class (dslot slot)) slot
+(defmethod hook-output progn
+ ((slot effective-slot) (reason (eql 'class)) sequencer)
+ (with-slots ((class %class) (dslot slot)) slot
(let ((instance *instance-class*)
(super (sod-slot-class dslot)))
(sequence-output (stream sequencer)
~mdw / sod / blobdiff