.\" contact Scott Fahlman or slisp-group@cs.cmu.edu.
.\" **********************************************************************
.\"
-.\" $Header$
-.\" FIXME: The date below should be $Date$.
.TH SBCL 1 "$Date$"
.AT 3
.SH NAME
;;;; files for more information.
(in-package "SB!C")
-
-(file-comment
- "$Header$")
\f
(defvar *do-assembly* nil
#!+sb-doc "If non-NIL, emit assembly code. If NIL, emit VOP templates.")
;;;; files for more information.
(in-package "SB!VM")
-
-(file-comment
- "$Header$")
\f
;;;; from signed/unsigned
;;;; files for more information.
(in-package "SB!VM")
-
-(file-comment
- "$Header$")
\f
;;;; addition, subtraction, and multiplication
;;;; files for more information.
(in-package "SB!VM")
-
-(file-comment
- "$Header$")
\f
;;;; allocation
;;;; files for more information.
(in-package "SB!VM")
-
-(file-comment
- "$Header$")
\f
;;;; RETURN-MULTIPLE
;;;; files for more information.
(in-package "SB!VM")
-
-(file-comment
- "$Header$")
(in-package "SB!VM")
-(file-comment
- "$Header$")
-
(def-vm-support-routine generate-call-sequence (name style vop)
(ecase style
(:raw
(in-package "SB!KERNEL")
-(file-comment
- "$Header$")
-
(!begin-collecting-cold-init-forms)
(defstruct (alien-type-type
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
#!-sb-fluid
(declaim (inline fill-pointer array-has-fill-pointer-p adjustable-array-p
array-displacement))
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
;;; The flags passed back by BACKQUOTIFY can be interpreted as follows:
;;;
;;; |`,|: [a] => a
;;;; files for more information.
(in-package "SB!BIGNUM")
-
-(file-comment
- "$Header$")
\f
;;;; notes
;;;; files for more information.
(in-package "SB!VM")
-
-(file-comment
- "$Header$")
\f
;;;; constants and types
(in-package "SB!EXT")
-(file-comment
- "$Header$")
-
;;; Lots of code wants to get to the KEYWORD package or the COMMON-LISP package
;;; without a lot of fuss, so we cache them in variables. TO DO: How much
;;; does this actually buy us? It sounds sensible, but I don't know for sure
;;;; Carnegie Mellon University, and has been placed in the public
;;;; domain.
-(sb!int:file-comment
- "$Header$")
-
(in-package "SB!SYS")
;;;; Check that target machine features are set up consistently with
(in-package "SB!C")
-(file-comment
- "$Header$")
-
;;;; This software is part of the SBCL system. See the README file for
;;;; more information.
;;;;
;;;; files for more information.
(in-package "SB!C")
-
-(file-comment
- "$Header$")
\f
;;;; types
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
;;; We compile some trivial character operations via inline expansion.
#!-sb-fluid
(declaim (inline standard-char-p graphic-char-p alpha-char-p
(in-package "COMMON-LISP")
-(sb!int:file-comment
- "$Header$")
-
(sb!xc:proclaim '(special cl:*
cl:**
cl:***
(in-package "SB!KERNEL")
-(file-comment
- "$Header$")
-
(!begin-collecting-cold-init-forms)
\f
;;;; the CLASS structure
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
(macrolet ((def-frob (name result access src-type &optional typep)
`(defun ,name (object ,@(if typep '(type) ()))
(do* ((index 0 (1+ index))
(in-package "SB!CONDITIONS")
-(sb!int:file-comment
- "$Header$")
-
(defvar *break-on-signals* nil
#!+sb-doc
"When (TYPEP condition *BREAK-ON-SIGNALS*) is true, then calls to SIGNAL will
;;; FIXME: Perhaps this belongs in the %SYS package like some other
;;; cold load stuff.
-(file-comment
- "$Header$")
-
(eval-when (:compile-toplevel :load-toplevel :execute)
(defvar *cold-init-forms*))
;;;; files for more information.
(in-package "SB!IMPL")
-
-(file-comment
- "$Header$")
\f
;;;; burning our ships behind us
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
;;; There seems to be no portable way to mask float traps, but we shouldn't
;;; encounter any float traps when cross-compiling SBCL itself, anyway, so we
;;; just make this a no-op.
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
;;;; fast-read operations
;;;;
;;;; (Portable versions of these are needed at cross-compile time because
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
-;;; In correct code, TRULY-THE has only a performance impact and can be
-;;; safely degraded to ordinary THE.
+;;; In correct code, TRULY-THE has only a performance impact and can
+;;; be safely degraded to ordinary THE.
(defmacro truly-the (type expr)
`(the ,type ,expr))
;;; (possibly at some cost in efficiency).
(declaim (declaration freeze-type maybe-inline))
-;;; INHIBIT-WARNINGS declarations can be safely ignored (although we may then
-;;; have to wade through some irrelevant warnings).
+;;; INHIBIT-WARNINGS declarations can be safely ignored (although we
+;;; may then have to wade through some irrelevant warnings).
(declaim (declaration inhibit-warnings))
-;;; Interrupt control isn't an issue in the cross-compiler: we don't use
-;;; address-dependent (and thus GC-dependent) hashes, and we only have a single
-;;; thread of control.
+;;; Interrupt control isn't an issue in the cross-compiler: we don't
+;;; use address-dependent (and thus GC-dependent) hashes, and we only
+;;; have a single thread of control.
(defmacro without-interrupts (&rest forms)
`(progn ,@forms))
-;;; When we're running as a cross-compiler in an arbitrary host ANSI Lisp, we
-;;; don't have any hooks available to manipulate the debugging name and
-;;; debugging argument list of an interpreted function object (and don't care
-;;; much about getting debugging name and debugging argument list right
-;;; anyway).
+;;; When we're running as a cross-compiler in an arbitrary host ANSI
+;;; Lisp, we don't have any hooks available to manipulate the
+;;; debugging name and debugging argument list of an interpreted
+;;; function object (and don't care much about getting debugging name
+;;; and debugging argument list right anyway).
(defun try-to-rename-interpreted-function-as-macro (f name lambda-list)
(declare (ignore f name lambda-list))
(values))
-;;; When we're running as a cross-compiler in an arbitrary host ANSI Lisp, we
-;;; shouldn't be doing anything which is sensitive to GC. KLUDGE: I (WHN
-;;; 19990131) think the proper long-term solution would be to remove any
-;;; operations from cross-compiler source files (putting them in target-only
-;;; source files) if they refer to these hooks. This is a short-term hack.
+;;; When we're running as a cross-compiler in an arbitrary host ANSI
+;;; Lisp, we shouldn't be doing anything which is sensitive to GC.
+;;; KLUDGE: I (WHN 19990131) think the proper long-term solution would
+;;; be to remove any operations from cross-compiler source files
+;;; (putting them in target-only source files) if they refer to these
+;;; hooks. This is a short-term hack.
(defvar *before-gc-hooks* nil)
(defvar *after-gc-hooks* nil)
-;;; The GENESIS function works with fasl code which would, in the target SBCL,
-;;; work on LISP-STREAMs. A true LISP-STREAM doesn't seem to be a meaningful
-;;; concept in ANSI Common Lisp, but we can fake it acceptably well using a
-;;; standard STREAM.
+;;; The GENESIS function works with fasl code which would, in the
+;;; target SBCL, work on LISP-STREAMs. A true LISP-STREAM doesn't seem
+;;; to be a meaningful concept in ANSI Common Lisp, but we can fake it
+;;; acceptably well using a standard STREAM.
(deftype lisp-stream () 'stream)
-;;; In the target SBCL, the INSTANCE type refers to a base implementation
-;;; for compound types. There's no way to express exactly that concept
-;;; portably, but we can get essentially the same effect by testing for
-;;; any of the standard types which would, in the target SBCL, be derived
-;;; from INSTANCE:
+;;; In the target SBCL, the INSTANCE type refers to a base
+;;; implementation for compound types. There's no way to express
+;;; exactly that concept portably, but we can get essentially the same
+;;; effect by testing for any of the standard types which would, in
+;;; the target SBCL, be derived from INSTANCE:
(deftype sb!kernel:instance ()
'(or condition standard-object structure-object))
;;; host Common Lisp.
(defun funcallable-instance-p (x)
(if (typep x 'generic-function)
- ;; In the target SBCL, FUNCALLABLE-INSTANCEs are used to implement generic
- ;; functions, so any case which tests for this might in fact be trying to
- ;; test for generic functions. My (WHN 19990313) expectation is that this
- ;; case won't arise in the cross-compiler, but if it does, it deserves a
- ;; little thought, rather than reflexively returning NIL.
+ ;; In the target SBCL, FUNCALLABLE-INSTANCEs are used to implement
+ ;; generic functions, so any case which tests for this might in
+ ;; fact be trying to test for generic functions. My (WHN 19990313)
+ ;; expectation is that this case won't arise in the
+ ;; cross-compiler, but if it does, it deserves a little thought,
+ ;; rather than reflexively returning NIL.
(error "not clear how to handle GENERIC-FUNCTION")
nil))
-;;; This seems to be the portable Common Lisp type test which corresponds
-;;; to the effect of the target SBCL implementation test..
+;;; This seems to be the portable Common Lisp type test which
+;;; corresponds to the effect of the target SBCL implementation test..
(defun sb!kernel:array-header-p (x)
(and (typep x 'simple-array)
(= 1 (array-rank x))))
-;;; Genesis needs these at cross-compile time. The target implementation of
-;;; these is reasonably efficient by virtue of its ability to peek into the
-;;; internals of the package implementation; this reimplementation is portable
-;;; but slow.
+;;; Genesis needs these at cross-compile time. The target
+;;; implementation of these is reasonably efficient by virtue of its
+;;; ability to peek into the internals of the package implementation;
+;;; this reimplementation is portable but slow.
(defun package-internal-symbol-count (package)
(let ((result 0))
(declare (type fixnum result))
(do-symbols (i package)
- ;; KLUDGE: The ANSI Common Lisp specification warns that DO-SYMBOLS may
- ;; execute its body more than once for symbols that are inherited from
- ;; multiple packages, and we currently make no attempt to correct for
- ;; that here. (The current uses of this function at cross-compile time
- ;; don't really care if the count is a little too high.) -- WHN 19990826
+ ;; KLUDGE: The ANSI Common Lisp specification warns that
+ ;; DO-SYMBOLS may execute its body more than once for symbols
+ ;; that are inherited from multiple packages, and we currently
+ ;; make no attempt to correct for that here. (The current uses
+ ;; of this function at cross-compile time don't really care if
+ ;; the count is a little too high.) -- WHN 19990826
(multiple-value-bind (symbol status)
(find-symbol (symbol-name i) package)
(declare (ignore symbol))
(incf result))
result))
-;;; In the target Lisp, INTERN* is the primitive and INTERN is implemented in
-;;; terms of it. This increases efficiency by letting us reuse a fixed-size
-;;; buffer; the alternative would be particularly painful because we don't
-;;; implement DYNAMIC-EXTENT. In the host Lisp, this is only used at
-;;; cold load time, and we don't care as much about efficiency, so it's fine
-;;; to treat the host Lisp's INTERN as primitive and implement INTERN* in
-;;; terms of it.
+;;; In the target Lisp, INTERN* is the primitive and INTERN is
+;;; implemented in terms of it. This increases efficiency by letting
+;;; us reuse a fixed-size buffer; the alternative would be
+;;; particularly painful because we don't implement DYNAMIC-EXTENT. In
+;;; the host Lisp, this is only used at cold load time, and we don't
+;;; care as much about efficiency, so it's fine to treat the host
+;;; Lisp's INTERN as primitive and implement INTERN* in terms of it.
(defun intern* (nameoid length package)
(intern (replace (make-string length) nameoid :end2 length) package))
-;;; In the target Lisp this is implemented by reading a fixed slot in the
-;;; symbol. In portable ANSI Common Lisp the same criteria can be met (more
-;;; slowly, and with the extra property of repeatability between runs) by just
-;;; calling SXHASH.
+;;; In the target Lisp this is implemented by reading a fixed slot in
+;;; the symbol. In portable ANSI Common Lisp the same criteria can be
+;;; met (more slowly, and with the extra property of repeatability
+;;; between runs) by just calling SXHASH.
(defun symbol-hash (symbol)
(declare (type symbol symbol))
(sxhash symbol))
(in-package "SB!SYS")
-(file-comment
- "$Header$")
-
-;;; SYSTEM-AREA-POINTER is not a primitive type in ANSI Common Lisp, so we
-;;; need a compound type to represent it in the host Common Lisp at
-;;; cross-compile time:
+;;; SYSTEM-AREA-POINTER is not a primitive type in ANSI Common Lisp,
+;;; so we need a compound type to represent it in the host Common Lisp
+;;; at cross-compile time:
(defstruct (system-area-pointer (:constructor make-sap) (:conc-name "SAP-"))
;; the integer representation of the address
(int (error "missing SAP-INT argument") :type sap-int-type :read-only t))
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
;;; (This was a useful warning when trying to get bootstrapping
;;; to work, but it's mostly irrelevant noise now that the system
;;; works.)
;;;; files for more information.
(in-package "SB!C")
-
-(file-comment
- "$Header$")
\f
;;;; SC-OFFSETs
;;;;
(in-package "SB!DI")
-(file-comment
- "$Header$")
-
;;; FIXME: There are an awful lot of package prefixes in this code.
;;; Couldn't we have SB-DI use the SB-C and SB-VM packages?
\f
;;;; files for more information.
(in-package "SB!C")
-
-(file-comment
- "$Header$")
\f
;;;; reading variable length integers
;;;;
(in-package "SB!VM")
-(file-comment
- "$Header$")
-
(defconstant bogus-lra-constants 2)
(defconstant real-lra-slot (+ code-constants-offset 0))
(defconstant known-return-p-slot (+ code-constants-offset 1))
;;;; files for more information.
(in-package "SB!DEBUG")
-
-(file-comment
- "$Header$")
\f
;;;; variables and constants
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
#+sb-xc-host
(progn
;; a description of the DEF!MACRO call to be stored until we get enough
(in-package "SB!KERNEL")
-(file-comment
- "$Header$")
-
;;; A bootstrap MAKE-LOAD-FORM method can be a function or the name
;;; of a function.
(deftype def!struct-type-make-load-form-fun () '(or function symbol))
;;;; files for more information.
(in-package "SB!KERNEL")
-
-(file-comment
- "$Header$")
\f
;;;; the DEF!TYPE macro
;;;; files for more information.
(in-package "SB!IMPL")
-
-(file-comment
- "$Header$")
\f
;;;; IN-PACKAGE
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
;;; the guts of the DEFMACRO macro, pulled out into a separate
;;; function in order to make it easier to express the common
;;; bootstrap idiom
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
(defmacro defpackage (package &rest options)
#!+sb-doc
"Defines a new package called PACKAGE. Each of OPTIONS should be one of the
;;;; provided with absolutely no warranty. See the COPYING and CREDITS
;;;; files for more information.
-(sb!int:file-comment
- "$Header$")
-
(sb!int:/show0 "entering defsetfs.lisp")
;;; from alieneval.lisp
;;;; files for more information.
(in-package "SB!KERNEL")
-
-(file-comment
- "$Header$")
\f
;;;; getting LAYOUTs
;;;; files for more information.
(in-package "SB!KERNEL")
-
-(file-comment
- "$Header$")
\f
;;;; Now that DEFTYPE is set up, any pending requests for it can
;;;; be honored.
;;;; files for more information.
(in-package "SB-IMPL")
-
-(file-comment
- "$Header$")
\f
(defvar *describe-indentation-step* 3
#+sb-doc
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
(defmacro-mundanely destructuring-bind (lambda-list arg-list &rest body)
#!+sb-doc
"Bind the variables in LAMBDA-LIST to the contents of ARG-LIST."
(in-package "SB!DYNCOUNT")
-(file-comment
- "$Header$")
-
#|
-Make sure multi-cycle instruction costs are plausible.
-VOP classification.
- Make tables of %cost for benchmark X class.
- Could be represented as a sort of bar chart.
+comments from CMU CL:
+ Make sure multi-cycle instruction costs are plausible.
+ VOP classification.
+ Make tables of %cost for benchmark X class.
+ Could be represented as a sort of bar chart.
|#
(eval-when (:compile-toplevel)
(in-package "SB!ALIEN")
-(file-comment
- "$Header$")
-
(defvar *alien-type-classes* (make-hash-table :test 'eq))
(defvar *new-auxiliary-types* nil)
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
(defconstant sb!xc:array-rank-limit 65529
#!+sb-doc
"the exclusive upper bound on the rank of an array")
(in-package "SB!KERNEL")
-(file-comment
- "$Header$")
-
;;; Common Lisp special variables which have SB-XC versions
(proclaim '(special sb!xc:*macroexpand-hook*))
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
#+sb-xc-host
(defmacro def!method (&rest args)
`(defmethod ,@args))
(in-package "SB!EXT")
-(file-comment
- "$Header$")
-
;;; helper function for various macros which expect clauses of a given
;;; length, etc.
;;;
;;;; provided with absolutely no warranty. See the COPYING and CREDITS
;;;; files for more information.
-;;;; $Header$
-
(;; Define the STRUCTURE-OBJECT class as a subclass of
;; INSTANCE. This has to be handled early because the design of the
;; DEFSTRUCT system, dating back to pre-1999 CMU CL, requires that
(in-package "SB!KERNEL")
-(file-comment
- "$Header$")
-
#.`(progn
,@(mapcar (lambda (args)
`(defstruct ,@args))
(in-package "SB!EXT")
-(file-comment
- "$Header$")
-
;;; a type used for indexing into arrays, and for related quantities
;;; like lengths of lists
;;;
(in-package "SB!FORMAT")
-(file-comment
- "$Header$")
-
(defparameter *format-whitespace-chars*
(vector #\space
#\newline
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
;;; entries in STATIC-SYMBOLS table, references to which can be compiled
;;; as though they're special variables
(declaim (special *posix-argv*
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
;;; information about non-Lisp-level linkage
;;;
;;; Note:
;;;; files for more information.
(in-package "SB!PRETTY")
-
-(file-comment
- "$Header$")
\f
;;;; utilities
;;;; files for more information.
(in-package "SB!IMPL")
-
-(file-comment
- "$Header$")
\f
;;;; level and length abbreviations
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
;;; The inverse for a generalized-variable reference function is stored in
;;; one of two ways:
;;;
;;;; files for more information.
(in-package "SB!CONDITIONS")
-
-(sb!int:file-comment
- "$Header$")
\f
;;;; restarts
(in-package "SB!KERNEL")
-(file-comment
- "$Header$")
-
(!begin-collecting-cold-init-forms)
;;; Has the type system been properly initialized? (I.e. is it OK to
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
;;; These specials are used by ERROR-ERROR to track the success of recovery
;;; attempts.
(defvar *error-error-depth* 0)
(in-package "SB!CONDITIONS")
-(sb!int:file-comment
- "$Header$")
-
(define-condition simple-style-warning (simple-condition style-warning) ())
;;; not sure this is the right place, but where else?
(in-package "SB!EVAL")
-(file-comment
- "$Header$")
-
;;; This flag is used by EVAL-WHEN to keep track of when code has already been
;;; evaluated so that it can avoid multiple evaluation of nested EVAL-WHEN
;;; (COMPILE)s.
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
(deftype file-stream () 'fd-stream)
\f
;;;; buffer manipulation routines
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
(sb!int::/show0 "fdefinition.lisp 22")
\f
;;;; fdefinition (fdefn) objects
;;;; files for more information.
(in-package "SB!IMPL")
-
-(file-comment
- "$Header$")
\f
;;;; Unix pathname host support
(in-package "SB!EXT")
-(file-comment
- "$Header$")
-
(defvar *objects-pending-finalization* nil)
(defun finalize (object function)
(in-package "SB!VM")
-(file-comment
- "$Header$")
-
(eval-when (:compile-toplevel :load-toplevel :execute)
(defconstant float-trap-alist
;;;; files for more information.
(in-package "SB!KERNEL")
-
-(file-comment
- "$Header$")
\f
;;;; utilities
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
;;; Define NAME as a fasl operation, with op-code FOP-CODE. PUSHP
;;; describes what the body does to the fop stack:
;;; :NOPE
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
#+sb-xc-host (force-delayed-def!macros)
(in-package "SB-IMPL")
-(file-comment
- "$Header$")
-
(macrolet ((force-delayed-def!methods ()
`(progn
,@(mapcar (lambda (args)
(in-package "SB!KERNEL")
-(file-comment
- "$Header$")
-
#+sb-xc-host (force-delayed-def!structs)
(in-package "SB-SYS")
-(file-comment
- "$Header$")
-
;;; not needed until we implement full-blown LOAD-FOREIGN
#|
(defun pick-temporary-file-name (&optional
(in-package "SB!EXT")
-(file-comment
- "$Header$")
-
(defconstant abbrev-weekday-table
'#("Mon" "Tue" "Wed" "Thu" "Fri" "Sat" "Sun"))
;;;; files for more information.
(in-package "SB!KERNEL")
-
-(file-comment
- "$Header$")
\f
;;;; DYNAMIC-USAGE and friends
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
;;; FIXME: The COMMON-LISP specials here are already handled in
;;; cl-specials.lisp.
(declaim (special *keyword-package* *cl-package* *package* *query-io*
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
;;; an internal tag for marking empty slots
;;;
;;; CMU CL 18b used :EMPTY for this purpose, which was somewhat nasty
;;;; files for more information.
(in-package "SB!ALIEN")
-
-(file-comment
- "$Header$")
\f
;;;; utility functions
(in-package "SB!C-CALL")
-(sb!int:file-comment
- "$Header$")
-
(def-alien-type-class (c-string :include pointer :include-args (to)))
(def-alien-type-translator c-string ()
(in-package "SB-INSPECT")
-(file-comment
- "$Header$")
-
;;; The inspector views LISP objects as being composed of parts. A
;;; list, for example, would be divided into its members, and a
;;; instance into its slots. These parts are stored in a list. The
;;;; files for more information.
(in-package "SB!KERNEL")
-
-(file-comment
- "$Header$")
\f
;;;; internal errors
;;;; files for more information.
(in-package "SB!KERNEL")
-
-(file-comment
- "$Header$")
\f
;;;; miscellaneous constants, utility functions, and macros
(in-package "SB!KERNEL")
-(file-comment
- "$Header$")
-
(defun get-header-data (x)
#!+sb-doc
"Return the 24 bits of data in the header of object X, which must be an
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
;;; DEF!METHOD = cold DEFMETHOD, a version of DEFMETHOD which, when used
;;; before real CLOS DEFMETHOD is available, saves up its definition to be
;;; executed later when CLOS is available
(in-package "SB!EXT")
-(file-comment
- "$Header$")
-
(defun featurep (x)
#!+sb-doc
"If X is an atom, see whether it is present in *FEATURES*. Also
;;;; files for more information.
(in-package "SB!FORMAT")
-
-(file-comment
- "$Header$")
\f
(define-condition format-error (error)
((complaint :reader format-error-complaint :initarg :complaint)
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
(defmacro-mundanely psetf (&rest args &environment env)
#!+sb-doc
"This is to SETF as PSETQ is to SETQ. Args are alternating place
;;;; files for more information.
(in-package "SB!CONDITIONS")
-
-(sb!int:file-comment
- "$Header$")
\f
;;;; the CONDITION class
(in-package "SB!KERNEL")
-(file-comment
- "$Header$")
-
(!begin-collecting-cold-init-forms)
;;; ### Remaining incorrectnesses:
(in-package "SB!SYS")
-(file-comment
- "$Header$")
-
-;;; Check that target machine features are set up consistently with this file.
+;;; Check that target machine features are set up consistently with
+;;; this file.
#!-linux (error "missing :LINUX feature")
(defun software-type ()
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
(eval-when (:compile-toplevel :load-toplevel :execute)
(defconstant in-buffer-length 512 "the size of a stream in-buffer"))
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
;;;; KLUDGE: comment from CMU CL, what does it mean?
;;;; NSUBLIS, things at the beginning broken.
;;;; -- WHN 20000127
;;;; files for more information.
(in-package "SB!IMPL")
-
-(file-comment
- "$Header$")
\f
;;;; variables
(in-package "SB!LOOP")
-(sb!int:file-comment
- "$Header$")
-
;;;; The design of this LOOP is intended to permit, using mostly the same
;;;; kernel of code, up to three different "loop" macros:
;;;;
;;;; files for more information.
(in-package "SB!IMPL")
-
-(file-comment
- "$Header$")
\f
;;;; syntactic environment access
;;;; files for more information.
(in-package "SB!IMPL")
-
-(file-comment
- "$Header$")
\f
;;;; ASSERT and CHECK-TYPE
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
;(defun %sp-byte-blt (src-string src-start dst-string dst-start dst-end)
; "Moves bytes from Src-String into Dst-String between Dst-Start (inclusive)
;and Dst-End (exclusive) (Dst-Start - Dst-End bytes are moved). Overlap of the
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
(defun sb!xc:lisp-implementation-type ()
"SBCL")
;;;; files for more information.
(in-package "SB!IMPL")
-
-(file-comment
- "$Header$")
\f
;;;; exported specials
(in-package "SB-DEBUG")
-(file-comment
- "$Header$")
-
-;;; FIXME: Why, oh why, doesn't the SB-DEBUG package use the SB-DI package?
-;;; That would let us get rid of a whole lot of stupid prefixes..
+;;; FIXME: Why, oh why, doesn't the SB-DEBUG package use the SB-DI
+;;; package? That would let us get rid of a whole lot of stupid
+;;; prefixes..
(defvar *trace-values* nil
#+sb-doc
(in-package "SB!KERNEL")
-(file-comment
- "$Header$")
-
;;; FIXME: This probably belongs in SB-INT instead of SB-KERNEL.
;;; And couldn't it be limited to FIXNUM arguments?
(defun positive-primep (x)
;;;; files for more information.
(in-package "SB!IMPL")
-
-(file-comment
- "$Header$")
\f
;;;; the PACKAGE-HASHTABLE structure
(in-package "SB!INT")
-(file-comment
- "$Header$")
-
(/show0 "entering parse-body.lisp")
;;; Given a sequence of declarations (and possibly a documentation
(in-package "SB!KERNEL")
-(file-comment
- "$Header$")
-
;;; We save space in macro definitions by calling this function.
(defun do-arg-count-error (error-kind name arg lambda-list minimum maximum)
(multiple-value-bind (fname sb!debug:*stack-top-hint*) (find-caller-name)
(in-package "SB!KERNEL")
-(file-comment
- "$Header$")
-
;;; variables for accumulating the results of parsing a DEFMACRO. (Declarations
;;; in DEFMACRO are the reason this isn't as easy as it sounds.)
(defvar *arg-tests* nil) ; tests that do argument counting at expansion time
;;;; files for more information.
(in-package "SB!IMPL")
-
-(file-comment
- "$Header$")
\f
;;;; data types used by pathnames
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
(defun backq-unparse-expr (form splicing)
(ecase splicing
((nil)
;;;; files for more information.
(in-package "SB!PRETTY")
-
-(file-comment
- "$Header$")
\f
;;;; pretty streams
;;;; files for more information.
(in-package "SB!IMPL")
-
-(file-comment
- "$Header$")
\f
;;;; miscellaneous non-primitive predicates
;;;; files for more information.
(in-package "SB!IMPL")
-
-(file-comment
- "$Header$")
\f
;;;; exported printer control variables
(in-package "SB!KERNEL")
-(file-comment
- "$Header$")
-
(sb!alien:def-alien-routine ("purify" %purify) sb!c-call:void
(static-roots sb!c-call:unsigned-long)
(read-only-roots sb!c-call:unsigned-long))
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
(defun query-readline ()
(force-output *query-io*)
(string-trim " " (read-line *query-io*)))
(in-package "SB!KERNEL")
-(file-comment
- "$Header$")
-
;;; the size of the chunks returned by RANDOM-CHUNK
(defconstant random-chunk-length 32)
;;;; files for more information.
(in-package "SB!IMPL")
-
-(file-comment
- "$Header$")
\f
;;; miscellaneous global variables
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
(sb!xc:deftype attribute-table ()
'(simple-array (unsigned-byte 8) (#.char-code-limit)))
;;;; files for more information.
(in-package "SB!VM")
-
-(file-comment
- "$Header$")
\f
;;;; type format database
;;;; files for more information.
(in-package "SB-EXT")
-
-(file-comment
- "$Header$")
\f
;;;; Import wait3(2) from Unix.
;;;; files for more information.
(in-package "SB!IMPL")
-
-(file-comment
- "$Header$")
\f
(defvar *before-save-initializations* nil
#!+sb-doc
;;;; files for more information.
(in-package "SB!IMPL")
-
-(file-comment
- "$Header$")
\f
;;;; utilities
;;;; files for more information.
(in-package "SB!IMPL")
-
-(file-comment
- "$Header$")
\f
#|
;;;; object set stuff
(in-package "SB!KERNEL")
-(file-comment
- "$Header$")
-
(eval-when (:compile-toplevel :execute)
(defun compute-one-setter (name type)
;;;; files for more information.
(in-package "SB!IMPL")
-
-(file-comment
- "$Header$")
\f
(declaim (special *read-suppress* *standard-readtable* *bq-vector-flag*))
etc."
(declare (ignore string))
'(values))
-
-;;; Now that we've got it, we can use it.
-(file-comment
- "$Header$")
\f
;;;; various SB-SHOW-dependent forms
;;;; files for more information.
(in-package "SB!UNIX")
-
-(file-comment
- "$Header$")
\f
;;;; macros for dynamically enabling and disabling signal handling
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
(defun sort (sequence predicate &key key)
#!+sb-doc
"Destructively sorts sequence. Predicate should return non-Nil if
(in-package "SB!KERNEL")
-(file-comment
- "$Header$")
-
;;; It's hard to dump specialized vectors portably, because ANSI
;;; doesn't guarantee much about what specialized vectors exist.
;;; Thus, if we do
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
(deftype string-stream ()
'(or string-input-stream string-output-stream
fill-pointer-output-stream))
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
(defun string (x)
#!+sb-doc
"Coerces X into a string. If X is a string, X is returned. If X is a
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
(declaim (maybe-inline get %put getf remprop %putf get-properties keywordp))
(defun symbol-value (variable)
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
;;; This checks to see whether the array is simple and the start and
;;; end are in bounds. If so, it proceeds with those values.
;;; Otherwise, it calls %WITH-ARRAY-DATA. Note that there is a
;;;; files for more information.
(in-package "SB!ALIEN")
-
-(file-comment
- "$Header$")
\f
;;;; alien variables
;;;; files for more information.
(in-package "SB!C-CALL")
-
-(sb!int:file-comment
- "$Header$")
\f
;;;; extra types
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
(defvar *delayed-def!method-args* nil)
;;;; files for more information.
(in-package "SB!KERNEL")
-
-(file-comment
- "$Header$")
\f
;;;; structure frobbing primitives
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
;;; FIXME: These probably belong in some package other than SB!IMPL.
;;; Perhaps SB!KERNEL?
(in-package "SB!EXT")
-(file-comment
- "$Header$")
-
;;; 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)
;;;; files for more information.
(in-package "SB!FORMAT")
-
-(file-comment
- "$Header$")
\f
;;;; FORMAT
;;;; files for more information.
(in-package "SB!IMPL")
-
-(file-comment
- "$Header$")
\f
;;;; utilities
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
(defvar *load-source-types* '("lisp" "l" "cl" "lsp")
#!+sb-doc
"The source file types which LOAD recognizes.")
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
;;; cobbled from stuff in describe.lisp.
(defun function-doc (x)
(let ((name
;;;; files for more information.
(in-package "SB!KERNEL")
-
-(file-comment
- "$Header$")
\f
;;;; the NUMBER-DISPATCH macro
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
(!begin-collecting-cold-init-forms)
(!cold-init-forms
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
#!-sb-fluid (declaim (freeze-type logical-pathname logical-host))
\f
;;; host methods
;;;; files for more information.
(in-package "SB!KERNEL")
-
-(file-comment
- "$Header$")
\f
;;;; RANDOM-STATEs
(in-package "SB!SYS")
;;; FIXME: Shouldn't these be IN-PACKAGE SB!KERNEL instead? (They're
;;; not dependent on the OS, only on the CPU architecture.)
-
-(file-comment
- "$Header$")
\f
;;;; primitive SAP operations
(in-package "SB!UNIX")
-(file-comment
- "$Header$")
-
;;; These should probably be somewhere, but I don't know where.
(defconstant sig_dfl 0)
(defconstant sig_ign 1)
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
;;; the depthoid explored when calculating hash values
;;;
;;; "Depthoid" here is a sort of mixture of what Common Lisp ordinarily calls
(in-package "SB!KERNEL")
-(file-comment
- "$Header$")
-
(!begin-collecting-cold-init-forms)
\f
;;; Just call %TYPEP.
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
(defconstant internal-time-units-per-second 100
#!+sb-doc
"The number of internal time units that fit into a second. See
;;;; files for more information.
(in-package "SB!IMPL")
-
-(file-comment
- "$Header$")
\f
(defconstant most-positive-fixnum #.sb!vm:*target-most-positive-fixnum*
#!+sb-doc
(in-package "SB!KERNEL")
-(file-comment
- "$Header$")
-
(!begin-collecting-cold-init-forms)
(defvar *type-classes*)
(in-package "SB!KERNEL")
-(file-comment
- "$Header$")
-
;;; built-in classes
(/show0 "beginning type-init.lisp")
(dolist (x *built-in-classes*)
(in-package "SB!KERNEL")
-(file-comment
- "$Header$")
-
(!begin-collecting-cold-init-forms)
;;; Define the translation from a type-specifier to a type structure for
(in-package "SB!KERNEL")
-(file-comment
- "$Header$")
-
;;; The actual TYPEP engine. The compiler only generates calls to this
;;; function when it can't figure out anything more intelligent to do.
(defun %typep (object specifier)
(in-package "SB!INT")
-;;;; $Header$
-
;;; In the target system's compiler, uncrossing is just identity.
#-sb-xc-host
(progn
(in-package "SB!UNIX")
-(file-comment
- "$Header$")
-
(/show0 "unix.lisp 21")
;;;; common machine-independent structures
(in-package "SB!EXT")
-(file-comment
- "$Header$")
-
(defun make-weak-pointer (object)
#!+sb-doc
"Allocates and returns a weak pointer which points to OBJECT."
;;;; files for more information.
(in-package "SB!VM")
-
-(file-comment
- "$Header$")
\f
;;;; OS-CONTEXT-T
;;;; provided with absolutely no warranty. See the COPYING and CREDITS
;;;; files for more information.
-;;;; $Header$
-
#+clisp
(locally
(in-package "SB-COLD")
-;;;; $Header$
-
(defvar *target-object-file-names*)
;;; KLUDGE..
(in-package "SB-COLD")
-;;;; $Header$
-
;;; Either load or compile-then-load the cross-compiler into the
;;; cross-compilation host Common Lisp.
(defun load-or-cload-xcompiler (load-or-cload-stem)
(in-package "SB-COLD")
-;;;; $Header$
-
;;; Return an expression read from the file named PATHNAME-DESIGNATOR.
(export 'read-from-file)
(defun read-from-file (pathname-designator)
(in-package "SB-COLD")
-;;;; $Header$
-
;;; RENAME-PACKAGE in two steps in order to avoid the possibility of undefined
;;; behavior when one of the new names is the same as one of the old names.
;;; (ANSI on RENAME-PACKAGE: "The consequences are undefined if new-name or any
(in-package "SB-COLD")
-;;;; $Header$
-
;;; an entry in the table which describes the non-standard part (i.e. not
;;; CL/CL-USER/KEYWORD) of the package structure of the SBCL system
;;;
;;;; provided with absolutely no warranty. See the COPYING and CREDITS
;;;; files for more information.
-;;;; $Header$
-
;;; TO DO: Might it be possible to increase the efficiency of CMU CL's garbage
;;; collection on my large (256Mb) machine by doing larger incremental GC steps
;;; than the default 2 Mb of CMU CL 2.4.9? A quick test 19990729, setting this
;;;; files for more information.
(in-package "SB-COLD")
-
-;;;; $Header$
\f
;;;; definition of #!+ and #!- as a mechanism analogous to #+/#-,
;;;; but redirectable to any list of features. (This is handy when
(in-package "SB-COLD")
-;;;; $Header$
-
(defstruct snapshot
(hash-table (make-hash-table :test 'eq)
:type hash-table
;;;; files for more information.
(in-package "COMMON-LISP-USER")
-
-;;;; $Header$
\f
;;;; general warm init compilation policy
(in-package "SB-COLD")
-;;;; $Header$
-
;;; a helper macro for WITH-ADDITIONAL-NICKNAME and WITHOUT-SOME-NICKNAME
(defmacro with-given-nicknames ((package-designator nicknames) &body body)
(let ((p (gensym "P"))
;;;; files for more information.
(in-package "SB!C")
-
-(file-comment
- "$Header$")
\f
;;;; DEFKNOWNs
;;;; files for more information.
(in-package "SB!C")
-
-(file-comment
- "$Header$")
\f
;;;; Derive-Type Optimizers
;;;; files for more information.
(in-package "SB!ASSEM")
-
-(sb!int:file-comment
- "$Header$")
\f
;;;; assembly control parameters
;;;; files for more information.
(in-package "SB!C")
-
-(file-comment
- "$Header$")
\f
;;;; miscellaneous backend properties
(in-package "SB!C")
-(file-comment
- "$Header$")
-
#!-sb-fluid
(declaim (inline clear-bit-vector set-bit-vector bit-vector-replace
bit-vector-copy))
(in-package "SB!C")
-(file-comment
- "$Header$")
-
;;;; the fasl file format that we use
(defconstant byte-fasl-file-version 1)
;;;; files for more information.
(in-package "SB!C")
-
-(file-comment
- "$Header$")
\f
;;;; cost estimation
;;;; files for more information.
(in-package "SB!C")
-
-(file-comment
- "$Header$")
\f
;;;; utilities used during code generation
(in-package "SB!IMPL")
-(file-comment "$Header$")
-
(defun %compiler-deftype (name expander &optional doc)
(ecase (info :type :kind name)
(:primitive
(in-package "SB!C")
-(file-comment
- "$Header$")
-
;;; a function that is called to unwind out of COMPILER-ERROR
(declaim (type (function () nil) *compiler-error-bailout*))
(defvar *compiler-error-bailout*
(in-package "SB!C")
-(file-comment
- "$Header$")
-
(defstruct (constraint
(:include sset-element)
(:constructor make-constraint (number kind x y not-p)))
(in-package "SB!C")
-(file-comment
- "$Header$")
-
;;; Insert Block in the emission order after the block After.
(defun add-to-emit-order (block after)
(declare (type block-annotation block after))
(in-package "SB!C")
-(file-comment
- "$Header$")
-
;;; In copy propagation, we manipulate sets of TNs. We only consider TNs whose
;;; sole write is by a MOVE VOP. This allows us to use a degenerate version of
;;; reaching definitions: since each such TN has only one definition, the TN
(in-package "SB!C")
-(file-comment
- "$Header$")
-
;;; These are the functions that are to be called when a problem is
;;; detected. They are passed format arguments. If null, we don't do
;;; anything. The error function is called when something is
(in-package "SB!C")
-(file-comment
- "$Header$")
-
(deftype byte-buffer () '(vector (unsigned-byte 8)))
(defvar *byte-buffer*)
(declaim (type byte-buffer *byte-buffer*))
(in-package "SB!C")
-(file-comment
- "$Header$")
-
(defvar *args* ()
#!+sb-doc
"This variable is bound to the format arguments when an error is signalled
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
(def!macro sb!xc:deftype (name arglist &body body)
#!+sb-doc
"Define a new type, with syntax like DEFMACRO."
(in-package "SB!C")
-(file-comment
- "$Header$")
-
;;; Find the DFO for a component, deleting any unreached blocks and
;;; merging any other components we reach. We repeatedly iterate over
;;; the entry points, since new ones may show up during the walk.
;;;; files for more information.
(in-package "SB!DISASSEM")
-
-(file-comment
- "$Header$")
\f
;;; types and defaults
(in-package "SB!C")
-(file-comment
- "$Header$")
-
;;; FIXME: Double colons are bad, and there are lots of them in this
;;; file, because both dump logic in SB!C and load logic in SB!IMPL
;;; need to know about fops. Perhaps all the load/dump logic should be
(in-package "SB!DYNCOUNT")
-(file-comment
- "$Header$")
-
(defvar *collect-dynamic-statistics* nil
#!+sb-doc
"When T, emit extra code to collect dynamic statistics about vop usages.")
(in-package "SB!ASSEM")
-(sb!int:file-comment
- "$Header$")
-
;;; FIXME: It might make sense to use SB!VM:BYTE-FOO values here
;;; instead of the various ASSEMBLY-UNIT-FOO things, and then define a
;;; BYTE type. One problem: BYTE is exported from the CL package, so
(in-package "SB!C")
-(file-comment
- "$Header$")
-
;;; FIXME: shouldn't SB-C::&MORE be in this list?
(defconstant sb!xc:lambda-list-keywords
'(&optional &rest &key &aux &body &whole &allow-other-keys &environment)
(in-package "SB!C")
-(file-comment
- "$Header$")
-
;;; This phase runs before IR2 conversion, initializing each XEP's
;;; Entry-Info structure. We call the VM-supplied
;;; Select-Component-Format function to make VM-dependent
(in-package "SB!C")
-(file-comment
- "$Header$")
-
;;; Do environment analysis on the code in Component. This involves
;;; various things:
;;; 1. Make an Environment structure for each non-let lambda, assigning
(in-package "SB!C")
-(file-comment
- "$Header$")
-
;;; FIXME: Doesn't this belong somewhere else, like early-c.lisp?
(declaim (special *constants* *free-variables* *component-being-compiled*
*code-vector* *next-location* *result-fixups*
;;;; files for more information.
(in-package "SB!EVAL")
-
-(file-comment
- "$Header$")
\f
;;;; interpreter stack
(in-package "SB!C")
-(file-comment
- "$Header$")
-
;;; FIXUP -- A fixup of some kind.
(defstruct (fixup
(:constructor make-fixup (name flavor &optional offset)))
;;;; files for more information.
(in-package "SB!C")
-
-(file-comment
- "$Header$")
\f
;;;; coercions
;;;; files for more information.
(in-package "SB!C")
-
-(file-comment
- "$Header$")
\f
;;;; information for known functions:
(in-package "SB!C")
-(file-comment
- "$Header$")
-
;;; A CORE-OBJECT structure holds the state needed to resolve cross-component
;;; references during in-core compilation.
(defstruct (core-object
(in-package "SB!VM")
-(file-comment
- "$Header$")
-
;;; FIXME: It's clever using :SUFFIX -TYPE for these things, but it's
;;; a pain for people just learning to find their way around the code
;;; who want to figure out where things like EVEN-FIXNUM type are
(in-package "SB!VM")
-(file-comment
- "$Header$")
-
(defmacro defenum ((&key (prefix "") (suffix "") (start 0) (step 1))
&rest identifiers)
(let ((results nil)
(in-package "SB!VM")
-(file-comment
- "$Header$")
-
(eval-when (:compile-toplevel :execute :load-toplevel)
(defconstant lowtag-bits 3
(in-package "SB!IMPL")
-(file-comment
- "$Header$")
-
;;; a magic number used to identify our core files
(defconstant core-magic
(logior (ash (char-code #\S) 24)
(in-package "SB!KERNEL")
-(file-comment
- "$Header$")
-
(defun error-number-or-lose (name)
(or (position name sb!c:*backend-internal-errors* :key #'car)
(error "unknown internal error: ~S" name)))
;;;; files for more information.
(in-package "SB!VM")
-
-(file-comment
- "$Header$")
\f
;;;; the primitive objects themselves
;;;; files for more information.
(in-package "SB!VM")
-
-(file-comment
- "$Header$")
\f
;;;; primitive type definitions
(in-package "SB!C")
-(file-comment
- "$Header$")
-
;;; Make a function entry, filling in slots from the ENTRY-INFO.
(defun make-function-entry (entry code-obj object)
(declare (type entry-info entry) (type core-object object))
;;;; files for more information.
(in-package "SB!VM")
-
-(file-comment
- "$Header$")
\f
(defun fixnumize (num)
#!+sb-doc
;;;; files for more information.
(in-package "SB!C")
-
-(file-comment
- "$Header$")
\f
;;;; internal type predicates
(in-package "SB!C")
-(file-comment
- "$Header$")
-
(defoptimizer ir2-convert-reffer ((object) node block name offset lowtag)
(let* ((cont (node-cont node))
(locs (continuation-result-tns cont
;;;; files for more information.
(in-package "SB!VM")
-
-(file-comment
- "$Header$")
\f
;;;; other miscellaneous stuff
(in-package "SB!C")
-(file-comment
- "$Header$")
-
;;; FIXME: It would be good to implement SB!XC:DEFCONSTANT, and use
;;; use that here, so that the compiler is born knowing this value.
;;; FIXME: Add a comment telling whether this holds for all vectors
(in-package "SB!KERNEL")
-(file-comment
- "$Header$")
-
(!begin-collecting-cold-init-forms)
\f
;;;; FIXME: I'm not sure where to put this. -- WHN 19990817
;;;; files for more information.
(in-package "SB!C")
-
-(file-comment
- "$Header$")
\f
;;;; internal predicates
(in-package "SB!C")
-(file-comment
- "$Header$")
-
(!begin-collecting-cold-init-forms)
#!+sb-show (!cold-init-forms (/show0 "early in globaldb.lisp cold init"))
(in-package "SB!C")
-(file-comment
- "$Header$")
-
;;; We make a pass over the component's environments, assigning argument
;;; passing locations and return conventions and TNs for local variables.
(defun gtn-analyze (component)
;;;; files for more information.
(in-package "SB!C")
-
-(file-comment
- "$Header$")
\f
;;; Check the legality of a function name that is being introduced.
;;; -- If it names a macro, then give a warning and blast the macro
(in-package "SB!C")
-(file-comment
- "$Header$")
-
;;; Give the user grief about optimizations that we weren't able to do. It
;;; is assumed that they want to hear, or there wouldn't be any entries in the
;;; table. If the node has been deleted or is no longer a known call, then do
;;;; files for more information.
(in-package "SB!C")
-
-(file-comment
- "$Header$")
\f
;;;; interface for obtaining results of constant folding
(in-package "SB!C")
-(file-comment
- "$Header$")
-
(declaim (special *compiler-error-bailout*))
;;; *SOURCE-PATHS* is a hashtable from source code forms to the path
;;;; files for more information.
(in-package "SB!C")
-
-(file-comment
- "$Header$")
\f
;;;; cleanup hackery
;;;; files for more information.
(in-package "SB!C")
-
-(file-comment
- "$Header$")
\f
;;;; moves and type checks
(in-package "SB!C")
-(file-comment
- "$Header$")
-
;;; IR1 boolean function attributes
;;;
;;; There are a number of boolean attributes of known functions which we like
(in-package "SB!C")
-(file-comment
- "$Header$")
-
#+sb-xc-host
(sb!xc:defmacro def-boolean-attribute (name &rest attribute-names)
#!+sb-doc
(in-package "SB!C")
-(file-comment
- "$Header$")
-
(defun note-this-location (vop kind)
#!+sb-doc
"NOTE-THIS-LOCATION VOP Kind
(in-package "SB!C")
-(file-comment
- "$Header$")
-
#!-sb-fluid (declaim (inline internal-make-lexenv)) ; only called in one place
;;; The LEXENV represents the lexical environment used for IR1 conversion.
;;;; files for more information.
(in-package "SB!C")
-
-(file-comment
- "$Header$")
\f
;;;; utilities
(in-package "SB!C")
-(file-comment
- "$Header$")
-
;;; This function propagates information from the variables in the function
;;; Fun to the actual arguments in Call. This is also called by the VALUES IR1
;;; optimizer when it sleazily converts MV-BINDs to LETs.
;;;; files for more information.
(in-package "SB!C")
-
-(file-comment
- "$Header$")
\f
;;;; utilities
(in-package "SB!C")
-(file-comment
- "$Header$")
-
(defknown %load-time-value (t) t (flushable movable))
(def-ir1-translator load-time-value ((form &optional read-only-p) start cont)
(in-package "SB!C")
-(file-comment
- "$Header$")
-
(declaim (special *wild-type* *universal-type* *compiler-error-context*))
;;; An INLINEP value describes how a function is called. The values have these
(in-package "SB!C")
-(file-comment
- "$Header$")
-
;;; FIXME: Doesn't this belong somewhere else, like early-c.lisp?
(declaim (special *constants* *free-variables* *component-being-compiled*
*code-vector* *next-location* *result-fixups*
;;;; files for more information.
(in-package "SB!C")
-
-(file-comment
- "$Header$")
\f
;;;; storage class and storage base definition
(in-package "SB!C")
-(file-comment
- "$Header$")
-
;;; The front-end data structure (IR1) is composed of nodes and
;;; continuations. The general idea is that continuations contain
;;; top-down information and nodes contain bottom-up, derived
(in-package "SB!C")
-(file-comment
- "$Header$")
-
-;;; for debugging: Some parameters controlling which optimizations we attempt.
+;;; for debugging: some parameters controlling which optimizations we
+;;; attempt
(defvar *pack-assign-costs* t)
(defvar *pack-optimize-saves* t)
-;;; FIXME: Perhaps SB-FLUID should be renamed to SB-TWEAK and these should be
-;;; made conditional on SB-TWEAK.
+;;; FIXME: Perhaps SB-FLUID should be renamed to SB-TWEAK and these
+;;; should be made conditional on SB-TWEAK.
(declaim (ftype (function (component) index) ir2-block-count))
\f
(in-package "SB!C")
-(file-comment
- "$Header$")
-
;;; Break a lambda-list into its component parts. We return eleven
;;; values:
;;; 1. A list of the required args.
(in-package "SB!C")
-(file-comment
- "$Header$")
-
;;; !COLD-INIT calls this twice to initialize the cookies, once before
;;; any toplevel forms are executed, then again to undo any lingering
;;; effects of toplevel DECLAIMs.
(in-package "SB!C")
-(file-comment
- "$Header$")
-
;;; This notes the place at which the environment is properly
;;; initialized, for debug-info purposes.
(define-vop (note-environment-start)
;;;; files for more information.
(in-package "SB!C")
-
-(file-comment
- "$Header$")
\f
;;;; error routines
;;;;
;;;; files for more information.
(in-package "SB!C")
-
-(file-comment
- "$Header$")
\f
;;;; DEFKNOWNs
;;;; files for more information.
(in-package "SB!C")
-
-(file-comment
- "$Header$")
\f
;;;; mapping onto lists: the MAPFOO functions
(in-package "SB!C")
-(file-comment
- "$Header$")
-
;;; Convert into an IF so that IF optimizations will eliminate redundant
;;; negations.
(def-source-transform not (x) `(if ,x nil t))
(in-package "SB!C")
-(file-comment
- "$Header$")
-
;;; Each structure that may be placed in a SSet must include the
;;; SSet-Element structure. We allow an initial value of NIL to mean
;;; that no ordering has been assigned yet (although an ordering must
;;;; files for more information.
(in-package "SB!C")
-
-(file-comment
- "$Header$")
\f
;;; Scan through Block looking for uses of :Unknown continuations that have
;;; their Dest outside of the block. We do some checking to verify the
(in-package "SB!C")
-(file-comment
- "$Header$")
-
;;; Generate trace-file output for the byte compiler back-end.
;;;
;;; (Note: As of sbcl-0.6.7, this is target-only code not because it's
(in-package "SB!DISASSEM")
-(file-comment
- "$Header$")
-
;;;; FIXME: A lot of stupid package prefixes would go away if DISASSEM
;;;; would use the SB!DI package. And some more would go away if it would
;;;; use SB!SYS (in order to get to the SAP-FOO operators).
(in-package "SB!C")
-(file-comment
- "$Header$")
-
;;; Dump the first N bytes of VEC out to FILE. VEC is some sort of unboxed
;;; vector-like thing that we can BLT from.
(defun dump-raw-bytes (vec n fasl-file)
;;;; files for more information.
(in-package "SB!C")
-
-(file-comment
- "$Header$")
\f
;;;; COMPILE and UNCOMPILE
(in-package "SB!C")
-(file-comment
- "$Header$")
-
;;; The component that is currently being compiled. TNs are allocated
;;; in this component.
(defvar *component-being-compiled*)
(in-package "SB!C")
-(file-comment
- "$Header$")
-
(defun trace-table-entry (state)
(let ((label (gen-label)))
(emit-label label)
;;;; files for more information.
(in-package "SB!C")
-
-(file-comment
- "$Header$")
\f
;;;; type predicate translation
;;;;
(in-package "SB!C")
-(file-comment
- "$Header$")
-
;;; Return the template having the specified name, or die trying.
(defun template-or-lose (x)
(the template
(or (gethash x *backend-template-names*)
(error "~S is not a defined template." x))))
-;;; Return the SC structure, SB structure or SC number corresponding to a
-;;; name, or die trying.
+;;; Return the SC structure, SB structure or SC number corresponding
+;;; to a name, or die trying.
(defun sc-or-lose (x)
(the sc
(or (gethash x *backend-sc-names*)
(in-package "SB!C")
-(file-comment
- "$Header$")
-
(eval-when (:compile-toplevel :load-toplevel :execute)
- ;; the largest number of TNs whose liveness changes that we can have in any
- ;; block
+ ;; the largest number of TNs whose liveness changes that we can have
+ ;; in any block
(defconstant local-tn-limit 64))
(deftype local-tn-number () `(integer 0 (,local-tn-limit)))
;;;; files for more information.
(in-package "SB!VM")
-
-(file-comment
- "$Header$")
\f
;;;; LIST and LIST*
;;;; files for more information.
(in-package "SB!VM")
-
-(file-comment
- "$Header$")
\f
;;;; unary operations
;;;; files for more information.
(in-package "SB!VM")
-
-(file-comment
- "$Header$")
\f
;;;; allocator for the array header
;;;; files for more information.
(in-package "SB!VM")
-
-(file-comment
- "$Header$")
\f
;;;; compiler constants
(in-package "SB!VM")
-(file-comment
- "$Header$")
-
;; The move-argument vop is going to store args on the stack for
;; call-out. These tn's will be used for that. move-arg is normally
;; used for things going down the stack but C wants to have args
;;;; files for more information.
(in-package "SB!VM")
-
-(file-comment
- "$Header$")
\f
;;;; interfaces to IR2 conversion
;;;; files for more information.
(in-package "SB!VM")
-
-(file-comment
- "$Header$")
\f
;;;; data object ref/set stuff
;;;; files for more information.
(in-package "SB!VM")
-
-(file-comment
- "$Header$")
\f
;;;; moves and coercions
(in-package "SB!VM")
-(file-comment
- "$Header$")
-
(define-vop (debug-cur-sp)
(:translate current-sp)
(:policy :fast-safe)
;;;; files for more information.
(in-package "SB!VM")
-
-(file-comment
- "$Header$")
\f
(macrolet ((ea-for-xf-desc (tn slot)
`(make-ea
;;; I wonder whether the separation of the disassembler from the
;;; virtual machine is valid or adds value.
-(file-comment
- "$Header$")
-
;;; FIXME: In CMU CL, the code in this file seems to be fully
;;; compiled, not byte compiled. I'm not sure that's reasonable:
;;; there's a lot of code in this file, and considering the overall
(in-package "SB!VM")
-(file-comment
- "$Header$")
-
;;; We can load/store into fp registers through the top of
;;; stack %st(0) (fr0 here). Loads imply a push to an empty register
;;; which then changes all the reg numbers. These macros help manage that.
(in-package "SB!VM")
-(file-comment
- "$Header$")
-
-;;; Cell-Ref and Cell-Set are used to define VOPs like CAR, where the
+;;; CELL-REF and CELL-SET are used to define VOPs like CAR, where the
;;; offset to be read or written is a property of the VOP used.
-;;; Cell-Setf is similar to Cell-Set, but delivers the new value as
-;;; the result. Cell-Setf-Function takes its arguments as if it were a
-;;; setf function (new value first, as apposed to a setf macro, which
+;;; CELL-SETF is similar to CELL-SET, but delivers the new value as
+;;; the result. CELL-SETF-FUNCTION takes its arguments as if it were a
+;;; SETF function (new value first, as apposed to a SETF macro, which
;;; takes the new value last).
(define-vop (cell-ref)
(:args (object :scs (descriptor-reg)))
(storew value object offset lowtag)
(move result value)))
-;;; Define accessor VOPs for some cells in an object. If the operation name
-;;; is NIL, then that operation isn't defined. If the translate function is
-;;; null, then we don't define a translation.
+;;; Define accessor VOPs for some cells in an object. If the operation
+;;; name is NIL, then that operation isn't defined. If the translate
+;;; function is null, then we don't define a translation.
(defmacro define-cell-accessors (offset lowtag
ref-op ref-trans set-op set-trans)
`(progn
:disp (- (* offset word-bytes) lowtag))
value)))
-;;; Slot-Ref and Slot-Set are used to define VOPs like Closure-Ref, where the
-;;; offset is constant at compile time, but varies for different uses.
+;;; SLOT-REF and SLOT-SET are used to define VOPs like CLOSURE-REF,
+;;; where the offset is constant at compile time, but varies for
+;;; different uses.
(define-vop (slot-ref)
(:args (object :scs (descriptor-reg)))
(:results (value :scs (descriptor-reg any-reg)))
(in-package "SB!VM")
-(file-comment
- "$Header$")
-
(define-move-function (load-immediate 1) (vop x y)
((immediate)
(any-reg descriptor-reg))
(in-package "SB!VM")
-(file-comment
- "$Header$")
-
;;; Make an environment-live stack TN for saving the SP for NLX entry.
(def-vm-support-routine make-nlx-sp-tn (env)
(environment-live-tn
(in-package "SB!VM")
-(file-comment
- "$Header$")
-
;;; ### Note: we simultaneously use ``word'' to mean a 32 bit quantity
;;; and a 16 bit quantity depending on context. This is because Intel
;;; insists on calling 16 bit things words and 32 bit things
;;;; files for more information.
(in-package "SB!VM")
-
-(file-comment
- "$Header$")
\f
;;;; the branch VOP
;;;; files for more information.
(in-package "SB!VM")
-
-(file-comment
- "$Header$")
\f
;;;; moves and coercions
(in-package "SB!VM")
-(file-comment
- "$Header$")
-
;;; FIXME: should probably become conditional on #!+SB-SHOW
;;; FIXME: should be called DEBUG-PRINT or COLD-PRINT
(define-vop (print)
(in-package "SB!VM")
-(file-comment
- "$Header$")
-
(define-vop (static-function-template)
(:save-p t)
(:policy :safe)
;;;; files for more information.
(in-package "SB!VM")
-
-(file-comment
- "$Header$")
\f
;;;; LENGTH
;;;; files for more information.
(in-package "SB!VM")
-
-(file-comment
- "$Header$")
\f
;;;; type frobbing VOPs
(in-package "SB!VM")
-(file-comment
- "$Header$")
-
(defun print-mem-access (value stream print-size-p dstate)
(declare (type list value)
(type stream stream)
;;;; files for more information.
(in-package "SB!VM")
-
-(file-comment
- "$Header$")
\f
;;;; test generation utilities
(in-package "SB!VM")
-(file-comment
- "$Header$")
-
(define-vop (reset-stack-pointer)
(:args (ptr :scs (any-reg)))
(:generator 1
(in-package "SB!VM")
-(file-comment
- "$Header$")
-
;;; the size of an INTEGER representation of a SYSTEM-AREA-POINTER, i.e.
;;; size of a native memory address
(deftype sap-int-type () '(unsigned-byte 32))
;;;; specification.
(in-package "SB-PCL")
-
-(sb-int:file-comment
- "$Header$")
\f
#|
;;;; specification.
(in-package "SB-PCL")
-
-(sb-int:file-comment
- "$Header$")
\f
(defun allocate-standard-instance (wrapper
&optional (slots-init nil slots-init-p))
;;;; specification.
(in-package "SB-PCL")
-
-(sb-int:file-comment
- "$Header$")
\f
;;; FIXME: SB-PCL should probably USE-PACKAGE SB-KERNEL, since SB-PCL is built
;;; on SB-KERNEL, and in the absence of USE-PACKAGE, it ends up using a
;;;; specification.
(in-package "SB-PCL")
-
-(sb-int:file-comment
- "$Header$")
\f
(defun get-method-function (method &optional method-alist wrappers)
(let ((fn (cadr (assoc method method-alist))))
;;;; specification.
(in-package "SB-PCL")
-
-(sb-int:file-comment
- "$Header$")
\f
;;; defconstructor is used to define special purpose functions which just
;;; call make-instance with a symbol as the first argument. The semantics
;;;; specification.
(in-package "SB-PCL")
-
-(sb-int:file-comment
- "$Header$")
\f
;;; compute-class-precedence-list
;;;
;;;; specification.
(in-package "SB-PCL")
-
-(sb-int:file-comment
- "$Header$")
\f
;;; The built-in method combination types as taken from page 1-31 of 88-002R.
;;; Note that the STANDARD method combination type is defined by hand in the
;;;; specification.
(in-package "SB-PCL")
-
-(sb-int:file-comment
- "$Header$")
\f
;;; MAKE-TOP-LEVEL-FORM is used by all PCL macros that appear `at top-level'.
;;;
;;;; specification.
(in-package "SB-PCL")
-
-(sb-int:file-comment
- "$Header$")
\f
(defmacro define-method-combination (&whole form &rest args)
(declare (ignore args))
;;;; specification.
(in-package "SB-PCL")
-
-(sb-int:file-comment
- "$Header$")
\f
(eval-when (:compile-toplevel :load-toplevel :execute)
(in-package "SB-PCL")
-(sb-int:file-comment
- "$Header$")
-
(defmethod slots-to-inspect ((class slot-class) (object slot-object))
(class-slots class))
;;;; specification.
(in-package "SB-PCL")
-
-(sb-int:file-comment
- "$Header$")
\f
#|
;;;; specification.
(in-package "SB-PCL")
-
-(sb-int:file-comment
- "$Header$")
\f
;;; This file is (almost) functionally equivalent to dlap.lisp, but easier to
;;; read.
;;;; specification.
(in-package "SB-PCL")
-
-(sb-int:file-comment
- "$Header$")
\f
(defun emit-reader/writer-function (reader/writer 1-or-2-class class-slot-p)
(values
;;;; specification.
(in-package "SB-PCL")
-
-(sb-int:file-comment
- "$Header$")
\f
(eval-when (:compile-toplevel :load-toplevel :execute)
(defparameter *checking-or-caching-list*
;;;; This software is in the public domain and is provided with absolutely no
;;;; warranty. See the COPYING and CREDITS files for more information.
-(sb-int:file-comment
- "$Header$")
-
(in-package "SB-PCL")
;;; Note some cases are handled by the documentation methods in
;;;; warranty about the software, its performance or its conformity to any
;;;; specification.
-(sb-int:file-comment
- "$Header$")
-
(in-package "SB-PCL")
\f
;;; FIXME: The PCL package is internal and is used by code in potential
;;;; specification.
(in-package "SB-PCL")
-
-(sb-int:file-comment
- "$Header$")
\f
;;; FIXME: This stuff isn't part of the ANSI spec, and isn't even
;;; exported from PCL, but it looks as though it might be useful,
;;;; specification.
(in-package "SB-PCL")
-
-(sb-int:file-comment
- "$Header$")
\f
(defvar *compile-make-instance-functions-p* nil)
;;;; specification.
(in-package "SB-PCL")
-
-(sb-int:file-comment
- "$Header$")
\f
;;; Each implementation must provide the following functions and macros:
;;;
(in-package "SB-PCL")
-(sb-int:file-comment
- "$Header$")
-
(fix-early-generic-functions)
(setq *boot-state* 'complete)
;;;; specification.
(in-package "SB-PCL")
-
-(sb-int:file-comment
- "$Header$")
\f
;;; GET-FUNCTION is the main user interface to this code. It is like
;;; COMPILE-LAMBDA, only more efficient. It achieves this efficiency by
;;;; specification.
(in-package "SB-PCL")
-
-(sb-int:file-comment
- "$Header$")
\f
(defmethod wrapper-fetcher ((class funcallable-standard-class))
'fsc-instance-wrapper)
;;;; warranty. See the COPYING and CREDITS files for more information.
(in-package "SB-PCL")
-
-(sb-int:file-comment
- "$Header$")
\f
;;;; class predicates
;;;; warranty. See the COPYING and CREDITS files for more information.
(in-package "SB-GRAY")
-
-(sb-int:file-comment
- "$Header$")
\f
;;; Bootstrap the FUNDAMENTAL-STREAM class.
(let ((sb-pcl::*pcl-class-boot* 'fundamental-stream))
;;;; warranty. See the COPYING and CREDITS files for more information.
(in-package "SB-GRAY")
-
-(sb-int:file-comment
- "$Header$")
\f
(fmakunbound 'stream-element-type)
;;;; specification.
(in-package "SB-PCL")
-
-(sb-int:file-comment
- "$Header$")
\f
(defmethod make-instance ((class symbol) &rest initargs)
(apply #'make-instance (find-class class) initargs))
;;;; specification.
(in-package "SB-ITERATE")
-
-(sb-int:file-comment
- "$Header$")
\f
;;; Are warnings to be issued for iterate/gather forms that aren't optimized?
;;; NIL => never
;;;; specification.
(in-package "SB-PCL")
-
-(sb-int:file-comment
- "$Header$")
\f
(eval-when (:compile-toplevel :load-toplevel :execute)
(defvar *optimize-speed* '(optimize (speed 3) (safety 0)))
\f
(in-package "SB-PCL")
-(sb-int:file-comment
- "$Header$")
-
(declaim (declaration
;; FIXME: Since none of these are supported in SBCL, the
;; declarations using them are just noise now that this is
;;;; specification.
(in-package "SB-PCL")
-
-(sb-int:file-comment
- "$Header$")
\f
(defmethod shared-initialize :after ((slotd standard-slot-definition)
slot-names &key)
;;;; specification.
(in-package "SB-PCL")
-
-(sb-int:file-comment
- "$Header$")
\f
;;; Pre-allocate generic function caches. The hope is that this will put
;;; them nicely together in memory, and that that may be a win. Of course
(in-package "SB-PCL")
-(sb-int:file-comment
- "$Header$")
-
(precompile-random-code-segments pcl)
;;;; warranty about the software, its performance or its conformity to any
;;;; specification.
-(sb-int:file-comment
- "$Header$")
-
(in-package "SB-PCL")
\f
;;;; the PRINT-OBJECT generic function
;;;; specification.
(in-package "SB-PCL")
-
-(sb-int:file-comment
- "$Header$")
\f
(defmacro slot-symbol (slot-name type)
`(if (and (symbolp ,slot-name) (symbol-package ,slot-name))
;;;; specification.
(in-package "SB-PCL")
-
-(sb-int:file-comment
- "$Header$")
\f
;;;; ANSI CL condition for unbound slots
;;;; warranty about the software, its performance or its conformity to any
;;;; specification.
-(sb-int:file-comment
- "$Header$")
-
(in-package "SB-PCL")
\f
(defmethod slot-accessor-function ((slotd effective-slot-definition) type)
;;;; warranty about the software, its performance or its conformity to any
;;;; specification.
-(sb-int:file-comment
- "$Header$")
-
(in-package "SB-PCL")
\f
(defmethod initialize-internal-slot-functions :after
(in-package "SB-PCL")
-(sb-int:file-comment
- "$Header$")
-
(declaim (optimize (speed 3) (safety 0) (compilation-speed 0)))
(defvar *tests*)
;;;; specification.
(in-package "SB-PCL")
-
-(sb-int:file-comment
- "$Header$")
\f
(defmacro instance-slot-index (wrapper slot-name)
`(let ((pos 0))
;;;; specification.
(in-package "SB-WALKER")
-
-(sb-int:file-comment
- "$Header$")
\f
;;;; environment frobbing stuff
* files for more information.
*/
-/*
- * $Header$
- */
-
#include "runtime.h"
#include "sbcl.h"
#include "alloc.h"
* files for more information.
*/
-/*
- * $Header$
- */
-
#ifndef _ALLOC_H_
#define _ALLOC_H_
* files for more information.
*/
-/*
- * $Header$
- */
-
#ifndef __ARCH_H__
#define __ARCH_H__
* files for more information.
*/
-/*
- * $Header$
- */
-
#include <stdio.h>
#include <signal.h>
#include "runtime.h"
* files for more information.
*/
-/*
- * $Header$
- */
-
#include <stdio.h>
#include <signal.h>
* files for more information.
*/
-/*
- * $Header$
- */
-
#ifndef _BREAKPOINT_H_
#define _BREAKPOINT_H_
* files for more information.
*/
-/*
- * $Header$
- */
-
#include <stdio.h>
#include <sys/param.h>
#include <sys/file.h>
* files for more information.
*/
-/*
- * $Header$
- */
-
#ifdef __FreeBSD__
#include <osreldate.h>
#endif
* files for more information.
*/
-/*
- * $Header$
- */
-
#ifndef _CORE_H_
#define _CORE_H_
* files for more information.
*/
-/*
- * $Header$
- */
-
#include <stdio.h>
#include <sys/types.h>
#include <sys/file.h>
* files for more information.
*/
-/*
- * $Header$
- */
-
#include "runtime.h"
#include "sbcl.h"
#include "globals.h"
* files for more information.
*/
-/*
- * $Header$
- */
-
#ifndef _DYNBIND_H_
#define _DYNBIND_H_
* files for more information.
*/
-/*
- * $Header$
- */
-
#ifndef _GC_H_
#define _GC_H_
*/
/*
- * $Header$
- */
-
-/*
* For a review of garbage collection techniques (e.g. generational
* GC) and terminology (e.g. "scavenging") see Paul R. Wilson,
* "Uniprocessor Garbage Collection Techniques". As of 20000618, this
* files for more information.
*/
-/*
- * $Header$
- */
-
#ifndef _GENCGC_H_
#define _GENCGC_H_
* files for more information.
*/
-/*
- * $Header$
- */
-
#include <stdio.h>
#include "runtime.h"
* files for more information.
*/
-/*
- * $Header$
- */
-
#if !defined(_INCLUDE_GLOBALS_H_)
#define _INCLUDED_GLOBALS_H_
* files for more information.
*/
-/*
- * $Header$
- */
-
#include <stdio.h>
#include <stdarg.h>
* files for more information.
*/
-/*
- * $Header$
- */
-
#ifndef _INTERR_H_
#define _INTERR_H_
* files for more information.
*/
-/*
- * $Header$
- */
-
#include <stdio.h>
#include <signal.h>
* files for more information.
*/
-/*
- * $Header$
- */
-
#if !defined(_INCLUDE_INTERRUPT_H_)
#define _INCLUDE_INTERRUPT_H_
* files for more information.
*/
-/*
- * $Header$
- */
-
#include <stdio.h>
#include <sys/param.h>
#include <sys/file.h>
* files for more information.
*/
-/*
- * $Header$
- */
-
#include <stdlib.h>
#include <sys/types.h>
#include <sys/mman.h>
*
* These are needed because the locations of the
* libraries are filled in by ld.so at runtime.
- *
- * $Header$
*/
/*
* files for more information.
*/
-/*
- * $Header$
- */
-
#if defined(mips) || defined(irix)
#include "mips-lispregs.h"
#endif
* files for more information.
*/
-/*
- * $Header$
- */
-
#include <stdio.h>
#include <sys/types.h>
#include <stdlib.h>
* files for more information.
*/
-/*
- * $Header$
- */
-
extern void ldb_monitor(void);
extern void throw_to_monitor(void);
* files for more information.
*/
-/*
- * $Header$
- */
-
#include <stdio.h>
#include <errno.h>
* files for more information.
*/
-/*
- * $Header$
- */
-
#if !defined(_OS_H_INCLUDED_)
#define _OS_H_INCLUDED_
* files for more information.
*/
-/*
- * $Header$
- */
-
#include <stdio.h>
#include <ctype.h>
#include <signal.h>
* files for more information.
*/
-/*
- * $Header$
- */
-
/* All parse routines take a char ** as their only argument */
extern boolean more_p(char **ptr);
extern char *parse_token(char **ptr);
*/
/*
- * $Header$
- */
-
-/*
* FIXME:
* 1. Ordinary users won't get much out of this code, so it shouldn't
* be compiled into the ordinary build of the system. Probably it
* files for more information.
*/
-/*
- * $Header$
- */
-
#ifndef _PRINT_H_
#define _PRINT_H_
* files for more information.
*/
-/*
- * $Header$
- */
-
#include <stdio.h>
#include <sys/types.h>
#include <stdlib.h>
* files for more information.
*/
-/*
- * $Header$
- */
-
#if !defined(_PURIFY_H_)
#define _PURIFY_H_
* files for more information.
*/
-/*
- * $Header$
- */
-
#include "lispregs.h"
char *lisp_register_names[] = { REGNAMES, 0 };
* files for more information.
*/
-/*
- * $Header$
- */
-
#include <sys/file.h>
#include <sys/fcntl.h>
#include <sys/ioctl.h>
* files for more information.
*/
-/*
- * $Header$
- */
-
#include <stdio.h>
#include <sys/types.h>
#include <stdlib.h>
* files for more information.
*/
-/*
- * $Header$
- */
-
/* FIXME: Aren't symbols with underscore prefixes supposed to be
* reserved for system libraries? Perhaps rename stuff like this
* to names like INCLUDED_SBCL_RUNTIME_H. */
* files for more information.
*/
-/*
- * $Header$
- */
-
#include <stdio.h>
#include <signal.h>
#include <sys/file.h>
* files for more information.
*/
-/*
- * $Header$
- */
-
#ifndef _SAVE_H_
#define _SAVE_H_
* files for more information.
*/
-/*
- * $Header$
- */
-
#include "runtime.h"
#include "sbcl.h"
#include "os.h"
* files for more information.
*/
-/*
- * $Header$
- */
-
#ifndef _SEARCH_H_
#define _SEARCH_H_
* files for more information.
*/
-/*
- * $Header$
- */
-
#include <stdio.h>
#include <time.h>
#include "runtime.h"
* files for more information.
*/
-/*
- * $Header$
- */
-
#ifdef sun
#ifndef MACH
#if !defined(SUNOS) && !defined(SOLARIS)
* files for more information.
*/
-/*
- * $Header$
- */
-
/* Pick up all the syscalls. */
F(accept)
F(access)
* files for more information.
*/
-/*
- * $Header$
- */
-
#include <stdio.h>
#include "runtime.h"
#include "os.h"
* files for more information.
*/
-/*
- * $Header$
- */
-
#if !defined(_INCLUDE_VALIDATE_H_)
#define _INCLUDE_VALIDATE_H_
* files for more information.
*/
-/*
- * $Header$
- */
-
#include <stdio.h>
#include <sys/types.h>
#include <stdlib.h>
* files for more information.
*/
-/*
- * $Header$
- */
-
/* FIXME: I wonder what this stuff is for. A comment or two would be
* nice.. */
* files for more information.
*/
-/*
- * $Header$
- */
-
#include <stdio.h>
#include "runtime.h"
/*
* very-low-level utilities for runtime support
- *
- * $Header$
*/
/*
* files for more information.
*/
-/*
- * $Header$
- */
-
/* the number of registers visible as registers in the virtual machine
* (excludes stuff like segment registers) */
#define NREGS (8)
* files for more information.
*/
-/*
- * $Header$
- */
-
#define BINDING_STACK_SIZE ( BINDING_STACK_END - BINDING_STACK_START)
#define CONTROL_STACK_SIZE ( CONTROL_STACK_END - CONTROL_STACK_START)
#define DYNAMIC_SPACE_SIZE ( DYNAMIC_SPACE_END - DYNAMIC_SPACE_START)
;;; versions, and a string a la "0.6.5.12" is used for versions which
;;; aren't released but correspond only to CVS tags or snapshots.
-"0.6.7.21"
+"0.6.7.22"
projects / sbcl.git / commitdiff