Perhaps any number of such consecutive lines ought to turn into a
single "compiling top-level forms:" line.
-19:
- (I *think* this is a bug. It certainly seems like strange behavior. But
- the ANSI spec is scary, dark, and deep.. -- WHN)
- (FORMAT NIL "~,1G" 1.4) => "1. "
- (FORMAT NIL "~3,1G" 1.4) => "1. "
-
27:
Sometimes (SB-EXT:QUIT) fails with
Argh! maximum interrupt nesting depth (4096) exceeded, exiting
a STYLE-WARNING for references to variables similar to locals might
be a good thing.)
-125:
- (as reported by Gabe Garza on cmucl-help 2001-09-21)
- (defvar *tmp* 3)
- (defun test-pred (x y)
- (eq x y))
- (defun test-case ()
- (let* ((x *tmp*)
- (func (lambda () x)))
- (print (eq func func))
- (print (test-pred func func))
- (delete func (list func))))
- Now calling (TEST-CASE) gives output
- NIL
- NIL
- (#<FUNCTION {500A9EF9}>)
- Evidently Python thinks of the lambda as a code transformation so
- much that it forgets that it's also an object.
-
135:
Ideally, uninterning a symbol would allow it, and its associated
FDEFINITION and PROCLAIM data, to be reclaimed by the GC. However,
Expected: (2 6 15 38)
Got: ERROR
-317: "FORMAT of floating point numbers"
- reported by Bruno Haible sbcl-devel "various SBCL bugs" from CLISP
- test suite.
- (format nil "~1F" 10) => "0." ; "10." expected
- (format nil "~0F" 10) => "0." ; "10." expected
- (format nil "~2F" 1234567.1) => "1000000." ; "1234567." expected
- it would be nice if whatever fixed this also untangled the two
- competing implementations of floating point printing (Steele and
- White, and Burger and Dybvig) present in src/code/print.lisp
-
318: "stack overflow in compiler warning with redefined class"
reported by Bruno Haible sbcl-devel "various SBCL bugs" from CLISP
test suite.
(let ((i (sb-c::values-type-intersection x y)))
(assert (sb-c::type= i (sb-c::values-type-intersection i x)))
(assert (sb-c::type= i (sb-c::values-type-intersection i y)))))))
+
+370: reader misbehaviour on large-exponent floats
+ (read-from-string "1.0s1000000000000000000000000000000000000000")
+ causes the reader to attempt to create a very large bignum (which it
+ will then attempt to coerce to a rational). While this isn't
+ completely wrong, it is probably not ideal -- checking the floating
+ point control word state and then returning the relevant float
+ (most-positive-short-float or short-float-infinity) or signalling an
+ error immediately would seem to make more sense.