X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fpcl%2Flow.lisp;h=a8e412224c4d6bfc2c9b70dded0dfa202203cf1b;hb=9c3a9502bc872f024c365412d991ef43fd866e4c;hp=277416f0fc260cb1110accd730ff0d8370eea04b;hpb=95d19447c10434753c2168ac943152fd5e3ded3d;p=sbcl.git diff --git a/src/pcl/low.lisp b/src/pcl/low.lisp index 277416f..a8e4122 100644 --- a/src/pcl/low.lisp +++ b/src/pcl/low.lisp @@ -39,7 +39,7 @@ (eval-when (:compile-toplevel :load-toplevel :execute) (defvar *optimize-speed* - '(optimize (speed 3) (safety 0))) + '(optimize (speed 3) (safety 0) (sb-ext:inhibit-warnings 3))) ) ; EVAL-WHEN (defmacro dotimes-fixnum ((var count &optional (result nil)) &body body) @@ -51,22 +51,20 @@ (defun random-fixnum () (random (1+ most-positive-fixnum))) -(defconstant n-fixnum-bits #.(integer-length most-positive-fixnum)) - ;;; Lambda which executes its body (or not) randomly. Used to drop ;;; random cache entries. (defmacro randomly-punting-lambda (lambda-list &body body) (with-unique-names (drops drop-pos) `(let ((,drops (random-fixnum)) - (,drop-pos n-fixnum-bits)) + (,drop-pos sb-vm:n-fixnum-bits)) (declare (fixnum ,drops) - (type (integer 0 #.n-fixnum-bits) ,drop-pos)) + (type (integer 0 #.sb-vm:n-fixnum-bits) ,drop-pos)) (lambda ,lambda-list (when (logbitp (the unsigned-byte (decf ,drop-pos)) ,drops) (locally ,@body)) (when (zerop ,drop-pos) (setf ,drops (random-fixnum) - ,drop-pos n-fixnum-bits)))))) + ,drop-pos sb-vm:n-fixnum-bits)))))) ;;;; early definition of WRAPPER ;;;; @@ -92,8 +90,7 @@ (for-std-class-p t)) (:constructor make-wrapper-internal) (:copier nil)) - (instance-slots-layout nil :type list) - (class-slots nil :type list)) + (slots () :type list)) #-sb-fluid (declaim (sb-ext:freeze-type wrapper)) ;;;; PCL's view of funcallable instances @@ -120,8 +117,14 @@ (import 'sb-kernel:funcallable-instance-p) (defun set-funcallable-instance-function (fin new-value) - (declare (type function new-value)) - (aver (funcallable-instance-p fin)) + (declare (type function new-value) + ;; KLUDGE: it might be nice to restrict + ;; SB-MOP:SET-FUNCALLABLE-INSTANCE-FUNCTION to operate only + ;; on generalized instances of + ;; SB-MOP:FUNCALLABLE-STANDARD-OBJECT; at present, even + ;; PCL's internal use of SET-FUNCALLABLE-INSTANCE-FUNCTION + ;; doesn't obey this restriction. + (type funcallable-instance fin)) (setf (funcallable-instance-fun fin) new-value)) ;;; FIXME: these macros should just go away. It's not clear whether @@ -173,17 +176,20 @@ ;;; this an interned symbol. That means that the fast check to see ;;; whether a slot is unbound is to say (EQ '..SLOT-UNBOUND..). ;;; That is considerably faster than looking at the value of a special -;;; variable. Be careful, there are places in the code which actually -;;; use ..SLOT-UNBOUND.. rather than this variable. So much for -;;; modularity.. +;;; variable. ;;; -;;; FIXME: Now that we're tightly integrated into SBCL, we could use -;;; the SBCL built-in unbound value token instead. Perhaps if we did -;;; so it would be a good idea to define collections of CLOS slots as -;;; a new type of heap object, instead of using bare SIMPLE-VECTOR, in -;;; order to avoid problems (in the debugger if nowhere else) with -;;; SIMPLE-VECTORs some of whose elements are unbound tokens. -(defconstant +slot-unbound+ '..slot-unbound..) +;;; It seems only reasonable to also export this for users, since +;;; otherwise dealing with STANDARD-INSTANCE-ACCESS becomes harder +;;; -- and slower -- than it needs to be. +(defconstant +slot-unbound+ '..slot-unbound.. + "SBCL specific extentions to MOP: if this value is read from an +instance using STANDARD-INSTANCE-ACCESS, the slot is unbound. +Similarly, an :INSTANCE allocated slot can be made unbound by +assigning this to it using (SETF STANDARD-INSTANCE-ACCESS). + +Value of +SLOT-UNBOUND+ is unspecified, and should not be relied to be +of any particular type, but it is guaranteed to be suitable for EQ +comparison.") (defmacro %allocate-static-slot-storage--class (no-of-slots) `(make-array ,no-of-slots :initial-element +slot-unbound+)) @@ -202,7 +208,6 @@ (defun set-fun-name (fun new-name) #+sb-doc "Set the name of a compiled function object. Return the function." - (declare (special *boot-state* *the-class-standard-generic-function*)) (when (valid-function-name-p fun) (setq fun (fdefinition fun))) (typecase fun @@ -211,7 +216,7 @@ (sb-eval:interpreted-function (setf (sb-eval:interpreted-function-name fun) new-name)) (funcallable-instance ;; KLUDGE: probably a generic function... - (cond ((if (eq *boot-state* 'complete) + (cond ((if (eq **boot-state** 'complete) (typep fun 'generic-function) (eq (class-of fun) *the-class-standard-generic-function*)) (setf (%funcallable-instance-info fun 2) new-name)) @@ -349,6 +354,12 @@ (member (dsd-name included-slot) slot-overrides :test #'eq)) collect slot))))) +(defun uninitialized-accessor-function (type slotd) + (lambda (&rest args) + (declare (ignore args)) + (error "~:(~A~) function~@[ for ~S ~] not yet initialized." + type slotd))) + (defun structure-slotd-name (slotd) (dsd-name slotd)) @@ -356,13 +367,19 @@ (dsd-accessor-name slotd)) (defun structure-slotd-reader-function (slotd) - (fdefinition (dsd-accessor-name slotd))) + (let ((name (dsd-accessor-name slotd))) + (if (fboundp name) + (fdefinition name) + (uninitialized-accessor-function :reader slotd)))) (defun structure-slotd-writer-function (type slotd) (if (dsd-read-only slotd) (let ((dd (find-defstruct-description type))) (coerce (slot-setter-lambda-form dd slotd) 'function)) - (fdefinition `(setf ,(dsd-accessor-name slotd))))) + (let ((name `(setf ,(dsd-accessor-name slotd)))) + (if (fboundp name) + (fdefinition name) + (uninitialized-accessor-function :writer slotd))))) (defun structure-slotd-type (slotd) (dsd-type slotd))