;;; -*-lisp-*-
;;;
;;; Output functions for classes
;;;
;;; (c) 2009 Straylight/Edgeware
;;;

;;;----- Licensing notice ---------------------------------------------------
;;;
;;; This file is part of the Simple Object Definition system.
;;;
;;; SOD is free software; you can redistribute it and/or modify
;;; it under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 2 of the License, or
;;; (at your option) any later version.
;;;
;;; SOD is distributed in the hope that it will be useful,
;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;;; GNU General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with SOD; if not, write to the Free Software Foundation,
;;; Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

(cl:in-package #:sod)

;;;--------------------------------------------------------------------------
;;; Utility macro.

(defmacro sequence-output
    ((streamvar sequencer) &body clauses)
  (let ((seqvar (gensym "SEQ")))
    (labels ((convert-item-name (name)
	       (if (listp name)
		   (cons 'list name)
		   name))
	     (convert-constraint (constraint)
	       (cons 'list (mapcar #'convert-item-name constraint)))
	     (process-body (clauses)
	       (if (eq (car clauses) :constraint)
		   (cons `(add-sequencer-constraint
			   ,seqvar
			   ,(convert-constraint (cadr clauses)))
			 (process-body (cddr clauses)))
		   (mapcar (lambda (clause)
			     (let ((name (car clause))
				   (body (cdr clause)))
			       `(add-sequencer-item-function
				 ,seqvar
				 ,(convert-item-name name)
				 (lambda (,streamvar)
				   ,@body))))
			   clauses))))
      `(let ((,seqvar ,sequencer))
	 ,@(process-body clauses)))))

;;;--------------------------------------------------------------------------
;;; Classes.

(defmethod add-output-hooks progn
    ((class sod-class) (reason (eql :h)) sequencer)

  ;; Main output sequencing.
  (sequence-output (stream sequencer)

    :constraint
    (:typedefs)

    :constraint
    ((:classes :start)
     (class :banner)
     (class :islots :start) (class :islots :slots) (class :islots :end)
     (class :vtmsgs :start) (class :vtmsgs :end)
     (class :vtables :start) (class :vtables :end)
     (class :vtable-externs) (class :vtable-externs-after)
     (class :direct-methods)
     (class :ichains :start) (class :ichains :end)
     (class :ilayout :start) (class :ilayout :slots) (class :ilayout :end)
     (class :conversions)
     (:classes :end))

    (:typedefs
     (format stream "typedef struct ~A ~A;~%"
	     (ichain-struct-tag class (sod-class-chain-head class)) class))

    ((class :banner)
     (banner (format nil "Class ~A" class) stream))
    ((class :vtable-externs-after)
     (terpri stream)))

  ;; Maybe generate an islots structure.
  (when (sod-class-slots class)
    (dolist (slot (sod-class-slots class))
      (add-output-hooks slot 'populate-islots sequencer))
    (sequence-output (stream sequencer)
      ((class :islots :start)
       (format stream "struct ~A {~%" (islots-struct-tag class)))
      ((class :islots :end)
       (format stream "};~2%"))))

  ;; Declare the direct methods.
  (when (sod-class-methods class)
    (dolist (method (sod-class-methods class))
      (add-output-hooks method :declare-direct-methods sequencer))
    (sequence-output (stream sequencer)
      ((class :direct-methods)
       (terpri stream))))

  ;; Provide upcast macros which do the right thing.
  (when (sod-class-direct-superclasses class)
    (sequence-output (stream sequencer)
      ((class :conversions)
       (let ((chain-head (sod-class-chain-head class)))
	 (dolist (super (cdr (sod-class-precedence-list class)))
	   (let ((super-head (sod-class-chain-head super)))
	     (format stream (concatenate 'string "#define "
					 "~:@(~A__CONV_~A~)(p) ((~A *)"
					 "~:[SOD_XCHAIN(~A, p)~;p~])~%")
		     class (sod-class-nickname super) super
		     (eq chain-head super-head)
		     (sod-class-nickname super-head))))))))

  ;; Generate vtmsgs structure for all superclasses.
  (add-output-hooks (car (sod-class-vtables class))
		    'populate-vtmsgs
		    sequencer))

(defmethod add-output-hooks progn ((class sod-class) reason sequencer)
  (with-slots (ilayout vtables) class
    (add-output-hooks ilayout reason sequencer)
    (dolist (vtable vtables) (add-output-hooks vtable reason sequencer))))

;;;--------------------------------------------------------------------------
;;; Instance structure.

(defmethod add-output-hooks progn
    ((slot sod-slot) (reason (eql 'populate-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 add-output-hooks progn ((ilayout ilayout) reason sequencer)
  (with-slots (ichains) ilayout
    (dolist (ichain ichains) (add-output-hooks ichain reason sequencer))))

(defmethod add-output-hooks progn
    ((ilayout ilayout) (reason (eql :h)) sequencer)
  (with-slots (class ichains) ilayout
    (sequence-output (stream sequencer)
      ((class :ilayout :start)
       (format stream "struct ~A {~%" (ilayout-struct-tag class)))
      ((class :ilayout :end)
       (format stream "};~2%")))
    (dolist (ichain ichains)
      (add-output-hooks ichain 'populate-ilayout sequencer))))

(defmethod add-output-hooks progn
    ((ichain ichain) (reason (eql :h)) sequencer)
  (with-slots (class chain-head) ichain
    (sequence-output (stream sequencer)
      :constraint ((class :ichains :start)
		   (class :ichain chain-head :start)
		   (class :ichain chain-head :slots)
		   (class :ichain chain-head :end)
		   (class :ichains :end))
      ((class :ichain chain-head :start)
       (format stream "struct ~A {~%" (ichain-struct-tag class chain-head)))
      ((class :ichain chain-head :end)
       (format stream "};~2%")))))

(defmethod add-output-hooks progn
    ((ichain ichain) (reason (eql 'populate-ilayout)) sequencer)
  (with-slots (class chain-head) ichain
    (sequence-output (stream sequencer)
      ((class :ilayout :slots)
       (format stream "  struct ~A ~A;~%"
	       (ichain-struct-tag class chain-head)
	       (sod-class-nickname chain-head))))))

(defmethod add-output-hooks progn ((ichain ichain) reason sequencer)
  (with-slots (body) ichain
    (dolist (item body) (add-output-hooks item reason sequencer))))

(defmethod add-output-hooks progn
    ((vtptr vtable-pointer) (reason (eql :h)) sequencer)
  (with-slots (class chain-head) vtptr
    (sequence-output (stream sequencer)
      ((class :ichain chain-head :slots)
       (format stream "  const struct ~A *_vt;~%"
	       (vtable-struct-tag class chain-head))))))

(defmethod add-output-hooks progn
    ((islots islots) (reason (eql :h)) sequencer)
  (with-slots (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))))))

;;;--------------------------------------------------------------------------
;;; Vtable structure.

(defmethod add-output-hooks progn ((vtable vtable) reason sequencer)
  (with-slots (body) vtable
    (dolist (item body) (add-output-hooks item reason sequencer))))

(defmethod add-output-hooks progn
    ((vtable vtable) (reason (eql :h)) sequencer)
  (with-slots (class chain-head) vtable
    (sequence-output (stream sequencer)
      :constraint ((class :vtables :start)
		   (class :vtable chain-head :start)
		   (class :vtable chain-head :slots)
		   (class :vtable chain-head :end)
		   (class :vtables :end))
      ((class :vtable chain-head :start)
       (format stream "struct ~A {~%" (vtable-struct-tag class chain-head)))
      ((class :vtable chain-head :end)
       (format stream "};~2%"))
      ((class :vtable-externs)
       (format stream "~@<extern struct ~A ~2I~_~A__vtable_~A;~:>~%"
	       (vtable-struct-tag class chain-head)
	       class (sod-class-nickname chain-head))))))

(defmethod add-output-hooks progn
    ((vtmsgs vtmsgs) (reason (eql :h)) sequencer)
  (with-slots (class subclass chain-head) 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 add-output-hooks progn
    ((vtmsgs vtmsgs) (reason (eql 'populate-vtmsgs)) sequencer)
  (when (vtmsgs-entries vtmsgs)
    (with-slots (class subclass) vtmsgs
      (sequence-output (stream sequencer)
	:constraint ((subclass :vtmsgs :start)
		     (subclass :vtmsgs class :start)
		     (subclass :vtmsgs class :slots)
		     (subclass :vtmsgs class :end)
		     (subclass :vtmsgs :end))
	((subclass :vtmsgs class :start)
	 (format stream "struct ~A {~%" (vtmsgs-struct-tag subclass class)))
	((subclass :vtmsgs class :end)
	 (format stream "};~2%"))))))

(defmethod add-output-hooks progn ((vtmsgs vtmsgs) reason sequencer)
  (with-slots (entries) vtmsgs
    (dolist (entry entries) (add-output-hooks entry reason sequencer))))

(defmethod add-output-hooks progn ((entry method-entry) reason sequencer)
  (with-slots (method) entry
    (add-output-hooks method reason sequencer)))

(defmethod add-output-hooks progn
    ((method effective-method) (reason (eql 'populate-vtmsgs)) sequencer)
  (let* ((message (effective-method-message method))
	 (class (effective-method-class method))
	 (class-type (find-class-type (sod-class-name class)))
	 (raw-type (sod-message-type message))
	 (type (c-type (* (fun (lisp (c-type-subtype raw-type))
			       ("/*me*/" (* (lisp class-type)))
			       . (commentify-argument-names
				  (c-function-arguments raw-type)))))))
    (sequence-output (stream sequencer)
      ((class :vtmsgs (sod-message-class message) :slots)
       (pprint-logical-block (stream nil :prefix "  " :suffix ";")
	 (pprint-c-type type stream (sod-message-name message)))
       (terpri stream)))))

(defmethod add-output-hooks progn
    ((cptr class-pointer) (reason (eql :h)) sequencer)
  (with-slots (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
	       (if (sod-class-direct-superclasses meta-chain-head)
		   (sod-class-nickname meta-chain-head)
		   nil))))))

(defmethod add-output-hooks progn
    ((boff base-offset) (reason (eql :h)) sequencer)
  (with-slots (class chain-head) boff
    (sequence-output (stream sequencer)
      ((class :vtable chain-head :slots)
       (write-line "  size_t _base;" stream)))))

(defmethod add-output-hooks progn
    ((choff chain-offset) (reason (eql :h)) sequencer)
  (with-slots (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))))))

;;;--------------------------------------------------------------------------
;;; Testing.

#+test
(defun test (name)
  (let ((sequencer (make-instance 'sequencer))
	(class (find-sod-class name)))
    (add-output-hooks class :h sequencer)
    (invoke-sequencer-items sequencer *standard-output*)
    sequencer))

;;;----- That's all, folks --------------------------------------------------