X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcode%2Fpred.lisp;h=2830c518a48505cffcab42342f9f3a2e896c0087;hb=3cb38bad21763eb16bd89d89a5fac9a186ac625b;hp=f0bf985f8cbcbc00597b30317faa21911cd72171;hpb=8735f137435f1a90c05df67a03e48602a79572f8;p=sbcl.git

diff --git a/src/code/pred.lisp b/src/code/pred.lisp
index f0bf985..2830c51 100644
--- a/src/code/pred.lisp
+++ b/src/code/pred.lisp
@@ -21,7 +21,40 @@
 (defun vector-t-p (x)
   (or (simple-vector-p x)
       (and (complex-vector-p x)
-           (simple-vector-p (%array-data-vector x)))))
+           (do ((data (%array-data-vector x) (%array-data-vector data)))
+               ((not (array-header-p data)) (simple-vector-p data))))))
+
+;;; Is X an extended sequence?
+(defun extended-sequence-p (x)
+  (and (not (listp x))
+       (not (vectorp x))
+       (let* ((slayout #.(info :type :compiler-layout 'sequence))
+             (depthoid #.(layout-depthoid (info :type :compiler-layout 'sequence)))
+             (layout (layout-of x)))
+        (when (layout-invalid layout)
+          (setq layout (update-object-layout-or-invalid x slayout)))
+        (if (eq layout slayout)
+            t
+            (let ((inherits (layout-inherits layout)))
+              (declare (optimize (safety 0)))
+              (and (> (length inherits) depthoid)
+                   (eq (svref inherits depthoid) slayout)))))))
+
+;;; Is X a SEQUENCE?  Harder than just (OR VECTOR LIST)
+(defun sequencep (x)
+  (or (listp x)
+      (vectorp x)
+      (let* ((slayout #.(info :type :compiler-layout 'sequence))
+             (depthoid #.(layout-depthoid (info :type :compiler-layout 'sequence)))
+             (layout (layout-of x)))
+        (when (layout-invalid layout)
+          (setq layout (update-object-layout-or-invalid x slayout)))
+        (if (eq layout slayout)
+            t
+            (let ((inherits (layout-inherits layout)))
+              (declare (optimize (safety 0)))
+              (and (> (length inherits) depthoid)
+                   (eq (svref inherits depthoid) slayout)))))))
 
 ;;;; primitive predicates. These must be supported directly by the
 ;;;; compiler.
@@ -73,6 +106,8 @@
   (def-type-predicate-wrapper integerp)
   (def-type-predicate-wrapper listp)
   (def-type-predicate-wrapper long-float-p)
+  #!+(and sb-thread sb-lutex)
+  (def-type-predicate-wrapper lutexp)
   (def-type-predicate-wrapper lra-p)
   (def-type-predicate-wrapper null)
   (def-type-predicate-wrapper numberp)
@@ -93,8 +128,14 @@
   (def-type-predicate-wrapper system-area-pointer-p)
   (def-type-predicate-wrapper weak-pointer-p)
   (def-type-predicate-wrapper vectorp)
+  #!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
   (def-type-predicate-wrapper unsigned-byte-32-p)
+  #!+#.(cl:if (cl:= 32 sb!vm:n-word-bits) '(and) '(or))
   (def-type-predicate-wrapper signed-byte-32-p)
+  #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
+  (def-type-predicate-wrapper unsigned-byte-64-p)
+  #!+#.(cl:if (cl:= 64 sb!vm:n-word-bits) '(and) '(or))
+  (def-type-predicate-wrapper signed-byte-64-p)
   (def-type-predicate-wrapper simple-array-nil-p)
   (def-type-predicate-wrapper simple-array-unsigned-byte-2-p)
   (def-type-predicate-wrapper simple-array-unsigned-byte-4-p)
@@ -135,7 +176,8 @@
     (extended-char 'extended-char)
     ((member t) 'boolean)
     (keyword 'keyword)
-    ((or array complex) (type-specifier (ctype-of object)))
+    ((or array complex)
+     (type-specifier (ctype-of object)))
     (t
      (let* ((classoid (layout-classoid (layout-of object)))
             (name (classoid-name classoid)))
@@ -212,10 +254,9 @@
 
 (defun equal (x y)
   #!+sb-doc
-  "Return T if X and Y are EQL or if they are structured components
-  whose elements are EQUAL. Strings and bit-vectors are EQUAL if they
-  are the same length and have identical components. Other arrays must be
-  EQ to be EQUAL."
+  "Return T if X and Y are EQL or if they are structured components whose
+elements are EQUAL. Strings and bit-vectors are EQUAL if they are the same
+length and have identical components. Other arrays must be EQ to be EQUAL."
   ;; Non-tail self-recursion implemented with a local auxiliary function
   ;; is a lot faster than doing it the straightforward way (at least
   ;; on x86oids) due to calling convention differences. -- JES, 2005-12-30
@@ -277,18 +318,21 @@
               (hash-table-equalp x y)))
         ((%instancep x)
          (let* ((layout-x (%instance-layout x))
-                (len (layout-length layout-x)))
+                (raw-len (layout-n-untagged-slots layout-x))
+                (total-len (layout-length layout-x))
+                (normal-len (- total-len raw-len)))
            (and (%instancep y)
                 (eq layout-x (%instance-layout y))
                 (structure-classoid-p (layout-classoid layout-x))
-                (do ((i 1 (1+ i)))
-                    ((= i len) t)
-                  (declare (fixnum i))
+                (dotimes (i normal-len t)
                   (let ((x-el (%instance-ref x i))
                         (y-el (%instance-ref y i)))
                     (unless (or (eq x-el y-el)
                                 (equalp x-el y-el))
-                      (return nil)))))))
+                      (return nil))))
+                (if (zerop raw-len)
+                    t
+                    (raw-instance-slots-equalp layout-x x y)))))
         ((vectorp x)
          (let ((length (length x)))
            (and (vectorp y)
@@ -318,8 +362,9 @@
 #!+sb-test
 (let ((test-cases `((0.0 ,(load-time-value (make-unportable-float :single-float-negative-zero)) t)
                     (0.0 1.0 nil)
-                    (#c(1 0) #c(1.0 0) t)
-                    (#c(1.1 0) #c(11/10 0) nil) ; due to roundoff error
+                    (#c(1 0) #c(1.0 0.0) t)
+                    (#c(0 1) #c(0.0 1.0) t)
+                    (#c(1.1 0.0) #c(11/10 0) nil) ; due to roundoff error
                     ("Hello" "hello" t)
                     ("Hello" #(#\h #\E #\l #\l #\o) t)
                     ("Hello" "goodbye" nil))))