;; 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.38 2006/06/08 13:24:25 espen Exp $
+;; $Id: glib.lisp,v 1.45 2008/12/14 21:37:25 espen Exp $
(in-package "GLIB")
(use-prefix "g")
+#-sb-thread
+(progn
+ (defun make-mutex ()
+ nil)
+
+ (defmacro with-mutex ((mutex) &body body)
+ (declare (ignore mutex))
+ `(progn ,@body)))
+
;;;; Memory management
-(defbinding (%allocate-memory "g_malloc0") () pointer
- (size unsigned-long))
+(deftype gsize () 'unsigned-int)
+(deftype gssize () 'int)
+(deftype goffset () '(unsigned-int 64))
+
-(defbinding (%deallocate-memory "g_free") () nil
+(defbinding malloc0 () pointer
+ (size gsize))
+
+(defbinding free () nil
(address pointer))
-(setf
- (symbol-function 'allocate-memory) #'%allocate-memory
- (symbol-function 'deallocate-memory) #'%deallocate-memory)
+(setf *memory-allocator* #'malloc0)
+(setf *memory-deallocator* #'free)
+
+(defbinding (reallocate-memory "g_realloc") () pointer
+ (address pointer)
+ (size gsize))
+
+(defbinding (slice-alloc "g_slice_alloc0") () pointer
+ (block-size gsize))
+;;;; User data is a mechanism to store references to lisp objects in
+;;;; foreign code
-;;;; User data mechanism
+;; TODO: move to gffi
+(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))
- (incf *user-data-count*)
- (setf
- (gethash *user-data-count* *user-data*)
- (cons object destroy-function))
- *user-data-count*)
+ (with-mutex (*user-data-lock*)
+ (setf
+ (gethash *user-data-next-id* *user-data*)
+ (cons object destroy-function))
+ (1- (incf *user-data-next-id*))))
(defun find-user-data (id)
(check-type id fixnum)
- (multiple-value-bind (user-data p) (gethash id *user-data*)
- (values (car user-data) p)))
+ (with-mutex (*user-data-lock*)
+ (multiple-value-bind (user-data p) (gethash id *user-data*)
+ (values (car user-data) p))))
(defun user-data-exists-p (id)
(nth-value 1 (find-user-data id)))
(defun update-user-data (id object)
(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)))
- (setf (car user-data) object)))))
+ (with-mutex (*user-data-lock*)
+ (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)))
+ (setf (car user-data) object))))))
(defun destroy-user-data (id)
(check-type id fixnum)
- (let ((user-data (gethash id *user-data*)))
- (when (cdr user-data)
- (funcall (cdr user-data) (car user-data))))
- (remhash id *user-data*))
+ (with-mutex (*user-data-lock*)
+ (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
(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)
(declare (ignore type))
(alien-type 'pointer))
+(define-type-method argument-type ((type glist))
+ 'list)
+
+(define-type-method return-type ((type glist))
+ 'list)
+
(define-type-method size-of ((type glist) &key inlined)
(assert-not-inlined type inlined)
(size-of 'pointer))
#'(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)
(declare (ignore type))
(alien-type 'pointer))
+(define-type-method argument-type ((type gslist))
+ 'list)
+
+(define-type-method return-type ((type gslist))
+ 'list)
+
(define-type-method size-of ((type gslist) &key inlined)
(assert-not-inlined type inlined)
(size-of 'pointer))
~mdw / clg / blobdiff