X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcode%2Ftarget-defstruct.lisp;h=d41ff7a2a29a165e06a9712bfb286f87dac83eae;hb=08315e3cd273efbe55f8b85cf1c6e17016fbfd06;hp=5fb9ac18d968e385b0518c668c3526bc1ac71fc6;hpb=4898ef32c639b1c7f4ee13a5ba566ce6debd03e6;p=sbcl.git

diff --git a/src/code/target-defstruct.lisp b/src/code/target-defstruct.lisp
index 5fb9ac1..d41ff7a 100644
--- a/src/code/target-defstruct.lisp
+++ b/src/code/target-defstruct.lisp
@@ -71,8 +71,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 +127,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))
@@ -131,8 +135,8 @@
 (defun %set-instance-layout (instance new-value)
   (%set-instance-layout instance new-value))
 
-(defun %make-funcallable-instance (len layout)
-   (%make-funcallable-instance len layout))
+(defun %make-funcallable-instance (len)
+  (%make-funcallable-instance len))
 
 (defun funcallable-instance-p (x) (funcallable-instance-p x))
 
@@ -143,38 +147,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"). The
-;;; function for a FIN must be a magical INSTANCE-LAMBDA form. 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)
@@ -551,9 +527,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
@@ -627,5 +601,6 @@
            :datum x
            :expected-type (classoid-name (layout-classoid layout))))
   (values))
+
 
 (/show0 "target-defstruct.lisp end of file")