0.7.5.11:

[sbcl.git] / src / code / signal.lisp

diff --git a/src/code/signal.lisp b/src/code/signal.lisp
index cc8d985..23cdd63 100644 (file)
--- a/src/code/signal.lisp
+++ b/src/code/signal.lisp
@@ -23,33 +23,27 @@
 ;;; sets *interrupt-pending* and returns without handling the signal.
 ;;;
 ;;; When we drop out the without interrupts, we check to see whether
-;;; *interrupt-pending* has been set. If so, we call
-;;; do-pending-interrupt, which generates a SIGTRAP. The C code
+;;; *INTERRUPT-PENDING* has been set. If so, we call
+;;; RECEIVE-PENDING-INTERRUPT, which generates a SIGTRAP. The C code
 ;;; invokes the handler for the saved signal instead of the SIGTRAP
 ;;; after replacing the signal mask in the signal context with the
 ;;; saved value. When that hander returns, the original signal mask is
 ;;; installed, allowing any other pending signals to be handled.
 ;;;
-;;; This means that the cost of without-interrupts is just a special
+;;; This means that the cost of WITHOUT-INTERRUPTS is just a special
 ;;; binding in the case when no signals are delivered (the normal
 ;;; case). It's only when a signal is actually delivered that we use
 ;;; any system calls, and by then the cost of the extra system calls
 ;;; are lost in the noise when compared with the cost of delivering
 ;;; the signal in the first place.
 
-;;; Magically converted by the compiler into a break instruction.
-(defun do-pending-interrupt ()
-  (do-pending-interrupt))
-
-#!-gengc (progn
-
 (defvar *interrupts-enabled* t)
 (defvar *interrupt-pending* nil)
 
 (sb!xc:defmacro without-interrupts (&body body)
   #!+sb-doc
   "Execute BODY in a context impervious to interrupts."
-  (let ((name (gensym)))
+  (let ((name (gensym "WITHOUT-INTERRUPTS-BODY-")))
     `(flet ((,name () ,@body))
        (if *interrupts-enabled*
           (unwind-protect
@@ -61,7 +55,7 @@
             ;; whether interrupts are pending before executing themselves
             ;; immediately?
             (when *interrupt-pending*
-              (do-pending-interrupt)))
+              (receive-pending-interrupt)))
           (,name)))))
 
 (sb!xc:defmacro with-interrupts (&body body)
@@ -74,32 +68,8 @@
           (,name)
           (let ((*interrupts-enabled* t))
             (when *interrupt-pending*
-              (do-pending-interrupt))
+              (receive-pending-interrupt))
             (,name))))))
-
-) ; PROGN
-
-;;; On the GENGC system, we have to do it slightly differently because of the
-;;; existence of threads. Each thread has a suspends_disabled_count in its
-;;; mutator structure. When this value is other then zero, the low level stuff
-;;; will not suspend the thread, but will instead set the suspend_pending flag
-;;; (also in the mutator). So when we finish the without-interrupts, we just
-;;; check the suspend_pending flag and trigger a do-pending-interrupt if
-;;; necessary.
-
-#!+gengc
-(defmacro without-interrupts (&body body)
-  `(unwind-protect
-       (progn
-        (locally
-          (declare (optimize (speed 3) (safety 0)))
-          (incf (sb!kernel:mutator-interrupts-disabled-count)))
-        ,@body)
-     (locally
-       (declare (optimize (speed 3) (safety 0)))
-       (when (and (zerop (decf (sb!kernel:mutator-interrupts-disabled-count)))
-                 (not (zerop (sb!kernel:mutator-interrupt-pending))))
-        (do-pending-interrupt)))))
 \f
 ;;;; utilities for dealing with signal names and numbers
 
@@ -107,9 +77,9 @@
            (:constructor make-unix-signal (%name %number))
            (:copier nil))
   ;; signal keyword (e.g. :SIGINT for the Unix SIGINT signal)
-  (%name   (required-argument) :type keyword :read-only t)
+  (%name   (missing-arg) :type keyword :read-only t)
   ;; signal number
-  (%number (required-argument) :type integer :read-only t))
+  (%number (missing-arg) :type integer :read-only t))
 
 ;;; list of all defined UNIX-SIGNALs
 (defvar *unix-signals* nil)
@@ -237,12 +207,4 @@
 #!+svr4
 (!def-unix-signal :SIGWAITING 32) ; Process's LWPs are blocked.
 
-(sb!xc:defmacro sigmask (&rest signals)
-  #!+sb-doc
-  "Returns a mask given a set of signals."
-  (apply #'logior
-        (mapcar (lambda (signal)
-                  (ash 1 (1- (unix-signal-number signal))))
-                signals)))
-
 (/show0 "done with signal.lisp")