+ certain functions: see bug 192b.
+
+205: "environment issues in cross compiler"
+ (These bugs have no impact on user code, but should be fixed or
+ documented.)
+ a. Macroexpanders introduced with MACROLET are defined in the null
+ lexical environment.
+ b. The body of (EVAL-WHEN (:COMPILE-TOPLEVEL) ...) is evaluated in
+ the null lexical environment.
+ c. The cross-compiler cannot inline functions defined in a non-null
+ lexical environment.
+
+206: ":SB-FLUID feature broken"
+ (reported by Antonio Martinez-Shotton sbcl-devel 2002-10-07)
+ Enabling :SB-FLUID in the target-features list in sbcl-0.7.8 breaks
+ the build.
+
+207: "poorly distributed SXHASH results for compound data"
+ SBCL's SXHASH could probably try a little harder. ANSI: "the
+ intent is that an implementation should make a good-faith
+ effort to produce hash-codes that are well distributed
+ within the range of non-negative fixnums". But
+ (let ((hits (make-hash-table)))
+ (dotimes (i 16)
+ (dotimes (j 16)
+ (let* ((ij (cons i j))
+ (newlist (push ij (gethash (sxhash ij) hits))))
+ (when (cdr newlist)
+ (format t "~&collision: ~S~%" newlist))))))
+ reports lots of collisions in sbcl-0.7.8. A stronger MIX function
+ would be an obvious way of fix. Maybe it would be acceptably efficient
+ to redo MIX using a lookup into a 256-entry s-box containing
+ 29-bit pseudorandom numbers?
+
+208: "package confusion in PCL handling of structure slot handlers"
+ In sbcl-0.7.8 compiling and loading
+ (in-package :cl)
+ (defstruct foo (slot (error "missing")) :type list :read-only t)
+ (defmethod print-object ((foo foo) stream) (print nil stream))
+ causes CERROR "attempting to modify a symbol in the COMMON-LISP
+ package: FOO-SLOT". (This is fairly bad code, but still it's hard
+ to see that it should cause symbols to be interned in the CL package.)
+
+211: "keywords processing"
+ a. :ALLOW-OTHER-KEYS T should allow a function to receive an odd
+ number of keyword arguments.
+ e. Compiling
+
+ (flet ((foo (&key y) (list y)))
+ (list (foo :y 1 :y 2)))
+
+ issues confusing message
+
+ ; in: LAMBDA NIL
+ ; (FOO :Y 1 :Y 2)
+ ;
+ ; caught STYLE-WARNING:
+ ; The variable #:G15 is defined but never used.
+
+212: "Sequence functions and circular arguments"
+ COERCE, MERGE and CONCATENATE go into an infinite loop when given
+ circular arguments; it would be good for the user if they could be
+ given an error instead (ANSI 17.1.1 allows this behaviour on the part
+ of the implementation, as conforming code cannot give non-proper
+ sequences to these functions. MAP also has this problem (and
+ solution), though arguably the convenience of being able to do
+ (MAP 'LIST '+ FOO '#1=(1 . #1#))
+ might be classed as more important (though signalling an error when
+ all of the arguments are circular is probably desireable).
+
+213: "Sequence functions and type checking"
+ a. MAKE-SEQUENCE, COERCE, MERGE and CONCATENATE cannot deal with
+ various complicated, though recognizeable, CONS types [e.g.
+ (CONS * (CONS * NULL))
+ which according to ANSI should be recognized] (and, in SAFETY 3
+ code, should return a list of LENGTH 2 or signal an error)
+ b. MAP, when given a type argument that is SUBTYPEP LIST, does not
+ check that it will return a sequence of the given type. Fixing
+ it along the same lines as the others (cf. work done around
+ sbcl-0.7.8.45) is possible, but doing so efficiently didn't look
+ entirely straightforward.
+ c. All of these functions will silently accept a type of the form
+ (CONS INTEGER *)
+ whether or not the return value is of this type. This is
+ probably permitted by ANSI (see "Exceptional Situations" under
+ ANSI MAKE-SEQUENCE), but the DERIVE-TYPE mechanism does not
+ know about this escape clause, so code of the form
+ (INTEGERP (CAR (MAKE-SEQUENCE '(CONS INTEGER *) 2)))
+ can erroneously return T.
+
+214:
+ SBCL 0.6.12.43 fails to compile
+
+ (locally
+ (declare (optimize (inhibit-warnings 0) (compilation-speed 2)))
+ (flet ((foo (&key (x :vx x-p)) (list x x-p)))
+ (foo 1 2)))
+
+ or a more simple example:
+
+ (locally
+ (declare (optimize (inhibit-warnings 0) (compilation-speed 2)))
+ (lambda (x) (declare (fixnum x)) (if (< x 0) 0 (1- x))))
+
+215: ":TEST-NOT handling by functions"
+ a. FIND and POSITION currently signal errors when given non-NIL for
+ both their :TEST and (deprecated) :TEST-NOT arguments, but by
+ ANSI 17.2 "the consequences are unspecified", which by ANSI 1.4.2
+ means that the effect is "unpredictable but harmless". It's not
+ clear what that actually means; it may preclude conforming
+ implementations from signalling errors.
+ b. COUNT, REMOVE and the like give priority to a :TEST-NOT argument
+ when conflict occurs. As a quality of implementation issue, it
+ might be preferable to treat :TEST and :TEST-NOT as being in some
+ sense the same &KEY, and effectively take the first test function in
+ the argument list.
+ c. Again, a quality of implementation issue: it would be good to issue a
+ STYLE-WARNING at compile-time for calls with :TEST-NOT, and a
+ WARNING for calls with both :TEST and :TEST-NOT; possibly this
+ latter should be WARNed about at execute-time too.
+
+216: "debugger confused by frames with invalid number of arguments"
+ In sbcl-0.7.8.51, executing e.g. (VECTOR-PUSH-EXTEND T), BACKTRACE, Q
+ leaves the system confused, enough so that (QUIT) no longer works.
+ It's as though the process of working with the uninitialized slot in
+ the bad VECTOR-PUSH-EXTEND frame causes GC problems, though that may
+ not be the actual problem. (CMU CL 18c doesn't have problems with this.)
+
+217: "Bad type operations with FUNCTION types"
+ In sbcl.0.7.7:
+
+ * (values-type-union (specifier-type '(function (base-char)))
+ (specifier-type '(function (integer))))
+
+ #<FUN-TYPE (FUNCTION (BASE-CHAR) *)>
+
+ It causes insertion of wrong type assertions into generated
+ code. E.g.
+
+ (defun foo (x s)
+ (let ((f (etypecase x
+ (character #'write-char)
+ (integer #'write-byte))))
+ (funcall f x s)
+ (etypecase x
+ (character (write-char x s))
+ (integer (write-byte x s)))))
+
+ Then (FOO #\1 *STANDARD-OUTPUT*) signals type error.
+
+ (In 0.7.9.1 the result type is (FUNCTION * *), so Python does not
+ produce invalid code, but type checking is not accurate. Similar
+ problems exist with VALUES-TYPE-INTERSECTION.)
+
+218: "VALUES type specifier semantics"
+ (THE (VALUES ...) ...) in safe code discards extra values.
+
+ (defun test (x y) (the (values integer) (truncate x y)))
+ (test 10 4) => 2
+
+220:
+ Sbcl 0.7.9 fails to compile
+
+ (multiple-value-call #'list
+ (the integer (helper))
+ nil)
+
+ Type check for INTEGER, the result of which serves as the first
+ argument of M-V-C, is inserted after evaluation of NIL. So arguments
+ of M-V-C are pushed in the wrong order. As a temporary workaround
+ type checking was disabled for M-V-Cs in 0.7.9.13. A better solution
+ would be to put the check between evaluation of arguments, but it
+ could be tricky to check result types of PROG1, IF etc.
+
+228: "function-lambda-expression problems"
+ in sbcl-0.7.9.6x, from the REPL:
+ * (progn (declaim (inline foo)) (defun foo (x) x))
+ FOO
+ * (function-lambda-expression #'foo)
+ (SB-C:LAMBDA-WITH-LEXENV NIL NIL NIL (X) (BLOCK FOO X)), NIL, FOO
+ but this first return value is not suitable for input to FUNCTION or
+ COMPILE, as required by ANSI.
+
+229:
+ (subtypep 'function '(function)) => nil, t.
+
+233:
+ Bug in constraint propagation:
+
+ (defun foo (x)
+ (declare (optimize (speed 2) (safety 3)))
+ (let ((y 0d0))
+ (values
+ (the double-float x)
+ (setq y (+ x 1d0))
+ (setq x 3d0)
+ (quux y (+ y 2d0) (* y 3d0)))))
+ (foo 4) => segmentation violation
+
+ (see usage of CONTINUATION-ASSERTED-TYPE in USE-RESULT-CONSTRAINTS)
+
+234:
+ clocc-ansi-test :EXCEPSIT-LEGACY-1277 fails in sbcl-0.7.10.33
+
+ In sbcl-0.7.10.33 (but not ca. 0.7.10.29),
+ (defclass foo54 () ())
+ (reinitialize-instance (make-instance 'foo54) :dummy 0)
+ does not signal an error. ANSI's definition of REINITIALIZE-INSTANCE
+ says
+ The system-supplied primary method for REINITIALIZE-INSTANCE signals
+ an error if an initarg is supplied that is not declared as valid.
+ and defines what that means in
+ 7.1.2 Declaring the Validity of Initialization Arguments
+ In effect, even though the signature shown for the REINITIALIZE-INSTANCE
+ gf in its ANSI definition page is &ALLOW-OTHER-KEYS, and that might
+ make it look as though anything goes, the gf+methods ensemble is required
+ to have more complicated &KEY-checking behavior than that.
projects / sbcl.git / blobdiff