X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fpcl%2Fstd-class.lisp;h=a65384294c8edea2fc9e2b58151b0ec1d0f69c46;hb=df679ed627975948b1cee190f4d79c397588c43e;hp=a34f739671ddf5ef29a3a3fb7ccf800a8c63c454;hpb=3ecee4526a55b3b4e6d7f86d69dc411f074968ec;p=sbcl.git diff --git a/src/pcl/std-class.lisp b/src/pcl/std-class.lisp index a34f739..a653842 100644 --- a/src/pcl/std-class.lisp +++ b/src/pcl/std-class.lisp @@ -86,6 +86,20 @@ (compute-slot-accessor-info slotd type gf))) (initialize-internal-slot-gfs name))) +;;; CMUCL (Gerd PCL 2003-04-25) comment: +;;; +;;; Compute an effective method for SLOT-VALUE-USING-CLASS, (SETF +;;; SLOT-VALUE-USING-CLASS) or SLOT-BOUNDP-USING-CLASS for reading/ +;;; writing/testing effective slot SLOTD. +;;; +;;; TYPE is one of the symbols READER, WRITER or BOUNDP, depending on +;;; GF. Store the effective method in the effective slot definition +;;; object itself; these GFs have special dispatch functions calling +;;; effective methods directly retrieved from effective slot +;;; definition objects, as an optimization. +;;; +;;; FIXME: Change the function name to COMPUTE-SVUC-SLOTD-FUNCTION, +;;; or some such. (defmethod compute-slot-accessor-info ((slotd effective-slot-definition) type gf) (let* ((name (slot-value slotd 'name)) @@ -151,10 +165,6 @@ ;;;; various class accessors that are a little more complicated than can be ;;;; done with automatically generated reader methods -(defmethod class-finalized-p ((class pcl-class)) - (with-slots (wrapper) class - (not (null wrapper)))) - (defmethod class-prototype ((class std-class)) (with-slots (prototype) class (or prototype (setq prototype (allocate-instance class))))) @@ -322,30 +332,30 @@ :definition-source `((defclass ,name) ,*load-pathname*) other))) - ;; Defclass of a class with a forward-referenced superclass does not - ;; have a wrapper. RES is the incomplete PCL class. The Lisp class - ;; does not yet exist. Maybe should return NIL in that case as RES - ;; is not useful to the user? - (and (class-wrapper res) (sb-kernel:layout-class (class-wrapper res))))) + res)) (setf (gdefinition 'load-defclass) #'real-load-defclass) (defun ensure-class (name &rest all) - (apply #'ensure-class-using-class name (find-class name nil) all)) + (apply #'ensure-class-using-class (find-class name nil) name all)) -(defmethod ensure-class-using-class (name (class null) &rest args &key) +(defmethod ensure-class-using-class ((class null) name &rest args &key) (multiple-value-bind (meta initargs) (ensure-class-values class args) + (set-class-type-translation (class-prototype meta) name) (setf class (apply #'make-instance meta :name name initargs) (find-class name) class) + (set-class-type-translation class name) class)) -(defmethod ensure-class-using-class (name (class pcl-class) &rest args &key) +(defmethod ensure-class-using-class ((class pcl-class) name &rest args &key) (multiple-value-bind (meta initargs) (ensure-class-values class args) - (unless (eq (class-of class) meta) (change-class class meta)) + (unless (eq (class-of class) meta) + (apply #'change-class class meta initargs)) (apply #'reinitialize-instance class initargs) (setf (find-class name) class) + (set-class-type-translation class name) class)) (defmethod class-predicate-name ((class t)) @@ -354,12 +364,11 @@ (defun fix-super (s) (cond ((classp s) s) ((not (legal-class-name-p s)) - (error "~S is not a class or a legal class name." s)) + (error "~S is not a class or a legal class name." s)) (t - (or (find-class s nil) - (setf (find-class s) - (make-instance 'forward-referenced-class - :name s)))))) + (or (find-class s nil) + (make-instance 'forward-referenced-class + :name s))))) (defun ensure-class-values (class args) (let* ((initargs (copy-list args)) @@ -382,45 +391,77 @@ ;; However, after playing around a little, I couldn't find that ;; way, so I've left it as is, but if someone does come up with a ;; better way... -- CSR, 2002-09-08 - (loop for (slot . more) on (getf initargs :direct-slots) - for slot-name = (getf slot :name) - if (some (lambda (s) (eq slot-name (getf s :name))) more) - ;; FIXME: It's quite possible that we ought to define an - ;; SB-INT:PROGRAM-ERROR function to signal these and other - ;; errors throughout the code base that are required to be - ;; of type PROGRAM-ERROR. - do (error 'simple-program-error - :format-control "More than one direct slot with name ~S." - :format-arguments (list slot-name)) - else - do (loop for (option value . more) on slot by #'cddr - when (and (member option - '(:allocation :type + (do ((direct-slots (getf initargs :direct-slots) (cdr direct-slots))) + ((endp direct-slots) nil) + (destructuring-bind (slot &rest more) direct-slots + (let ((slot-name (getf slot :name))) + (when (some (lambda (s) (eq slot-name (getf s :name))) more) + ;; FIXME: It's quite possible that we ought to define an + ;; SB-INT:PROGRAM-ERROR function to signal these and other + ;; errors throughout the codebase that are required to be + ;; of type PROGRAM-ERROR. + (error 'simple-program-error + :format-control "~@" + :format-arguments (list slot-name))) + (do ((stuff slot (cddr stuff))) + ((endp stuff) nil) + (destructuring-bind (option value &rest more) stuff + (cond + ((and (member option '(:allocation :type :initform :documentation)) - (not (eq unsupplied - (getf more option unsupplied)))) - do (error 'simple-program-error - :format-control "Duplicate slot option ~S for slot ~S." - :format-arguments (list option slot-name)))) + (not (eq unsupplied + (getf more option unsupplied)))) + (error 'simple-program-error + :format-control "~@" + :format-arguments (list option slot-name))) + ((and (eq option :readers) + (notevery #'symbolp value)) + (error 'simple-program-error + :format-control "~@" + :format-arguments (list slot-name))) + ((and (eq option :initargs) + (notevery #'symbolp value)) + (error 'simple-program-error + :format-control "~@" + :format-arguments (list slot-name))))))))) (loop for (initarg . more) on (getf initargs :direct-default-initargs) for name = (car initarg) when (some (lambda (a) (eq (car a) name)) more) do (error 'simple-program-error - :format-control "Duplicate initialization argument ~ - name ~S in :default-initargs of class ~A." + :format-control "~@" :format-arguments (list name class))) - (loop (unless (remf initargs :metaclass) (return))) + (let ((metaclass 0) + (default-initargs 0)) + (do ((args initargs (cddr args))) + ((endp args) nil) + (case (car args) + (:metaclass + (when (> (incf metaclass) 1) + (error 'simple-program-error + :format-control "~@"))) + (:direct-default-initargs + (when (> (incf default-initargs) 1) + (error 'simple-program-error + :format-control "~@")))))) + (remf initargs :metaclass) (loop (unless (remf initargs :direct-superclasses) (return))) (loop (unless (remf initargs :direct-slots) (return))) - (values meta - (list* :direct-superclasses - (and (neq supplied-supers unsupplied) - (mapcar #'fix-super supplied-supers)) - :direct-slots - (and (neq supplied-slots unsupplied) supplied-slots) - initargs)))) + (values + meta + (nconc + (when (neq supplied-supers unsupplied) + (list :direct-superclasses (mapcar #'fix-super supplied-supers))) + (when (neq supplied-slots unsupplied) + (list :direct-slots supplied-slots)) + initargs)))) - (defmethod shared-initialize :after ((class std-class) slot-names @@ -458,6 +499,9 @@ (setq direct-default-initargs (plist-value class 'direct-default-initargs))) (setf (plist-value class 'class-slot-cells) + ;; The below initializes shared slots from direct initforms, + ;; but one might inherit initforms from superclasses + ;; (cf. UPDATE-SHARED-SLOT-VALUES). (let (collect) (dolist (dslotd direct-slots) (when (eq :class (slot-definition-allocation dslotd)) @@ -476,9 +520,71 @@ (make-class-predicate-name (class-name class)))))) (add-direct-subclasses class direct-superclasses) - (update-class class nil) (make-class-predicate class predicate-name) - (add-slot-accessors class direct-slots)) + (update-class class nil) + (do* ((slots (slot-value class 'slots) (cdr slots)) + (dupes nil)) + ((null slots) (when dupes + (style-warn + ;; FIXME: the indentation request ("~4I") + ;; below appears not to do anything. Finding + ;; out why would be nice. -- CSR, 2003-04-24 + "~@~@:>" + class + dupes))) + (let* ((slot (car slots)) + (oslots (remove (slot-definition-name slot) (cdr slots) + :test-not #'string= :key #'slot-definition-name))) + (when oslots + (pushnew (cons (slot-definition-name slot) + (mapcar #'slot-definition-name oslots)) + dupes + :test #'string= :key #'car)))) + (add-slot-accessors class direct-slots) + (make-preliminary-layout class)) + +(defmethod shared-initialize :after ((class forward-referenced-class) + slot-names &key &allow-other-keys) + (declare (ignore slot-names)) + (make-preliminary-layout class)) + +(defvar *allow-forward-referenced-classes-in-cpl-p* nil) + +;;; Give CLASS a preliminary layout if it doesn't have one already, to +;;; make it known to the type system. +(defun make-preliminary-layout (class) + (flet ((compute-preliminary-cpl (root) + (let ((*allow-forward-referenced-classes-in-cpl-p* t)) + (compute-class-precedence-list root)))) + (unless (class-finalized-p class) + (let ((name (class-name class))) + (setf (find-class name) class) + ;; KLUDGE: This is fairly horrible. We need to make a + ;; full-fledged CLASSOID here, not just tell the compiler that + ;; some class is forthcoming, because there are legitimate + ;; questions one can ask of the type system, implemented in + ;; terms of CLASSOIDs, involving forward-referenced classes. So. + (when (and (eq *boot-state* 'complete) + (null (find-classoid name nil))) + (setf (find-classoid name) + (make-standard-classoid :name name))) + (set-class-type-translation class name) + (let ((layout (make-wrapper 0 class)) + (classoid (find-classoid name))) + (setf (layout-classoid layout) classoid) + (setf (classoid-pcl-class classoid) class) + (setf (slot-value class 'wrapper) layout) + (let ((cpl (compute-preliminary-cpl class))) + (setf (layout-inherits layout) + (order-layout-inherits + (map 'simple-vector #'class-wrapper + (reverse (rest cpl)))))) + (register-layout layout :invalidate t) + (setf (classoid-layout classoid) layout) + (mapc #'make-preliminary-layout (class-direct-subclasses class))))))) + (defmethod shared-initialize :before ((class class) slot-names &key name) (declare (ignore slot-names name)) @@ -499,6 +605,23 @@ (lambda (dependent) (apply #'update-dependent class dependent initargs)))) +(defmethod shared-initialize :after ((class condition-class) slot-names + &key direct-superclasses) + (declare (ignore slot-names)) + (let ((classoid (find-classoid (class-name class)))) + (with-slots (wrapper class-precedence-list prototype predicate-name + (direct-supers direct-superclasses)) + class + (setf (slot-value class 'finalized-p) t) + (setf (classoid-pcl-class classoid) class) + (setq direct-supers direct-superclasses) + (setq wrapper (classoid-layout classoid)) + (setq class-precedence-list (compute-class-precedence-list class)) + (setq prototype (make-condition (class-name class))) + (add-direct-subclasses class direct-superclasses) + (setq predicate-name (make-class-predicate-name (class-name class))) + (make-class-predicate class predicate-name)))) + (defmethod shared-initialize :after ((slotd structure-slot-definition) slot-names &key (allocation :instance) allocation-class) @@ -521,18 +644,14 @@ +slot-unbound+)) direct-slots))) (reader-names (mapcar (lambda (slotd) - (intern (format nil - "~A~A reader" - conc-name - (slot-definition-name - slotd)))) + (list 'slot-accessor name + (slot-definition-name slotd) + 'reader)) direct-slots)) (writer-names (mapcar (lambda (slotd) - (intern (format nil - "~A~A writer" - conc-name - (slot-definition-name - slotd)))) + (list 'slot-accessor name + (slot-definition-name slotd) + 'writer)) direct-slots)) (readers-init (mapcar (lambda (slotd reader-name) @@ -613,9 +732,10 @@ (setf (slot-value class 'class-precedence-list) (compute-class-precedence-list class)) (setf (slot-value class 'slots) (compute-slots class)) - (let ((lclass (cl:find-class (class-name class)))) - (setf (sb-kernel:class-pcl-class lclass) class) - (setf (slot-value class 'wrapper) (sb-kernel:class-layout lclass))) + (let ((lclass (find-classoid (class-name class)))) + (setf (classoid-pcl-class lclass) class) + (setf (slot-value class 'wrapper) (classoid-layout lclass))) + (setf (slot-value class 'finalized-p) t) (update-pv-table-cache-info class) (setq predicate-name (if predicate-name-p (setf (slot-value class 'predicate-name) @@ -626,8 +746,8 @@ (class-name class)))))) (make-class-predicate class predicate-name) (add-slot-accessors class direct-slots))) - -(defmethod direct-slot-definition-class ((class structure-class) initargs) + +(defmethod direct-slot-definition-class ((class structure-class) &rest initargs) (declare (ignore initargs)) (find-class 'structure-direct-slot-definition)) @@ -699,6 +819,7 @@ (return-from update-class)) (when (or finalizep (class-finalized-p class) (not (class-has-a-forward-referenced-superclass-p class))) + (setf (find-class (class-name class)) class) (update-cpl class (compute-class-precedence-list class)) ;; This invocation of UPDATE-SLOTS, in practice, finalizes the ;; class. The hoops above are to ensure that FINALIZE-INHERITANCE @@ -708,13 +829,27 @@ (update-slots class (compute-slots class)) (update-gfs-of-class class) (update-inits class (compute-default-initargs class)) - (update-make-instance-function-table class)) + (update-shared-slot-values class) + (update-ctors 'finalize-inheritance :class class)) (unless finalizep (dolist (sub (class-direct-subclasses class)) (update-class sub nil)))) +(defun update-shared-slot-values (class) + (dolist (slot (class-slots class)) + (when (eq (slot-definition-allocation slot) :class) + (let ((cell (assq (slot-definition-name slot) (class-slot-cells class)))) + (when cell + (let ((initfn (slot-definition-initfunction slot))) + (when initfn + (setf (cdr cell) (funcall initfn))))))))) + (defun update-cpl (class cpl) (if (class-finalized-p class) - (unless (equal (class-precedence-list class) cpl) + (unless (and (equal (class-precedence-list class) cpl) + (dolist (c cpl t) + (when (position :class (class-direct-slots c) + :key #'slot-definition-allocation) + (return nil)))) ;; comment from the old CMU CL sources: ;; Need to have the cpl setup before update-lisp-class-layout ;; is called on CMU CL. @@ -749,8 +884,10 @@ :key #'slot-definition-location))) (nslots (length nlayout)) (nwrapper-class-slots (compute-class-slots class-slots)) - (owrapper (class-wrapper class)) - (olayout (and owrapper (wrapper-instance-slots-layout owrapper))) + (owrapper (when (class-finalized-p class) + (class-wrapper class))) + (olayout (when owrapper + (wrapper-instance-slots-layout owrapper))) (owrapper-class-slots (and owrapper (wrapper-class-slots owrapper))) (nwrapper (cond ((null owrapper) @@ -777,7 +914,7 @@ (wrapper-class-slots nwrapper) nwrapper-class-slots (wrapper-no-of-instance-slots nwrapper) nslots wrapper nwrapper)) - + (setf (slot-value class 'finalized-p) t) (unless (eq owrapper nwrapper) (update-pv-table-cache-info class))))) @@ -810,29 +947,20 @@ (setf (plist-value class 'default-initargs) inits)) (defmethod compute-default-initargs ((class slot-class)) - (let ((cpl (class-precedence-list class)) - (direct (class-direct-default-initargs class))) - (labels ((walk (tail) - (if (null tail) - nil - (let ((c (pop tail))) - (append (if (eq c class) - direct - (class-direct-default-initargs c)) - (walk tail)))))) - (let ((initargs (walk cpl))) - (delete-duplicates initargs :test #'eq :key #'car :from-end t))))) + (let ((initargs (loop for c in (class-precedence-list class) + append (class-direct-default-initargs c)))) + (delete-duplicates initargs :test #'eq :key #'car :from-end t))) ;;;; protocols for constructing direct and effective slot definitions -(defmethod direct-slot-definition-class ((class std-class) initargs) +(defmethod direct-slot-definition-class ((class std-class) &rest initargs) (declare (ignore initargs)) (find-class 'standard-direct-slot-definition)) (defun make-direct-slotd (class initargs) (let ((initargs (list* :class class initargs))) (apply #'make-instance - (direct-slot-definition-class class initargs) + (apply #'direct-slot-definition-class class initargs) initargs))) (defmethod compute-slots ((class std-class)) @@ -850,6 +978,7 @@ (push (list name slot) name-dslotds-alist))))) (mapcar (lambda (direct) (compute-effective-slot-definition class + (car direct) (nreverse (cdr direct)))) name-dslotds-alist))) @@ -923,8 +1052,10 @@ (defmethod compute-slots ((class structure-class)) (mapcan (lambda (superclass) (mapcar (lambda (dslotd) - (compute-effective-slot-definition class - (list dslotd))) + (compute-effective-slot-definition + class + (slot-definition-name dslotd) + (list dslotd))) (class-direct-slots superclass))) (reverse (slot-value class 'class-precedence-list)))) @@ -933,16 +1064,17 @@ (mapc #'initialize-internal-slot-functions eslotds) eslotds)) -(defmethod compute-effective-slot-definition ((class slot-class) dslotds) +(defmethod compute-effective-slot-definition ((class slot-class) name dslotds) + (declare (ignore name)) (let* ((initargs (compute-effective-slot-definition-initargs class dslotds)) - (class (effective-slot-definition-class class initargs))) + (class (apply #'effective-slot-definition-class class initargs))) (apply #'make-instance class initargs))) -(defmethod effective-slot-definition-class ((class std-class) initargs) +(defmethod effective-slot-definition-class ((class std-class) &rest initargs) (declare (ignore initargs)) (find-class 'standard-effective-slot-definition)) -(defmethod effective-slot-definition-class ((class structure-class) initargs) +(defmethod effective-slot-definition-class ((class structure-class) &rest initargs) (declare (ignore initargs)) (find-class 'structure-effective-slot-definition)) @@ -1101,7 +1233,7 @@ ;;; obsolete the wrapper. ;;; ;;; FIXME: either here or in INVALID-WRAPPER-P looks like a good place -;;; for (AVER (NOT (EQ (SB-KERNEL:LAYOUT-INVALID OWRAPPER) +;;; for (AVER (NOT (EQ (LAYOUT-INVALID OWRAPPER) ;;; :UNINITIALIZED))) ;;; ;;; Thanks to Gerd Moellmann for the explanation. -- CSR, 2002-10-29 @@ -1117,14 +1249,14 @@ ;; a violation of locality or what might be considered ;; good style. There has to be a better way! -- CSR, ;; 2002-10-29 - (eq (sb-kernel:layout-invalid owrapper) t)) + (eq (layout-invalid owrapper) t)) (let ((nwrapper (make-wrapper (wrapper-no-of-instance-slots owrapper) class))) (setf (wrapper-instance-slots-layout nwrapper) (wrapper-instance-slots-layout owrapper)) (setf (wrapper-class-slots nwrapper) (wrapper-class-slots owrapper)) - (sb-sys:without-interrupts + (with-pcl-lock (update-lisp-class-layout class nwrapper) (setf (slot-value class 'wrapper) nwrapper) (invalidate-wrapper owrapper :flush nwrapper)))))) @@ -1144,7 +1276,7 @@ (wrapper-instance-slots-layout owrapper)) (setf (wrapper-class-slots nwrapper) (wrapper-class-slots owrapper)) - (sb-sys:without-interrupts + (with-pcl-lock (update-lisp-class-layout class nwrapper) (setf (slot-value class 'wrapper) nwrapper) (invalidate-wrapper owrapper :obsolete nwrapper)