;;; interface
(defun specializer-from-type (type &aux args)
+ (when (symbolp type)
+ (return-from specializer-from-type (find-class type)))
(when (consp type)
(setq args (cdr type) type (car type)))
(cond ((symbolp type)
- (or (and (null args) (find-class type))
- (ecase type
+ (or (ecase type
(class (coerce-to-class (car args)))
(prototype (make-instance 'class-prototype-specializer
:object (coerce-to-class (car args))))
definition-source-mixin
metaobject
funcallable-standard-object)
- ((%documentation :initform nil :initarg :documentation)
+ ((%documentation
+ :initform nil
+ :initarg :documentation)
;; We need to make a distinction between the methods initially set
;; up by :METHOD options to DEFGENERIC and the ones set up later by
;; DEFMETHOD, because ANSI specifies that executing DEFGENERIC on
;; DEFMETHOD, then modifying and reloading a.lisp and/or b.lisp
;; tends to leave the generic function in a state consistent with
;; the most-recently-loaded state of a.lisp and b.lisp.)
- (initial-methods :initform ()
- :accessor generic-function-initial-methods))
+ (initial-methods
+ :initform ()
+ :accessor generic-function-initial-methods))
(:metaclass funcallable-standard-class))
(defclass standard-generic-function (generic-function)
:reader gf-arg-info)
(dfun-state
:initform ()
- :accessor gf-dfun-state))
+ :accessor gf-dfun-state)
+ ;; Used to make DFUN-STATE & FIN-FUNCTION updates atomic.
+ (%lock
+ :initform (sb-thread::make-spinlock :name "GF lock")
+ :reader gf-lock))
(:metaclass funcallable-standard-class)
(:default-initargs :method-class *the-class-standard-method*
:method-combination *standard-method-combination*))
(defclass method (metaobject) ())
(defclass standard-method (plist-mixin definition-source-mixin method)
- ((%generic-function
- :initform nil
- :accessor method-generic-function)
- (qualifiers
- :initform ()
- :initarg :qualifiers
- :reader method-qualifiers)
- (specializers
- :initform ()
- :initarg :specializers
- :reader method-specializers)
- (lambda-list
- :initform ()
- :initarg :lambda-list
- :reader method-lambda-list)
+ ((%generic-function :initform nil :accessor method-generic-function)
+ (qualifiers :initform () :initarg :qualifiers :reader method-qualifiers)
+ (specializers :initform () :initarg :specializers
+ :reader method-specializers)
+ (lambda-list :initform () :initarg :lambda-list :reader method-lambda-list)
(%function :initform nil :initarg :function :reader method-function)
(%documentation :initform nil :initarg :documentation)))
(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