X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fgeneric%2Fgenesis.lisp;h=582bb3dc26bca1d9e664bdbb27c4fa39f7649a11;hb=993d5b779638756473181dda8d928d33038d4cc3;hp=89c51d826f4edc81e4f45d7361ec4fdd05e7bec8;hpb=cea4896b2482b7b2b429c1631d774b4cfbc0efba;p=sbcl.git

diff --git a/src/compiler/generic/genesis.lisp b/src/compiler/generic/genesis.lisp
index 89c51d8..582bb3d 100644
--- a/src/compiler/generic/genesis.lisp
+++ b/src/compiler/generic/genesis.lisp
@@ -6,13 +6,20 @@
 ;;;; As explained by Rob MacLachlan on the CMU CL mailing list Wed, 06
 ;;;; Jan 1999 11:05:02 -0500, this cold load generator more or less
 ;;;; fakes up static function linking. I.e. it makes sure that all the
-;;;; functions in the fasl files it reads are bound to the
+;;;; DEFUN-defined functions in the fasl files it reads are bound to the
 ;;;; corresponding symbols before execution starts. It doesn't do
 ;;;; anything to initialize variable values; instead it just arranges
 ;;;; for !COLD-INIT to be called at cold load time. !COLD-INIT is
 ;;;; responsible for explicitly initializing anything which has to be
 ;;;; initialized early before it transfers control to the ordinary
 ;;;; top-level forms.
+;;;;
+;;;; (In CMU CL, and in SBCL as of 0.6.9 anyway, functions not defined
+;;;; by DEFUN aren't set up specially by GENESIS. In particular,
+;;;; structure slot accessors are not set up. Slot accessors are
+;;;; available at cold init time because they're usually compiled
+;;;; inline. They're not available as out-of-line functions until the
+;;;; toplevel forms installing them have run.)
 
 ;;;; This software is part of the SBCL system. See the README file for
 ;;;; more information.
@@ -44,7 +51,9 @@
 ;;;
 ;;; 0: inherited from CMU CL
 ;;; 1: rearranged static symbols for sbcl-0.6.8
-(defconstant sbcl-core-version-integer 1)
+;;; 2: eliminated non-ANSI %DEFCONSTANT/%%DEFCONSTANT support,
+;;;    deleted a slot from DEBUG-SOURCE structure
+(defconstant sbcl-core-version-integer 2)
 
 (defun round-up (number size)
   #!+sb-doc
@@ -62,12 +71,11 @@
 (defvar *read-only*)
 (defconstant read-only-space-id 3)
 
-(eval-when (:compile-toplevel :execute :load-toplevel)
-  (defconstant descriptor-low-bits 16
-    "the number of bits in the low half of the descriptor")
-  (defconstant target-space-alignment (ash 1 descriptor-low-bits)
-    "the alignment requirement for spaces in the target.
-  Must be at least (ASH 1 DESCRIPTOR-LOW-BITS)"))
+(defconstant descriptor-low-bits 16
+  "the number of bits in the low half of the descriptor")
+(defconstant target-space-alignment (ash 1 descriptor-low-bits)
+  "the alignment requirement for spaces in the target.
+  Must be at least (ASH 1 DESCRIPTOR-LOW-BITS)")
 
 ;;; a GENESIS-time representation of a memory space (e.g. read-only space,
 ;;; dynamic space, or static space)
@@ -1740,16 +1748,17 @@
 
 (defvar *normal-fop-functions*)
 
-;;; This is like DEFINE-FOP which defines fops for warm load, but unlike
-;;; DEFINE-FOP, this version
-;;;   (1) looks up the code for this name (created by a previous DEFINE-FOP)
-;;;       instead of creating a code, and
-;;;   (2) stores its definition in the *COLD-FOP-FUNCTIONS* vector, instead
-;;;       of storing in the *FOP-FUNCTIONS* vector.
+;;; Cause a fop to have a special definition for cold load.
+;;; 
+;;; This is similar to DEFINE-FOP, but unlike DEFINE-FOP, this version
+;;;   (1) looks up the code for this name (created by a previous
+;;        DEFINE-FOP) instead of creating a code, and
+;;;   (2) stores its definition in the *COLD-FOP-FUNCTIONS* vector,
+;;;       instead of storing in the *FOP-FUNCTIONS* vector.
 (defmacro define-cold-fop ((name &optional (pushp t)) &rest forms)
   (check-type pushp (member nil t :nope))
   (let ((code (get name 'fop-code))
-	(fname (concat-pnames 'cold- name)))
+	(fname (symbolicate "COLD-" name)))
     (unless code
       (error "~S is not a defined FOP." name))
     `(progn
@@ -1772,8 +1781,9 @@
   `(define-cold-fop (,name)
      (error "The fop ~S is not supported in cold load." ',name)))
 
-;;; COLD-LOAD loads stuff into the core image being built by calling FASLOAD
-;;; with the fop function table rebound to a table of cold loading functions.
+;;; COLD-LOAD loads stuff into the core image being built by calling
+;;; FASLOAD with the fop function table rebound to a table of cold
+;;; loading functions.
 (defun cold-load (filename)
   #!+sb-doc
   "Load the file named by FILENAME into the cold load image being built."