;;; FIXME: The DEFVAR here is redundant with the (DECLAIM (SPECIAL ..))
;;; of all static symbols in early-impl.lisp.
(progn
- (defvar *current-catch-block*)
- (defvar *current-unwind-protect-block*)
+ (defvar sb!vm::*current-catch-block*)
+ (defvar sb!vm::*current-unwind-protect-block*)
(defvar *free-interrupt-context-index*))
\f
;;; specials initialized by !COLD-INIT
;;; counts of nested errors (with internal errors double-counted)
(defvar *maximum-error-depth*)
(defvar *current-error-depth*)
+
+;;;; stepping control
+(defvar *step*)
+(defvar *stepping*)
+(defvar *step-form-stack* nil
+ "A place for single steppers to push information about
+STEP-FORM-CONDITIONS avaiting the corresponding
+STEP-VALUES-CONDITIONS. The system is guaranteed to empty the stack
+when stepping terminates, so that it remains in sync, but doesn't
+modify it in any other way: it is provided for implmentors of single
+steppers to maintain contextual information.")
\f
;;;; miscellaneous utilities for working with with TOPLEVEL
((= offset bytes-per-scrub-unit)
(look (sap+ ptr bytes-per-scrub-unit) 0 count))
(t
- (setf (sap-ref-32 ptr offset) 0)
+ (setf (sap-ref-word ptr offset) 0)
(scrub ptr (+ offset sb!vm:n-word-bytes) count))))
(look (ptr offset count)
(declare (type system-area-pointer ptr)
(cond ((>= (sap-int ptr) end-of-stack) 0)
((= offset bytes-per-scrub-unit)
count)
- ((zerop (sap-ref-32 ptr offset))
+ ((zerop (sap-ref-word ptr offset))
(look ptr (+ offset sb!vm:n-word-bytes) count))
(t
(scrub ptr offset (+ count sb!vm:n-word-bytes))))))
- (declare (type (unsigned-byte 32) csp))
+ (declare (type sb!vm::word csp))
(scrub (int-sap (- csp initial-offset))
(* (floor initial-offset sb!vm:n-word-bytes) sb!vm:n-word-bytes)
0)))
(look (int-sap (- (sap-int ptr) bytes-per-scrub-unit))
0 count))
(t ;; need to fix bug in %SET-STACK-REF
- (setf (sap-ref-32 loc 0) 0)
+ (setf (sap-ref-word loc 0) 0)
(scrub ptr (+ offset sb!vm:n-word-bytes) count)))))
(look (ptr offset count)
(declare (type system-area-pointer ptr)
(look ptr (+ offset sb!vm:n-word-bytes) count))
(t
(scrub ptr offset (+ count sb!vm:n-word-bytes)))))))
- (declare (type (unsigned-byte 32) csp))
+ (declare (type sb!vm::word csp))
(scrub (int-sap (+ csp initial-offset))
(* (floor initial-offset sb!vm:n-word-bytes) sb!vm:n-word-bytes)
0))))
+++, ++, +, ///, //, /, and -."
(setf - form)
(let ((results
- (multiple-value-list
- (eval-in-lexenv form
- (make-null-interactive-lexenv)))))
+ (multiple-value-list
+ (eval-in-lexenv form
+ (make-null-interactive-lexenv)))))
(setf /// //
// /
/ results
;;; the default system top level function
(defun toplevel-init ()
-
- (/show0 "entering TOPLEVEL-INIT")
- (sb!thread::init-job-control)
- (sb!thread::get-foreground)
+ (/show0 "entering TOPLEVEL-INIT")
(let (;; value of --sysinit option
(sysinit nil)
;; value of --userinit option
;; USERINITish files
(probe-init-files (explicitly-specified-init-file-name
&rest default-init-file-names)
- (declare (type list possible-init-file-names))
+ (declare (type list default-init-file-names))
(if explicitly-specified-init-file-name
(or (probe-file explicitly-specified-init-file-name)
(startup-error "The file ~S was not found."
;; Each REPL in a multithreaded world should have bindings of
;; most CL specials (most critically *PACKAGE*).
(with-rebound-io-syntax
- ;; WITH-SIMPLE-RESTART doesn't actually restart its body as
- ;; some (like WHN for an embarrassingly long time
- ;; ca. 2001-12-07) might think, but instead drops control back
- ;; out at the end. So when a TOPLEVEL or outermost-ABORT
- ;; restart happens, we need this outer LOOP wrapper to grab
- ;; control and start over again. (And it also wraps CATCH
- ;; 'TOPLEVEL-CATCHER for similar reasons.)
- (loop
- (/show0 "about to set up restarts in TOPLEVEL-REPL")
- ;; There should only be one TOPLEVEL restart, and it's here,
- ;; so restarting at TOPLEVEL always bounces you all the way
- ;; out here.
- (with-simple-restart (toplevel
- "Restart at toplevel READ/EVAL/PRINT loop.")
- ;; We add a new ABORT restart for every debugger level, so
- ;; restarting at ABORT in a nested debugger gets you out to
- ;; the innermost enclosing debugger, and only when you're
- ;; in the outermost, unnested debugger level does
- ;; restarting at ABORT get you out to here.
- (with-simple-restart
- (abort
- "~@<Reduce debugger level (leaving debugger, returning to toplevel).~@:>")
- (catch 'toplevel-catcher
- (sb!unix::reset-signal-mask)
- ;; In the event of a control-stack-exhausted-error, we
- ;; should have unwound enough stack by the time we get
- ;; here that this is now possible.
- (sb!kernel::protect-control-stack-guard-page 1)
- (funcall repl-fun noprint)
- (critically-unreachable "after REPL")))))))))
+ (handler-bind ((step-condition 'invoke-stepper))
+ (let ((*stepping* nil)
+ (*step* nil))
+ ;; WITH-SIMPLE-RESTART doesn't actually restart its body as
+ ;; some (like WHN for an embarrassingly long time
+ ;; ca. 2001-12-07) might think, but instead drops control back
+ ;; out at the end. So when a TOPLEVEL or outermost-ABORT
+ ;; restart happens, we need this outer LOOP wrapper to grab
+ ;; control and start over again. (And it also wraps CATCH
+ ;; 'TOPLEVEL-CATCHER for similar reasons.)
+ (loop
+ (/show0 "about to set up restarts in TOPLEVEL-REPL")
+ ;; There should only be one TOPLEVEL restart, and it's here,
+ ;; so restarting at TOPLEVEL always bounces you all the way
+ ;; out here.
+ (with-simple-restart (toplevel
+ "Restart at toplevel READ/EVAL/PRINT loop.")
+ ;; We add a new ABORT restart for every debugger level, so
+ ;; restarting at ABORT in a nested debugger gets you out to
+ ;; the innermost enclosing debugger, and only when you're
+ ;; in the outermost, unnested debugger level does
+ ;; restarting at ABORT get you out to here.
+ (with-simple-restart
+ (abort "~@<Reduce debugger level (leaving debugger, ~
+ returning to toplevel).~@:>")
+ (catch 'toplevel-catcher
+ (sb!unix::reset-signal-mask)
+ ;; In the event of a control-stack-exhausted-error, we
+ ;; should have unwound enough stack by the time we get
+ ;; here that this is now possible.
+ (sb!kernel::protect-control-stack-guard-page 1)
+ (funcall repl-fun noprint)
+ (critically-unreachable "after REPL")))))))))))
;;; Our default REPL prompt is the minimal traditional one.
(defun repl-prompt-fun (stream)
(defun repl-fun (noprint)
(/show0 "entering REPL")
(loop
- ;; (See comment preceding the definition of SCRUB-CONTROL-STACK.)
- (scrub-control-stack)
- (sb!thread::get-foreground)
- (unless noprint
- (funcall *repl-prompt-fun* *standard-output*)
- ;; (Should *REPL-PROMPT-FUN* be responsible for doing its own
- ;; FORCE-OUTPUT? I can't imagine a valid reason for it not to
- ;; be done here, so leaving it up to *REPL-PROMPT-FUN* seems
- ;; odd. But maybe there *is* a valid reason in some
- ;; circumstances? perhaps some deadlock issue when being driven
- ;; by another process or something...)
- (force-output *standard-output*))
- (let* ((form (funcall *repl-read-form-fun*
- *standard-input*
- *standard-output*))
- (results (multiple-value-list (interactive-eval form))))
- (unless noprint
- (dolist (result results)
- (fresh-line)
- (prin1 result))))))
+ (unwind-protect
+ (progn
+ ;; (See comment preceding the definition of SCRUB-CONTROL-STACK.)
+ (scrub-control-stack)
+ (sb!thread::get-foreground)
+ (unless noprint
+ (funcall *repl-prompt-fun* *standard-output*)
+ ;; (Should *REPL-PROMPT-FUN* be responsible for doing its own
+ ;; FORCE-OUTPUT? I can't imagine a valid reason for it not to
+ ;; be done here, so leaving it up to *REPL-PROMPT-FUN* seems
+ ;; odd. But maybe there *is* a valid reason in some
+ ;; circumstances? perhaps some deadlock issue when being driven
+ ;; by another process or something...)
+ (force-output *standard-output*))
+ (let* ((form (funcall *repl-read-form-fun*
+ *standard-input*
+ *standard-output*))
+ (results (multiple-value-list (interactive-eval form))))
+ (unless noprint
+ (dolist (result results)
+ (fresh-line)
+ (prin1 result)))))
+ ;; If we started stepping in the debugger we want to stop now.
+ (setf *stepping* nil
+ *step* nil))))
\f
;;; a convenient way to get into the assembly-level debugger
(defun %halt ()
projects / sbcl.git / blobdiff