X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcode%2Ffinal.lisp;h=597d5d08ec296ab166dc9efec6699732ab1cf5b7;hb=c6b078527eb68acc281dc79c91824c937f9447fe;hp=945cd5ec0ddae0560970af82fd7c300cfbd8f3a6;hpb=7861e493d9ba821f82471b81bed0223d8033a001;p=sbcl.git

diff --git a/src/code/final.lisp b/src/code/final.lisp
index 945cd5e..597d5d0 100644
--- a/src/code/final.lisp
+++ b/src/code/final.lisp
@@ -13,11 +13,11 @@
 
 (defvar *finalizer-store* nil)
 
-(defvar *finalizer-store-lock* 
+(defvar *finalizer-store-lock*
   (sb!thread:make-mutex :name "Finalizer store lock."))
 
 (defun finalize (object function)
-  #!+sb-doc 
+  #!+sb-doc
   "Arrange for the designated FUNCTION to be called when there
 are no more references to OBJECT, including references in
 FUNCTION itself.
@@ -32,10 +32,9 @@ signalled in whichever thread the FUNCTION was called in.
 
 Examples:
 
-  ;;; good
+  ;;; good (assumes RELEASE-HANDLE is re-entrant)
   (let* ((handle (get-handle))
          (object (make-object handle)))
-   ;; assumes RELEASE-HANDLE is re-entrant
    (finalize object (lambda () (release-handle handle)))
    object)
 
@@ -49,19 +48,19 @@ Examples:
   (defvar *rec* nil)
 
   (defun oops ()
-   (when *rec* 
+   (when *rec*
      (error \"recursive OOPS\"))
    (let ((*rec* t))
      (gc))) ; or just cons enough to cause one
 
-  (progn 
+  (progn
     (finalize \"oops\" #'oops)
     (oops)) ; causes GC and re-entry to #'oops due to the finalizer
             ; -> ERROR, caught, WARNING signalled"
   (sb!sys:without-gcing
       (sb!thread:with-mutex (*finalizer-store-lock*)
-	(push (cons (make-weak-pointer object) function)
-	      *finalizer-store*)))
+        (push (cons (make-weak-pointer object) function)
+              *finalizer-store*)))
   object)
 
 (defun cancel-finalization (object)
@@ -71,28 +70,28 @@ Examples:
   ;; run.
   (when object
     (sb!sys:without-gcing
-	(sb!thread:with-mutex (*finalizer-store-lock*)
-	  (setf *finalizer-store*
-		(delete object *finalizer-store*
-			:key (lambda (pair) 
-			       (weak-pointer-value (car pair)))))))
+        (sb!thread:with-mutex (*finalizer-store-lock*)
+          (setf *finalizer-store*
+                (delete object *finalizer-store*
+                        :key (lambda (pair)
+                               (weak-pointer-value (car pair)))))))
     object))
 
 (defun run-pending-finalizers ()
   (let (pending)
     (sb!sys:without-gcing
-	(sb!thread:with-mutex (*finalizer-store-lock*)
-	  (setf *finalizer-store*
-		(delete-if  (lambda (pair)
-			      (when (null (weak-pointer-value (car pair)))
-				(push (cdr pair) pending)
-				t))
-			    *finalizer-store*))))
+        (sb!thread:with-mutex (*finalizer-store-lock*)
+          (setf *finalizer-store*
+                (delete-if  (lambda (pair)
+                              (when (null (weak-pointer-value (car pair)))
+                                (push (cdr pair) pending)
+                                t))
+                            *finalizer-store*))))
     ;; We want to run the finalizer bodies outside the lock in case
     ;; finalization of X causes finalization to be added for Y.
     (dolist (fun pending)
       (handler-case
-	  (funcall fun)
-	(error (c)
-	  (warn "Error calling finalizer ~S:~%  ~S" fun c)))))
+          (funcall fun)
+        (error (c)
+          (warn "Error calling finalizer ~S:~%  ~S" fun c)))))
   nil)