X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcode%2Ftarget-defstruct.lisp;h=ef0761face226e618efccabb8f2e124a4e80eced;hb=cf0b72cd4052a09b9a305081524bd44e2948c1e5;hp=2ccc8187b42b07ea0f8c9da376dc4d4432398f0b;hpb=f12f2c5a8ae794dc414dd6a42e0b25740d576aa1;p=sbcl.git

diff --git a/src/code/target-defstruct.lisp b/src/code/target-defstruct.lisp
index 2ccc818..ef0761f 100644
--- a/src/code/target-defstruct.lisp
+++ b/src/code/target-defstruct.lisp
@@ -31,6 +31,15 @@
 (defun %instance-set (instance index new-value)
   (setf (%instance-ref instance index) new-value))
 
+(defun %instance-compare-and-swap (instance index old new)
+  #!+(or x86 x86-64)
+  (%instance-compare-and-swap instance index old new)
+  #!-(or x86 x86-64)
+  (let ((n-old (%instance-ref instance index)))
+    (when (eq old n-old)
+      (%instance-set instance index new))
+    n-old))
+
 #!-hppa
 (progn
   (defun %raw-instance-ref/word (instance index)
@@ -71,8 +80,11 @@
   (defun %raw-instance-set/complex-double (instance index new-value)
     (declare (type index index)
              (type (complex double-float) new-value))
-    (%raw-instance-set/complex-double instance index new-value)))
+    (%raw-instance-set/complex-double instance index new-value))
+) ; #!-HPPA
 
+#!+hppa
+(progn
 (defun %raw-ref-single (vec index)
   (declare (type index index))
   (%raw-ref-single vec index))
@@ -124,6 +136,7 @@
 (defun %raw-set-complex-long (vec index val)
   (declare (type index index))
   (%raw-set-complex-long vec index val))
+) ; #!+HPPA
 
 (defun %instance-layout (instance)
   (%instance-layout instance))
@@ -143,37 +156,10 @@
   (%set-funcallable-instance-info fin i new-value))
 
 (defun funcallable-instance-fun (fin)
-  (%funcallable-instance-lexenv fin))
-
-;;; The heart of the magic of funcallable instances ("FINs").  When
-;;; called (as with any other function), we grab the code pointer, and
-;;; call it, leaving the original function object in LEXENV (in case
-;;; it was a closure).  If it is actually a FIN, then we need to do an
-;;; extra indirection with funcallable-instance-lexenv to get at any
-;;; closure environment.  This extra indirection is set up when
-;;; accessing the closure environment of an INSTANCE-LAMBDA. Note that
-;;; the original FIN pointer is lost, so if the called function wants
-;;; to get at the original object to do some slot accesses, it must
-;;; close over the FIN object.
-;;;
-;;; If we set the FIN function to be a FIN, we directly copy across
-;;; both the code pointer and the lexenv, since that code pointer (for
-;;; an instance-lambda) is expecting that lexenv to be accessed.  This
-;;; effectively pre-flattens what would otherwise be a chain of
-;;; indirections.  (That used to happen when PCL dispatch functions
-;;; were byte-compiled; now that the byte compiler is gone, I can't
-;;; think of another example offhand. -- WHN 2001-10-06)
-;;;
-;;; The only loss is that if someone accesses the
-;;; FUNCALLABLE-INSTANCE-FUN, then won't get a FIN back.  This
-;;; probably doesn't matter, since PCL only sets the FIN function.
+  (%funcallable-instance-function fin))
+
 (defun (setf funcallable-instance-fun) (new-value fin)
-  (setf (%funcallable-instance-fun fin)
-        (%closure-fun new-value))
-  (setf (%funcallable-instance-lexenv fin)
-        (if (funcallable-instance-p new-value)
-            (%funcallable-instance-lexenv new-value)
-            new-value)))
+  (setf (%funcallable-instance-function fin) new-value))
 
 ;;; service function for structure constructors
 (defun %make-instance-with-layout (layout)
@@ -550,9 +536,7 @@
   (when (layout-invalid layout)
     (error "An obsolete structure accessor function was called."))
   (/noshow0 "back from testing LAYOUT-INVALID LAYOUT")
-  ;; FIXME: CMU CL used (%INSTANCEP OBJ) here. Check that
-  ;; (TYPEP OBJ 'INSTANCE) is optimized to equally efficient code.
-  (and (typep obj 'instance)
+  (and (%instancep obj)
        (let ((obj-layout (%instance-layout obj)))
          (cond ((eq obj-layout layout)
                 ;; (In this case OBJ-LAYOUT can't be invalid, because
@@ -626,5 +610,6 @@
            :datum x
            :expected-type (classoid-name (layout-classoid layout))))
   (values))
+
 
 (/show0 "target-defstruct.lisp end of file")