X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~mdw/git/clg/blobdiff_plain/eeda1c2da2663832d114329d58e92f77c86cf2fa..73572c12ccd49c661d06287903bfa725f5fd93a5:/glib/proxy.lisp

diff --git a/glib/proxy.lisp b/glib/proxy.lisp
index 72f201f..6ad8b90 100644
--- a/glib/proxy.lisp
+++ b/glib/proxy.lisp
@@ -15,7 +15,7 @@
 ;; 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: proxy.lisp,v 1.15 2004-12-16 23:19:17 espen Exp $
+;; $Id: proxy.lisp,v 1.19 2005-02-03 23:09:04 espen Exp $
 
 (in-package "GLIB")
 
@@ -35,7 +35,7 @@   (defclass effective-virtual-slot-definition (standard-effective-slot-definitio
     ((setter :reader slot-definition-setter :initarg :setter)
      (getter :reader slot-definition-getter :initarg :getter)
      (unbound :reader slot-definition-unbound :initarg :unbound)
-     (boundp :reader slot-definition-boundp :initarg :boundp)))
+     (boundp :reader slot-definition-boundp :initarg :boundp))))
   
   (defvar *unbound-marker* (gensym "UNBOUND-MARKER-"))
 
@@ -47,7 +47,7 @@ 				   (default *unbound-marker*))
 		   instances)))
       (if object
 	  (slot-value object slot)
-	  default))))
+	  default)));)
 
   
 
@@ -84,23 +84,20 @@ (defmethod initialize-internal-slot-functions ((slotd effective-virtual-slot-def
 		  (setf (slot-value slotd 'reader-function)
 			#'(lambda (object)
 			    (unless reader
-			    (setq reader
-			     (mkbinding getter 
-			      (slot-definition-type slotd) 'pointer)))
+			      (setq reader
+			       (mkbinding getter 
+				(slot-definition-type slotd) 'pointer)))
 			    (funcall reader (proxy-location object))))))))))
 
       (setf 
        (slot-value slotd 'boundp-function)
        (cond
-	((and 
-	  (not (slot-boundp slotd 'unbound))
-	  (not (slot-boundp slotd 'boundp)))
-	 #'(lambda (object) (declare (ignore object)) t))  
 	((slot-boundp slotd 'unbound)
 	 (let ((unbound-value (slot-value slotd 'unbound)))
-	   (lambda (object)
-	     (not (eq (funcall getter-function object) unbound-value)))))
-	((let ((boundp (slot-value slotd 'boundp)))
+	   #'(lambda (object)
+	       (not (eq (funcall getter-function object) unbound-value)))))
+	((slot-boundp slotd 'boundp)
+	 (let ((boundp (slot-value slotd 'boundp)))
 	   (etypecase boundp
 	     (function boundp)
 	     (symbol #'(lambda (object)
@@ -111,7 +108,13 @@ (defmethod initialize-internal-slot-functions ((slotd effective-virtual-slot-def
 			     (setq reader
 			      (mkbinding boundp
 			       (slot-definition-type slotd) 'pointer)))
-			   (funcall reader (proxy-location object))))))))))
+			   (funcall reader (proxy-location object))))))))
+	((multiple-value-bind (unbound-p unbound-value)
+	     (unbound-value (slot-definition-type slotd))
+	   (when unbound-p
+	     #'(lambda (object)
+		 (not (eq (funcall getter-function object) unbound-value))))))
+	(#'(lambda (object) (declare (ignore object)) t))))
 
       (setf
        (slot-value slotd 'reader-function)
@@ -119,17 +122,26 @@ (defmethod initialize-internal-slot-functions ((slotd effective-virtual-slot-def
 	((slot-boundp slotd 'unbound)
 	 (let ((unbound (slot-value slotd 'unbound))
 	       (slot-name (slot-definition-name slotd)))
-	   (lambda (object)
-	     (let ((value (funcall getter-function object)))
-	       (if (eq value unbound)
-		   (slot-unbound (class-of object) object slot-name)
-		 value)))))
+	   #'(lambda (object)
+	       (let ((value (funcall getter-function object)))
+		 (if (eq value unbound)
+		     (slot-unbound (class-of object) object slot-name)
+		   value)))))
 	((slot-boundp slotd 'boundp)
 	 (let ((boundp-function (slot-value slotd 'boundp-function)))
-	   (lambda (object)
-	     (and
-	      (funcall boundp-function object)
-	      (funcall getter-function object)))))
+	   #'(lambda (object)
+	       (and
+		(funcall boundp-function object)
+		(funcall getter-function object)))))
+	((multiple-value-bind (unbound-p unbound-value)
+	     (unbound-value (slot-definition-type slotd))
+	   (let ((slot-name (slot-definition-name slotd)))
+	     (when unbound-p
+	       #'(lambda (object)
+		   (let ((value (funcall getter-function object)))
+		     (if (eq value unbound-value)
+			 (slot-unbound (class-of object) object slot-name)
+			 value)))))))
 	(getter-function)))))
 
   (setf 
@@ -211,26 +223,26 @@ (defvar *instance-cache* (make-hash-table :test #'eql))
 
 (defun cache-instance (instance)
   (setf
-   (gethash (system:sap-int (proxy-location instance)) *instance-cache*)
-   (ext:make-weak-pointer instance)))
+   (gethash (sap-int (proxy-location instance)) *instance-cache*)
+   (make-weak-pointer instance)))
 
 (defun find-cached-instance (location)
-  (let ((ref (gethash (system:sap-int location) *instance-cache*)))
+  (let ((ref (gethash (sap-int location) *instance-cache*)))
     (when ref
-      (ext:weak-pointer-value ref))))
+      (weak-pointer-value ref))))
 
 (defun instance-cached-p (location)
-  (gethash (system:sap-int location) *instance-cache*))
+  (gethash (sap-int location) *instance-cache*))
 
 (defun remove-cached-instance (location)
-  (remhash (system:sap-int location) *instance-cache*))
+  (remhash (sap-int location) *instance-cache*))
 
 ;; For debuging
 (defun cached-instances ()
   (let ((instances ()))
     (maphash #'(lambda (location ref)
 		 (declare (ignore location))
-		 (push (ext:weak-pointer-value ref) instances))
+		 (push (weak-pointer-value ref) instances))
 	     *instance-cache*)
     instances))
 			
@@ -246,6 +258,12 @@ (defgeneric instance-finalizer (object))
 (defgeneric reference-foreign (class location))
 (defgeneric unreference-foreign (class location))
 
+(defmethod reference-foreign ((name symbol) location)
+  (reference-foreign (find-class name) location))
+
+(defmethod unreference-foreign ((name symbol) location)
+  (unreference-foreign (find-class name) location))
+
 (defmethod unreference-foreign :around ((class class) location)
   (unless (null-pointer-p location)
 ;;     (format t "Unreferencing ~A at ~A" (class-name class) location)
@@ -265,7 +283,7 @@ (defmethod initialize-instance :around ((instance proxy) &key location)
       (setf (slot-value instance 'location) location)      
     (call-next-method))
   (cache-instance instance)
-  (ext:finalize instance (instance-finalizer instance))
+  (finalize instance (instance-finalizer instance))
   instance)
 
 (defmethod instance-finalizer ((instance proxy))
@@ -280,6 +298,10 @@ (defmethod instance-finalizer ((instance proxy))
 
 ;;;; Metaclass used for subclasses of proxy
 
+(defgeneric most-specific-proxy-superclass (class))
+(defgeneric direct-proxy-superclass (class))
+  
+
 (eval-when (:compile-toplevel :load-toplevel :execute)
   (defclass proxy-class (virtual-slots-class)
     ((size :reader proxy-instance-size)))
@@ -291,13 +313,12 @@   (defclass direct-alien-slot-definition (direct-virtual-slot-definition)
   (defclass effective-alien-slot-definition (effective-virtual-slot-definition)
     ((offset :reader slot-definition-offset :initarg :offset)))
 
-
   (defmethod most-specific-proxy-superclass ((class proxy-class))
     (find-if
      #'(lambda (class)
 	 (subtypep (class-name class) 'proxy))
      (cdr (compute-class-precedence-list class))))
-  
+
   (defmethod direct-proxy-superclass ((class proxy-class))
     (find-if
      #'(lambda (class)
@@ -357,7 +378,11 @@   (defconstant +struct-alignmen+ 4)
 
   (defmethod compute-slots ((class proxy-class))
     (loop 
-     with offset = (proxy-instance-size (most-specific-proxy-superclass class))
+     with offset = (let ((size-of-super-classes
+			  (proxy-instance-size 
+			   (most-specific-proxy-superclass class))))
+		     (+ size-of-super-classes 
+			(mod size-of-super-classes +struct-alignmen+)))
      with size = offset
      for slotd in (class-direct-slots class)
      when (eq (slot-definition-allocation slotd) :alien)
@@ -380,6 +405,9 @@   (defmethod validate-superclass ((class proxy-class) (super standard-class))
   (defmethod proxy-instance-size (class)
     (declare (ignore class))
     0)
+
+  (defmethod proxy-instance-size ((class-name symbol))
+    (proxy-instance-size (find-class class-name)))
 )
   
 (defmethod alien-type ((class proxy-class) &rest args)
@@ -423,7 +451,7 @@ (defmethod copy-to-alien-form (instance (class proxy-class) &rest args)
   `(reference-foreign ',(class-name class) (proxy-location ,instance)))
 
 (defmethod copy-to-alien-function ((class proxy-class) &rest args)
-  (declare (ignore class args))
+  (declare (ignore args))
   #'(lambda (instance)
       (reference-foreign class (proxy-location instance))))
 
@@ -447,6 +475,9 @@ (defmethod destroy-function ((class proxy-class) &rest args)
   #'(lambda (location &optional (offset 0))
       (unreference-foreign class (sap-ref-sap location offset))))
 
+(defmethod unbound-value ((class proxy-class) &rest args)
+  (declare (ignore args))
+  (values t nil))
 
 (defgeneric ensure-proxy-instance (class location)
   (:documentation "Returns a proxy object representing the foreign object at the give location."))
@@ -476,7 +507,7 @@ (defmethod initialize-instance ((struct struct) &rest initargs)
     (let ((size (proxy-instance-size (class-of struct))))
       (if (zerop size)
 	  (error "~A has zero size" (class-of struct))
-	  (setf (slot-value struct 'location) (allocate-memory size)))))
+	(setf (slot-value struct 'location) (allocate-memory size)))))
   (call-next-method))