X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcode%2Ftarget-extensions.lisp;h=088694dc90a177fcab171afc0adc0a910c290d63;hb=0c3bbfaa2286626a2d915c8810f690aefc702661;hp=fe2bbfc8861990adb71a77c9c674dd612a118706;hpb=a18f0a95bc9a457e4d2d00c702b746f29c2662b1;p=sbcl.git diff --git a/src/code/target-extensions.lisp b/src/code/target-extensions.lisp index fe2bbfc..088694d 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. @@ -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,15 +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)) + 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)))) + +;;; 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))))