[clg] / glib / gtype.lisp

;; Common Lisp bindings for GTK+ v2.0
;; Copyright (C) 2000-2001 Espen S. Johnsen <esj@stud.cs.uit.no>
;;
;; This library is free software; you can redistribute it and/or
;; modify it under the terms of the GNU Lesser General Public
;; License as published by the Free Software Foundation; either
;; version 2 of the License, or (at your option) any later version.
;;
;; This library 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
;; Lesser General Public License for more details.
;;
;; You should have received a copy of the GNU Lesser General Public
;; License along with this library; if not, write to the Free Software
;; Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

;; $Id: gtype.lisp,v 1.26 2005/02/10 00:20:02 espen Exp $

(in-package "GLIB")

(use-prefix "g")

;; Initialize the glib type system
(defbinding type-init () nil)
(type-init)

(deftype type-number () '(unsigned 32))

(deftype gtype () 'symbol)

(defmethod alien-type ((type (eql 'gtype)) &rest args)
  (declare (ignore type args))
  (alien-type 'type-number))

(defmethod size-of ((type (eql 'gtype)) &rest args)
  (declare (ignore type args))
  (size-of 'type-number))

(defmethod to-alien-form (gtype (type (eql 'gtype)) &rest args)
  (declare (ignore type args))
  `(find-type-number ,gtype t)) 

(defmethod to-alien-function ((type (eql 'gtype)) &rest args)
  (declare (ignore type args))
  #'(lambda (gtype)
      (find-type-number gtype t)))

(defmethod from-alien-form (type-number (type (eql 'gtype)) &rest args)
  (declare (ignore type args))
  `(type-from-number ,type-number)) 

(defmethod from-alien-function ((type (eql 'gtype)) &rest args)
  (declare (ignore type args))
  #'(lambda (type-number)
      (type-from-number type-number)))

(defmethod writer-function ((type (eql 'gtype)) &rest args)
  (declare (ignore type args))
  (let ((writer (writer-function 'type-number)))
    #'(lambda (gtype location &optional (offset 0))
	(funcall writer (find-type-number gtype t) location offset))))

(defmethod reader-function ((type (eql 'gtype)) &rest args)
  (declare (ignore type args))
  (let ((reader (reader-function 'type-number)))
    #'(lambda (location &optional (offset 0))
	(type-from-number (funcall reader location offset)))))


(eval-when (:compile-toplevel :load-toplevel :execute)
  (defclass type-query (struct)
    ((type-number :allocation :alien :type type-number)
     (name :allocation :alien :type string)
     (class-size :allocation :alien :type unsigned-int)
     (instance-size :allocation :alien :type unsigned-int))
    (:metaclass struct-class)))


(defbinding type-query (type) nil
  ((find-type-number type t) type-number)
  ((make-instance 'type-query) type-query :return))

(defun type-instance-size (type)
  (slot-value (type-query type) 'instance-size))

(defun type-class-size (type)
  (slot-value (type-query type) 'class-size))

(defbinding type-class-ref (type) pointer
  ((find-type-number type t) type-number))

(defbinding type-class-unref (type) nil
  ((find-type-number type t) type-number))

(defbinding type-class-peek (type) pointer
  ((find-type-number type t) type-number))


;;;; Mapping between lisp types and glib types

(defvar *type-to-number-hash* (make-hash-table))
(defvar *number-to-type-hash* (make-hash-table))

(defun register-type (type id)
  (let ((type-number
	 (etypecase id
	   (integer id)
	   (string (find-type-number id t))
	   (symbol (gethash id *type-to-number-hash*)))))
    (setf (gethash type *type-to-number-hash*) type-number)
    (unless (symbolp id)
      (setf (gethash type-number *number-to-type-hash*) type))
    type-number))

(defbinding %type-from-name () type-number
  (name string))

(defun find-type-number (type &optional error)
  (etypecase type
    (integer type)
    (string
     (let ((type-number (%type-from-name type)))
       (cond
	((and (zerop type-number) error)
	 (error "Invalid gtype name: ~A" type))
	((zerop type-number) nil)
	(t type-number))))
    (symbol
     (let ((type-number (gethash type *type-to-number-hash*)))
       (or
	type-number
	(and error (error "Type not registered: ~A" type)))))
    (class (find-type-number (class-name type) error))))
 
(defun type-from-number (type-number &optional error)
  (multiple-value-bind (type found)
      (gethash type-number *number-to-type-hash*)
    (when (and error (not found))
      (let ((name (find-type-name type-number)))
	(if name
	    (error "Type number not registered: ~A (~A)" type-number name)
	  (error "Invalid type number: ~A" type-number))))
    type))

(defun type-from-name (name)
  (etypecase name
    (string (type-from-number (find-type-number name t)))))

(defbinding (find-type-name "g_type_name") (type) (copy-of string)
  ((find-type-number type t) type-number))

(defun type-number-of (object)
  (find-type-number (type-of object) t))

(eval-when (:compile-toplevel :load-toplevel :execute)
  (defun %find-types-in-library (pathname prefix ignore)
    (let ((process (run-program
		    "/usr/bin/nm" (list "--defined-only" "-D" (namestring (truename pathname)))
		    :output :stream :wait nil)))
      (unwind-protect
	  (loop 
	   as symbol = (let ((line (read-line (process-output process) nil)))
			 (when line (subseq line 11)))			  
	   while symbol
	   when (and
		 (> (length symbol) (length prefix))
		 (string= prefix symbol :end2 (length prefix))
		 (search "_get_type" symbol)
		 (not (member symbol ignore :test #'string=)))
	   collect symbol)
	(process-close process)))))


(defmacro init-types-in-library (filename &key (prefix "") ignore)
  (let ((names (%find-types-in-library filename prefix ignore)))
    `(progn
       ,@(mapcar #'(lambda (name)
		     `(progn
			(defbinding (,(intern name) ,name) () type-number)
			(,(intern name))))
		 names))))


;;;; Metaclass for subclasses of ginstance

(eval-when (:compile-toplevel :load-toplevel :execute)
  (defclass ginstance-class (proxy-class)
    ()))


(defmethod shared-initialize ((class ginstance-class) names
			      &rest initargs &key name alien-name)
  (declare (ignore names))
  (let* ((class-name (or name (class-name class)))
	 (type-number
	  (find-type-number
	   (or (first alien-name) (default-alien-type-name class-name)) t)))
    (register-type class-name type-number)
    (if (getf initargs :size)
	(call-next-method)
      (let ((size (type-instance-size type-number)))
	(apply #'call-next-method class names :size (list size) initargs)))))


(defmethod validate-superclass ((class ginstance-class) (super standard-class))
  (subtypep (class-name super) 'ginstance))


;;;; Superclass for wrapping types in the glib type system

(eval-when (:compile-toplevel :load-toplevel :execute)
  (defclass ginstance (proxy)
    ((class :allocation :alien :type pointer))
    (:metaclass proxy-class)))

(defun %type-of-ginstance (location)
  (let ((class (sap-ref-sap location 0)))
    (type-from-number (sap-ref-32 class 0))))

(defmethod ensure-proxy-instance ((class ginstance-class) location)
  (declare (ignore class))
  (let ((class (find-class (%type-of-ginstance location))))
    (if class
	(make-instance class :location (reference-foreign class location))
      ;; TODO: (make-instance 'ginstance ...)
      location)))

(defmethod copy-from-alien-form (location (class ginstance-class) &rest args)
  (declare (ignore location class args))
  (error "Doing copy-from-alien on a ref. counted class is most certainly an error, but if it really is what you want you should use REFERENCE-FOREIGN on the returned instance instead."))

(defmethod copy-from-alien-function ((class ginstance-class) &rest args)
  (declare (ignore class args))  
  (error "Doing copy-from-alien on a ref. counted class is most certainly an error, but if it really is what you want you should use REFERENCE-FOREIGN on the returned instance instead."))

(defmethod reader-function ((class ginstance-class) &rest args)
  (declare (ignore args))
  #'(lambda (location &optional (offset 0))
      (ensure-proxy-instance class (sap-ref-sap location offset))))


;;;; Registering fundamental types

(register-type 'nil "void")
(register-type 'pointer "gpointer")
(register-type 'char "gchar")
(register-type 'unsigned-char "guchar")
(register-type 'boolean "gboolean")
(register-type 'fixnum "gint")
(register-type 'int "gint")
(register-type 'unsigned-int "guint")
(register-type 'long "glong")
(register-type 'unsigned-long "gulong")
(register-type 'single-float "gfloat")
(register-type 'double-float "gdouble")
(register-type 'pathname "gchararray")
(register-type 'string "gchararray")


;;;; Introspection of type information

(defvar *derivable-type-info* (make-hash-table))

(defun register-derivable-type (type id expander &optional dependencies)
  (register-type type id)
  (let ((type-number (register-type type id)))
    (setf 
     (gethash type-number *derivable-type-info*) 
     (list expander dependencies))))

(defun find-type-info (type)
  (dolist (super (cdr (type-hierarchy type)))
    (let ((info (gethash super *derivable-type-info*)))
      (return-if info))))

(defun expand-type-definition (type forward-p options)
  (let ((expander (first (find-type-info type))))
    (funcall expander (find-type-number type t) forward-p options)))

(defbinding type-parent (type) type-number
  ((find-type-number type t) type-number))

(defun supertype (type)
  (type-from-number (type-parent type)))

(defbinding %type-interfaces (type) pointer
  ((find-type-number type t) type-number)
  (n-interfaces unsigned-int :out))

(defun type-interfaces (type)
  (multiple-value-bind (array length) (%type-interfaces type)
    (unwind-protect
	(map-c-vector 'list #'identity array 'type-number length)
      (deallocate-memory array))))

(defun implements (type)
  (mapcar #'type-from-number (type-interfaces type)))

(defun type-hierarchy (type)
  (let ((type-number (find-type-number type t)))
    (unless (= type-number 0)
      (cons type-number (type-hierarchy (type-parent type-number))))))
  
(defbinding (type-is-p "g_type_is_a") (type super) boolean
  ((find-type-number type) type-number)
  ((find-type-number super) type-number))

(defbinding %type-children () pointer
  (type-number type-number)
  (num-children unsigned-int :out))

(defun map-subtypes (function type &optional prefix)
  (let ((type-number (find-type-number type t)))
    (multiple-value-bind (array length) (%type-children type-number)
      (unwind-protect
	  (map-c-vector
	   'nil
	   #'(lambda (type-number)
	       (when (or
		      (not prefix)
		      (string-prefix-p prefix (find-type-name type-number)))
		 (funcall function type-number))
	       (map-subtypes function type-number prefix))
	   array 'type-number length)
	(deallocate-memory array)))))

(defun find-types (prefix)
  (let ((type-list nil))
    (maphash
     #'(lambda (type-number expander)
	 (declare (ignore expander))
	 (map-subtypes
	  #'(lambda (type-number)
	      (pushnew type-number type-list))
	  type-number prefix))
     *derivable-type-info*)
    type-list))

(defun find-type-dependencies (type)
  (let ((list-dependencies (second (find-type-info type))))
    (when list-dependencies
      (funcall list-dependencies (find-type-number type t)))))

(defun %sort-types-topologicaly (types)
  (let ((partial-sorted
	 (sort
	  (mapcar 
	   #'(lambda (type)
	       (cons type (remove-if #'(lambda (dep)
					 (not (find dep types)))
				     (find-type-dependencies type))))
	   types)
	  #'(lambda (type1 type2) (type-is-p type2 type1)) :key #'car))
	(sorted ()))

    (loop
     as tmp = partial-sorted then (or (rest tmp) partial-sorted)
     while tmp
     do (destructuring-bind (type . dependencies) (first tmp)
	  (cond
	   ((every #'(lambda (dep)
		       (assoc dep sorted))
		   dependencies)
	    (push (cons type nil) sorted) ; no forward definition needed
	    (setq partial-sorted (delete type partial-sorted :key #'first)))
	   ((some #'(lambda (dep)
		      (find type (find-type-dependencies dep)))
		  dependencies)
	    (push (cons type t) sorted) ; forward definition needed
	    (setq partial-sorted (delete type partial-sorted :key #'first))))))
    (nreverse sorted)))


(defun expand-type-definitions (prefix &optional args)
 (flet ((type-options (type-number)
	   (let ((name (find-type-name type-number)))
	     (cdr (assoc name args :test #'string=)))))

   (let ((type-list
	  (delete-if
	   #'(lambda (type-number)
	       (let ((name (find-type-name type-number)))
		 (or
		  (getf (type-options type-number) :ignore)
		  (find-if
		   #'(lambda (options)
		       (and
			(string-prefix-p (first options) name)
			(getf (cdr options) :ignore-prefix)
			(not (some
			      #'(lambda (exception)
				  (string= name exception))
			      (getf (cdr options) :except)))))
		   args))))
	   (find-types prefix))))

     (dolist (type-number type-list)
       (let ((name (find-type-name type-number)))
	 (register-type
	  (getf (type-options type-number) :type (default-type-name name))
	  type-number)))

     (let ((sorted-type-list (%sort-types-topologicaly type-list)))
       `(progn
	  ,@(mapcar
	     #'(lambda (pair)
		 (destructuring-bind (type . forward-p) pair
		   (expand-type-definition type forward-p (type-options type))))
	     sorted-type-list)
	  ,@(mapcar
	     #'(lambda (pair)
		 (destructuring-bind (type . forward-p) pair
		   (when forward-p
		     (expand-type-definition type nil (type-options type)))))
	     sorted-type-list))))))

(defmacro define-types-by-introspection (prefix &rest args)
  (expand-type-definitions prefix args))


;;;; Initialize all non static types in GObject

(init-types-in-library #.(concatenate 'string (pkg-config:pkg-variable "glib-2.0" "libdir") "/libgobject-2.0.so"))
Commit	Line	Data
0d07716f	1	;; Common Lisp bindings for GTK+ v2.0
3a935dfa	2	;; Copyright (C) 2000-2001 Espen S. Johnsen <esj@stud.cs.uit.no>
0d07716f	3	;;
	4	;; This library is free software; you can redistribute it and/or
	5	;; modify it under the terms of the GNU Lesser General Public
	6	;; License as published by the Free Software Foundation; either
	7	;; version 2 of the License, or (at your option) any later version.
	8	;;
	9	;; This library is distributed in the hope that it will be useful,
	10	;; but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	12	;; Lesser General Public License for more details.
	13	;;
	14	;; You should have received a copy of the GNU Lesser General Public
	15	;; License along with this library; if not, write to the Free Software
	16	;; Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	17
6556dccd	18	;; $Id: gtype.lisp,v 1.26 2005/02/10 00:20:02 espen Exp $
0d07716f	19
	20	(in-package "GLIB")
	21
	22	(use-prefix "g")
	23
d1266407	24	;; Initialize the glib type system
	25	(defbinding type-init () nil)
	26	(type-init)
0d07716f	27
	28	(deftype type-number () '(unsigned 32))
	29
b4a2c852	30	(deftype gtype () 'symbol)
	31
	32	(defmethod alien-type ((type (eql 'gtype)) &rest args)
	33	(declare (ignore type args))
	34	(alien-type 'type-number))
	35
	36	(defmethod size-of ((type (eql 'gtype)) &rest args)
	37	(declare (ignore type args))
	38	(size-of 'type-number))
	39
	40	(defmethod to-alien-form (gtype (type (eql 'gtype)) &rest args)
	41	(declare (ignore type args))
	42	`(find-type-number ,gtype t))
	43
	44	(defmethod to-alien-function ((type (eql 'gtype)) &rest args)
	45	(declare (ignore type args))
	46	#'(lambda (gtype)
	47	(find-type-number gtype t)))
	48
	49	(defmethod from-alien-form (type-number (type (eql 'gtype)) &rest args)
	50	(declare (ignore type args))
40c346ec	51	`(type-from-number ,type-number))
b4a2c852	52
	53	(defmethod from-alien-function ((type (eql 'gtype)) &rest args)
	54	(declare (ignore type args))
	55	#'(lambda (type-number)
40c346ec	56	(type-from-number type-number)))
b4a2c852	57
b4a2c852	58	(defmethod writer-function ((type (eql 'gtype)) &rest args)
3d36c5d6	59	(declare (ignore type args))
b4a2c852	60	(let ((writer (writer-function 'type-number)))
	61	#'(lambda (gtype location &optional (offset 0))
	62	(funcall writer (find-type-number gtype t) location offset))))
	63
	64	(defmethod reader-function ((type (eql 'gtype)) &rest args)
3d36c5d6	65	(declare (ignore type args))
b4a2c852	66	(let ((reader (reader-function 'type-number)))
b4a2c852	67	#'(lambda (location &optional (offset 0))
40c346ec	68	(type-from-number (funcall reader location offset)))))
b4a2c852	69
b4a2c852	70
fc47a022	71	(eval-when (:compile-toplevel :load-toplevel :execute)
3a935dfa	72	(defclass type-query (struct)
fc47a022	73	((type-number :allocation :alien :type type-number)
	74	(name :allocation :alien :type string)
	75	(class-size :allocation :alien :type unsigned-int)
	76	(instance-size :allocation :alien :type unsigned-int))
4d1d3921	77	(:metaclass struct-class)))
fc47a022	78
fc47a022	79
b4a2c852	80	(defbinding type-query (type) nil
	81	((find-type-number type t) type-number)
	82	((make-instance 'type-query) type-query :return))
fc47a022	83
	84	(defun type-instance-size (type)
	85	(slot-value (type-query type) 'instance-size))
	86
	87	(defun type-class-size (type)
	88	(slot-value (type-query type) 'class-size))
0d07716f	89
3a935dfa	90	(defbinding type-class-ref (type) pointer
3a935dfa	91	((find-type-number type t) type-number))
0d07716f	92
3a935dfa	93	(defbinding type-class-unref (type) nil
3a935dfa	94	((find-type-number type t) type-number))
fc47a022	95
3a935dfa	96	(defbinding type-class-peek (type) pointer
3a935dfa	97	((find-type-number type t) type-number))
fc47a022	98
0d07716f	99
3a935dfa	100	;;;; Mapping between lisp types and glib types
0d07716f	101
	102	(defvar type-to-number-hash (make-hash-table))
	103	(defvar number-to-type-hash (make-hash-table))
	104
3a935dfa	105	(defun register-type (type id)
	106	(let ((type-number
	107	(etypecase id
	108	(integer id)
935a783c	109	(string (find-type-number id t))
935a783c	110	(symbol (gethash id type-to-number-hash)))))
3a935dfa	111	(setf (gethash type type-to-number-hash) type-number)
935a783c	112	(unless (symbolp id)
935a783c	113	(setf (gethash type-number number-to-type-hash) type))
3a935dfa	114	type-number))
	115
	116	(defbinding %type-from-name () type-number
	117	(name string))
	118
	119	(defun find-type-number (type &optional error)
0d07716f	120	(etypecase type
0d07716f	121	(integer type)
3a935dfa	122	(string
	123	(let ((type-number (%type-from-name type)))
	124	(cond
	125	((and (zerop type-number) error)
4d1d3921	126	(error "Invalid gtype name: ~A" type))
3a935dfa	127	((zerop type-number) nil)
	128	(t type-number))))
	129	(symbol
	130	(let ((type-number (gethash type type-to-number-hash)))
	131	(or
	132	type-number
	133	(and error (error "Type not registered: ~A" type)))))
3d36c5d6	134	(class (find-type-number (class-name type) error))))
0d07716f	135
b011356b	136	(defun type-from-number (type-number &optional error)
	137	(multiple-value-bind (type found)
	138	(gethash type-number number-to-type-hash)
	139	(when (and error (not found))
	140	(let ((name (find-type-name type-number)))
	141	(if name
	142	(error "Type number not registered: ~A (~A)" type-number name)
	143	(error "Invalid type number: ~A" type-number))))
	144	type))
0d07716f	145
3a935dfa	146	(defun type-from-name (name)
	147	(etypecase name
	148	(string (type-from-number (find-type-number name t)))))
0d07716f	149
508d13a7	150	(defbinding (find-type-name "g_type_name") (type) (copy-of string)
3a935dfa	151	((find-type-number type t) type-number))
	152
	153	(defun type-number-of (object)
	154	(find-type-number (type-of object) t))
	155
6556dccd	156	(eval-when (:compile-toplevel :load-toplevel :execute)
	157	(defun %find-types-in-library (pathname prefix ignore)
	158	(let ((process (run-program
	159	"/usr/bin/nm" (list "--defined-only" "-D" (namestring (truename pathname)))
	160	:output :stream :wait nil)))
	161	(unwind-protect
	162	(loop
	163	as symbol = (let ((line (read-line (process-output process) nil)))
	164	(when line (subseq line 11)))
	165	while symbol
	166	when (and
	167	(> (length symbol) (length prefix))
	168	(string= prefix symbol :end2 (length prefix))
	169	(search "_get_type" symbol)
	170	(not (member symbol ignore :test #'string=)))
	171	collect symbol)
	172	(process-close process)))))
	173
0d07716f	174
4d1d3921	175	(defmacro init-types-in-library (filename &key (prefix "") ignore)
6556dccd	176	(let ((names (%find-types-in-library filename prefix ignore)))
	177	`(progn
	178	,@(mapcar #'(lambda (name)
	179	`(progn
	180	(defbinding (,(intern name) ,name) () type-number)
	181	(,(intern name))))
	182	names))))
	183
	184
	185
	186	;;;; Metaclass for subclasses of ginstance
	187
	188	(eval-when (:compile-toplevel :load-toplevel :execute)
	189	(defclass ginstance-class (proxy-class)
	190	()))
	191
	192
	193	(defmethod shared-initialize ((class ginstance-class) names
	194	&rest initargs &key name alien-name)
	195	(declare (ignore names))
	196	(let* ((class-name (or name (class-name class)))
	197	(type-number
	198	(find-type-number
	199	(or (first alien-name) (default-alien-type-name class-name)) t)))
	200	(register-type class-name type-number)
	201	(if (getf initargs :size)
	202	(call-next-method)
	203	(let ((size (type-instance-size type-number)))
	204	(apply #'call-next-method class names :size (list size) initargs)))))
b011356b	205
b011356b	206
6556dccd	207	(defmethod validate-superclass ((class ginstance-class) (super standard-class))
	208	(subtypep (class-name super) 'ginstance))
	209
0d07716f	210
fc47a022	211	;;;; Superclass for wrapping types in the glib type system
0d07716f	212
0d07716f	213	(eval-when (:compile-toplevel :load-toplevel :execute)
fc47a022	214	(defclass ginstance (proxy)
3a935dfa	215	((class :allocation :alien :type pointer))
3a935dfa	216	(:metaclass proxy-class)))
0d07716f	217
fc47a022	218	(defun %type-of-ginstance (location)
fc47a022	219	(let ((class (sap-ref-sap location 0)))
4d1d3921	220	(type-from-number (sap-ref-32 class 0))))
0d07716f	221
4d1d3921	222	(defmethod ensure-proxy-instance ((class ginstance-class) location)
	223	(declare (ignore class))
	224	(let ((class (find-class (%type-of-ginstance location))))
	225	(if class
	226	(make-instance class :location (reference-foreign class location))
	227	;; TODO: (make-instance 'ginstance ...)
	228	location)))
0d07716f	229
508d13a7	230	(defmethod copy-from-alien-form (location (class ginstance-class) &rest args)
	231	(declare (ignore location class args))
	232	(error "Doing copy-from-alien on a ref. counted class is most certainly an error, but if it really is what you want you should use REFERENCE-FOREIGN on the returned instance instead."))
	233
	234	(defmethod copy-from-alien-function ((class ginstance-class) &rest args)
	235	(declare (ignore class args))
	236	(error "Doing copy-from-alien on a ref. counted class is most certainly an error, but if it really is what you want you should use REFERENCE-FOREIGN on the returned instance instead."))
	237
	238	(defmethod reader-function ((class ginstance-class) &rest args)
	239	(declare (ignore args))
	240	#'(lambda (location &optional (offset 0))
	241	(ensure-proxy-instance class (sap-ref-sap location offset))))
	242
0d07716f	243
3a935dfa	244	;;;; Registering fundamental types
3a935dfa	245
40c346ec	246	(register-type 'nil "void")
3a935dfa	247	(register-type 'pointer "gpointer")
	248	(register-type 'char "gchar")
	249	(register-type 'unsigned-char "guchar")
	250	(register-type 'boolean "gboolean")
	251	(register-type 'fixnum "gint")
	252	(register-type 'int "gint")
	253	(register-type 'unsigned-int "guint")
	254	(register-type 'long "glong")
	255	(register-type 'unsigned-long "gulong")
	256	(register-type 'single-float "gfloat")
	257	(register-type 'double-float "gdouble")
b77fe850	258	(register-type 'pathname "gchararray")
b011356b	259	(register-type 'string "gchararray")
3a935dfa	260
3a935dfa	261
e9934f39	262	;;;; Introspection of type information
3a935dfa	263
4812615b	264	(defvar derivable-type-info (make-hash-table))
3a935dfa	265
e9934f39	266	(defun register-derivable-type (type id expander &optional dependencies)
3a935dfa	267	(register-type type id)
4812615b	268	(let ((type-number (register-type type id)))
e9934f39	269	(setf
	270	(gethash type-number derivable-type-info)
	271	(list expander dependencies))))
3a935dfa	272
b011356b	273	(defun find-type-info (type)
b011356b	274	(dolist (super (cdr (type-hierarchy type)))
4812615b	275	(let ((info (gethash super derivable-type-info)))
b011356b	276	(return-if info))))
b011356b	277
e9934f39	278	(defun expand-type-definition (type forward-p options)
	279	(let ((expander (first (find-type-info type))))
	280	(funcall expander (find-type-number type t) forward-p options)))
3a935dfa	281
3a935dfa	282	(defbinding type-parent (type) type-number
	283	((find-type-number type t) type-number))
	284
	285	(defun supertype (type)
	286	(type-from-number (type-parent type)))
	287
7858d45e	288	(defbinding %type-interfaces (type) pointer
	289	((find-type-number type t) type-number)
	290	(n-interfaces unsigned-int :out))
	291
	292	(defun type-interfaces (type)
	293	(multiple-value-bind (array length) (%type-interfaces type)
	294	(unwind-protect
4d1d3921	295	(map-c-vector 'list #'identity array 'type-number length)
7858d45e	296	(deallocate-memory array))))
	297
	298	(defun implements (type)
	299	(mapcar #'type-from-number (type-interfaces type)))
	300
3a935dfa	301	(defun type-hierarchy (type)
	302	(let ((type-number (find-type-number type t)))
	303	(unless (= type-number 0)
	304	(cons type-number (type-hierarchy (type-parent type-number))))))
	305
	306	(defbinding (type-is-p "g_type_is_a") (type super) boolean
	307	((find-type-number type) type-number)
	308	((find-type-number super) type-number))
	309
	310	(defbinding %type-children () pointer
	311	(type-number type-number)
	312	(num-children unsigned-int :out))
	313
	314	(defun map-subtypes (function type &optional prefix)
	315	(let ((type-number (find-type-number type t)))
	316	(multiple-value-bind (array length) (%type-children type-number)
	317	(unwind-protect
4d1d3921	318	(map-c-vector
3a935dfa	319	'nil
	320	#'(lambda (type-number)
	321	(when (or
	322	(not prefix)
	323	(string-prefix-p prefix (find-type-name type-number)))
	324	(funcall function type-number))
	325	(map-subtypes function type-number prefix))
	326	array 'type-number length)
	327	(deallocate-memory array)))))
	328
	329	(defun find-types (prefix)
	330	(let ((type-list nil))
4812615b	331	(maphash
	332	#'(lambda (type-number expander)
	333	(declare (ignore expander))
	334	(map-subtypes
	335	#'(lambda (type-number)
	336	(pushnew type-number type-list))
	337	type-number prefix))
	338	derivable-type-info)
3a935dfa	339	type-list))
3a935dfa	340
e9934f39	341	(defun find-type-dependencies (type)
	342	(let ((list-dependencies (second (find-type-info type))))
	343	(when list-dependencies
	344	(funcall list-dependencies (find-type-number type t)))))
	345
	346	(defun %sort-types-topologicaly (types)
6556dccd	347	(let ((partial-sorted
	348	(sort
	349	(mapcar
	350	#'(lambda (type)
	351	(cons type (remove-if #'(lambda (dep)
	352	(not (find dep types)))
	353	(find-type-dependencies type))))
	354	types)
	355	#'(lambda (type1 type2) (type-is-p type2 type1)) :key #'car))
e9934f39	356	(sorted ()))
	357
	358	(loop
6556dccd	359	as tmp = partial-sorted then (or (rest tmp) partial-sorted)
e9934f39	360	while tmp
e9934f39	361	do (destructuring-bind (type . dependencies) (first tmp)
3a935dfa	362	(cond
e9934f39	363	((every #'(lambda (dep)
6556dccd	364	(assoc dep sorted))
e9934f39	365	dependencies)
6556dccd	366	(push (cons type nil) sorted) ; no forward definition needed
6556dccd	367	(setq partial-sorted (delete type partial-sorted :key #'first)))
e9934f39	368	((some #'(lambda (dep)
	369	(find type (find-type-dependencies dep)))
	370	dependencies)
6556dccd	371	(push (cons type t) sorted) ; forward definition needed
	372	(setq partial-sorted (delete type partial-sorted :key #'first))))))
	373	(nreverse sorted)))
3a935dfa	374
	375
	376	(defun expand-type-definitions (prefix &optional args)
4812615b	377	(flet ((type-options (type-number)
3a935dfa	378	(let ((name (find-type-name type-number)))
b011356b	379	(cdr (assoc name args :test #'string=)))))
3a935dfa	380
4812615b	381	(let ((type-list
	382	(delete-if
	383	#'(lambda (type-number)
	384	(let ((name (find-type-name type-number)))
	385	(or
	386	(getf (type-options type-number) :ignore)
	387	(find-if
	388	#'(lambda (options)
	389	(and
	390	(string-prefix-p (first options) name)
17c607d0	391	(getf (cdr options) :ignore-prefix)
	392	(not (some
	393	#'(lambda (exception)
	394	(string= name exception))
	395	(getf (cdr options) :except)))))
4812615b	396	args))))
4812615b	397	(find-types prefix))))
6556dccd	398
4812615b	399	(dolist (type-number type-list)
	400	(let ((name (find-type-name type-number)))
	401	(register-type
	402	(getf (type-options type-number) :type (default-type-name name))
	403	type-number)))
6556dccd	404
6556dccd	405	(let ((sorted-type-list (%sort-types-topologicaly type-list)))
e9934f39	406	`(progn
e9934f39	407	,@(mapcar
6556dccd	408	#'(lambda (pair)
	409	(destructuring-bind (type . forward-p) pair
	410	(expand-type-definition type forward-p (type-options type))))
	411	sorted-type-list)
e9934f39	412	,@(mapcar
6556dccd	413	#'(lambda (pair)
	414	(destructuring-bind (type . forward-p) pair
	415	(when forward-p
	416	(expand-type-definition type nil (type-options type)))))
e9934f39	417	sorted-type-list))))))
4812615b	418
3a935dfa	419	(defmacro define-types-by-introspection (prefix &rest args)
b011356b	420	(expand-type-definitions prefix args))
6556dccd	421
	422
	423	;;;; Initialize all non static types in GObject
	424
	425	(init-types-in-library #.(concatenate 'string (pkg-config:pkg-variable "glib-2.0" "libdir") "/libgobject-2.0.so"))