0.pre8.106:

	doc tweaking
	refactoring in preparation for checking *FEATURES* compatibility
		in fasl load

diff --git a/doc/sbcl.1 b/doc/sbcl.1
index 98204ae..9211aac 100644 (file)
--- a/doc/sbcl.1
+++ b/doc/sbcl.1
@@ -466,15 +466,6 @@ result as a function value) is a fundamentally slow operation.
 
 There are still some nagging pre-ANSIisms, notably
 .TP 3
-\--
-CLOS (based on the PCL reference implementation) is incompletely
-integrated into the system, so that e.g. SB-PCL::FIND-CLASS is a
-different function than CL::FIND-CLASS. (In practice, you need to
-be a pretty advanced user before this is a serious problem, and
-by then you can usually work around it, but it's still distasteful.
-It's arguably the outstanding "This should be fixed by version 1.0"
-issue.)
-.TP 3
 --
 The ANSI-recommended idiom for creating a function which is only
 sometimes expanded inline,

diff --git a/src/code/debug.lisp b/src/code/debug.lisp
index 927ba88..cf7f9db 100644 (file)
--- a/src/code/debug.lisp
+++ b/src/code/debug.lisp
@@ -792,7 +792,8 @@ reset to ~S."
                 "~&(no restarts: If you didn't do this on purpose, ~
                   please report it as a bug.)~%"))
        (t
-        (format s "~&restarts:~%")
+        (format s "~&restarts (invokable by number or by ~
+                    possibly-abbreviated name):~%")
         (let ((count 0)
               (names-used '(nil))
               (max-name-len 0))

diff --git a/src/code/load.lisp b/src/code/load.lisp
index 1b552ae..f7f7ca9 100644 (file)
--- a/src/code/load.lisp
+++ b/src/code/load.lisp
@@ -222,7 +222,7 @@
   (let ((byte (read-byte stream nil)))
     (when byte
 
-      ;; Read the string part of the fasl header, or die.
+      ;; Read and validate constant string prefix in fasl header.
       (let* ((fhsss *fasl-header-string-start-string*)
             (fhsss-length (length fhsss)))
        (unless (= byte (char-code (schar fhsss 0)))
@@ -237,33 +237,40 @@
            (error
             "illegal subsequent (not first) byte in fasl file header"))))
 
-      ;; Read and validate implementation and version, or die.
-      (let* ((implementation-length (read-arg 4))
-            (implementation-string (make-string implementation-length))
-            (ignore (read-string-as-bytes stream implementation-string))
-            (implementation (keywordicate implementation-string))
-            ;; FIXME: The logic above to read a keyword from the fasl file
-            ;; could probably be shared with the read-a-keyword fop.
-            (version (read-arg 4)))
-       (declare (ignore ignore))
-       (flet ((check-version (variant possible-implementation needed-version)
-                (when (string= possible-implementation implementation)
-                  (unless (= version needed-version)
-                    (error "~@<~S is in ~A fasl file format version ~W, ~
-                             but this version of SBCL uses ~
-                             format version ~W.~:@>"
-                           stream
-                           variant
-                           version
-                           needed-version))
-                  t)))
-         (or (check-version "native code"
-                            +backend-fasl-file-implementation+
-                            +fasl-file-version+)
-             (error "~S was compiled for implementation ~A, but this is a ~A."
-                    stream
-                    implementation
-                    +backend-fasl-file-implementation+)))))))
+      ;; Read and validate version-specific compatibility stuff.
+      (flet ((string-from-stream ()
+               (let* ((length (read-arg 4))
+                     (result (make-string length)))
+                (read-string-as-bytes stream result)
+                result)))
+       ;; Read and validate implementation and version.
+       (let* ((implementation (keywordicate (string-from-stream)))
+              ;; FIXME: The logic above to read a keyword from the fasl file
+              ;; could probably be shared with the read-a-keyword fop.
+              (version (read-arg 4)))
+         (flet ((check-version (variant
+                                possible-implementation
+                                needed-version)
+                  (when (string= possible-implementation implementation)
+                    (or (= version needed-version)
+                        (error "~@<~S is in ~A fasl file format version ~W, ~
+                                 but this version of SBCL uses ~
+                                 format version ~W.~:@>"
+                               stream
+                               variant
+                               version
+                               needed-version)))))
+           (or (check-version "native code"
+                              +backend-fasl-file-implementation+
+                              +fasl-file-version+)
+               (error "~S was compiled for implementation ~A, ~
+                        but this is a ~A."
+                      stream
+                      implementation
+                      +backend-fasl-file-implementation+))))
+       ;; TO DO: Check for *FEATURES* which affect binary compatibility.
+       ;; (And don't forget to return T.:-)
+       ))))
 
 ;; Setting this variable gives you a trace of fops as they are loaded and
 ;; executed.

diff --git a/version.lisp-expr b/version.lisp-expr
index b5476c8..4964c2a 100644 (file)
--- a/version.lisp-expr
+++ b/version.lisp-expr
@@ -17,4 +17,4 @@
 ;;; checkins which aren't released. (And occasionally for internal
 ;;; versions, especially for internal versions off the main CVS
 ;;; branch, it gets hairier, e.g. "0.pre7.14.flaky4.13".)
-"0.pre8.105"
+"0.pre8.106"