anchor.diff:  
   
   
  -;;;; Linked list
  -
  -(deftype glist () 'pointer)
  -(deftype double-list (type) `(or (null (cons ,type list))))
  -
  -
  -(define-foreign ("g_list_append" %glist-append) () glist
  -  (glist glist)
  +;;;; Linked list (GList)
  +
  +(deftype glist (type) `(or (null (cons ,type list))))
  +
  +(define-foreign ("g_list_append" %glist-append-unsigned) () pointer
  +  (glist pointer)
     (data unsigned))
  +
  +(define-foreign ("g_list_append" %glist-append-signed) () pointer
  +  (glist pointer)
  +  (data signed))
  +
  +(define-foreign ("g_list_append" %glist-append-sap) () pointer
  +  (glist pointer)
  +  (data pointer))
   
   (defmacro glist-append (glist value type-spec)
     (ecase (first (mklist (translate-type-spec type-spec)))
  -    (unsigned `(%glist-append ,glist ,value))
  -;    (signed `(%glist-append ,glist (signed-to-unsigned ,value)))
  -    (system-area-pointer `(%glist-append ,glist (system:sap-int ,value)))))
  -
  +    (unsigned `(%glist-append-unsigned ,glist ,value))
  +    (signed `(%glist-append-signed ,glist ,value))
  +    (system-area-pointer `(%glist-append-sap ,glist ,value))))
   
   (defmacro glist-data (glist type-spec)
     (ecase (first (mklist (translate-type-spec type-spec)))
  
positive.code: 	  '(glist-free glist))
         (nreverse list))))
  
  (deftype-method cleanup-alien double-list (type-spec glist &optional copied)
    (declare (ignore copied))
    (let* ((element-type-spec (second (type-expand-to 'double-list type-spec)))
  	 (alien-type-spec (translate-type-spec element-type-spec)))
      `(let ((glist ,glist))
         (unless (null-pointer-p glist)
  
negative.code:     (signed `(sap-ref-signed ,glist 0))
      (system-area-pointer `(sap-ref-sap ,glist 0))))
  
  (defun glist-next (glist)
    (unless (null-pointer-p glist)
      (sap-ref-sap glist +size-of-sap+)))
    
  (define-foreign ("g_list_free" glist-free) () nil
    (glist pointer))
  
  (deftype-method translate-type-spec glist (type-spec)
    (declare (ignore type-spec))
    (translate-type-spec 'pointer))
  
  (deftype-method size-of glist (type-spec)
    (declare (ignore type-spec))
    (size-of 'pointer))
  
  (deftype-method translate-to-alien glist (type-spec list &optional copy)
    (declare (ignore copy))
    (let* ((element-type-spec (second (type-expand-to 'glist type-spec)))
  	 (to-alien (translate-to-alien element-type-spec 'element t)))
      `(let ((glist (make-pointer 0))) 
         (dolist (element ,list glist)
  	 (setq glist (glist-append glist ,to-alien ,element-type-spec))))))
  
  (deftype-method translate-from-alien
      glist (type-spec glist &optional (alloc :reference))
    (let ((element-type-spec (second (type-expand-to 'glist type-spec))))
      `(let ((glist ,glist)
  	   (list nil))
         (do ((tmp glist (glist-next tmp)))
  