Fixed memory leak in with-gvalue

[clg] / glib / gcallback.lisp

diff --git a/glib/gcallback.lisp b/glib/gcallback.lisp
index cf0b9ea619e69aec56f709e8fcb0f57a23dc4ad2..65b77832b615775d5a8554fb9cb5fd4695ad40db 100644 (file)
--- a/glib/gcallback.lisp
+++ b/glib/gcallback.lisp
@@ -20,59 +20,91 @@
 ;; TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 ;; SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 ;; TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 ;; SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 

-;; $Id: gcallback.lisp,v 1.26 2006/02/01 14:18:49 espen Exp $
+;; $Id: gcallback.lisp,v 1.45 2007/06/25 13:49:05 espen Exp $

 
 (in-package "GLIB")
 
 (use-prefix "g")
 
 
 
 (in-package "GLIB")
 
 (use-prefix "g")
 
 

-;;;; Callback invokation
+;;;; Callback invocation
+
+(deftype gclosure () 'pointer)
+(register-type 'gclosure '|g_closure_get_type|)

 
 (defun register-callback-function (function)
   (check-type function (or null symbol function))
   (register-user-data function))
 
 
 (defun register-callback-function (function)
   (check-type function (or null symbol function))
   (register-user-data function))
 

-;; Callback marshal for regular signal handlers
-(defcallback closure-marshal (nil
-                             (gclosure pointer)
-                             (return-value gvalue)
-                             (n-params unsigned-int) 
-                             (param-values pointer)
-                             (invocation-hint pointer) 
-                             (callback-id unsigned-int))
+;; Callback marshaller for regular signal handlers
+(define-callback signal-handler-marshal nil
+    ((gclosure gclosure) (return-value gvalue) (n-params unsigned-int) 
+     (param-values pointer) (invocation-hint pointer) 
+     (callback-id pointer-data))
+  (declare (ignore gclosure invocation-hint))
+  (callback-trampoline #'invoke-signal-handler callback-id n-params param-values return-value))
+
+;; Callback marshaller for class handlers
+(define-callback class-handler-marshal nil
+    ((gclosure gclosure) (return-value gvalue) (n-params unsigned-int) 
+     (param-values pointer) (invocation-hint pointer) 
+     (callback-id pointer-data))

   (declare (ignore gclosure invocation-hint))
   (declare (ignore gclosure invocation-hint))

-  (callback-trampoline callback-id n-params param-values return-value))
-
-;; Callback function for emission hooks
-(defcallback signal-emission-hook (nil
-                                  (invocation-hint pointer)
-                                  (n-params unsigned-int) 
-                                  (param-values pointer)
-                                  (callback-id unsigned-int))
-  (callback-trampoline callback-id n-params param-values))
-
-(defun callback-trampoline (callback-id n-params param-values &optional
-                           (return-value (make-pointer 0)))
+  (callback-trampoline #'invoke-callback callback-id n-params param-values return-value))
+
+;; Callback marshaller for emission hooks
+(define-callback emission-hook-marshal nil
+    ((invocation-hint pointer) (n-params unsigned-int) (param-values pointer)
+     (callback-id pointer-data))
+  (declare (ignore invocation-hint))
+  (callback-trampoline #'invoke-callback callback-id n-params param-values))
+
+(defun callback-trampoline (restart-wrapper callback-id n-params param-values 
+                           &optional (return-value (make-pointer 0)))

   (let* ((return-type (unless (null-pointer-p return-value)
                        (gvalue-type return-value)))
         (args (loop
                for n from 0 below n-params
   (let* ((return-type (unless (null-pointer-p return-value)
                        (gvalue-type return-value)))
         (args (loop
                for n from 0 below n-params

-               collect (gvalue-get (sap+ param-values (* n +gvalue-size+))))))
-    (let ((result (apply #'invoke-callback callback-id return-type args)))
-      (when return-type
-       (gvalue-set return-value result)))))
+               for offset from 0 by +gvalue-size+
+               collect (gvalue-peek (pointer+ param-values offset)))))
+    (unwind-protect
+       (multiple-value-bind (result aborted-p)
+           (apply restart-wrapper callback-id nil args)
+         (when (and return-type (not aborted-p))
+           (gvalue-set return-value result)))
+      ;; TODO: this should be made more general, by adding a type
+      ;; method to return invalidating functions.
+      (loop 
+       for arg in args
+       when (typep arg 'struct)
+       do (invalidate-instance arg)))))
+
+(defun invoke-signal-handler (callback-id return-type &rest args)
+  (declare (ignore return-type))
+  (let* ((instance (first args))
+        (handler-id (signal-handler-find instance '(:data) 
+                     0 0 nil nil callback-id)))
+    (signal-handler-block instance handler-id)
+    (unwind-protect
+       (restart-case (apply #'invoke-callback callback-id nil args)
+         (disconnect () :report "Disconnect and exit signal handler"
+           (when (signal-handler-is-connected-p instance handler-id)
+             (signal-handler-disconnect instance handler-id))
+           (values nil t))))
+      (when (signal-handler-is-connected-p instance handler-id)
+       (signal-handler-unblock instance handler-id))))

 
 (defun invoke-callback (callback-id return-type &rest args)
 
 (defun invoke-callback (callback-id return-type &rest args)

-  (restart-case
-      (apply (find-user-data callback-id) args)
+  (restart-case (apply (find-user-data callback-id) args)

     (continue nil :report "Return from callback function"
     (continue nil :report "Return from callback function"

-             (when return-type
-               (format *query-io* "Enter return value of type ~S: " return-type)
-               (force-output *query-io*)
-               (eval (read *query-io*))))
+      (cond
+       (return-type
+       (format *query-io* "Enter return value of type ~S: " return-type)
+       (force-output *query-io*)
+       (eval (read *query-io*)))
+       (t (values nil t))))

     (re-invoke nil :report "Re-invoke callback function"
     (re-invoke nil :report "Re-invoke callback function"

-              (apply #'invoke-callback callback-id return-type args))))
+      (apply #'invoke-callback callback-id return-type args))))

 
 
 ;;;; Timeouts and idle functions
 
 
 ;;;; Timeouts and idle functions


@@ -86,16 +118,26 @@ (defconstant +priority-low+ 300)
 (defbinding source-remove () boolean
   (tag unsigned-int))
 
 (defbinding source-remove () boolean
   (tag unsigned-int))
 

-(defcallback source-callback-marshal (nil (callback-id unsigned-int))
-  (callback-trampoline callback-id 0 nil))
+(define-callback source-callback-marshal boolean ((callback-id unsigned-int))
+  (invoke-source-callback callback-id))
+
+(defun invoke-source-callback (callback-id &rest args)
+  (restart-case (apply (find-user-data callback-id) args)
+    (remove () :report "Exit and remove source callback"
+      nil)
+    (continue () :report "Return from source callback"
+      t)
+    (re-invoke nil :report "Re-invoke source callback"
+      (apply #'invoke-source-callback callback-id args))))
+

 
 (defbinding (timeout-add "g_timeout_add_full")
     (interval function &optional (priority +priority-default+)) unsigned-int 
   (priority int)
   (interval unsigned-int)
 
 (defbinding (timeout-add "g_timeout_add_full")
     (interval function &optional (priority +priority-default+)) unsigned-int 
   (priority int)
   (interval unsigned-int)

-  ((callback source-callback-marshal) pointer)
+  (source-callback-marshal callback)

   ((register-callback-function function) unsigned-long)
   ((register-callback-function function) unsigned-long)

-  ((callback user-data-destroy-func) pointer))
+  (user-data-destroy-callback callback))

 
 (defun timeout-remove (timeout)
   (source-remove timeout))
 
 (defun timeout-remove (timeout)
   (source-remove timeout))


@@ -103,9 +145,9 @@ (defun timeout-remove (timeout)
 (defbinding (idle-add "g_idle_add_full")
     (function &optional (priority +priority-default-idle+)) unsigned-int 
   (priority int)
 (defbinding (idle-add "g_idle_add_full")
     (function &optional (priority +priority-default-idle+)) unsigned-int 
   (priority int)

-  ((callback source-callback-marshal) pointer)
+  (source-callback-marshal callback)

   ((register-callback-function function) unsigned-long)
   ((register-callback-function function) unsigned-long)

-  ((callback user-data-destroy-func) pointer))
+  (user-data-destroy-callback callback))

 
 (defun idle-remove (idle)
   (source-remove idle))
 
 (defun idle-remove (idle)
   (source-remove idle))


@@ -146,6 +188,9 @@   (deftype signal-flags ()
     '(flags :run-first :run-last :run-cleanup :no-recurse 
            :detailed :action :no-hooks))
 
     '(flags :run-first :run-last :run-cleanup :no-recurse 
            :detailed :action :no-hooks))
 

+  (define-flags-type signal-match-type
+    :id :detail :closure :func :data :unblocked)
+

   (defclass signal-query (struct)
     ((id :allocation :alien :type unsigned-int)
      (name :allocation :alien :type (copy-of string))
   (defclass signal-query (struct)
     ((id :allocation :alien :type unsigned-int)
      (name :allocation :alien :type (copy-of string))


@@ -159,7 +204,7 @@   (defclass signal-query (struct)
 (defbinding signal-query 
     (signal-id &optional (signal-query (make-instance 'signal-query))) nil
   (signal-id unsigned-int)
 (defbinding signal-query 
     (signal-id &optional (signal-query (make-instance 'signal-query))) nil
   (signal-id unsigned-int)

-  (signal-query signal-query :return))
+  (signal-query signal-query :in/return))

 
 (defun signal-param-types (info)
   (with-slots (n-params param-types) info
 
 (defun signal-param-types (info)
   (with-slots (n-params param-types) info


@@ -172,16 +217,18 @@ (defun signal-param-types (info)
 (defun describe-signal (signal-id &optional type)
   (let ((info (signal-query (ensure-signal-id-from-type signal-id type))))
     (with-slots (id name type flags return-type n-params) info
 (defun describe-signal (signal-id &optional type)
   (let ((info (signal-query (ensure-signal-id-from-type signal-id type))))
     (with-slots (id name type flags return-type n-params) info

-      (format t "The signal with id ~D is named '~A' and may be emitted on instances of type ~S~%~%" id name (type-from-number type t))
-      (format t "Signal handlers should return ~A and take ~A~%"
-       (cond
-       ((= return-type (find-type-number "void")) "no values")
-       ((not (type-from-number return-type)) "values of unknown type")
-       ((format nil "values of type ~S" (type-from-number return-type))))
+      (format t "The signal with id ~D is named '~A' and may be emitted on instances of type ~S." id name (type-from-number type t))
+      (when flags
+       (format t " It has the followin invocation flags: ~{~S ~}" flags))
+      (format t "~%~%Signal handlers should take ~A and return ~A~%"

        (if (zerop n-params)
           "no arguments"
         (format nil "arguments with the following types: ~A"
        (if (zerop n-params)
           "no arguments"
         (format nil "arguments with the following types: ~A"

-         (signal-param-types info)))))))
+         (signal-param-types info)))
+       (cond
+       ((= return-type (find-type-number "void")) "no values")
+       ((not (type-from-number return-type)) "values of unknown type")
+       ((format nil "values of type ~S" (type-from-number return-type))))))))

 
 
 ;;;; Signal connecting and controlling
 
 
 ;;;; Signal connecting and controlling


@@ -201,7 +248,7 @@ (defun signal-override-class-closure (name type function)
     (if callback-id
        (update-user-data callback-id function)
       (multiple-value-bind (callback-closure callback-id)
     (if callback-id
        (update-user-data callback-id function)
       (multiple-value-bind (callback-closure callback-id)

-         (make-callback-closure function)
+         (make-callback-closure function class-handler-marshal)

        (%signal-override-class-closure signal-id type-number callback-closure)
        (setf 
         (gethash (cons type-number signal-id) *overridden-signals*)
        (%signal-override-class-closure signal-id type-number callback-closure)
        (setf 
         (gethash (cons type-number signal-id) *overridden-signals*)


@@ -213,15 +260,13 @@ (defbinding %signal-chain-from-overridden () nil
   (return-value (or null gvalue)))
 
 
   (return-value (or null gvalue)))
 
 

-(defun %call-next-handler (n-params types args defaults return-type)
+(defun %call-next-handler (n-params types args return-type)

   (let ((params (allocate-memory (* n-params +gvalue-size+))))
     (loop 
   (let ((params (allocate-memory (* n-params +gvalue-size+))))
     (loop 

-     as tmp = args then (rest tmp)
-     for default in defaults
+     for arg in args

      for type in types
      for offset from 0 by +gvalue-size+
      for type in types
      for offset from 0 by +gvalue-size+

-     as arg = (if tmp (car tmp) default)
-     do (gvalue-init (sap+ params offset) type arg))
+     do (gvalue-init (pointer+ params offset) type arg))

 
     (unwind-protect
        (if return-type
 
     (unwind-protect
        (if return-type


@@ -232,7 +277,7 @@ (defun %call-next-handler (n-params types args defaults return-type)
        (loop
         repeat n-params
         for offset from 0 by +gvalue-size+
        (loop
         repeat n-params
         for offset from 0 by +gvalue-size+

-        do (gvalue-unset (sap+ params offset)))
+        do (gvalue-unset (pointer+ params offset)))

        (deallocate-memory params)))))
 
 
        (deallocate-memory params)))))
 
 


@@ -246,16 +291,17 @@ (defmacro define-signal-handler (name ((object class) &rest args) &body body)
                until (eq arg '&rest)
                collect arg))
         (rest (cadr (member '&rest args)))
                until (eq arg '&rest)
                collect arg))
         (rest (cadr (member '&rest args)))

-        (next (make-symbol "ARGS")))
+        (next (make-symbol "ARGS"))
+        (default (make-symbol "DEFAULT")))

 
     `(progn
        (signal-override-class-closure ',name ',class 
        #'(lambda (,object ,@args)
 
     `(progn
        (signal-override-class-closure ',name ',class 
        #'(lambda (,object ,@args)

-           (flet ((call-next-handler (&rest ,next)
-                    (let ((defaults (list* ,object ,@vars ,rest)))
+           (let ((,default (list* ,object ,@vars ,rest)))
+             (flet ((call-next-handler (&rest ,next)

                       (%call-next-handler 
                       (%call-next-handler 

-                       ,n-params ',types ,next defaults ',return-type))))
-             ,@body)))
+                       ,n-params ',types (or ,next ,default) ',return-type)))
+             ,@body))))

        ',name)))
 
 
        ',name)))
 
 


@@ -274,16 +320,16 @@ (defun signal-stop-emission ()
 
 
 (defbinding signal-add-emission-hook (type signal function &key (detail 0))
 
 
 (defbinding signal-add-emission-hook (type signal function &key (detail 0))

-    unsigned-int
+    unsigned-long

   ((ensure-signal-id-from-type signal type) unsigned-int)
   (detail quark)
   ((ensure-signal-id-from-type signal type) unsigned-int)
   (detail quark)

-  ((callback signal-emission-hook) pointer)
+  (emission-hook-marshal callback)

   ((register-callback-function function) unsigned-int)
   ((register-callback-function function) unsigned-int)

-  ((callback user-data-destroy-func) pointer))
+  (user-data-destroy-callback callback))

 
 (defbinding signal-remove-emission-hook (type signal hook-id) nil
   ((ensure-signal-id-from-type signal type) unsigned-int)
 
 (defbinding signal-remove-emission-hook (type signal hook-id) nil
   ((ensure-signal-id-from-type signal type) unsigned-int)

-  (hook-id unsigned-int))
+  (hook-id unsigned-long))

 
 
 (defbinding (signal-has-handler-pending-p "g_signal_has_handler_pending")
 
 
 (defbinding (signal-has-handler-pending-p "g_signal_has_handler_pending")


@@ -293,7 +339,7 @@ (defbinding (signal-has-handler-pending-p "g_signal_has_handler_pending")
   ((or detail 0) quark)
   (blocked boolean))
     
   ((or detail 0) quark)
   (blocked boolean))
     

-(defbinding %signal-connect-closure-by-id () unsigned-int
+(defbinding %signal-connect-closure-by-id () unsigned-long

   (instance ginstance)
   (signal-id unsigned-int)
   (detail quark)
   (instance ginstance)
   (signal-id unsigned-int)
   (detail quark)


@@ -302,47 +348,73 @@ (defbinding %signal-connect-closure-by-id () unsigned-int
 
 (defbinding signal-handler-block () nil
   (instance ginstance)
 
 (defbinding signal-handler-block () nil
   (instance ginstance)

-  (handler-id unsigned-int))
+  (handler-id unsigned-long))

 
 (defbinding signal-handler-unblock () nil
   (instance ginstance)
 
 (defbinding signal-handler-unblock () nil
   (instance ginstance)

-  (handler-id unsigned-int))
+  (handler-id unsigned-long))
+
+;; Internal
+(defbinding signal-handler-find () unsigned-long
+  (instance gobject)
+  (mask signal-match-type)
+  (signal-id unsigned-int)
+  (detail quark)
+  (closure (or null pointer))
+  (func (or null pointer))
+  (data pointer-data))

 
 (defbinding signal-handler-disconnect () nil
   (instance ginstance)
 
 (defbinding signal-handler-disconnect () nil
   (instance ginstance)

-  (handler-id unsigned-int))
+  (handler-id unsigned-long))

 
 (defbinding signal-handler-is-connected-p () boolean
   (instance ginstance)
 
 (defbinding signal-handler-is-connected-p () boolean
   (instance ginstance)

-  (handler-id unsigned-int))
-
-(deftype gclosure () 'pointer)
-(register-type 'gclosure "GClosure")
+  (handler-id unsigned-long))

 
 

-(defbinding (callback-closure-new "clg_callback_closure_new") () gclosure
+(defbinding (closure-new "g_cclosure_new") () gclosure
+  ((make-pointer #xFFFFFFFF) pointer)

   (callback-id unsigned-int) 
   (callback-id unsigned-int) 

-  (callback pointer)
-  (destroy-notify pointer))
+  (destroy-notify callback))

 
 

-(defun make-callback-closure (function)
+(defbinding closure-set-meta-marshal () nil
+  (gclosure gclosure)
+  (callback-id unsigned-int)
+  (callback callback))
+
+(defun callback-closure-new (callback-id callback destroy-notify)
+  (let ((gclosure (closure-new callback-id destroy-notify)))
+    (closure-set-meta-marshal gclosure callback-id callback)
+    gclosure))
+
+(defun make-callback-closure (function &optional (marshaller signal-handler-marshal))

   (let ((callback-id (register-callback-function function)))
     (values
   (let ((callback-id (register-callback-function function)))
     (values

-     (callback-closure-new 
-      callback-id (callback closure-marshal) 
-      (callback user-data-destroy-func))
+     (callback-closure-new callback-id marshaller user-data-destroy-callback)

      callback-id)))
 
      callback-id)))
 

-(defgeneric compute-signal-function (gobject signal function object))
+(defgeneric compute-signal-function (gobject signal function object args))

 
 

-(defmethod compute-signal-function ((gobject gobject) signal function object)
+(defmethod compute-signal-function ((gobject gobject) signal function object args)

   (declare (ignore signal))
   (cond
   (declare (ignore signal))
   (cond

-   ((or (eq object t) (eq object gobject)) function)
-   ((not object)
-    #'(lambda (&rest args) (apply function (rest args))))
+   ((or (eq object t) (eq object gobject))
+    (if args 
+       #'(lambda (&rest emission-args) 
+           (apply function (nconc emission-args args)))
+      function))
+   (object
+    (if args 
+       #'(lambda (&rest emission-args) 
+           (apply function object (nconc (rest emission-args) args)))
+      #'(lambda (&rest emission-args) 
+         (apply function object (rest emission-args)))))
+   (args 
+    #'(lambda (&rest emission-args) 
+       (apply function (nconc (rest emission-args) args))))

    (t
    (t

-    #'(lambda (&rest args) (apply function object (rest args))))))
-
+    #'(lambda (&rest emission-args) 
+       (apply function (rest emission-args))))))

 
 (defgeneric compute-signal-id (gobject signal))
 
 
 (defgeneric compute-signal-id (gobject signal))
 


@@ -350,7 +422,7 @@ (defmethod compute-signal-id ((gobject gobject) signal)
   (ensure-signal-id signal gobject))
 
 
   (ensure-signal-id signal gobject))
 
 

-(defgeneric signal-connect (gobject signal function &key detail after object remove))
+(defgeneric signal-connect (gobject signal function &key detail after object remove args))

 
 (defmethod signal-connect :around ((gobject gobject) signal function &rest args)
   (declare (ignore gobject signal args))
 
 (defmethod signal-connect :around ((gobject gobject) signal function &rest args)
   (declare (ignore gobject signal args))


@@ -359,25 +431,26 @@ (defmethod signal-connect :around ((gobject gobject) signal function &rest args)
 
 
 (defmethod signal-connect ((gobject gobject) signal function
 
 
 (defmethod signal-connect ((gobject gobject) signal function

-                          &key detail after object remove)
+                          &key detail after object remove args)

 "Connects a callback function to a signal for a particular object. If
 :OBJECT is T, the object connected to is passed as the first argument
 to the callback function, or if :OBJECT is any other non NIL value, it
 is passed as the first argument instead. If :AFTER is non NIL, the
 handler will be called after the default handler for the signal. If
 :REMOVE is non NIL, the handler will be removed after beeing invoked
 "Connects a callback function to a signal for a particular object. If
 :OBJECT is T, the object connected to is passed as the first argument
 to the callback function, or if :OBJECT is any other non NIL value, it
 is passed as the first argument instead. If :AFTER is non NIL, the
 handler will be called after the default handler for the signal. If
 :REMOVE is non NIL, the handler will be removed after beeing invoked

-once."
+once. ARGS is a list of additional arguments passed to the callback
+function."

 (let* ((signal-id (compute-signal-id gobject signal))
        (detail-quark (if detail (quark-intern detail) 0))
        (signal-stop-emission
        #'(lambda ()
            (%signal-stop-emission gobject signal-id detail-quark)))
 (let* ((signal-id (compute-signal-id gobject signal))
        (detail-quark (if detail (quark-intern detail) 0))
        (signal-stop-emission
        #'(lambda ()
            (%signal-stop-emission gobject signal-id detail-quark)))

-       (callback (compute-signal-function gobject signal function object))
+       (callback (compute-signal-function gobject signal function object args))

        (wrapper #'(lambda (&rest args)
                    (let ((*signal-stop-emission* signal-stop-emission))
                      (apply callback args)))))
       (multiple-value-bind (closure-id callback-id)
        (wrapper #'(lambda (&rest args)
                    (let ((*signal-stop-emission* signal-stop-emission))
                      (apply callback args)))))
       (multiple-value-bind (closure-id callback-id)

-         (make-callback-closure wrapper)
+         (make-callback-closure wrapper signal-handler-marshal)

        (let ((handler-id (%signal-connect-closure-by-id 
                           gobject signal-id detail-quark closure-id after)))
          (when remove
        (let ((handler-id (%signal-connect-closure-by-id 
                           gobject signal-id detail-quark closure-id after)))
          (when remove


@@ -386,7 +459,8 @@ (let* ((signal-id (compute-signal-id gobject signal))
                 (unwind-protect
                     (let ((*signal-stop-emission* signal-stop-emission))
                       (apply callback args))
                 (unwind-protect
                     (let ((*signal-stop-emission* signal-stop-emission))
                       (apply callback args))

-                  (signal-handler-disconnect gobject handler-id)))))
+                  (when (signal-handler-is-connected-p gobject handler-id)
+                    (signal-handler-disconnect gobject handler-id))))))

          handler-id))))
 
 
          handler-id))))
 
 


@@ -409,12 +483,12 @@ (defun create-signal-emit-function (signal-id)
           (params (allocate-memory (* n-params +gvalue-size+))))
       #'(lambda (detail object &rest args)
          (unless (= (length args) (1- n-params))
           (params (allocate-memory (* n-params +gvalue-size+))))
       #'(lambda (detail object &rest args)
          (unless (= (length args) (1- n-params))

-           (error "Invalid number of arguments: ~A" (+ 2 (length args))))
+           (error "Invalid number of arguments in emmision of signal ~A: ~A" signal-id (length args)))

          (unwind-protect
              (loop
               for arg in (cons object args)
               for type in param-types
          (unwind-protect
              (loop
               for arg in (cons object args)
               for type in param-types

-              as tmp = params then (sap+ tmp +gvalue-size+)
+              as tmp = params then (pointer+ tmp +gvalue-size+)

               do (gvalue-init tmp type arg)          
               finally 
               (if return-type
               do (gvalue-init tmp type arg)          
               finally 
               (if return-type


@@ -424,7 +498,7 @@ (defun create-signal-emit-function (signal-id)
                 (%signal-emitv params signal-id detail (make-pointer 0))))
            (loop
             repeat n-params
                 (%signal-emitv params signal-id detail (make-pointer 0))))
            (loop
             repeat n-params

-            as tmp = params then (sap+ tmp +gvalue-size+)
+            as tmp = params then (pointer+ tmp +gvalue-size+)

             while (gvalue-p tmp)
             do (gvalue-unset tmp)))))))
 
             while (gvalue-p tmp)
             do (gvalue-unset tmp)))))))
 


@@ -441,18 +515,55 @@ (defun signal-emit (object signal &rest args)
   (apply #'signal-emit-with-detail object signal 0 args))
 
 
   (apply #'signal-emit-with-detail object signal 0 args))
 
 

+;;;; Signal registration
+
+(defbinding %signal-newv (name itype flags return-type param-types) 
+    unsigned-int
+  ((signal-name-to-string name) string)
+  (itype gtype)
+  (flags signal-flags)
+  (nil null) ; class closure
+  (nil null) ; accumulator
+  (nil null) ; accumulator data
+  (nil null) ; c marshaller
+  (return-type gtype)
+  ((length param-types) unsigned-int)
+  (param-types (vector gtype)))
+
+(defun signal-new (name itype flags return-type param-types)
+  (when (zerop (signal-lookup name itype))
+    (%signal-newv name itype flags return-type param-types)))
+

 ;;;; Convenient macros
 
 ;;;; Convenient macros
 

-(defmacro def-callback-marshal (name (return-type &rest args))
-  (let ((names (loop 
-               for arg in args 
-               collect (if (atom arg) (gensym) (first arg))))
-       (types (loop 
-               for arg in args 
-               collect (if (atom arg) arg (second arg)))))
-    `(defcallback ,name (,return-type ,@(mapcar #'list names types)
-                        (callback-id unsigned-int))
-      (invoke-callback callback-id ',return-type ,@names))))
+(defmacro define-callback-marshal (name return-type args &key (callback-id :last))
+  (let* ((ignore ())
+        (params ())
+        (names (loop 
+                for arg in args 
+                collect (if (or 
+                             (eq arg :ignore) 
+                             (and (consp arg) (eq (first arg) :ignore)))
+                            (let ((name (gensym "IGNORE")))
+                              (push name ignore)
+                              name)
+                          (let ((name (if (atom arg)
+                                          (gensym (string arg))
+                                        (first arg))))
+                            (push name params)
+                            name))))
+        (types (loop 
+                for arg in args 
+                collect (cond
+                         ((eq arg :ignore) 'pointer)
+                         ((atom arg) arg)
+                         (t (second arg))))))
+    `(define-callback ,name ,return-type 
+       ,(ecase callback-id
+         (:first `((callback-id pointer-data) ,@(mapcar #'list names types)))
+         (:last `(,@(mapcar #'list names types) (callback-id pointer-data))))
+       (declare (ignore ,@ignore))
+       (invoke-callback callback-id ',return-type ,@(nreverse params)))))

 
 (defmacro with-callback-function ((id function) &body body)
   `(let ((,id (register-callback-function ,function)))
 
 (defmacro with-callback-function ((id function) &body body)
   `(let ((,id (register-callback-function ,function)))