(and (complex-vector-p 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)))))))
\f
;;;; primitive predicates. These must be supported directly by the
;;;; compiler.
(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)
(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
(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)