;;; FIXME: These could be converted to DEFVARs.
(declaim (special *gc-inhibit* *need-to-collect-garbage*
- *before-gc-hooks* *after-gc-hooks*
+ *after-gc-hooks*
#!+x86 *pseudo-atomic-atomic*
#!+x86 *pseudo-atomic-interrupted*
sb!unix::*interrupts-enabled*
:format-arguments (list n)
:datum n
:expected-type '(real 0)))
- (multiple-value-bind (sec usec)
+ (multiple-value-bind (sec nsec)
(if (integerp n)
(values n 0)
(multiple-value-bind (sec frac)
(truncate n)
- (values sec (truncate frac 1e-6))))
- (sb!unix:unix-select 0 0 0 0 sec usec))
+ (values sec (truncate frac 1e-9))))
+ (sb!unix:nanosleep sec nsec))
nil)
\f
;;;; SCRUB-CONTROL-STACK
"Evaluate FORM, returning whatever it returns and adjusting ***, **, *,
+++, ++, +, ///, //, /, and -."
(setf - form)
- (let ((results
- (multiple-value-list
- (eval-in-lexenv form
- (make-null-interactive-lexenv)))))
+ (let ((results (multiple-value-list (eval form))))
(setf /// //
// /
/ results
(finish-output (symbol-value name)))
(values))
+(defun process-init-file (truename)
+ (when truename
+ (restart-case
+ (with-open-file (s truename :if-does-not-exist nil)
+ (flet ((next ()
+ (let ((form (read s nil s)))
+ (if (eq s form)
+ (return-from process-init-file nil)
+ (eval form)))))
+ (loop
+ (restart-case
+ (handler-bind ((error (lambda (e)
+ (error
+ "Error during processing of ~
+ initialization file ~A:~%~% ~A"
+ truename e))))
+ (next))
+ (continue ()
+ :report "Ignore and continue processing.")))))
+ (abort ()
+ :report "Skip rest of initialization file."))))
+
+(defun process-eval-options (eval-strings)
+ (/show0 "handling --eval options")
+ (flet ((process-1 (string)
+ (multiple-value-bind (expr pos) (read-from-string string)
+ (unless (eq string (read-from-string string nil string :start pos))
+ (error "More the one expression in ~S" string))
+ (eval expr)
+ (flush-standard-output-streams))))
+ (restart-case
+ (dolist (expr-as-string eval-strings)
+ (/show0 "handling one --eval option")
+ (restart-case
+ (handler-bind ((error (lambda (e)
+ (error "Error during processing of --eval ~
+ option ~S:~%~% ~A"
+ expr-as-string e))))
+ (process-1 expr-as-string))
+ (continue ()
+ :report "Ignore and continue with next --eval option.")))
+ (abort ()
+ :report "Skip rest of --eval options."))))
+
;;; the default system top level function
(defun toplevel-init ()
(/show0 "entering TOPLEVEL-INIT")
((string= option "--noprint")
(pop-option)
(setf noprint t))
- ;; FIXME: --noprogrammer was deprecated in 0.7.5, and
- ;; in a year or so this backwards compatibility can
- ;; go away.
- ((string= option "--noprogrammer")
- (warn "treating deprecated --noprogrammer as --disable-debugger")
- (pop-option)
- (push "(|DISABLE-DEBUGGER|)" reversed-evals))
((string= option "--disable-debugger")
(pop-option)
(push "(|DISABLE-DEBUGGER|)" reversed-evals))
(init-file-name (posix-getenv "HOME")
".sbclrc"))))
- ;; We wrap all the pre-REPL user/system customized startup code
- ;; in a restart.
- ;;
- ;; (Why not wrap everything, even the stuff above, in this
- ;; restart? Errors above here are basically command line or
- ;; Unix environment errors, e.g. a missing file or a typo on
- ;; the Unix command line, and you don't need to get into Lisp
- ;; to debug them, you should just start over and do it right
- ;; at the Unix level. Errors below here are generally errors
- ;; in user Lisp code, and it might be helpful to let the user
- ;; reach the REPL in order to help figure out what's going
- ;; on.)
- (restart-case
- (progn
- (flet ((process-init-file (truename)
- (when truename
- (unless (load truename)
- (error "~S was not successfully loaded."
- truename))
- (flush-standard-output-streams))))
- (process-init-file sysinit-truename)
- (process-init-file userinit-truename))
-
- ;; Process --eval options.
- (/show0 "handling --eval options in TOPLEVEL-INIT")
- (dolist (expr-as-string (reverse reversed-evals))
- (/show0 "handling one --eval option in TOPLEVEL-INIT")
- (let ((expr (with-input-from-string (eval-stream
- expr-as-string)
- (let* ((eof-marker (cons :eof :eof))
- (result (read eval-stream
- nil
- eof-marker))
- (eof (read eval-stream nil eof-marker)))
- (cond ((eq result eof-marker)
- (error "unable to parse ~S"
- expr-as-string))
- ((not (eq eof eof-marker))
- (error
- "more than one expression in ~S"
- expr-as-string))
- (t
- result))))))
- (eval expr)
- (flush-standard-output-streams))))
- (continue ()
- :report
- "Continue anyway (skipping to toplevel read/eval/print loop)."
- (/show0 "CONTINUEing from pre-REPL RESTART-CASE")
- (values)) ; (no-op, just fall through)
- (quit ()
- :report "Quit SBCL (calling #'QUIT, killing the process)."
- (/show0 "falling through to QUIT from pre-REPL RESTART-CASE")
- (quit))))
+ ;; This CATCH is needed for the debugger command TOPLEVEL to
+ ;; work.
+ (catch 'toplevel-catcher
+ ;; We wrap all the pre-REPL user/system customized startup
+ ;; code in a restart.
+ ;;
+ ;; (Why not wrap everything, even the stuff above, in this
+ ;; restart? Errors above here are basically command line
+ ;; or Unix environment errors, e.g. a missing file or a
+ ;; typo on the Unix command line, and you don't need to
+ ;; get into Lisp to debug them, you should just start over
+ ;; and do it right at the Unix level. Errors below here
+ ;; are generally errors in user Lisp code, and it might be
+ ;; helpful to let the user reach the REPL in order to help
+ ;; figure out what's going on.)
+ (restart-case
+ (progn
+ (process-init-file sysinit-truename)
+ (process-init-file userinit-truename)
+ (process-eval-options (reverse reversed-evals)))
+ (abort ()
+ :report "Skip to toplevel READ/EVAL/PRINT loop."
+ (/show0 "CONTINUEing from pre-REPL RESTART-CASE")
+ (values)) ; (no-op, just fall through)
+ (quit ()
+ :report "Quit SBCL (calling #'QUIT, killing the process)."
+ (/show0 "falling through to QUIT from pre-REPL RESTART-CASE")
+ (quit)))))
;; one more time for good measure, in case we fell out of the
;; RESTART-CASE above before one of the flushes in the ordinary
(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.
+ ;; CLHS recommends that there should always be an
+ ;; ABORT restart; we have this one here, and one per
+ ;; debugger level.
(with-simple-restart
- (abort "~@<Reduce debugger level (leaving debugger, ~
- returning to toplevel).~@:>")
+ (abort "~@<Exit debugger, returning to top level.~@:>")
(catch 'toplevel-catcher
(sb!unix::reset-signal-mask)
;; In the event of a control-stack-exhausted-error, we
;; here that this is now possible.
(sb!kernel::protect-control-stack-guard-page 1)
(funcall repl-fun noprint)
- (critically-unreachable "after REPL")))))))))))
+ (critically-unreachable "after REPL"))))))))))
;;; Our default REPL prompt is the minimal traditional one.
(defun repl-prompt-fun (stream)
projects / sbcl.git / blobdiff