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

diff --git a/src/code/target-defstruct.lisp b/src/code/target-defstruct.lisp
index ef0761f..5d580c7 100644
--- a/src/code/target-defstruct.lisp
+++ b/src/code/target-defstruct.lisp
@@ -31,112 +31,68 @@
 (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)
-    (declare (type index index))
-    (%raw-instance-ref/word instance index))
-  (defun %raw-instance-set/word (instance index new-value)
-    (declare (type index index)
-             (type sb!vm:word new-value))
-    (%raw-instance-set/word instance index new-value))
-
-  (defun %raw-instance-ref/single (instance index)
-    (declare (type index index))
-    (%raw-instance-ref/single instance index))
-  (defun %raw-instance-set/single (instance index new-value)
-    (declare (type index index)
-             (type single-float new-value))
-    (%raw-instance-set/single instance index new-value))
-
-  (defun %raw-instance-ref/double (instance index)
-    (declare (type index index))
-    (%raw-instance-ref/double instance index))
-  (defun %raw-instance-set/double (instance index new-value)
-    (declare (type index index)
-             (type double-float new-value))
-    (%raw-instance-set/double instance index new-value))
-
-  (defun %raw-instance-ref/complex-single (instance index)
-    (declare (type index index))
-    (%raw-instance-ref/complex-single instance index))
-  (defun %raw-instance-set/complex-single (instance index new-value)
-    (declare (type index index)
-             (type (complex single-float) new-value))
-    (%raw-instance-set/complex-single instance index new-value))
-
-  (defun %raw-instance-ref/complex-double (instance index)
-    (declare (type index index))
-    (%raw-instance-ref/complex-double instance index))
-  (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))
-) ; #!-HPPA
-
-#!+hppa
-(progn
-(defun %raw-ref-single (vec index)
+;;; Normally IR2 converted, definition needed for interpreted structure
+;;; constructors only.
+#!+sb-eval
+(defun %make-structure-instance (dd slot-specs &rest slot-values)
+  (let ((instance (%make-instance (dd-instance-length dd))))
+    (setf (%instance-layout instance) (dd-layout-or-lose dd))
+    (mapc (lambda (spec value)
+            (destructuring-bind (raw-type . index) (cdr spec)
+              (macrolet ((make-case ()
+                           `(ecase raw-type
+                              ((t)
+                               (setf (%instance-ref instance index) value))
+                              ,@(mapcar
+                                 (lambda (rsd)
+                                   `(,(raw-slot-data-raw-type rsd)
+                                      (setf (,(raw-slot-data-accessor-name rsd)
+                                              instance index)
+                                            value)))
+                                 *raw-slot-data-list*))))
+                (make-case))))
+          slot-specs slot-values)
+    instance))
+
+(defun %raw-instance-ref/word (instance index)
   (declare (type index index))
-  (%raw-ref-single vec index))
+  (%raw-instance-ref/word instance index))
+(defun %raw-instance-set/word (instance index new-value)
+  (declare (type index index)
+           (type sb!vm:word new-value))
+  (%raw-instance-set/word instance index new-value))
 
-(defun %raw-ref-double (vec index)
+(defun %raw-instance-ref/single (instance index)
   (declare (type index index))
-  (%raw-ref-double vec index))
+  (%raw-instance-ref/single instance index))
+(defun %raw-instance-set/single (instance index new-value)
+  (declare (type index index)
+           (type single-float new-value))
+  (%raw-instance-set/single instance index new-value))
 
-#!+long-float
-(defun %raw-ref-long (vec index)
+(defun %raw-instance-ref/double (instance index)
   (declare (type index index))
-  (%raw-ref-long vec index))
+  (%raw-instance-ref/double instance index))
+(defun %raw-instance-set/double (instance index new-value)
+  (declare (type index index)
+           (type double-float new-value))
+  (%raw-instance-set/double instance index new-value))
 
-(defun %raw-set-single (vec index val)
+(defun %raw-instance-ref/complex-single (instance index)
   (declare (type index index))
-  (%raw-set-single vec index val))
+  (%raw-instance-ref/complex-single instance index))
+(defun %raw-instance-set/complex-single (instance index new-value)
+  (declare (type index index)
+           (type (complex single-float) new-value))
+  (%raw-instance-set/complex-single instance index new-value))
 
-(defun %raw-set-double (vec index val)
+(defun %raw-instance-ref/complex-double (instance index)
   (declare (type index index))
-  (%raw-set-double vec index val))
-
-#!+long-float
-(defun %raw-set-long (vec index val)
-  (declare (type index index))
-  (%raw-set-long vec index val))
-
-(defun %raw-ref-complex-single (vec index)
-  (declare (type index index))
-  (%raw-ref-complex-single vec index))
-
-(defun %raw-ref-complex-double (vec index)
-  (declare (type index index))
-  (%raw-ref-complex-double vec index))
-
-#!+long-float
-(defun %raw-ref-complex-long (vec index)
-  (declare (type index index))
-  (%raw-ref-complex-long vec index))
-
-(defun %raw-set-complex-single (vec index val)
-  (declare (type index index))
-  (%raw-set-complex-single vec index val))
-
-(defun %raw-set-complex-double (vec index val)
-  (declare (type index index))
-  (%raw-set-complex-double vec index val))
-
-#!+long-float
-(defun %raw-set-complex-long (vec index val)
-  (declare (type index index))
-  (%raw-set-complex-long vec index val))
-) ; #!+HPPA
+  (%raw-instance-ref/complex-double instance index))
+(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))
 
 (defun %instance-layout (instance)
   (%instance-layout instance))
@@ -160,19 +116,6 @@
 
 (defun (setf funcallable-instance-fun) (new-value fin)
   (setf (%funcallable-instance-function fin) new-value))
-
-;;; service function for structure constructors
-(defun %make-instance-with-layout (layout)
-  ;; Make sure the object ends at a two-word boundary.  Note that this does
-  ;; not affect the amount of memory used, since the allocator would add the
-  ;; same padding anyway.  However, raw slots are indexed from the length of
-  ;; the object as indicated in the header, so the pad word needs to be
-  ;; included in that length to guarantee proper alignment of raw double float
-  ;; slots, necessary for (at least) the SPARC backend.
-  (let* ((length (layout-length layout))
-         (result (%make-instance (+ length (mod (1+ length) 2)))))
-    (setf (%instance-layout result) layout)
-    result))
 
 ;;;; target-only parts of the DEFSTRUCT top level code
 
@@ -413,7 +356,7 @@
     (when (layout-invalid layout)
       (error "attempt to copy an obsolete structure:~%  ~S" structure))
 
-    ;; Copy ordinary slots.
+    ;; Copy ordinary slots and layout.
     (dotimes (i (- len nuntagged))
       (declare (type index i))
       (setf (%instance-ref res i)
@@ -426,84 +369,113 @@
             (%raw-instance-ref/word structure i)))
 
     res))
+
+
+
+;; Do an EQUALP comparison on the raw slots (only, not the normal slots) of a
+;; structure.
+(defun raw-instance-slots-equalp (layout x y)
+  ;; This implementation sucks, but hopefully EQUALP on raw structures
+  ;; won't be a major bottleneck for anyone. It'd be tempting to do
+  ;; all this with %RAW-INSTANCE-REF/WORD and bitwise comparisons, but
+  ;; that'll fail in some cases. For example -0.0 and 0.0 are EQUALP
+  ;; but have different bit patterns. -- JES, 2007-08-21
+  (loop with i = -1
+        for dsd in (dd-slots (layout-info layout))
+        for raw-type = (dsd-raw-type dsd)
+        for rsd = (when raw-type
+                    (find raw-type
+                          *raw-slot-data-list*
+                          :key 'raw-slot-data-raw-type))
+        for accessor = (when rsd
+                         (raw-slot-data-accessor-name rsd))
+        always (or (not accessor)
+                   (progn
+                     (incf i)
+                     (equalp (funcall accessor x i)
+                             (funcall accessor y i))))))
 
 ;;; default PRINT-OBJECT method
 
+(defun %print-structure-sans-layout-info (name stream)
+  ;; KLUDGE: during PCL build debugging, we can sometimes
+  ;; attempt to print out a PCL object (with null LAYOUT-INFO).
+  (pprint-logical-block (stream nil :prefix "#<" :suffix ">")
+    (prin1 name stream)
+    (write-char #\space stream)
+    (write-string "(no LAYOUT-INFO)" stream)))
+
+(defun %print-structure-sans-slots (name stream)
+  ;; the structure type doesn't count as a component for *PRINT-LEVEL*
+  ;; processing. We can likewise elide the logical block processing,
+  ;; since all we have to print is the type name. -- CSR, 2004-10-05
+  (write-string "#S(" stream)
+  (prin1 name stream)
+  (write-char #\) stream))
+
 (defun %default-structure-pretty-print (structure stream)
   (let* ((layout (%instance-layout structure))
          (name (classoid-name (layout-classoid layout)))
          (dd (layout-info layout)))
-    ;; KLUDGE: during the build process with SB-SHOW, we can sometimes
-    ;; attempt to print out a PCL object (with null LAYOUT-INFO).
-    #!+sb-show
-    (when (null dd)
-      (pprint-logical-block (stream nil :prefix "#<" :suffix ">")
-        (prin1 name stream)
-        (write-char #\space stream)
-        (write-string "(no LAYOUT-INFO)"))
-      (return-from %default-structure-pretty-print nil))
-    ;; the structure type doesn't count as a component for
-    ;; *PRINT-LEVEL* processing.  We can likewise elide the logical
-    ;; block processing, since all we have to print is the type name.
-    ;; -- CSR, 2004-10-05
-    (when (and dd (null (dd-slots dd)))
-      (write-string "#S(" stream)
-      (prin1 name stream)
-      (write-char #\) stream)
-      (return-from %default-structure-pretty-print nil))
-    (pprint-logical-block (stream nil :prefix "#S(" :suffix ")")
-      (prin1 name stream)
-      (let ((remaining-slots (dd-slots dd)))
-        (when remaining-slots
-          (write-char #\space stream)
-          ;; CMU CL had (PPRINT-INDENT :BLOCK 2 STREAM) here,
-          ;; but I can't see why. -- WHN 20000205
-          (pprint-newline :linear stream)
-          (loop
-           (pprint-pop)
-           (let ((slot (pop remaining-slots)))
-             (write-char #\: stream)
-             (output-symbol-name (symbol-name (dsd-name slot)) stream)
-             (write-char #\space stream)
-             (pprint-newline :miser stream)
-             (output-object (funcall (fdefinition (dsd-accessor-name slot))
-                                     structure)
-                            stream)
-             (when (null remaining-slots)
-               (return))
-             (write-char #\space stream)
-             (pprint-newline :linear stream))))))))
+    (cond ((not dd)
+           (%print-structure-sans-layout-info name stream))
+          ((not (dd-slots dd))
+           (%print-structure-sans-slots name stream))
+          (t
+           (pprint-logical-block (stream nil :prefix "#S(" :suffix ")")
+             (prin1 name stream)
+             (let ((remaining-slots (dd-slots dd)))
+               (when remaining-slots
+                 (write-char #\space stream)
+                 ;; CMU CL had (PPRINT-INDENT :BLOCK 2 STREAM) here,
+                 ;; but I can't see why. -- WHN 20000205
+                 (pprint-newline :linear stream)
+                 (loop
+                   (pprint-pop)
+                   (let ((slot (pop remaining-slots)))
+                     (write-char #\: stream)
+                     (output-symbol-name (symbol-name (dsd-name slot)) stream)
+                     (write-char #\space stream)
+                     (pprint-newline :miser stream)
+                     (output-object (funcall (fdefinition (dsd-accessor-name slot))
+                                             structure)
+                                    stream)
+                     (when (null remaining-slots)
+                       (return))
+                     (write-char #\space stream)
+                     (pprint-newline :linear stream))))))))))
+
 (defun %default-structure-ugly-print (structure stream)
   (let* ((layout (%instance-layout structure))
          (name (classoid-name (layout-classoid layout)))
          (dd (layout-info layout)))
-    (when (and dd (null (dd-slots dd)))
-      (write-string "#S(" stream)
-      (prin1 name stream)
-      (write-char #\) stream)
-      (return-from %default-structure-ugly-print nil))
-    (descend-into (stream)
-      (write-string "#S(" stream)
-      (prin1 name stream)
-      (do ((index 0 (1+ index))
-           (remaining-slots (dd-slots dd) (cdr remaining-slots)))
-          ((or (null remaining-slots)
-               (and (not *print-readably*)
-                    *print-length*
-                    (>= index *print-length*)))
-           (if (null remaining-slots)
-               (write-string ")" stream)
-               (write-string " ...)" stream)))
-        (declare (type index index))
-        (write-char #\space stream)
-        (write-char #\: stream)
-        (let ((slot (first remaining-slots)))
-          (output-symbol-name (symbol-name (dsd-name slot)) stream)
-          (write-char #\space stream)
-          (output-object
-           (funcall (fdefinition (dsd-accessor-name slot))
-                    structure)
-           stream))))))
+    (cond ((not dd)
+           (%print-structure-sans-layout-info name stream))
+          ((not (dd-slots dd))
+           (%print-structure-sans-slots name stream))
+          (t
+           (descend-into (stream)
+             (write-string "#S(" stream)
+             (prin1 name stream)
+             (do ((index 0 (1+ index))
+                  (remaining-slots (dd-slots dd) (cdr remaining-slots)))
+                 ((or (null remaining-slots)
+                      (and (not *print-readably*)
+                           *print-length*
+                           (>= index *print-length*)))
+                  (if (null remaining-slots)
+                      (write-string ")" stream)
+                      (write-string " ...)" stream)))
+               (declare (type index index))
+               (write-string " :" stream)
+               (let ((slot (first remaining-slots)))
+                 (output-symbol-name (symbol-name (dsd-name slot)) stream)
+                 (write-char #\space stream)
+                 (output-object
+                  (funcall (fdefinition (dsd-accessor-name slot))
+                           structure)
+                  stream))))))))
+
 (defun default-structure-print (structure stream depth)
   (declare (ignore depth))
   (cond ((funcallable-instance-p structure)
@@ -512,6 +484,7 @@
          (%default-structure-pretty-print structure stream))
         (t
          (%default-structure-ugly-print structure stream))))
+
 (def!method print-object ((x structure-object) stream)
   (default-structure-print x stream *current-level-in-print*))