0.6.12.14:

	fixes from Arthur Lemmens' 2001-05-05 sbcl-devel message I..
	..wrapped an EVAL-WHEN around the definition of +EMPTY-HT-SLOT+
	..removed irrelevant COUNT term in in LOOP form in
		compiler/x86/call.lisp
	..moved DEFCONDITION SIMPLE-TYPE-ERROR from error.lisp to
		late-target-error.lisp
	..moved DEFUN DO-PENDING-INTERRUPT from signal.lisp to
		target-signal.lisp, since its definition ("magically
		converted to a BREAK instruction") only makes sense
		to Python (and causes a warning in Lispworks)

diff --git a/BUGS b/BUGS
index e728c3e..10de5c0 100644 (file)
--- a/BUGS
+++ b/BUGS
@@ -940,6 +940,22 @@ Error in function C::GET-LAMBDA-TO-COMPILE:
     Structure for accessor FOO-X is not a FOO:
     301988783
 
+102:
+  As reported by Arthur Lemmens sbcl-devel 2001-05-05, ANSI
+  requires that SYMBOL-MACROLET refuse to rebind special variables,
+  but SBCL doesn't do this. (Also as reported by AL in the same
+  message, SBCL depended on this nonconforming behavior to build
+  itself, because of the way that **CURRENT-SEGMENT** was implemented.
+  As of sbcl-0.6.12.x, this dependence on the nonconforming behavior
+  has been fixed, but the nonconforming behavior remains.)
+
+103:
+  As reported by Arthur Lemmens sbcl-devel 2001-05-05, ANSI's
+  definition of (LOOP .. DO ..) requires that the terms following
+  DO all be compound forms. SBCL's implementation of LOOP allows
+  non-compound forms (like the bare symbol COUNT, in his example)
+  here.
+
 
 KNOWN BUGS RELATED TO THE IR1 INTERPRETER
 

diff --git a/src/code/error.lisp b/src/code/error.lisp
index 8197a27..cd7a39d 100644 (file)
--- a/src/code/error.lisp
+++ b/src/code/error.lisp
@@ -21,8 +21,6 @@
        :format-control format-control
        :format-arguments format-arguments))
 
-(define-condition simple-type-error (simple-condition type-error) ())
-
 (define-condition sb!kernel:layout-invalid (type-error)
   ()
   (:report

diff --git a/src/code/late-target-error.lisp b/src/code/late-target-error.lisp
index abd375f..1f470f4 100644 (file)
--- a/src/code/late-target-error.lisp
+++ b/src/code/late-target-error.lisp
@@ -547,8 +547,6 @@
 
 (define-condition simple-warning (simple-condition warning) ())
 
-;;; This is the condition type used by ERROR and CERROR when
-;;; a format-control string is supplied as the first argument.
 (define-condition simple-error (simple-condition error) ())
 
 (define-condition storage-condition (serious-condition) ())
@@ -563,6 +561,8 @@
             (type-error-datum condition)
             (type-error-expected-type condition)))))
 
+(define-condition simple-type-error (simple-condition type-error) ())
+
 (define-condition program-error (error) ())
 (define-condition parse-error   (error) ())
 (define-condition control-error (error) ())

diff --git a/src/code/primordial-extensions.lisp b/src/code/primordial-extensions.lisp
index 6d9e4f2..7e8e78d 100644 (file)
--- a/src/code/primordial-extensions.lisp
+++ b/src/code/primordial-extensions.lisp
@@ -35,7 +35,19 @@
 ;;; gencgc.c code on this value being a symbol. (This is only one of
 ;;; many nasty dependencies between that code and this, alas.)
 ;;; -- WHN 2001-02-28
-(defconstant +empty-ht-slot+ '%empty-ht-slot%)
+;;;
+;;; FIXME: We end up doing two DEFCONSTANT forms because (1) LispWorks
+;;; needs EVAL-WHEN wrapped around DEFCONSTANT, and (2) SBCL's
+;;; DEFCONSTANT expansion doesn't seem to behave properly inside
+;;; EVAL-WHEN, so that without this, the +EMPTY-HT-SLOT+ references in
+;;; e.g. DOHASH macroexpansions don't end up being replaced by
+;;; constant values, so that the system dies at cold init because
+;;; '+EMPTY-HT-SLOT+ isn't bound yet. It's hard to fix this properly
+;;; until SBCL's EVAL-WHEN is fixed, which is waiting for the IR1
+;;; interpreter to go away, which is waiting for sbcl-0.7.x..
+(eval-when (:compile-toplevel :load-toplevel :execute)
+  (defconstant +empty-ht-slot+ '%empty-ht-slot%))
+(defconstant +empty-ht-slot+ '#.+empty-ht-slot+) ; egads.. See FIXME above.
 ;;; KLUDGE: Using a private symbol still leaves us vulnerable to users
 ;;; getting nonconforming behavior by messing around with
 ;;; DO-ALL-SYMBOLS. That seems like a fairly obscure problem, so for

diff --git a/src/code/signal.lisp b/src/code/signal.lisp
index cc8d985..7b1b679 100644 (file)
--- a/src/code/signal.lisp
+++ b/src/code/signal.lisp
@@ -37,10 +37,6 @@
 ;;; are lost in the noise when compared with the cost of delivering
 ;;; the signal in the first place.
 
-;;; Magically converted by the compiler into a break instruction.
-(defun do-pending-interrupt ()
-  (do-pending-interrupt))
-
 #!-gengc (progn
 
 (defvar *interrupts-enabled* t)

diff --git a/src/code/target-signal.lisp b/src/code/target-signal.lisp
index e7a674d..5be6e2e 100644 (file)
--- a/src/code/target-signal.lisp
+++ b/src/code/target-signal.lisp
@@ -151,6 +151,13 @@
   (enable-interrupt :sigalrm #'sigalrm-handler)
   (values))
 \f
+;;;; etc.
+
+;;; CMU CL comment:
+;;;   Magically converted by the compiler into a break instruction.
+(defun do-pending-interrupt ()
+  (do-pending-interrupt))
+\f
 ;;; stale code which I'm insufficiently motivated to test -- WHN 19990714
 #|
 ;;;; WITH-ENABLED-INTERRUPTS

diff --git a/src/compiler/globaldb.lisp b/src/compiler/globaldb.lisp
index 844bfa9..410745f 100644 (file)
--- a/src/compiler/globaldb.lisp
+++ b/src/compiler/globaldb.lisp
@@ -802,8 +802,8 @@
   ;; inner loops.
   (let ((info (type-info-or-lose class type)))
     (if env-list-p
-      (get-info-value name (type-info-number info) env-list)
-      (get-info-value name (type-info-number info)))))
+       (get-info-value name (type-info-number info) env-list)
+       (get-info-value name (type-info-number info)))))
 #!-sb-fluid
 (define-compiler-macro info
   (&whole whole class type name &optional (env-list nil env-list-p))

diff --git a/src/compiler/x86/call.lisp b/src/compiler/x86/call.lisp
index 307e3f8..8c62d1b 100644 (file)
--- a/src/compiler/x86/call.lisp
+++ b/src/compiler/x86/call.lisp
@@ -254,7 +254,7 @@
            for tn-ref = (tn-ref-across 2nd-tn-ref)
            then (tn-ref-across tn-ref)
            for count from 2 below register-arg-count
-           do count (inst mov (tn-ref-tn tn-ref) 2nd-tn))))
+           do (inst mov (tn-ref-tn tn-ref) 2nd-tn))))
       (inst mov ebx-tn esp-tn)
       (emit-label regs-defaulted)
       (inst mov esp-tn ebx-tn)))

diff --git a/src/compiler/x86/static-fn.lisp b/src/compiler/x86/static-fn.lisp
index 111701b..da2966d 100644 (file)
--- a/src/compiler/x86/static-fn.lisp
+++ b/src/compiler/x86/static-fn.lisp
@@ -124,7 +124,7 @@
                       ,num-results)))
         ,@(moves (result-names) (temp-names)))))))
 
-) ; eval-when (compile load eval)
+) ; EVAL-WHEN
 
 (macrolet ((frob (num-args num-res)
             (static-function-template-vop (eval num-args) (eval num-res))))

diff --git a/version.lisp-expr b/version.lisp-expr
index c06db7c..ff4a8b8 100644 (file)
--- a/version.lisp-expr
+++ b/version.lisp-expr
@@ -15,4 +15,4 @@
 ;;; versions, and a string like "0.6.5.12" is used for versions which
 ;;; aren't released but correspond only to CVS tags or snapshots.
 
-"0.6.12.13"
+"0.6.12.14"