0.8.0.9:

	Minor buglet fixes:
	... remove bogus YES-OR-NO-P and Y-OR-N-P extra level of
		indirection.  (thanks to Antonio Martinez)
	... make clocc-ansi-test whine less, by not making
		COMPILER-ERROR inherit from SERIOUS-CONDITION
	... add a couple of IGNORE/IGNORABLEs

diff --git a/src/code/query.lisp b/src/code/query.lisp
index 4cbe3f8..bd08d5d 100644 (file)
--- a/src/code/query.lisp
+++ b/src/code/query.lisp
@@ -40,7 +40,7 @@
    n or N as a negative answer. It asks again if you enter any other
    characters."
   (flet ((print-query ()
-          (maybe-print-query "(y or n)" format-string arguments)))
+          (apply #'maybe-print-query "(y or n)" format-string arguments)))
     (loop (print-query)
          (case (query-read-char)
            ((#\y #\Y) (return t))
@@ -53,7 +53,7 @@
    input buffer, beeps, and uses READ-LINE to get the strings
    YES or NO."
   (flet ((print-query ()
-          (maybe-print-query "(yes or no)" format-string arguments)))
+          (apply #'maybe-print-query "(yes or no)" format-string arguments)))
     (beep *query-io*)
     (loop (print-query)
          (let ((input (query-read-line)))

diff --git a/src/compiler/compiler-error.lisp b/src/compiler/compiler-error.lisp
index e0d3def..7a62e25 100644 (file)
--- a/src/compiler/compiler-error.lisp
+++ b/src/compiler/compiler-error.lisp
@@ -56,10 +56,14 @@
 ;;; not be a generalized instance of ERROR, as otherwise code such as
 ;;; (IGNORE-ERRORS (DEFGENERIC IF (X))) will catch and claim to handle
 ;;; the COMPILER-ERROR.  So we make COMPILER-ERROR inherit from
-;;; SIMPLE-CONDITION and SERIOUS-CONDITION instead, as of
-;;; sbcl-0.8alpha.0.2x, so that unless the user claims to be able to
-;;; handle SERIOUS-CONDITION (and if he does, he deserves what's going
-;;; to happen :-)
+;;; SIMPLE-CONDITION instead, as of sbcl-0.8alpha.0.2x, so that unless
+;;; the user claims to be able to handle general CONDITIONs (and if he
+;;; does, he deserves what's going to happen :-) [ Note: we don't make
+;;; COMPILER-ERROR inherit from SERIOUS-CONDITION, because
+;;; conventionally SERIOUS-CONDITIONs, if unhandled, end up in the
+;;; debugger; although the COMPILER-ERROR might well trigger an entry
+;;; into the debugger, it won't be the COMPILER-ERROR itself that is
+;;; the direct cause. ]
 ;;;
 ;;; So, what if we're not inside the compiler, then?  Well, in that
 ;;; case we're in the evaluator, so we want to convert the
@@ -76,12 +80,15 @@
 ;;; COMPILER-ERROR call, and all is well.
 ;;;
 ;;; CSR, 2003-05-13
-(define-condition compiler-error (simple-condition serious-condition) ())
+(define-condition compiler-error (simple-condition) ())
 
 ;;; Signal the appropriate condition. COMPILER-ERROR calls the bailout
 ;;; function so that it never returns (but compilation continues).
 ;;; COMPILER-ABORT falls through to the default error handling, so
-;;; compilation terminates. 
+;;; compilation terminates.
+;;;
+;;; FIXME: what is COMPILER-ABORT for?  It isn't currently
+;;; (2003-05-27) used in SBCL at all.
 (declaim (ftype (function (string &rest t) nil) compiler-error compiler-abort))
 (declaim (ftype (function (string &rest t) (values))
                compiler-warning compiler-style-warning))

diff --git a/src/compiler/generic/array.lisp b/src/compiler/generic/array.lisp
index 6d79907..36f2d49 100644 (file)
--- a/src/compiler/generic/array.lisp
+++ b/src/compiler/generic/array.lisp
@@ -19,6 +19,7 @@
   (:arg-types simple-array-nil positive-fixnum)
   (:results (value :scs (descriptor-reg)))
   (:result-types *)
+  (:ignore index value)
   (:vop-var vop)
   (:save-p :compute-only)
   (:generator 1
@@ -41,8 +42,9 @@
         (index :scs (unsigned-reg))
         (value :scs (descriptor-reg)))
   (:arg-types simple-array-nil positive-fixnum *)
-  (:results (value :scs (descriptor-reg)))
+  (:results (result :scs (descriptor-reg)))
   (:result-types *)
+  (:ignore index value result)
   (:vop-var vop)
   (:save-p :compute-only)
   (:generator 1

diff --git a/src/compiler/ir1tran.lisp b/src/compiler/ir1tran.lisp
index 3d76cc5..8d3ff5e 100644 (file)
--- a/src/compiler/ir1tran.lisp
+++ b/src/compiler/ir1tran.lisp
@@ -2009,6 +2009,7 @@
 (defun ir1-convert-lambdalike (thing &rest args
                               &key (source-name '.anonymous.)
                               debug-name allow-debug-catch-tag)
+  (declare (ignorable source-name debug-name allow-debug-catch-tag))
   (ecase (car thing)
     ((lambda) (apply #'ir1-convert-lambda thing args))
     ((instance-lambda)

diff --git a/version.lisp-expr b/version.lisp-expr
index 5db49d0..c3f8ca6 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.8.0.8"
+"0.8.0.9"