-#!-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)))
-
-(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)
- (%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))
+ (%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))
- (%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))
+
- (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)))
-
-;;; 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))
+ (setf (%funcallable-instance-function fin) new-value))
- (/show0 "ACCESSOR-NAME=..")
- (/hexstr accessor-name)
- (protect-cl accessor-name)
- (/hexstr "getting READER-FUN and WRITER-FUN")
- (multiple-value-bind (reader-fun writer-fun)
- (slot-accessor-funs dd dsd)
- (declare (type function reader-fun writer-fun))
- (/show0 "got READER-FUN and WRITER-FUN=..")
- (/hexstr reader-fun)
- (setf (symbol-function accessor-name) reader-fun)
- (unless (dsd-read-only dsd)
- (/show0 "setting FDEFINITION for WRITER-FUN=..")
- (/hexstr writer-fun)
- (setf (fdefinition `(setf ,accessor-name)) writer-fun))))))
+ (/show0 "ACCESSOR-NAME=..")
+ (/hexstr accessor-name)
+ (protect-cl accessor-name)
+ (/hexstr "getting READER-FUN and WRITER-FUN")
+ (multiple-value-bind (reader-fun writer-fun)
+ (slot-accessor-funs dd dsd)
+ (declare (type function reader-fun writer-fun))
+ (/show0 "got READER-FUN and WRITER-FUN=..")
+ (/hexstr reader-fun)
+ (setf (symbol-function accessor-name) reader-fun)
+ (unless (dsd-read-only dsd)
+ (/show0 "setting FDEFINITION for WRITER-FUN=..")
+ (/hexstr writer-fun)
+ (setf (fdefinition `(setf ,accessor-name)) writer-fun))))))
- (ecase (dd-type dd)
- ;; structures with LAYOUTs
- ((structure funcallable-structure)
- (/show0 "with-LAYOUT case")
- (lambda (object)
- (locally ; <- to keep SAFETY 0 from affecting arg count checking
- (declare (optimize (speed 3) (safety 0)))
- (/noshow0 "in with-LAYOUT structure predicate closure, OBJECT,LAYOUT=..")
- (/nohexstr object)
- (/nohexstr layout)
- (typep-to-layout object layout))))
- ;; structures with no LAYOUT (i.e. :TYPE VECTOR or :TYPE LIST)
- ;;
- ;; FIXME: should handle the :NAMED T case in these cases
- (vector
- (/show0 ":TYPE VECTOR case")
- #'vectorp)
- (list
- (/show0 ":TYPE LIST case")
- #'listp))))
+ (ecase (dd-type dd)
+ ;; structures with LAYOUTs
+ ((structure funcallable-structure)
+ (/show0 "with-LAYOUT case")
+ (lambda (object)
+ (locally ; <- to keep SAFETY 0 from affecting arg count checking
+ (declare (optimize (speed 3) (safety 0)))
+ (/noshow0 "in with-LAYOUT structure predicate closure, OBJECT,LAYOUT=..")
+ (/nohexstr object)
+ (/nohexstr layout)
+ (typep-to-layout object layout))))
+ ;; structures with no LAYOUT (i.e. :TYPE VECTOR or :TYPE LIST)
+ ;;
+ ;; FIXME: should handle the :NAMED T case in these cases
+ (vector
+ (/show0 ":TYPE VECTOR case")
+ #'vectorp)
+ (list
+ (/show0 ":TYPE LIST case")
+ #'listp))))
- ;; ordinary STRUCTURE-OBJECT case: Handle native
- ;; structures with LAYOUTs and (possibly) raw slots.
- (%native-slot-accessor-funs (dd-ref-fun-name)
- (let ((instance-type-check-form
- '(%check-structure-type-from-layout instance layout)))
- (/show "macroexpanding %NATIVE-SLOT-ACCESSOR-FUNS" dd-ref-fun-name instance-type-check-form)
- `(let ((layout (dd-layout-or-lose dd))
- (dsd-raw-type (dsd-raw-type dsd)))
- #+sb-xc (/show0 "in %NATIVE-SLOT-ACCESSOR-FUNS macroexpanded code")
- ;; Map over all the possible RAW-TYPEs, compiling
- ;; a different closure function for each one, so
- ;; that once the COND over RAW-TYPEs happens (at
- ;; the time closure is allocated) there are no
- ;; more decisions to be made and things execute
- ;; reasonably efficiently.
- (cond
- ;; nonraw slot case
- ((eql dsd-raw-type t)
- #+sb-xc (/show0 "in nonraw slot case")
- (%slotplace-accessor-funs
- (,dd-ref-fun-name instance dsd-index)
- ,instance-type-check-form))
- ;; raw slot cases
- ,@(mapcar (lambda (rtd)
- (let ((raw-type (raw-slot-data-raw-type rtd))
- (accessor-name
- (raw-slot-data-accessor-name rtd)))
- `((equal dsd-raw-type ',raw-type)
- #+sb-xc (/show0 "in raw slot case")
- (%slotplace-accessor-funs
- (,accessor-name instance dsd-index)
- ,instance-type-check-form))))
- *raw-slot-data-list*)
- ;; oops
- (t
- (bug "unexpected DSD-RAW-TYPE ~S" dsd-raw-type))))))
- ;; code shared between DEFSTRUCT :TYPE LIST and
- ;; DEFSTRUCT :TYPE VECTOR cases: Handle the "typed
- ;; structure" case, with no LAYOUTs and no raw slots.
- (%colontyped-slot-accessor-funs () (error "stub"))
- ;; the common structure of the raw-slot and not-raw-slot
- ;; cases, defined in terms of the writable SLOTPLACE. All
- ;; possible flavors of slot access should be able to pass
- ;; through here.
- (%slotplace-accessor-funs (slotplace instance-type-check-form)
- (/show "macroexpanding %SLOTPLACE-ACCESSOR-FUNS" slotplace instance-type-check-form)
- `(let ((typecheckfun (typespec-typecheckfun dsd-type)))
+ ;; ordinary STRUCTURE-OBJECT case: Handle native
+ ;; structures with LAYOUTs and (possibly) raw slots.
+ (%native-slot-accessor-funs (dd-ref-fun-name)
+ (let ((instance-type-check-form
+ '(%check-structure-type-from-layout instance layout)))
+ (/show "macroexpanding %NATIVE-SLOT-ACCESSOR-FUNS" dd-ref-fun-name instance-type-check-form)
+ `(let ((layout (dd-layout-or-lose dd))
+ (dsd-raw-type (dsd-raw-type dsd)))
+ #+sb-xc (/show0 "in %NATIVE-SLOT-ACCESSOR-FUNS macroexpanded code")
+ ;; Map over all the possible RAW-TYPEs, compiling
+ ;; a different closure function for each one, so
+ ;; that once the COND over RAW-TYPEs happens (at
+ ;; the time closure is allocated) there are no
+ ;; more decisions to be made and things execute
+ ;; reasonably efficiently.
+ (cond
+ ;; nonraw slot case
+ ((eql dsd-raw-type t)
+ #+sb-xc (/show0 "in nonraw slot case")
+ (%slotplace-accessor-funs
+ (,dd-ref-fun-name instance dsd-index)
+ ,instance-type-check-form))
+ ;; raw slot cases
+ ,@(mapcar (lambda (rtd)
+ (let ((raw-type (raw-slot-data-raw-type rtd))
+ (accessor-name
+ (raw-slot-data-accessor-name rtd)))
+ `((equal dsd-raw-type ',raw-type)
+ #+sb-xc (/show0 "in raw slot case")
+ (%slotplace-accessor-funs
+ (,accessor-name instance dsd-index)
+ ,instance-type-check-form))))
+ *raw-slot-data-list*)
+ ;; oops
+ (t
+ (bug "unexpected DSD-RAW-TYPE ~S" dsd-raw-type))))))
+ ;; code shared between DEFSTRUCT :TYPE LIST and
+ ;; DEFSTRUCT :TYPE VECTOR cases: Handle the "typed
+ ;; structure" case, with no LAYOUTs and no raw slots.
+ (%colontyped-slot-accessor-funs () (error "stub"))
+ ;; the common structure of the raw-slot and not-raw-slot
+ ;; cases, defined in terms of the writable SLOTPLACE. All
+ ;; possible flavors of slot access should be able to pass
+ ;; through here.
+ (%slotplace-accessor-funs (slotplace instance-type-check-form)
+ (/show "macroexpanding %SLOTPLACE-ACCESSOR-FUNS" slotplace instance-type-check-form)
+ `(let ((typecheckfun (typespec-typecheckfun dsd-type)))
+
+\f
+
+;; 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))))))
- (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))))))))
+ (name (classoid-name (layout-classoid layout)))
+ (dd (layout-info layout)))
+ (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))))))))))
+
- (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))))))
+ (name (classoid-name (layout-classoid layout)))
+ (dd (layout-info layout)))
+ (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))))))))
+
- (cond ((eq obj-layout layout)
- ;; (In this case OBJ-LAYOUT can't be invalid, because
- ;; we determined LAYOUT is valid in the test above.)
- (/noshow0 "EQ case")
- t)
- ((layout-invalid obj-layout)
- (/noshow0 "LAYOUT-INVALID case")
- (error 'layout-invalid
- :expected-type (layout-classoid obj-layout)
- :datum obj))
- (t
- (let ((depthoid (layout-depthoid layout)))
- (/noshow0 "DEPTHOID case, DEPTHOID,LAYOUT-INHERITS=..")
- (/nohexstr depthoid)
- (/nohexstr layout-inherits)
- (and (> (layout-depthoid obj-layout) depthoid)
- (eq (svref (layout-inherits obj-layout) depthoid)
- layout))))))))
+ (cond ((eq obj-layout layout)
+ ;; (In this case OBJ-LAYOUT can't be invalid, because
+ ;; we determined LAYOUT is valid in the test above.)
+ (/noshow0 "EQ case")
+ t)
+ ((layout-invalid obj-layout)
+ (/noshow0 "LAYOUT-INVALID case")
+ (error 'layout-invalid
+ :expected-type (layout-classoid obj-layout)
+ :datum obj))
+ (t
+ (let ((depthoid (layout-depthoid layout)))
+ (/noshow0 "DEPTHOID case, DEPTHOID,LAYOUT-INHERITS=..")
+ (/nohexstr depthoid)
+ (/nohexstr layout-inherits)
+ (and (> (layout-depthoid obj-layout) depthoid)
+ (eq (svref (layout-inherits obj-layout) depthoid)
+ layout))))))))