Fix typos in docstrings and function names.

[sbcl.git] / src / code / target-hash-table.lisp

diff --git a/src/code/target-hash-table.lisp b/src/code/target-hash-table.lisp
index 27b7322..ba5f7d8 100644 (file)
--- a/src/code/target-hash-table.lisp
+++ b/src/code/target-hash-table.lisp
@@ -174,7 +174,7 @@ Examples:
 
   ;; We want to use objects of type FOO as keys (by their
   ;; names.) EQUALP would work, but would make the names
-  ;; case-insensitive -- wich we don't want.
+  ;; case-insensitive -- which we don't want.
   (defstruct foo (name nil :type (or null string)))
 
   ;; Define an equivalence test function and a hash function.
@@ -628,19 +628,19 @@ multiple threads accessing the same hash-table without locking."
            (hash-table-needs-rehash-p hash-table)))
     (declare (inline rehash-p rehash-without-growing-p))
     (cond ((rehash-p)
-           ;; Use recursive spinlocks since for weak tables the
-           ;; spinlock has already been acquired. GC must be inhibited
-           ;; to prevent the GC from seeing a rehash in progress.
-           (sb!thread::with-recursive-system-spinlock
-               ((hash-table-spinlock hash-table) :without-gcing t)
+           ;; Use recursive locks since for weak tables the lock has
+           ;; already been acquired. GC must be inhibited to prevent
+           ;; the GC from seeing a rehash in progress.
+           (sb!thread::with-recursive-system-lock
+               ((hash-table-lock hash-table) :without-gcing t)
              ;; Repeat the condition inside the lock to ensure that if
              ;; two reader threads enter MAYBE-REHASH at the same time
              ;; only one rehash is performed.
              (when (rehash-p)
                (rehash hash-table))))
           ((rehash-without-growing-p)
-           (sb!thread::with-recursive-system-spinlock
-               ((hash-table-spinlock hash-table) :without-gcing t)
+           (sb!thread::with-recursive-system-lock
+               ((hash-table-lock hash-table) :without-gcing t)
              (when (rehash-without-growing-p)
                (rehash-without-growing hash-table)))))))
 
@@ -660,15 +660,16 @@ multiple threads accessing the same hash-table without locking."
                 (locally (declare (inline ,@inline))
                   ,@body))))
        (if (hash-table-weakness ,hash-table)
-           (sb!thread::with-recursive-system-spinlock
-               ((hash-table-spinlock ,hash-table) :without-gcing t)
+           (sb!thread::with-recursive-system-lock
+               ((hash-table-lock ,hash-table) :without-gcing t)
              (,body-fun))
            (with-pinned-objects ,pin
              (if ,synchronized
-                 ;; We use a "system" spinlock here because it is very
-                 ;; slightly faster, as it doesn't re-enable interrupts.
-                 (sb!thread::with-recursive-system-spinlock
-                     ((hash-table-spinlock ,hash-table))
+                 ;; We use a "system" lock here because it is very
+                 ;; slightly faster, as it doesn't re-enable
+                 ;; interrupts.
+                 (sb!thread::with-recursive-system-lock
+                     ((hash-table-lock ,hash-table))
                    (,body-fun))
                  (,body-fun)))))))