0.6.11.32:

	MNA patches from sbcl-devel..
	..package cleanup (2001-03-29)
	..bug 94 compiler type mismatch nondetection fix (2001-03-30)
	(started trying to fix bug 87, following MNA 2001-04-04 patch,
		but fix doesn't work yet)
	renamed TYPES-INTERSECT and VALUES-TYPES-INTERSECT to
		TYPES-EQUAL-OR-INTERSECT and
		VALUES-TYPES-EQUAL-OR-INTERSECT
	removed redundant quotes from self-evaluating constants
	build-under-CMU-CL fixes from Christophe sbcl-devel 2001-04-05
	added CMU CL 18c workaround in cross-float.lisp

BUGS

@@ -811,13 +811,6 @@ Error in function C::GET-LAMBDA-TO-COMPILE:
   (I haven't tried to investigate this bug enough to guess whether
   there might be any user-level symptoms.)
 
-87:
-  Despite what the manual says, (DECLAIM (SPEED 0)) doesn't cause
-  things to be byte compiled. This seems to be true in cmucl-2.4.19,
-  too: (COMPILE-FILE .. :BYTE-COMPILE T) causes byte-compilation,
-  but ordinary COMPILE-FILE of a file containing (DECLAIM (SPEED 0))
-  does not.
-
 90: 
   a latent cross-compilation/bootstrapping bug: The cross-compilation
   host's CL:CHAR-CODE-LIMIT is used in target code in readtable.lisp
@@ -857,15 +850,33 @@ Error in function C::GET-LAMBDA-TO-COMPILE:
       (:LINUX :X86 :IEEE-FLOATING-POINT :SB-CONSTRAIN-FLOAT-TYPE :SB-TEST
        :SB-INTERPRETER :SB-DOC :UNIX ...) is not of type SYMBOL.
 
-94: 
-  As reported by Christophe Rhodes on sbcl-devel 2001-03-28, the
-  old declaration 
-   (declaim (ftype (function (list list symbol t) list) parse-deftransform))
-  above DEFUN PARSE-DEFTRANSFORM was incorrect. The bad declaration was
-  removed in sbcl-0.6.11.28, but the compiler problem remains: the compiler
-  should've complained about the mismatch between the declaration and the
-  definition, and didn't. (The compiler in cmucl-2.5.1 does detect the 
-  problem and complain.)
+94a: 
+  Inconsistencies between derived and declared VALUES return types for
+  DEFUN aren't checked very well. E.g. the logic which successfully
+  catches problems like
+    (declaim (ftype (function (fixnum) float) foo))
+    (defun foo (x)
+      (declare (type integer x))
+      (values x)) ; wrong return type, detected, gives warning, good!
+  fails to catch
+    (declaim (ftype (function (t) (values t t)) bar))
+    (defun bar (x)
+      (values x)) ; wrong number of return values, no warning, bad!
+  The cause of this is seems to be that (1) the internal function 
+  VALUES-TYPES-EQUAL-OR-INTERSECT used to make the check handles its
+  arguments symmetrically, and (2) when the type checking code was
+  written back when when SBCL's code was still CMU CL, the intent
+  was that this case
+    (declaim (ftype (function (t) t) bar))
+    (defun bar (x)
+      (values x x)) ; wrong number of return values; should give warning?
+  not be warned for, because a two-valued return value is considered
+  to be compatible with callers who expects a single value to be
+  returned. That intent is probably not appropriate for modern ANSI
+  Common Lisp, but fixing this might be complicated because of other
+  divergences between auld-style and new-style handling of
+  multiple-VALUES types. (Some issues related to this were discussed
+  on cmucl-imp at some length sometime in 2000.)
 
 
 KNOWN BUGS RELATED TO THE IR1 INTERPRETER

package-data-list.lisp-expr

@@ -327,13 +327,6 @@
     :use ("CL" "SB!ALIEN" "SB!BIGNUM" "SB!C-CALL" "SB!DEBUG" "SB!EXT"
           "SB!GRAY" "SB!INT" "SB!KERNEL" "SB!SYS"))
 
- ;; FIXME: It seems to me that this could go away, with its contents moved
- ;; into SB!KERNEL, like the implementation of the rest of the class system.
-;; #s(sb-cold:package-data
-;;    :name "SB!CONDITIONS"
-;;    :doc "private: the implementation of the condition system"
-;;    :use ("CL" "SB!EXT" "SB!INT" "SB!KERNEL"))
-
  #s(sb-cold:package-data
     :name "SB!DEBUG"
     :doc
@@ -475,20 +468,14 @@ like *STACK-TOP-HINT*"
     :doc "public: miscellaneous supported extensions to the ANSI Lisp spec"
     ;; FIXME: Why don't we just USE-PACKAGE %KERNEL here instead of importing?
     :use ("CL" "SB!ALIEN" "SB!C-CALL" "SB!INT" "SB!SYS" "SB!GRAY")
-    ;; FIXME: If we advertise these as extensions, they should be in the
-    ;; SB!EXT package (and perhaps re-exported from the %KERNEL
-    ;; package) rather than in some other package and reexported from
-    ;; SB!EXT.
-    :import-from (("SB!KERNEL" "WEAK-POINTER-P"))
-    :reexport ("LOAD-FOREIGN" "LOAD-1-FOREIGN" "WEAK-POINTER-P")
+    :reexport ("LOAD-FOREIGN" "LOAD-1-FOREIGN")
     :export (;; Information about how the program was invoked is
              ;; nonstandard but very useful.
              "*POSIX-ARGV*" "POSIX-GETENV" "POSIX-ENVIRON"
 
              ;; People have various good reasons to mess with the GC.
              "*AFTER-GC-HOOKS*" "*BEFORE-GC-HOOKS*"
              "*GC-NOTIFY-AFTER*" "*GC-NOTIFY-BEFORE*" "*GC-NOTIFY-STREAM*"
-             "*GC-VERBOSE*"
              "BYTES-CONSED-BETWEEN-GCS"
              "GC" "GC-OFF" "GC-ON" "GET-BYTES-CONSED"
              "*GC-RUN-TIME*"
@@ -545,10 +532,10 @@ like *STACK-TOP-HINT*"
              "INTERACTIVE-EVAL"
 
              ;; weak pointers and finalization
-             "FINALIZE" "CANCEL-FINALIZATION"
-             ;; FIXME: "WEAK-POINTER-P" here once it moves from SB!KERNEL
+             "CANCEL-FINALIZATION"
+             "FINALIZE"             
              "HASH-TABLE-WEAK-P" "MAKE-WEAK-POINTER"
-             "WEAK-POINTER" "WEAK-POINTER-VALUE"
+             "WEAK-POINTER" "WEAK-POINTER-P" "WEAK-POINTER-VALUE"
 
              ;; If the user knows we're doing IEEE, he might reasonably
              ;; want to do this stuff.
@@ -844,7 +831,7 @@ is a good idea, but see SB-SYS for blurring of boundaries."
     :use ("CL" "SB!ALIEN" "SB!ALIEN-INTERNALS" "SB!BIGNUM"
           "SB!EXT" "SB!INT" "SB!SYS" "SB!GRAY")
     :import-from (("SB!C-CALL" "VOID"))
-    :reexport ("DEF!STRUCT" "DEF!MACRO" "VOID")
+    :reexport ("DEF!STRUCT" "DEF!MACRO" "VOID" "WEAK-POINTER-P")
     :export ("%ACOS" "%ACOSH" "%ARRAY-AVAILABLE-ELEMENTS"
              "%ARRAY-DATA-VECTOR" "%ARRAY-DIMENSION"
              "%ARRAY-DISPLACED-P"
@@ -1124,9 +1111,9 @@ is a good idea, but see SB-SYS for blurring of boundaries."
              "TYPE-DIFFERENCE" "TYPE-EXPAND"
              "TYPE-INTERSECTION" "TYPE-INTERSECTION2"
              "TYPE-APPROX-INTERSECTION2"
-             "TYPE-SPECIFIER"
-             "TYPE-UNION" "TYPE/=" "TYPE="
-             "TYPES-INTERSECT" "UNBOUND-SYMBOL-ERROR" "UNBOXED-ARRAY"
+             "TYPE-SPECIFIER" "TYPE-UNION" "TYPE/=" "TYPE="
+             "TYPES-EQUAL-OR-INTERSECT"
+             "UNBOUND-SYMBOL-ERROR" "UNBOXED-ARRAY"
              "UNDEFINED-SYMBOL-ERROR" "UNION-TYPE" "UNION-TYPE-P"
              "UNION-TYPE-TYPES" "UNKNOWN-ERROR"
              "UNKNOWN-KEY-ARGUMENT-ERROR"
@@ -1139,7 +1126,7 @@ is a good idea, but see SB-SYS for blurring of boundaries."
              "VALUES-TYPE-KEYWORDS" "VALUES-TYPE-OPTIONAL"
              "VALUES-TYPE-P" "VALUES-TYPE-REQUIRED"
              "VALUES-TYPE-REST" "VALUES-TYPE-UNION"
-             "VALUES-TYPES" "VALUES-TYPES-INTERSECT" "VECTOR-T-P"
+             "VALUES-TYPES" "VALUES-TYPES-EQUAL-OR-INTERSECT" "VECTOR-T-P"
              "VECTOR-TO-VECTOR*" "VECTOR-TO-SIMPLE-STRING*"
              "VECTOR-TO-BIT-VECTOR*" "VECTOR-TO-SIMPLE-BIT-VECTOR*"
              "VECTOR-OF-CHECKED-LENGTH-GIVEN-LENGTH"
@@ -1165,7 +1152,7 @@ is a good idea, but see SB-SYS for blurring of boundaries."
              "DEFSTRUCT-DESCRIPTION" "UNDEFINE-STRUCTURE"
              "DD-COPIER" "UNDEFINE-FUNCTION-NAME" "DD-TYPE"
              "CLASS-STATE" "INSTANCE"
-             "*TYPE-SYSTEM-INITIALIZED*" "WEAK-POINTER-P" "FIND-LAYOUT"
+             "*TYPE-SYSTEM-INITIALIZED*" "FIND-LAYOUT"
              "DSD-NAME" "%TYPEP" "DD-RAW-INDEX"
              "DD-NAME" "CLASS-SUBCLASSES"
              "CLASS-LAYOUT" "CLASS-%NAME"

src/code/backq.lisp

@@ -133,7 +133,7 @@
   (cond ((atom code)
 	 (cond ((null code)
 		(values nil nil))
-	       ((or (numberp code) (eq code 't))
+	       ((or (numberp code) (eq code t))
 		(values t code))
 	       (t (values *bq-comma-flag* code))))
 	((eq (car code) 'quote)

src/code/byte-interp.lisp

@@ -27,19 +27,19 @@
    (etypecase x
      (simple-byte-function
       `(function ,(make-list (simple-byte-function-num-args x)
-			     :initial-element 't)
+			     :initial-element t)
 		 *))
      (hairy-byte-function
       (collect ((res))
 	(let ((min (hairy-byte-function-min-args x))
 	      (max (hairy-byte-function-max-args x)))
-	  (dotimes (i min) (res 't))
+	  (dotimes (i min) (res t))
 	  (when (> max min)
 	    (res '&optional)
 	    (dotimes (i (- max min))
-	      (res 't))))
+	      (res t))))
 	(when (hairy-byte-function-rest-arg-p x)
-	  (res '&rest 't))
+	  (res '&rest t))
 	(ecase (hairy-byte-function-keywords-p x)
 	  ((t :allow-others)
 	   (res '&key)

src/code/class.lisp

@@ -1092,15 +1092,15 @@
 				     '(t))))
 	x
       (declare (ignore codes state translation))
-      (let ((inherits-list (if (eq name 't)
-			     ()
-			     (cons 't (reverse inherits))))
+      (let ((inherits-list (if (eq name t)
+			       ()
+			       (cons t (reverse inherits))))
 	    (class (make-built-in-class
 		    :enumerable enumerable
 		    :name name
 		    :translation (if trans-p :initializing nil)
 		    :direct-superclasses
-		    (if (eq name 't)
+		    (if (eq name t)
 		      nil
 		      (mapcar #'sb!xc:find-class direct-superclasses)))))
 	(setf (info :type :kind name) :primitive