X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcode%2Ftoplevel.lisp;h=f5190028b4490a9d3fa4b4e56601f1460377dc1d;hb=3969fabecc7837eff2c7a8f8f6dc1e0a127c80c8;hp=135028c1658774e48e33582ee2105c387bc6cbea;hpb=ee222567ee95eaac8f6f4c877242dd116bfb8337;p=sbcl.git diff --git a/src/code/toplevel.lisp b/src/code/toplevel.lisp index 135028c..f519002 100644 --- a/src/code/toplevel.lisp +++ b/src/code/toplevel.lisp @@ -20,6 +20,7 @@ (progn (defvar sb!vm::*current-catch-block*) (defvar sb!vm::*current-unwind-protect-block*) + #!+hpux (defvar sb!vm::*c-lra*) (defvar *free-interrupt-context-index*)) ;;; specials initialized by !COLD-INIT @@ -155,125 +156,35 @@ command-line.") ;;;; miscellaneous external functions -(defun sleep (n) +(defun sleep (seconds) #!+sb-doc - "This function causes execution to be suspended for N seconds. N may - be any non-negative, non-complex number." - (when (or (not (realp n)) - (minusp n)) + "This function causes execution to be suspended for SECONDS. SECONDS may be +any non-negative real number." + (when (or (not (realp seconds)) + (minusp seconds)) (error 'simple-type-error :format-control "invalid argument to SLEEP: ~S" - :format-arguments (list n) - :datum n + :format-arguments (list seconds) + :datum seconds :expected-type '(real 0))) #!-win32 (multiple-value-bind (sec nsec) - (if (integerp n) - (values n 0) + (if (integerp seconds) + (values seconds 0) (multiple-value-bind (sec frac) - (truncate n) + (truncate seconds) (values sec (truncate frac 1e-9)))) + ;; nanosleep() accepts time_t as the first argument, but on some platforms + ;; it is restricted to 100 million seconds. Maybe someone can actually + ;; have a reason to sleep for over 3 years? + (loop while (> sec (expt 10 8)) + do (decf sec (expt 10 8)) + (sb!unix:nanosleep (expt 10 8) 0)) (sb!unix:nanosleep sec nsec)) #!+win32 - (sb!win32:millisleep (truncate (* n 1000))) + (sb!win32:millisleep (truncate (* seconds 1000))) nil) -;;;; SCRUB-CONTROL-STACK - -(defconstant bytes-per-scrub-unit 2048) - -;;; Zero the unused portion of the control stack so that old objects -;;; are not kept alive because of uninitialized stack variables. - -;;; "To summarize the problem, since not all allocated stack frame -;;; slots are guaranteed to be written by the time you call an another -;;; function or GC, there may be garbage pointers retained in your -;;; dead stack locations. The stack scrubbing only affects the part -;;; of the stack from the SP to the end of the allocated stack." -;;; - ram, on cmucl-imp, Tue, 25 Sep 2001 - -;;; So, as an (admittedly lame) workaround, from time to time we call -;;; scrub-control-stack to zero out all the unused portion. This is -;;; supposed to happen when the stack is mostly empty, so that we have -;;; a chance of clearing more of it: callers are currently (2002.07.18) -;;; REPL and SUB-GC - -(defun scrub-control-stack () - (declare (optimize (speed 3) (safety 0)) - (values (unsigned-byte 20))) ; FIXME: DECLARE VALUES? - - #!-stack-grows-downward-not-upward - (let* ((csp (sap-int (sb!c::control-stack-pointer-sap))) - (initial-offset (logand csp (1- bytes-per-scrub-unit))) - (end-of-stack - (- (sap-int (sb!di::descriptor-sap sb!vm:*control-stack-end*)) - sb!c:*backend-page-size*))) - (labels - ((scrub (ptr offset count) - (declare (type system-area-pointer ptr) - (type (unsigned-byte 16) offset) - (type (unsigned-byte 20) count) - (values (unsigned-byte 20))) - (cond ((>= (sap-int ptr) end-of-stack) 0) - ((= offset bytes-per-scrub-unit) - (look (sap+ ptr bytes-per-scrub-unit) 0 count)) - (t - (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) - (type (unsigned-byte 16) offset) - (type (unsigned-byte 20) count) - (values (unsigned-byte 20))) - (cond ((>= (sap-int ptr) end-of-stack) 0) - ((= offset bytes-per-scrub-unit) - count) - ((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 sb!vm::word csp)) - (scrub (int-sap (- csp initial-offset)) - (* (floor initial-offset sb!vm:n-word-bytes) sb!vm:n-word-bytes) - 0))) - - #!+stack-grows-downward-not-upward - (let* ((csp (sap-int (sb!c::control-stack-pointer-sap))) - (end-of-stack (+ (sap-int (sb!di::descriptor-sap sb!vm:*control-stack-start*)) - sb!c:*backend-page-size*)) - (initial-offset (logand csp (1- bytes-per-scrub-unit)))) - (labels - ((scrub (ptr offset count) - (declare (type system-area-pointer ptr) - (type (unsigned-byte 16) offset) - (type (unsigned-byte 20) count) - (values (unsigned-byte 20))) - (let ((loc (int-sap (- (sap-int ptr) (+ offset sb!vm:n-word-bytes))))) - (cond ((< (sap-int loc) end-of-stack) 0) - ((= offset bytes-per-scrub-unit) - (look (int-sap (- (sap-int ptr) bytes-per-scrub-unit)) - 0 count)) - (t ;; need to fix bug in %SET-STACK-REF - (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) - (type (unsigned-byte 16) offset) - (type (unsigned-byte 20) count) - (values (unsigned-byte 20))) - (let ((loc (int-sap (- (sap-int ptr) offset)))) - (cond ((< (sap-int loc) end-of-stack) 0) - ((= offset bytes-per-scrub-unit) - count) - ((zerop (sb!kernel::get-lisp-obj-address (stack-ref loc 0))) - (look ptr (+ offset sb!vm:n-word-bytes) count)) - (t - (scrub ptr offset (+ count sb!vm:n-word-bytes))))))) - (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)))) - ;;;; the default toplevel function (defvar / nil @@ -289,13 +200,13 @@ command-line.") (defvar +++ nil #!+sb-doc "the previous value of ++") (defvar - nil #!+sb-doc "the form currently being evaluated") -(defun interactive-eval (form) +(defun interactive-eval (form &key (eval #'eval)) #!+sb-doc "Evaluate FORM, returning whatever it returns and adjusting ***, **, *, +++, ++, +, ///, //, /, and -." (setf - form) (unwind-protect - (let ((results (multiple-value-list (eval form)))) + (let ((results (multiple-value-list (funcall eval form)))) (setf /// // // / / results @@ -381,29 +292,16 @@ command-line.") (dolist (option options) (process-1 option))))) -;;; Skips past the shebang line on stream, if any. -(defun maybe-skip-shebang-line (stream) - (let ((p (file-position stream))) - (flet ((next () (read-byte stream nil))) - (unwind-protect - (when (and (eq (next) (char-code #\#)) - (eq (next) (char-code #\!))) - (setf p nil) - (loop for x = (next) - until (or (not x) (eq x (char-code #\newline))))) - (when p - (file-position stream p)))) - t)) - (defun process-script (script) - (let ((pathname (native-pathname script)) - (ok nil)) - (unwind-protect - (with-open-file (f pathname :element-type :default) - (maybe-skip-shebang-line f) - (load f :verbose nil :print nil) - (setf ok t)) - (quit :unix-status (if ok 0 1))))) + (let ((pathname (native-pathname script))) + (handling-end-of-the-world + (with-open-file (f pathname :element-type :default) + (sb!fasl::maybe-skip-shebang-line f) + ;; Scripts don't need to be stylish or fast, but silence is usually a + ;; desirable quality... + (handler-bind (((or style-warning compiler-note) #'muffle-warning)) + (load f :verbose nil :print nil)) + (quit))))) ;; Errors while processing the command line cause the system to QUIT, ;; instead of trying to go into the Lisp debugger, because trying to @@ -619,12 +517,11 @@ that provides the REPL for the system. Assumes that *STANDARD-INPUT* and (with-simple-restart (abort "~@") (catch 'toplevel-catcher - #!-win32 (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. #!-win32 - (sb!kernel::protect-control-stack-guard-page 1) + (sb!kernel::reset-control-stack-guard-page) (funcall repl-fun noprint) (critically-unreachable "after REPL"))))))))) @@ -637,6 +534,11 @@ that provides the REPL for the system. Assumes that *STANDARD-INPUT* and ;;; handle the Unix-style EOF-is-end-of-process convention. (defun repl-read-form-fun (in out) (declare (type stream in out) (ignore out)) + ;; KLUDGE: *READ-SUPPRESS* makes the REPL useless, and cannot be + ;; recovered from -- flip it here. + (when *read-suppress* + (warn "Setting *READ-SUPPRESS* to NIL to restore toplevel usability.") + (setf *read-suppress* nil)) (let* ((eof-marker (cons nil nil)) (form (read in nil eof-marker))) (if (eq form eof-marker)