X-Git-Url: https://git.distorted.org.uk/~mdw/sod/blobdiff_plain/7c3bae74a11efeefafa38ea599409a69e2af5c4f..f458e64e36509fa8c204f1dbcafff1d3dc059619:/src/class-output.lisp

diff --git a/src/class-output.lisp b/src/class-output.lisp
index 91dc0bf..dec1e4e 100644
--- a/src/class-output.lisp
+++ b/src/class-output.lisp
@@ -7,7 +7,7 @@
 
 ;;;----- 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
@@ -26,6 +26,34 @@
 (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)
@@ -40,7 +68,8 @@
      (class :vtmsgs :start) (class :vtmsgs :end)
      (class :vtables :start) (class :vtables :end)
      (class :vtable-externs) (class :vtable-externs-after)
-     (class :methods :start) (class :methods) (class :methods :end)
+     (class :methods :start) (class :methods :defs)
+     (class :methods) (class :methods :end)
      (class :ichains :start) (class :ichains :end)
      (class :ilayout :start) (class :ilayout :slots) (class :ilayout :end)
      (class :conversions)
@@ -65,10 +94,17 @@
 	   (metaroot (find-root-metaclass class)))
        (format stream "/* The class object. */~@
 		       extern const struct ~A ~A__classobj;~@
-		       #define ~:*~A__class (&~:*~A__classobj.~A.~A)~2%"
+		       #define ~:*~A__class (&~:*~A__classobj.~A.~A)~%"
 	       (ilayout-struct-tag metaclass) class
 	       (sod-class-nickname (sod-class-chain-head metaroot))
-	       (sod-class-nickname metaroot)))))
+	       (sod-class-nickname metaroot))
+       (dolist (chain (sod-class-chains metaclass))
+	 (let ((tail (car chain)))
+	   (unless (eq tail metaroot)
+	     (format stream "#define ~A__cls_~A (&~2:*~A__classobj.~A.~A)~%"
+		     class (sod-class-nickname (sod-class-chain-head tail))
+		     (sod-class-nickname tail)))))
+       (terpri stream))))
 
   ;; Maybe generate an islots structure.
   (when (sod-class-slots class)
@@ -111,6 +147,14 @@
   ;; 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 (some (lambda (message)
+		(or (keyword-message-p message)
+		    (varargs-message-p message)))
+	      (sod-class-messages class))
+    (one-off-output 'varargs-macros sequencer :early-decls
+		    (lambda (stream)
+		      (format stream
+			      "~%SOD__VARARGS_MACROS_PREAMBLE~%"))))
   (when (sod-class-messages class)
     (sequence-output (stream sequencer)
       ((class :message-macros)
@@ -138,7 +182,7 @@
 				raw-name)))
 		 (cond ((and (cdr args) (eq (cadr args) :ellipsis))
 			(setf varargsp t)
-			(unless in-names (setf me "SOD_CAR(__VA_ARGS__)"))
+			(unless in-names (setf me "SOD__CAR(__VA_ARGS__)"))
 			(push (format nil "/*~A*/ ..." name) in-names)
 			(push "__VA_ARGS__" out-names)
 			(return))
@@ -146,9 +190,9 @@
 			(push name in-names)
 			(push name out-names)))))
 	     (when varargsp
-	       (format stream "#if __STDC_VERSION__ >= 199901~%"))
+	       (format stream "#ifdef SOD__HAVE_VARARGS_MACROS~%"))
 	     (format stream "#define ~A(~{~A~^, ~}) ~
-				   ~A->_vt->~A.~A(~{~A~^, ~})~%"
+				   (~A)->_vt->~A.~A(~{~A~^, ~})~%"
 		     (message-macro-name class entry)
 		     (nreverse in-names)
 		     me
@@ -160,37 +204,19 @@
 	 (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 %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 %class) ichains) ilayout
     (sequence-output (stream sequencer)
@@ -232,9 +258,8 @@
 				 (sod-class-nickname super)))
 			 (sod-class-chain chain-tail))))))))
 
-(defmethod hook-output progn ((ichain ichain)
-			      (reason (eql 'ilayout))
-			      sequencer)
+(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)
@@ -246,33 +271,27 @@
 			      (reason (eql :h))
 			      sequencer)
   (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)))
+    (when (eq class chain-tail)
+      (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 (eql :h)) sequencer)
   (with-slots ((class %class) subclass slots) islots
-    (sequence-output (stream sequencer)
-      ((subclass :ichain (sod-class-chain-head class) :slots)
-       (format stream "  struct ~A ~A;~%"
-	       (islots-struct-tag class)
-	       (sod-class-nickname class))))))
+    (let ((head (sod-class-chain-head class)))
+      (when (eq head (sod-class-chain-head subclass))
+	(sequence-output (stream sequencer)
+	  ((subclass :ichain (sod-class-chain-head class) :slots)
+	   (format stream "  struct ~A ~A;~%"
+		   (islots-struct-tag class)
+		   (sod-class-nickname class))))))))
 
 ;;;--------------------------------------------------------------------------
 ;;; 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)
+(defmethod hook-output progn
+    ((method sod-method) (reason (eql :h)) sequencer)
   (with-slots ((class %class)) method
     (sequence-output (stream sequencer)
       ((class :methods)
@@ -280,7 +299,17 @@
 	 (princ "extern " stream)
 	 (pprint-c-type (commentify-function-type type) stream
 			(sod-method-function-name method))
-	 (format stream ";~%"))))))
+	 (format stream ";~%")))
+      ((class :methods :defs)
+       (let* ((type (sod-method-type method))
+	      (keys (and (typep type 'c-keyword-function-type)
+			 (c-function-keywords type))))
+	 (when keys
+	   (format stream "struct ~A {~%~
+			   ~{  unsigned ~A: 1;~%~}~
+			   };~2%"
+		   (direct-method-suppliedp-struct-tag method)
+		   (mapcar #'argument-name keys))))))))
 
 (defmethod hook-output progn ((vtable vtable) (reason (eql :h)) sequencer)
   (with-slots ((class %class) chain-head chain-tail) vtable
@@ -317,15 +346,15 @@
 
 (defmethod hook-output progn ((vtmsgs vtmsgs) (reason (eql :h)) sequencer)
   (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))))))
+    (when (eq subclass chain-tail)
+      (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 %class) subclass) vtmsgs
       (sequence-output (stream sequencer)
@@ -342,13 +371,8 @@
 	((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))
@@ -361,36 +385,46 @@
 	 (pprint-c-type pointer-type stream (method-entry-slot-name entry)))
        (terpri stream)))))
 
-(defmethod hook-output progn ((cptr class-pointer)
-			      (reason (eql :h))
-			      sequencer)
+(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~];~%"
-	       metaclass
-	       (and (sod-class-direct-superclasses meta-chain-head)
-		    (sod-class-nickname meta-chain-head)))))))
+    (when (eq chain-head (sod-class-chain-head class))
+      (sequence-output (stream sequencer)
+	((class :vtable chain-head :slots)
+	 (format stream "  const ~A *~:[_class~;~:*_cls_~A~];~%"
+		 metaclass
+		 (and (sod-class-direct-superclasses meta-chain-head)
+		      (sod-class-nickname meta-chain-head))))))))
 
 (defmethod hook-output progn ((boff base-offset) (reason (eql :h)) sequencer)
   (with-slots ((class %class) chain-head) boff
-    (sequence-output (stream sequencer)
-      ((class :vtable chain-head :slots)
-       (write-line "  size_t _base;" stream)))))
+    (when (eq chain-head (sod-class-chain-head class))
+      (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)
+(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;~%"
-	       (sod-class-nickname target-head))))))
+    (when (eq chain-head (sod-class-chain-head class))
+      (sequence-output (stream sequencer)
+	((class :vtable chain-head :slots)
+	 (format stream "  ptrdiff_t _off_~A;~%"
+		 (sod-class-nickname target-head)))))))
 
 ;;;--------------------------------------------------------------------------
 ;;; 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)
@@ -418,15 +452,13 @@ const struct ~A ~A__classobj = {~%"
 
   (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)
+(defmethod hook-output progn
+    ((method delegating-direct-method) (reason (eql :c)) sequencer)
   (with-slots ((class %class) body) method
     (unless body
       (return-from hook-output))
@@ -439,18 +471,27 @@ const struct ~A ~A__classobj = {~%"
       ((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 %class) body) method
+(defmethod hook-output progn
+    ((method sod-method) (reason (eql :c)) sequencer)
+  (with-slots ((class %class) role body message) method
     (unless body
       (return-from hook-output))
     (sequence-output (stream sequencer)
       :constraint ((class :direct-methods :start)
+		   (class :direct-method method :banner)
 		   (class :direct-method method :start)
 		   (class :direct-method method :body)
 		   (class :direct-method method :end)
 		   (class :direct-methods :end))
+      ((class :direct-method method :banner)
+       (format-banner-comment stream "Direct ~@[~(~A~) ~]method ~:_~
+				      on `~A.~A' ~:_defined by `~A'."
+			      role
+			      (sod-class-nickname
+			       (sod-message-class message))
+			      (sod-message-name message)
+			      class)
+       (fresh-line stream))
       ((class :direct-method method :body)
        (pprint-c-type (sod-method-function-type method)
 		      stream
@@ -461,12 +502,29 @@ const struct ~A ~A__classobj = {~%"
       ((class :direct-method method :end)
        (terpri stream)))))
 
-(defmethod hook-output progn ((method basic-effective-method)
-			      (reason (eql :c))
-			      sequencer)
+(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)
+       (let* ((keys (effective-method-keywords method))
+	      (message (effective-method-message method))
+	      (msg-class (sod-message-class message)))
+	 (when keys
+	   (format-banner-comment stream "Keyword argument structure ~:_~
+					  for `~A.~A' ~:_on class `~A'."
+				  (sod-class-nickname msg-class)
+				  (sod-message-name message)
+				  class)
+	   (format stream "~&struct ~A {~%"
+		   (effective-method-keyword-struct-tag method))
+	   (format stream "~{  unsigned ~A__suppliedp: 1;~%~}"
+		   (mapcar #'argument-name keys))
+	   (dolist (key keys)
+	     (write-string "  " stream)
+	     (pprint-c-type (argument-type key) stream (argument-name key))
+	     (format stream ";~%"))
+	   (format stream "};~2%")))
        (dolist (func functions)
 	 (write func :stream stream :escape nil :circle nil))))))
 
@@ -489,9 +547,8 @@ const struct ~A ~A__classobj = {~%"
       ((class :vtable chain-head :end)
        (format stream "} };~2%")))))
 
-(defmethod hook-output progn ((cptr class-pointer)
-			      (reason (eql :c))
-			      sequencer)
+(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)
@@ -519,9 +576,8 @@ const struct ~A ~A__classobj = {~%"
 	       (ilayout-struct-tag class)
 	       (sod-class-nickname chain-head))))))
 
-(defmethod hook-output progn ((choff chain-offset)
-			      (reason (eql :c))
-			      sequencer)
+(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)
@@ -548,9 +604,8 @@ const struct ~A ~A__classobj = {~%"
       ((subclass :vtable chain-head :vtmsgs class :end)
        (format stream "  },~%")))))
 
-(defmethod hook-output progn ((entry method-entry)
-			      (reason (eql :c))
-			      sequencer)
+(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))
@@ -564,9 +619,8 @@ const struct ~A ~A__classobj = {~%"
 ;;;--------------------------------------------------------------------------
 ;;; Filling in the class object.
 
-(defmethod hook-output progn ((ichain ichain)
-			      (reason (eql 'class))
-			      sequencer)
+(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)
@@ -579,9 +633,8 @@ const struct ~A ~A__classobj = {~%"
       ((*instance-class* :object chain-head :ichain :end)
        (format stream "  } },~%")))))
 
-(defmethod hook-output progn ((islots islots)
-			      (reason (eql 'class))
-			      sequencer)
+(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)
@@ -595,9 +648,8 @@ const struct ~A ~A__classobj = {~%"
 	((*instance-class* :object class :slots :end)
 	 (format stream "      },~%"))))))
 
-(defmethod hook-output progn ((vtptr vtable-pointer)
-			      (reason (eql 'class))
-			      sequencer)
+(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)
@@ -609,15 +661,6 @@ const struct ~A ~A__classobj = {~%"
 	       (vtable-name class chain-head)
 	       (sod-class-nickname chain-tail))))))
 
-(defgeneric find-class-initializer (slot class)
-  (:method ((slot effective-slot) (class sod-class))
-    (let ((dslot (effective-slot-direct-slot slot)))
-      (or (some (lambda (super)
-		  (find dslot (sod-class-class-initializers super)
-			:test #'sod-initializer-slot))
-		(sod-class-precedence-list class))
-	  (effective-slot-initializer slot)))))
-
 (defgeneric output-class-initializer (slot instance stream)
   (:method ((slot sod-class-effective-slot) (instance sod-class) stream)
     (let ((func (effective-slot-initializer-function slot))
@@ -630,17 +673,12 @@ const struct ~A ~A__classobj = {~%"
   (:method ((slot effective-slot) (instance sod-class) stream)
     (let ((init (find-class-initializer slot instance))
 	  (direct-slot (effective-slot-direct-slot slot)))
-      (ecase (sod-initializer-value-kind init)
-	(:simple (format stream "        /* ~15@A = */ ~A,~%"
-			 (sod-slot-name direct-slot)
-			 (sod-initializer-value-form init)))
-	(:compound (format stream "        /* ~15@A = */ ~@<{ ~;~A~; },~:>~%"
-			   (sod-slot-name direct-slot)
-			   (sod-initializer-value-form init)))))))
-
-(defmethod hook-output progn ((slot sod-class-effective-slot)
-			      (reason (eql 'class))
-			      sequencer)
+      (format stream "        /* ~15@A = */ ~A,~%"
+	      (sod-slot-name direct-slot)
+	      (sod-initializer-value init)))))
+
+(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
@@ -648,9 +686,8 @@ const struct ~A ~A__classobj = {~%"
 	((instance :object :prepare)
 	 (funcall func instance stream))))))
 
-(defmethod hook-output progn ((slot effective-slot)
-			      (reason (eql 'class))
-			      sequencer)
+(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)))