X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcode%2Ftarget-extensions.lisp;h=088694dc90a177fcab171afc0adc0a910c290d63;hb=0c3bbfaa2286626a2d915c8810f690aefc702661;hp=b80eb8d41bb5dfd33cdca72aef8b47782d5ac65a;hpb=204f2fa9771ad9e55718dc76205afec7d11b3011;p=sbcl.git diff --git a/src/code/target-extensions.lisp b/src/code/target-extensions.lisp index b80eb8d..088694d 100644 --- a/src/code/target-extensions.lisp +++ b/src/code/target-extensions.lisp @@ -17,33 +17,57 @@ (in-package "SB!IMPL") -;;;; miscellaneous I/O +;;;; variables initialization and shutdown sequences -;;; INDENTING-FURTHER is a user-level macro which may be used to locally -;;; increment the indentation of a stream. -(defmacro indenting-further (stream more &rest body) +;; (Most of the save-a-core functionality is defined later, in its +;; own file, but we'd like to have these symbols declared special +;; and initialized ASAP.) +(defvar *save-hooks* nil #!+sb-doc - "Causes the output of the indenting Stream to indent More spaces. More is - evaluated twice." - `(unwind-protect - (progn - (incf (sb!impl::indenting-stream-indentation ,stream) ,more) - ,@body) - (decf (sb!impl::indenting-stream-indentation ,stream) ,more))) + "This is a list of functions which are called in an unspecified +order before creating a saved core image. Unused by SBCL itself: +reserved for user and applications.") -(defun skip-whitespace (&optional (stream *standard-input*)) - (loop (let ((char (read-char stream))) - (unless (sb!impl::whitespacep char) - (return (unread-char char stream)))))) +(defvar *init-hooks* nil + #!+sb-doc + "This is a list of functions which are called in an unspecified +order when a saved core image starts up, after the system itself has +been initialized. Unused by SBCL itself: reserved for user and +applications.") + +(defvar *exit-hooks* nil + #!+sb-doc + "This is a list of functions which are called in an unspecified +order when SBCL process exits. Unused by SBCL itself: reserved for +user and applications. Using (SB-EXT:EXIT :ABORT T), or calling +exit(3) directly will circumvent these hooks.") + + +;;; Binary search for simple vectors +(defun binary-search (value seq &key (key #'identity)) + (declare (simple-vector seq)) + (labels ((recurse (start end) + (when (< start end) + (let* ((i (+ start (truncate (- end start) 2))) + (elt (svref seq i)) + (key-value (funcall key elt))) + (cond ((< value key-value) + (recurse start i)) + ((> value key-value) + (recurse (1+ i) end)) + (t + elt)))))) + (recurse 0 (length seq)))) + ;;; like LISTEN, but any whitespace in the input stream will be flushed (defun listen-skip-whitespace (&optional (stream *standard-input*)) (do ((char (read-char-no-hang stream nil nil nil) - (read-char-no-hang stream nil nil nil))) + (read-char-no-hang stream nil nil nil))) ((null char) nil) - (cond ((not (whitespace-char-p char)) - (unread-char char stream) - (return t))))) + (cond ((not (whitespace[1]p char)) + (unread-char char stream) + (return t))))) ;;;; helpers for C library calls @@ -51,41 +75,52 @@ ;;; errno problem, arranging for the condition's print representation ;;; to be similar to the ANSI C perror(3) style. (defun simple-perror (prefix-string - &key - (errno (get-errno)) - (simple-error 'simple-error) - other-condition-args) + &key + (errno (get-errno)) + (simple-error 'simple-error) + other-condition-args) (declare (type symbol simple-error)) (aver (subtypep simple-error 'simple-condition)) (aver (subtypep simple-error 'error)) (apply #'error - simple-error - :format-control "~@<~A: ~2I~_~A~:>" - :format-arguments (list prefix-string (strerror errno)) - other-condition-args)) - -;;;; optimization idioms - -(eval-when (:compile-toplevel :load-toplevel :execute) + simple-error + :format-control "~@<~A: ~2I~_~A~:>" + :format-arguments (list prefix-string (strerror errno)) + other-condition-args)) - ;; Byte compile this thing if possible. - (defvar *optimize-byte-compilation* - '(optimize (speed 0) (safety 1))) +;;; Constructing shortish strings one character at a time. More efficient then +;;; a string-stream, as can directly use simple-base-strings when applicable, +;;; and if the maximum size is know doesn't need to copy the result at all -- +;;; but if the result is going to be HUGE, string-streams will win. +(defmacro with-push-char ((&key (element-type 'character) (initial-size 28)) &body body) + (with-unique-names (string size pointer) + `(let* ((,size ,initial-size) + (,string (make-array ,size :element-type ',element-type)) + (,pointer 0)) + (declare (type (integer 0 ,sb!xc:array-dimension-limit) ,size) + (type (integer 0 ,(1- sb!xc:array-dimension-limit)) ,pointer) + (type (simple-array ,element-type (*)) ,string)) + (flet ((push-char (char) + (declare (optimize (sb!c::insert-array-bounds-checks 0))) + (when (= ,pointer ,size) + (let ((old ,string)) + (setf ,size (* 2 (+ ,size 2)) + ,string (make-array ,size :element-type ',element-type)) + (replace ,string old))) + (setf (char ,string ,pointer) char) + (incf ,pointer)) + (get-pushed-string () + (let ((string ,string) + (size ,pointer)) + (setf ,size 0 + ,pointer 0 + ,string ,(coerce "" `(simple-array ,element-type (*)))) + ;; This is really local, so we can be destructive! + (%shrink-vector string size) + string))) + ,@body)))) - ;; This thing is externally visible, so compiling meta-information - ;; is more important than byte-compiling it; but it's otherwise - ;; suitable for byte-compilation. - ;; - ;; (As long as the byte compiler isn't capable of compiling - ;; meta-information such as the argument list required by functions - ;; (as in sbcl-0.6.12, anyway), it's not suitable for compiling - ;; externally visible things like CL:INSPECT even if their speed - ;; requirements are small enough that it'd otherwise be OK. If some - ;; later version of the byte compiler learns to compile such - ;; meta-information, we'll probably change the implementation of - ;; this idiom so that it causes byte compilation of the thing after - ;; all.) - (defvar *optimize-external-despite-byte-compilation* - '(optimize (speed 1) - ;; still might as well be as small as possible.. - (space 3)))) +;;; The smallest power of two that is equal to or greater than X. +(defun power-of-two-ceiling (x) + (declare (index x)) + (ash 1 (integer-length (1- x))))