X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcode%2Finterr.lisp;h=c3f039f838cb0c53ac0709ff56d89db7c69ad025;hb=7306e23c5a4687bef98fdfb3459aaf15fe79d5ca;hp=232f1a6e21a1d257b2d166f5da788acfc317d73e;hpb=ee3f2e0351674dde7229afdcccfcfaf8ce5b112e;p=sbcl.git

diff --git a/src/code/interr.lisp b/src/code/interr.lisp
index 232f1a6..c3f039f 100644
--- a/src/code/interr.lisp
+++ b/src/code/interr.lisp
@@ -22,40 +22,38 @@
 (sb!xc:defmacro deferr (name args &rest body)
   (let* ((rest-pos (position '&rest args))
          (required (if rest-pos (subseq args 0 rest-pos) args))
-         (fp (gensym))
-         (context (gensym))
-         (sc-offsets (gensym))
          (fn-name (symbolicate name "-HANDLER")))
-    `(progn
-       ;; FIXME: Having a separate full DEFUN for each error doesn't
-       ;; seem to add much value, and it takes a lot of space. Perhaps
-       ;; we could do this dispatch with a big CASE statement instead?
-       (defun ,fn-name (name ,fp ,context ,sc-offsets)
-         ;; FIXME: It would probably be good to do *STACK-TOP-HINT*
-         ;; tricks to hide this internal error-handling logic from the
-         ;; poor high level user, so his debugger tells him about
-         ;; where his error was detected instead of telling him where
-         ;; he ended up inside the system error-handling logic.
-         (declare (ignorable name ,fp ,context ,sc-offsets))
-         (let (,@(let ((offset -1))
-                   (mapcar (lambda (var)
-                             `(,var (sb!di::sub-access-debug-var-slot
-                                     ,fp
-                                     (nth ,(incf offset)
-                                          ,sc-offsets)
-                                     ,context)))
-                           required))
-               ,@(when rest-pos
-                   `((,(nth (1+ rest-pos) args)
-                      (mapcar (lambda (sc-offset)
-                                (sb!di::sub-access-debug-var-slot
-                                 ,fp
-                                 sc-offset
-                                 ,context))
-                              (nthcdr ,rest-pos ,sc-offsets))))))
-           ,@body))
-       (setf (svref *internal-errors* ,(error-number-or-lose name))
-             #',fn-name))))
+    (with-unique-names (fp context sc-offsets)
+      `(progn
+         ;; FIXME: Having a separate full DEFUN for each error doesn't
+         ;; seem to add much value, and it takes a lot of space. Perhaps
+         ;; we could do this dispatch with a big CASE statement instead?
+         (defun ,fn-name (name ,fp ,context ,sc-offsets)
+           ;; FIXME: It would probably be good to do *STACK-TOP-HINT*
+           ;; tricks to hide this internal error-handling logic from the
+           ;; poor high level user, so his debugger tells him about
+           ;; where his error was detected instead of telling him where
+           ;; he ended up inside the system error-handling logic.
+           (declare (ignorable name ,fp ,context ,sc-offsets))
+           (let (,@(let ((offset -1))
+                        (mapcar (lambda (var)
+                                  `(,var (sb!di::sub-access-debug-var-slot
+                                          ,fp
+                                          (nth ,(incf offset)
+                                           ,sc-offsets)
+                                          ,context)))
+                                required))
+                 ,@(when rest-pos
+                     `((,(nth (1+ rest-pos) args)
+                        (mapcar (lambda (sc-offset)
+                                  (sb!di::sub-access-debug-var-slot
+                                   ,fp
+                                   sc-offset
+                                   ,context))
+                         (nthcdr ,rest-pos ,sc-offsets))))))
+             ,@body))
+        (setf (svref *internal-errors* ,(error-number-or-lose name))
+              #',fn-name)))))
 
 ) ; EVAL-WHEN
 
@@ -260,7 +258,7 @@
          :format-arguments (list key-name)))
 
 (deferr invalid-array-index-error (array bound index)
-  (invalid-array-index-error array bound index))
+  (invalid-array-index-error array index bound))
 
 (deferr object-not-simple-array-error (object)
   (error 'type-error
@@ -426,14 +424,6 @@
          (multiple-value-bind (name sb!debug:*stack-top-hint*)
              (find-interrupted-name-and-frame)
            (/show0 "back from FIND-INTERRUPTED-NAME")
-           ;; Unblock trap signal here, we unwound the stack and can't return.
-           ;; FIXME: Should we not reset the _entire_ mask, but just
-           ;; restore it to the state before we got the condition?
-           ;; FIXME 2: Signals are currently unblocked in
-           ;; interrupt.c:internal_error before we do stack unwinding, can this
-           ;; introduce a race condition?
-           #!+(and linux mips)
-           (sb!unix::reset-signal-mask)
            (let ((fp (int-sap (sb!vm:context-register alien-context
                                                       sb!vm::cfp-offset)))
                  (handler (and (< -1 error-number (length *internal-errors*))
@@ -468,6 +458,20 @@
              "Control stack guard page temporarily disabled: proceed with caution~%")
      (error 'control-stack-exhausted))))
 
+(defun binding-stack-exhausted-error ()
+  (let ((sb!debug:*stack-top-hint* nil))
+    (infinite-error-protect
+     (format *error-output*
+             "Binding stack guard page temporarily disabled: proceed with caution~%")
+     (error 'binding-stack-exhausted))))
+
+(defun alien-stack-exhausted-error ()
+  (let ((sb!debug:*stack-top-hint* nil))
+    (infinite-error-protect
+     (format *error-output*
+             "Alien stack guard page temporarily disabled: proceed with caution~%")
+     (error 'alien-stack-exhausted))))
+
 ;;; KLUDGE: we keep a single HEAP-EXHAUSTED-ERROR object around, so
 ;;; that we don't need to allocate it when running out of
 ;;; memory. Similarly we pass the amounts in special variables as