X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcode%2Ftarget-extensions.lisp;h=f65e25d81e84d06e686f16fa5a4774ab44dc51d3;hb=4898febe4d3ab2eaa83c26cd4c1ff113772100c4;hp=123af88748afce8301a0fd6c97d5f04c9eb270d8;hpb=cea4896b2482b7b2b429c1631d774b4cfbc0efba;p=sbcl.git diff --git a/src/code/target-extensions.lisp b/src/code/target-extensions.lisp index 123af88..f65e25d 100644 --- a/src/code/target-extensions.lisp +++ b/src/code/target-extensions.lisp @@ -1,10 +1,10 @@ -;;;; This file contains things for the extensions package which can't -;;;; be built at cross-compile time, and perhaps also some things -;;;; which might as well not be built at cross-compile time because -;;;; they're not needed then. Things which can't be built at -;;;; cross-compile time (e.g. because they need machinery which only -;;;; exists inside SBCL's implementation of the LISP package) do not -;;;; belong in this file. +;;;; This file contains things for the extensions packages (SB-EXT and +;;;; also "internal extensions" SB-INT) which can't be built at +;;;; cross-compile time, and perhaps also some things which might as +;;;; well not be built at cross-compile time because they're not +;;;; needed then. Things which can't be built at cross-compile time +;;;; (e.g. because they need machinery which only exists inside SBCL's +;;;; implementation of the LISP package) do not belong in this file. ;;;; This software is part of the SBCL system. See the README file for ;;;; more information. @@ -15,31 +15,107 @@ ;;;; provided with absolutely no warranty. See the COPYING and CREDITS ;;;; files for more information. -(in-package "SB!EXT") +(in-package "SB!IMPL") + +;;;; 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))) - -(defun skip-whitespace (&optional (stream *standard-input*)) - (loop (let ((char (read-char stream))) - (unless (sb!impl::whitespacep char) - (return (unread-char char stream)))))) + "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 listen-skip-whitespace (&optional (stream *standard-input*)) +(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 - "See LISTEN. Any whitespace in the input stream will be flushed." + "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 (QUIT :RECKLESSLY-P 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 (sb!impl::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 + +;;; Signal a SIMPLE-CONDITION/ERROR condition associated with an ANSI C +;;; 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) + (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)) + +;;; 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))))