X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fpcl%2Fdefs.lisp;h=c6908d6e3af68946fc2a080c55d6aaca174dea59;hb=d25e3478acccec70402ff32554669a982be8e281;hp=3bf72dbe3017273121ef9dcfda4a47711addf1fc;hpb=990728854b8ba017888811d1b0453b15dfa8a581;p=sbcl.git

diff --git a/src/pcl/defs.lisp b/src/pcl/defs.lisp
index 3bf72db..c6908d6 100644
--- a/src/pcl/defs.lisp
+++ b/src/pcl/defs.lisp
@@ -76,7 +76,7 @@
         ;; FIXME: do we still need this?
         ((and (null args) (typep type 'classoid))
          (or (classoid-pcl-class type)
-             (ensure-non-standard-class (classoid-name type))))
+             (ensure-non-standard-class (classoid-name type) type)))
         ((specializerp type) type)))
 
 ;;; interface
@@ -195,12 +195,6 @@
         (push (list class-name symbol) *built-in-wrapper-symbols*)
         symbol)))
 
-(pushnew '%class *var-declarations*)
-(pushnew '%variable-rebinding *var-declarations*)
-
-(defun variable-class (var env)
-  (caddr (var-declaration 'class var env)))
-
 (defvar *standard-method-combination*)
 
 (defun plist-value (object name)
@@ -233,10 +227,10 @@
                (let ((subs (classoid-subclasses class)))
                  (/noshow subs)
                  (when subs
-                   (dohash (sub v subs)
+                   (dohash ((sub v) subs)
                      (declare (ignore v))
                      (/noshow sub)
-                     (when (member class (direct-supers sub))
+                     (when (member class (direct-supers sub) :test #'eq)
                        (res sub)))))
                (res))))
     (mapcar (lambda (kernel-bic-entry)
@@ -366,7 +360,12 @@
    ;; Used to make DFUN-STATE & FIN-FUNCTION updates atomic.
    (%lock
     :initform (sb-thread::make-spinlock :name "GF lock")
-    :reader gf-lock))
+    :reader gf-lock)
+   ;; Set to true by ADD-METHOD, REMOVE-METHOD; to false by
+   ;; MAYBE-UPDATE-INFO-FOR-GF.
+   (info-needs-update
+    :initform nil
+    :accessor gf-info-needs-update))
   (:metaclass funcallable-standard-class)
   (:default-initargs :method-class *the-class-standard-method*
                      :method-combination *standard-method-combination*))
@@ -550,35 +549,47 @@
   ;; responses in comp.lang.lisp).  -- CSR, 2006-02-27
   ((%type :initform nil :reader specializer-type)))
 
+;;; STANDARD in this name doesn't mean "blessed by a standard" but
+;;; "comes as standard with PCL"; that is, it includes CLASS-EQ
+;;; and vestiges of PROTOTYPE specializers
+(defclass standard-specializer (specializer) ())
+
 (defclass specializer-with-object (specializer) ())
 
 (defclass exact-class-specializer (specializer) ())
 
-(defclass class-eq-specializer (exact-class-specializer
+(defclass class-eq-specializer (standard-specializer
+                                exact-class-specializer
                                 specializer-with-object)
   ((object :initarg :class
            :reader specializer-class
            :reader specializer-object)))
 
-(defclass class-prototype-specializer (specializer-with-object)
+(defclass class-prototype-specializer (standard-specializer specializer-with-object)
   ((object :initarg :class
            :reader specializer-class
            :reader specializer-object)))
 
-(defclass eql-specializer (exact-class-specializer specializer-with-object)
+(defclass eql-specializer (standard-specializer exact-class-specializer specializer-with-object)
   ((object :initarg :object :reader specializer-object
            :reader eql-specializer-object)))
 
 (defvar *eql-specializer-table* (make-hash-table :test 'eql))
 
+(defvar *eql-specializer-table-lock*
+  (sb-thread::make-spinlock :name "EQL-specializer table lock"))
+
 (defun intern-eql-specializer (object)
-  (or (gethash object *eql-specializer-table*)
-      (setf (gethash object *eql-specializer-table*)
-            (make-instance 'eql-specializer :object object))))
+  ;; Need to lock, so that two threads don't get non-EQ specializers
+  ;; for an EQL object.
+  (sb-thread::with-spinlock (*eql-specializer-table-lock*)
+    (or (gethash object *eql-specializer-table*)
+        (setf (gethash object *eql-specializer-table*)
+              (make-instance 'eql-specializer :object object)))))
 
 (defclass class (dependent-update-mixin
                  definition-source-mixin
-                 specializer)
+                 standard-specializer)
   ((name
     :initform nil
     :initarg :name
@@ -645,10 +656,10 @@
 (defclass slot-class (pcl-class)
   ((direct-slots
     :initform ()
-    :accessor class-direct-slots)
+    :reader class-direct-slots)
    (slots
     :initform ()
-    :accessor class-slots)))
+    :reader class-slots)))
 
 ;;; The class STD-CLASS is an implementation-specific common
 ;;; superclass of the classes STANDARD-CLASS and
@@ -657,10 +668,14 @@
   ())
 
 (defclass standard-class (std-class)
-  ())
+  ()
+  (:default-initargs
+   :direct-superclasses (list *the-class-standard-object*)))
 
 (defclass funcallable-standard-class (std-class)
-  ())
+  ()
+  (:default-initargs
+   :direct-superclasses (list *the-class-funcallable-standard-object*)))
 
 (defclass forward-referenced-class (pcl-class) ())
 
@@ -669,15 +684,9 @@
 (defclass condition-class (slot-class) ())
 
 (defclass structure-class (slot-class)
-  ((defstruct-form
-     :initform ()
-     :accessor class-defstruct-form)
-   (defstruct-constructor
-     :initform nil
-     :accessor class-defstruct-constructor)
-   (from-defclass-p
-    :initform nil
-    :initarg :from-defclass-p)))
+  ((defstruct-form :initform () :accessor class-defstruct-form)
+   (defstruct-constructor :initform nil :accessor class-defstruct-constructor)
+   (from-defclass-p :initform nil :initarg :from-defclass-p)))
 
 (defclass definition-source-mixin (standard-object)
   ((source
@@ -692,6 +701,7 @@
 
 (defparameter *early-class-predicates*
   '((specializer specializerp)
+    (standard-specializer standard-specializer-p)
     (exact-class-specializer exact-class-specializer-p)
     (class-eq-specializer class-eq-specializer-p)
     (eql-specializer eql-specializer-p)