X-Git-Url: https://git.distorted.org.uk/~mdw/clg/blobdiff_plain/e1531bff3f558c21de73f423d9b19c66a0f33c7c..a666b391b604d3afe86079e064e648d9062430ef:/glib/glib.lisp

diff --git a/glib/glib.lisp b/glib/glib.lisp
index 2bb7101..43eb8bc 100644
--- a/glib/glib.lisp
+++ b/glib/glib.lisp
@@ -20,7 +20,7 @@
 ;; TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 ;; SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-;; $Id: glib.lisp,v 1.41 2007-09-07 07:33:51 espen Exp $
+;; $Id: glib.lisp,v 1.44 2008-10-08 18:11:12 espen Exp $
 
 
 (in-package "GLIB")
@@ -39,38 +39,38 @@
 
 ;;;; Memory management
 
-(defbinding (%allocate-memory "g_malloc0") () pointer
-  (size unsigned-long))
+(deftype gsize () 'unsigned-int)
 
-(defbinding (%deallocate-memory "g_free") () nil
-  (address pointer))
+(defbinding malloc0 () pointer
+  (size gsize))
 
-;; (setf
-;;  (symbol-function 'allocate-memory) #'%allocate-memory
-;;  (symbol-function 'deallocate-memory) #'%deallocate-memory)
+(defbinding free () nil
+  (address pointer))
 
-(setf *memory-allocator* #'%allocate-memory)
-(setf *memory-deallocator* #'%deallocate-memory)
+(setf *memory-allocator* #'malloc0)
+(setf *memory-deallocator* #'free)
 
 (defbinding (reallocate-memory "g_realloc") () pointer
   (address pointer)
-  (size unsigned-long))
+  (size gsize))
 
+(defbinding (slice-alloc "g_slice_alloc0") () pointer
+  (block-size gsize))
 
-;;;; User data mechanism
+;;;; User data is a mechanism to store references to lisp objects in
+;;;; foreign code
 
 (defvar *user-data-lock* (make-mutex))
 (defvar *user-data* (make-hash-table))
-(defvar *user-data-count* 0)
+(defvar *user-data-next-id* 1)
 
 (defun register-user-data (object &optional destroy-function)
   (check-type destroy-function (or null symbol function))
   (with-mutex (*user-data-lock*)
-    (incf *user-data-count*)
     (setf
-     (gethash *user-data-count* *user-data*)
+     (gethash *user-data-next-id* *user-data*)
      (cons object destroy-function))
-    *user-data-count*))
+    (1- (incf *user-data-next-id*))))
 
 (defun find-user-data (id)
   (check-type id fixnum)
@@ -95,10 +95,33 @@
 (defun destroy-user-data (id)
   (check-type id fixnum)
   (with-mutex (*user-data-lock*)
-    (let ((user-data (gethash id *user-data*)))
-      (when (cdr user-data)
-	(funcall (cdr user-data) (car user-data))))
-    (remhash id *user-data*)))
+    (multiple-value-bind (user-data exists-p) (gethash id *user-data*)
+      (cond
+;       ((not exists-p) (error "User data id ~A does not exist" id))
+       (t
+	(when (cdr user-data)
+	  (funcall (cdr user-data) (car user-data)))
+	(remhash id *user-data*))))))
+
+(defun take-user-data (id)
+  (check-type id fixnum)
+  (multiple-value-bind (user-data exists-p) (gethash id *user-data*)
+    (cond
+      ((not exists-p) (error "User data id ~A does not exist" id))
+      (t 
+	(when (cdr user-data)
+	  (funcall (cdr user-data) (car user-data)))
+	(remhash id *user-data*)
+	(car user-data)))))
+
+(defmacro with-user-data ((var object) &body body)
+  `(let ((,var (register-user-data ,object)))
+     (unwind-protect
+	  ,@body
+       (destroy-user-data ,var))))
+
+
+(deftype user-data-id () 'pointer-data)
 
 
 ;;;; Quarks
@@ -125,19 +148,22 @@
 (deftype glist (type) 
   `(or null (cons ,type list)))
 
-(defbinding (%glist-append "g_list_append") () pointer
+(defbinding (%glist-prepend "g_list_prepend") () pointer
   (glist (or null pointer))
   (nil null))
 
+(defbinding (%glist-reverse "g_list_reverse") () pointer
+  (glist (or null pointer)))
+
 (defun make-glist (element-type list &optional temp-p)
   (let ((writer (if (functionp element-type)
 		    element-type
 		  (writer-function element-type :temp temp-p))))
     (loop
      for element in list
-     as glist = (%glist-append nil) then (%glist-append glist)
+     as glist = (%glist-prepend nil) then (%glist-prepend glist)
      do (funcall writer element glist)
-     finally (return glist))))
+     finally (return (%glist-reverse glist)))))
 
 (defun glist-next (glist)
   (unless (null-pointer-p glist)
@@ -297,12 +323,11 @@
       #'(lambda (from to &optional (offset 0))
 	  (unless (null-pointer-p (ref-pointer from offset))
 	    (loop
-	     as from-list = (ref-pointer from offset) 
-	                    then (glist-next from-list)
-	     as to-list = (setf (ref-pointer to offset) (%glist-append nil)) 
-	                  then (%glist-append to-list)
+	     as from-list = (ref-pointer from offset) then (glist-next from-list)
+	     as to-list = (%glist-prepend nil) then (%glist-prepend to-list)
 	     do (funcall copy-element from-list to-list)
-	     while (glist-next from-lisT)))))))
+	     while (glist-next from-list)
+	     finally (setf (ref-pointer to offset) (%glist-reverse to-list))))))))
 
 
 ;;;; Single linked list (GSList)