chiark / gitweb /
Correctly sort out string-specified getters in virtual-slots.lisp
[clg] / gffi / virtual-slots.lisp
index 6551210..22a6af3 100644 (file)
@@ -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.
 
 ;; TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 ;; SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-;; $Id: virtual-slots.lisp,v 1.3 2006-08-16 12:09:03 espen Exp $
+;; $Id: virtual-slots.lisp,v 1.11 2007-11-08 13:49:26 espen Exp $
 
 (in-package "GFFI")
 
 
 (in-package "GFFI")
 
@@ -112,17 +112,16 @@ (defmethod compute-slot-reader-function :around ((slotd effective-virtual-slot-d
          (error 'unreadable-slot :name (slot-definition-name slotd) :instance object))
     (let ((reader-function (call-next-method)))
       (cond
          (error 'unreadable-slot :name (slot-definition-name slotd) :instance object))
     (let ((reader-function (call-next-method)))
       (cond
-       ;; Don't create an wrapper to signal unbound value
+       ;; Don't create wrapper to signal unbound value
        ((not signal-unbound-p) reader-function)
        
        ;; An explicit boundp function has been supplied
        ((slot-boundp slotd 'boundp) 
        ((not signal-unbound-p) reader-function)
        
        ;; An explicit boundp function has been supplied
        ((slot-boundp slotd 'boundp) 
-       (let ((unbound-value (slot-value slotd 'boundp)))
+       (let ((boundp (slot-value slotd 'boundp)))
          #'(lambda (object)
          #'(lambda (object)
-             (let ((value (funcall reader-function object)))
-               (if (eq value unbound-value)
-                   (slot-unbound (class-of object) object (slot-definition-name slotd))
-                 value)))))
+             (if (not (funcall boundp object))
+                 (slot-unbound (class-of object) object (slot-definition-name slotd))
+               (funcall reader-function object)))))
        
        ;; A type unbound value exists
        ((let ((unbound-method (find-applicable-type-method 'unbound-value 
        
        ;; A type unbound value exists
        ((let ((unbound-method (find-applicable-type-method 'unbound-value 
@@ -143,7 +142,12 @@ (defmethod compute-slot-reader-function :around ((slotd effective-virtual-slot-d
 
 (defmethod compute-slot-reader-function ((slotd effective-virtual-slot-definition) &optional signal-unbound-p)
   (declare (ignore signal-unbound-p))
 
 (defmethod compute-slot-reader-function ((slotd effective-virtual-slot-definition) &optional signal-unbound-p)
   (declare (ignore signal-unbound-p))
-  (slot-value slotd 'getter))
+  (let ((getter (slot-value slotd 'getter)))
+    #-sbcl getter
+    #+sbcl
+    (etypecase getter
+      (symbol #'(lambda (object) (funcall getter object)))
+      (function getter))))
 
 (defmethod compute-slot-boundp-function ((slotd effective-virtual-slot-definition))
   (cond
 
 (defmethod compute-slot-boundp-function ((slotd effective-virtual-slot-definition))
   (cond
@@ -152,8 +156,14 @@ (defmethod compute-slot-boundp-function ((slotd effective-virtual-slot-definitio
     #'(lambda (object) (declare (ignore object)) nil))
 
    ;; An explicit boundp function has been supplied
     #'(lambda (object) (declare (ignore object)) nil))
 
    ;; An explicit boundp function has been supplied
-   ((slot-boundp slotd 'boundp) (slot-value slotd 'boundp))
-   
+   ((slot-boundp slotd 'boundp)
+    (let ((boundp (slot-value slotd 'boundp)))
+      #-sbcl boundp
+      #+sbcl
+      (etypecase boundp
+       (symbol #'(lambda (object) (funcall boundp object)))
+       (function boundp))))
+
    ;; An unbound value has been supplied
    ((slot-boundp slotd 'unbound)
     (let ((reader-function (compute-slot-reader-function slotd nil))
    ;; An unbound value has been supplied
    ((slot-boundp slotd 'unbound)
     (let ((reader-function (compute-slot-reader-function slotd nil))
@@ -191,7 +201,14 @@ (defmethod compute-slot-writer-function :around ((slotd effective-virtual-slot-d
     (call-next-method)))
 
 (defmethod compute-slot-writer-function ((slotd effective-virtual-slot-definition))
     (call-next-method)))
 
 (defmethod compute-slot-writer-function ((slotd effective-virtual-slot-definition))
-  (slot-value slotd 'setter))
+  (let ((setter (slot-value slotd 'setter)))
+    #-sbcl setter
+    #+sbcl
+    (etypecase setter
+      (symbol #'(lambda (value object) (funcall setter value object)))
+      (list #'(lambda (value object)
+               (funcall setter value object)))
+      (function setter))))
 
 (define-condition slot-can-not-be-unbound (cell-error)
   ((instance :reader slot-can-not-be-unbound-instance :initarg :instance))
 
 (define-condition slot-can-not-be-unbound (cell-error)
   ((instance :reader slot-can-not-be-unbound-instance :initarg :instance))
@@ -205,7 +222,13 @@ (defmethod compute-slot-makunbound-function ((slotd effective-virtual-slot-defin
    ((not (slot-writable-p slotd))
     #'(lambda (object)
        (error 'unwritable-slot :name (slot-definition-name slotd) :instance object)))
    ((not (slot-writable-p slotd))
     #'(lambda (object)
        (error 'unwritable-slot :name (slot-definition-name slotd) :instance object)))
-   ((slot-boundp slotd 'makunbound) (slot-value slotd 'makunbound))
+   ((slot-boundp slotd 'makunbound)
+    (let ((makunbound (slot-value slotd 'makunbound)))
+      #-sbcl makunbound
+      #+sbcl
+      (etypecase makunbound
+       (symbol #'(lambda (object) (funcall makunbound object)))
+       (function makunbound))))
    ((slot-boundp slotd 'unbound)
     #'(lambda (object)
        (funcall (slot-value slotd 'writer-function) (slot-value slotd 'unbound) object)))
    ((slot-boundp slotd 'unbound)
     #'(lambda (object)
        (funcall (slot-value slotd 'writer-function) (slot-value slotd 'unbound) object)))
@@ -216,14 +239,8 @@ (defmethod compute-slot-makunbound-function ((slotd effective-virtual-slot-defin
 
 #-clisp
 (defmethod initialize-internal-slot-functions ((slotd effective-virtual-slot-definition))
 
 #-clisp
 (defmethod initialize-internal-slot-functions ((slotd effective-virtual-slot-definition))
-  #?-(sbcl>= 0 9 15) ; Delayed to avoid recursive call of finalize-inheritanze
-  (setf 
-   (slot-value slotd 'reader-function) (compute-slot-reader-function slotd)
-   (slot-value slotd 'boundp-function) (compute-slot-boundp-function slotd)
-   (slot-value slotd 'writer-function) (compute-slot-writer-function slotd)
-   (slot-value slotd 'makunbound-function) (compute-slot-makunbound-function slotd))
-
-  #?-(sbcl>= 0 9 8)(initialize-internal-slot-gfs (slot-definition-name slotd)))
+  #?-(sbcl>= 0 9 8)
+  (initialize-internal-slot-gfs (slot-definition-name slotd)))
 
 
 #-clisp
 
 
 #-clisp
@@ -265,49 +282,56 @@ (defmethod compute-effective-slot-definition-initargs ((class virtual-slots-clas
      (append '(:special t) (call-next-method)))
     (t (call-next-method))))
 
      (append '(:special t) (call-next-method)))
     (t (call-next-method))))
 
-#?(or (not (sbcl>= 0 9 14)) (featurep :clisp))
-(defmethod slot-value-using-class
-    ((class virtual-slots-class) (object virtual-slots-object)
-     (slotd effective-virtual-slot-definition))
-    (funcall (slot-value slotd 'reader-function) object))
-
-#?(or (not (sbcl>= 0 9 14)) (featurep :clisp))
-(defmethod slot-boundp-using-class
-    ((class virtual-slots-class) (object virtual-slots-object)
-     (slotd effective-virtual-slot-definition))
-    (funcall (slot-value slotd 'boundp-function) object))
-
-#?(or (not (sbcl>= 0 9 14)) (featurep :clisp))
-(defmethod (setf slot-value-using-class) 
-    (value (class virtual-slots-class) (object virtual-slots-object)
-     (slotd effective-virtual-slot-definition))
-  (funcall (slot-value slotd 'writer-function) value object))
-
-(defmethod slot-makunbound-using-class
-    ((class virtual-slots-class) (object virtual-slots-object)
-     (slotd effective-virtual-slot-definition))
-  (funcall (slot-value slotd 'makunbound-function) object))
-
+(defmacro vsc-slot-x-using-class (x x-slot-name computer &key allow-string-fun-p)
+  (let ((generic-name (intern (concatenate 'string
+                                           "SLOT-" (string x) "-USING-CLASS"))))
+    `(defmethod ,generic-name
+         ((class virtual-slots-class) (object virtual-slots-object)
+          (slotd effective-virtual-slot-definition))
+       (unless (and (slot-boundp slotd ',x-slot-name)
+                    ,@(when allow-string-fun-p
+                         `((not
+                            (stringp (slot-value slotd ',x-slot-name))))))
+         (setf (slot-value slotd ',x-slot-name) (,computer slotd)))
+       (funcall (slot-value slotd ',x-slot-name) object))))
+
+(vsc-slot-x-using-class value getter compute-slot-reader-function
+                        :allow-string-fun-p t)
+(vsc-slot-x-using-class boundp boundp-function compute-slot-boundp-function)
+(vsc-slot-x-using-class makunbound makunbound-function
+                        compute-slot-makunbound-function)
+
+(defmethod (setf slot-value-using-class) (value (class virtual-slots-class)
+                                          (object virtual-slots-object)
+                                          (slotd effective-virtual-slot-definition))
+  (unless (slot-boundp slotd 'setter)
+    (setf (slot-value slotd 'setter) (compute-slot-writer-function slotd)))
+  (funcall (slot-value slotd 'setter) value object))
 
 ;; In CLISP and SBCL (0.9.15 or newler) a class may not have been
 ;; finalized when update-slots are called. So to avoid the possibility
 
 ;; In CLISP and SBCL (0.9.15 or newler) a class may not have been
 ;; finalized when update-slots are called. So to avoid the possibility
-;; of finalize-instance beeing called recursivly we have to delay the
+;; of finalize-instance being called recursivly we have to delay the
 ;; initialization of slot functions until after an instance has been
 ;; created.
 ;; initialization of slot functions until after an instance has been
 ;; created.
-#?(or (sbcl>= 0 9 15) (featurep :clisp))
+;; 2007-11-08: done this for all implementations
+;; #?(or (sbcl>= 0 9 15) (featurep :clisp))
 (defmethod slot-unbound (class (slotd effective-virtual-slot-definition) (name (eql 'reader-function)))
 (defmethod slot-unbound (class (slotd effective-virtual-slot-definition) (name (eql 'reader-function)))
+  (declare (ignore class))
   (setf (slot-value slotd name) (compute-slot-reader-function slotd)))
 
   (setf (slot-value slotd name) (compute-slot-reader-function slotd)))
 
-#?(or (sbcl>= 0 9 15) (featurep :clisp))
+;; #?(or (sbcl>= 0 9 15) (featurep :clisp))
 (defmethod slot-unbound (class (slotd effective-virtual-slot-definition) (name (eql 'boundp-function)))
 (defmethod slot-unbound (class (slotd effective-virtual-slot-definition) (name (eql 'boundp-function)))
+  (declare (ignore class))
   (setf (slot-value slotd name) (compute-slot-boundp-function slotd)))
 
   (setf (slot-value slotd name) (compute-slot-boundp-function slotd)))
 
-#?(or (sbcl>= 0 9 15) (featurep :clisp))
+;; #?(or (sbcl>= 0 9 15) (featurep :clisp))
 (defmethod slot-unbound (class (slotd effective-virtual-slot-definition) (name (eql 'writer-function)))
 (defmethod slot-unbound (class (slotd effective-virtual-slot-definition) (name (eql 'writer-function)))
+  (declare (ignore class))
   (setf (slot-value slotd name) (compute-slot-writer-function slotd)))
 
   (setf (slot-value slotd name) (compute-slot-writer-function slotd)))
 
-#?(or (sbcl>= 0 9 15) (featurep :clisp))
+;; #?(or (sbcl>= 0 9 15) (featurep :clisp))
 (defmethod slot-unbound (class (slotd effective-virtual-slot-definition) (name (eql 'makunbound-function)))
 (defmethod slot-unbound (class (slotd effective-virtual-slot-definition) (name (eql 'makunbound-function)))
+  (declare (ignore class))
   (setf (slot-value slotd name) (compute-slot-makunbound-function slotd)))
 
 
   (setf (slot-value slotd name) (compute-slot-makunbound-function slotd)))
 
 
@@ -326,7 +350,7 @@ (defmethod slot-definition-special ((slotd standard-effective-slot-definition))
 
 ;;; To determine if a slot should be initialized with the initform,
 ;;; CLISP checks whether it is unbound or not. This doesn't work with
 
 ;;; To determine if a slot should be initialized with the initform,
 ;;; CLISP checks whether it is unbound or not. This doesn't work with
-;;; virtual slots which does not have an unbound state, so we have to
+;;; virtual slots that does not have an unbound state, so we have to
 ;;; implement initform initialization in a way similar to how it is
 ;;; done in PCL.
 #+clisp
 ;;; implement initform initialization in a way similar to how it is
 ;;; done in PCL.
 #+clisp