You can subscribe to this list here.
2005 
_{Jan}
(159) 
_{Feb}
(96) 
_{Mar}
(145) 
_{Apr}
(192) 
_{May}
(132) 
_{Jun}
(190) 
_{Jul}
(194) 
_{Aug}
(280) 
_{Sep}
(195) 
_{Oct}
(207) 
_{Nov}
(154) 
_{Dec}
(101) 

2011 
_{Jan}
(18) 
_{Feb}
(39) 
_{Mar}
(18) 
_{Apr}
(27) 
_{May}
(45) 
_{Jun}
(135) 
_{Jul}
(31) 
_{Aug}
(82) 
_{Sep}
(14) 
_{Oct}
(60) 
_{Nov}
(112) 
_{Dec}
(117) 
2003 
_{Jan}
(126) 
_{Feb}
(228) 
_{Mar}
(238) 
_{Apr}
(299) 
_{May}
(257) 
_{Jun}
(283) 
_{Jul}
(192) 
_{Aug}
(227) 
_{Sep}
(295) 
_{Oct}
(202) 
_{Nov}
(180) 
_{Dec}
(70) 
2006 
_{Jan}
(156) 
_{Feb}
(110) 
_{Mar}
(261) 
_{Apr}
(183) 
_{May}
(148) 
_{Jun}
(133) 
_{Jul}
(94) 
_{Aug}
(141) 
_{Sep}
(137) 
_{Oct}
(111) 
_{Nov}
(172) 
_{Dec}
(124) 
2009 
_{Jan}
(143) 
_{Feb}
(168) 
_{Mar}
(68) 
_{Apr}
(142) 
_{May}
(224) 
_{Jun}
(202) 
_{Jul}
(83) 
_{Aug}
(86) 
_{Sep}
(68) 
_{Oct}
(37) 
_{Nov}
(93) 
_{Dec}
(80) 
2012 
_{Jan}
(15) 
_{Feb}
(4) 
_{Mar}
(30) 
_{Apr}
(62) 
_{May}
(45) 
_{Jun}
(30) 
_{Jul}
(9) 
_{Aug}
(23) 
_{Sep}
(41) 
_{Oct}
(56) 
_{Nov}
(35) 
_{Dec}
(43) 
2007 
_{Jan}
(111) 
_{Feb}
(72) 
_{Mar}
(155) 
_{Apr}
(286) 
_{May}
(138) 
_{Jun}
(170) 
_{Jul}
(129) 
_{Aug}
(156) 
_{Sep}
(170) 
_{Oct}
(90) 
_{Nov}
(119) 
_{Dec}
(112) 
2002 
_{Jan}

_{Feb}

_{Mar}
(23) 
_{Apr}
(68) 
_{May}
(99) 
_{Jun}
(109) 
_{Jul}
(112) 
_{Aug}
(104) 
_{Sep}
(177) 
_{Oct}
(211) 
_{Nov}
(162) 
_{Dec}
(135) 
2013 
_{Jan}
(19) 
_{Feb}
(41) 
_{Mar}
(31) 
_{Apr}
(28) 
_{May}
(109) 
_{Jun}
(90) 
_{Jul}
(24) 
_{Aug}
(37) 
_{Sep}
(52) 
_{Oct}
(45) 
_{Nov}
(58) 
_{Dec}
(35) 
2004 
_{Jan}
(88) 
_{Feb}
(73) 
_{Mar}
(133) 
_{Apr}
(141) 
_{May}
(205) 
_{Jun}
(130) 
_{Jul}
(148) 
_{Aug}
(247) 
_{Sep}
(228) 
_{Oct}
(175) 
_{Nov}
(158) 
_{Dec}
(222) 
2008 
_{Jan}
(135) 
_{Feb}
(102) 
_{Mar}
(115) 
_{Apr}
(42) 
_{May}
(132) 
_{Jun}
(106) 
_{Jul}
(94) 
_{Aug}
(67) 
_{Sep}
(33) 
_{Oct}
(123) 
_{Nov}
(54) 
_{Dec}
(219) 
2010 
_{Jan}
(39) 
_{Feb}
(76) 
_{Mar}
(144) 
_{Apr}
(141) 
_{May}
(27) 
_{Jun}
(70) 
_{Jul}
(23) 
_{Aug}
(155) 
_{Sep}
(152) 
_{Oct}
(167) 
_{Nov}
(87) 
_{Dec}
(12) 
2014 
_{Jan}
(24) 
_{Feb}
(48) 
_{Mar}
(93) 
_{Apr}
(100) 
_{May}
(204) 
_{Jun}
(107) 
_{Jul}
(43) 
_{Aug}

_{Sep}

_{Oct}

_{Nov}

_{Dec}

S  M  T  W  T  F  S 





1

2
(2) 
3

4
(3) 
5
(11) 
6
(17) 
7
(5) 
8

9

10

11

12
(6) 
13
(2) 
14

15

16

17

18

19
(6) 
20

21

22
(3) 
23

24
(1) 
25
(1) 
26

27
(6) 
28
(9) 



From: Kingo kotov <K<ingo@ma...>  20070227 23:52:06

From: William Harold Newman <wnewman@us...>  20070227 23:25:47

Update of /cvsroot/sbcl/sbcl In directory sc8prcvs8.sourceforge.net:/tmp/cvsserv843 Modified Files: BUGS version.lispexpr Log Message: 1.0.2: logged bug Index: BUGS =================================================================== RCS file: /cvsroot/sbcl/sbcl/BUGS,v retrieving revision 1.506 retrieving revision 1.507 diff u d r1.506 r1.507  BUGS 9 Jan 2007 16:27:20 0000 1.506 +++ BUGS 27 Feb 2007 23:25:38 0000 1.507 @@ 1752,3 +1752,40 @@ 2: (SBKERNEL:%SINGLEFLOAT ...) 3: (SBC::BOUNDFUNC ...) 4: (SBC::%SINGLEFLOATDERIVETYPEAUX ...) + +408: SUBTYPEP confusion re. OR of SATISFIES of notyetdefined predicate + As reported by Levente M\'{e}sz\'{a}ros sbcldevel 20060220, + (aver (equal (multiplevaluelist + (subtypep '(or (satisfies x) string) + '(or (satisfies x) integer))) + '(nil nil))) + fails. Also, beneath that failure lurks another failure, + (aver (equal (multiplevaluelist + (subtypep 'string + '(or (satisfies x) integer))) + '(nil nil))) + Having looked at this for an hour or so in sbcl1.0.2, and + specifically having looked at the output from + laptop$ sbcl + * (let ((x 'string) + (y '(or (satisfies x) integer))) + (trace sbkernel::unioncomplexsubtypeparg2 + sbkernel::invokecomplexsubtypeparg1method + sbkernel::typeunion + sbkernel::typeintersection + sbkernel::type=) + (subtypep x y)) + my (WHN) impression is that the problem is that the semantics of TYPE= + are wrong for what the UNIONCOMPLEXSUBTYPEPARG2 code is trying + to use it for. The comments on the definition of TYPE= probably + date back to CMU CL and seem to define it as a confusing thing: + its primary value is something like "certainly equal," and its + secondary value is something like "certain about that certainty." + I'm left uncertain how to fix UNIONCOMPLEXSUBTYPEPARG2 without + reducing its generality by removing the TYPE= cleverness. Possibly + the tempting TYPE/= relative defined next to it might be a + suitable replacement for the purpose. Probably, though, it would + be best to start by reverse engineering exactly what TYPE= and + TYPE/= do, and writing an explanation which is so clear that one + can see immediately what it's supposed to mean in odd cases like + (TYPE= '(SATISFIES X) 'INTEGER) when X isn't defined yet. Index: version.lispexpr =================================================================== RCS file: /cvsroot/sbcl/sbcl/version.lispexpr,v retrieving revision 1.3208 retrieving revision 1.3209 diff u d r1.3208 r1.3209  version.lispexpr 27 Feb 2007 21:57:13 0000 1.3208 +++ version.lispexpr 27 Feb 2007 23:25:38 0000 1.3209 @@ 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".) "1.0.3.1" +"1.0.3.2" 
From: Nikodemus Siivola <demoss@us...>  20070227 21:57:31

Update of /cvsroot/sbcl/sbcl In directory sc8prcvs8.sourceforge.net:/tmp/cvsserv25942 Modified Files: NEWS version.lispexpr Log Message: 1.0.3.1: fix behaviour of >= and <= with NaNs * Problem: (>= (/ 0.0 0.0) 1.0) evaluates to true. Move inversion from >= to < and from <= to > from the source transformations to new deftransforms, and make it conditional on the derived type, avoiding the inversion for potential floats. This fixes the NaN issues with >= and <=, but exposes gaps in our transformations for =, causing a constraint propagation test to fail... * Tweak the deftransform for = so that another transformation can coexist with it. Write INTERVAL= and INTERVAL/=, and deftransforms for = and /= based on them. This fixes the constant propagation issue, except for the bug it exposes elsewhere... * INTERVALINTERSECTION/DIFFERENCE returns bogus intersections  fix it. ...and all is well. * Tests. * NUMERICTYPEORLOSE is unused, deleted. * Also fix tests/stream.impure.lisp for UTF8 environments. Index: NEWS =================================================================== RCS file: /cvsroot/sbcl/sbcl/NEWS,v retrieving revision 1.1138 retrieving revision 1.1139 diff u d r1.1138 r1.1139  NEWS 12 Feb 2007 03:43:11 0000 1.1138 +++ NEWS 27 Feb 2007 21:57:12 0000 1.1139 @@ 1,4 +1,7 @@ ;;;; * coding: utf8; * +changes in sbcl1.0.4 relative to sbcl1.0.3: + * bug fix: >= and <= gave wrong results when used with NaNs. + changes in sbcl1.0.3 relative to sbcl1.0.2: * new platform: NetBSD/PPC. (thanks to Aymeric Vincent) * optimization: calls of the form (AREF FOO (+ INDEX <constant>)) now Index: version.lispexpr =================================================================== RCS file: /cvsroot/sbcl/sbcl/version.lispexpr,v retrieving revision 1.3207 retrieving revision 1.3208 diff u d r1.3207 r1.3208  version.lispexpr 27 Feb 2007 20:03:42 0000 1.3207 +++ version.lispexpr 27 Feb 2007 21:57:13 0000 1.3208 @@ 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".) "1.0.3" +"1.0.3.1" 
From: Nikodemus Siivola <demoss@us...>  20070227 21:57:30

Update of /cvsroot/sbcl/sbcl/src/compiler In directory sc8prcvs8.sourceforge.net:/tmp/cvsserv25942/src/compiler Modified Files: srctran.lisp Log Message: 1.0.3.1: fix behaviour of >= and <= with NaNs * Problem: (>= (/ 0.0 0.0) 1.0) evaluates to true. Move inversion from >= to < and from <= to > from the source transformations to new deftransforms, and make it conditional on the derived type, avoiding the inversion for potential floats. This fixes the NaN issues with >= and <=, but exposes gaps in our transformations for =, causing a constraint propagation test to fail... * Tweak the deftransform for = so that another transformation can coexist with it. Write INTERVAL= and INTERVAL/=, and deftransforms for = and /= based on them. This fixes the constant propagation issue, except for the bug it exposes elsewhere... * INTERVALINTERSECTION/DIFFERENCE returns bogus intersections  fix it. ...and all is well. * Tests. * NUMERICTYPEORLOSE is unused, deleted. * Also fix tests/stream.impure.lisp for UTF8 environments. Index: srctran.lisp =================================================================== RCS file: /cvsroot/sbcl/sbcl/src/compiler/srctran.lisp,v retrieving revision 1.144 retrieving revision 1.145 diff u d r1.144 r1.145  srctran.lisp 3 Dec 2006 14:45:52 0000 1.144 +++ srctran.lisp 27 Feb 2007 21:57:15 0000 1.145 @@ 511,15 +511,13 @@ ;;; 1] and Y = [1, 2] to determine intersection. (defun intervalintersectp (x y &optional closedintervalsp) (declare (type interval x y))  (multiplevaluebind (intersect diff)  (intervalintersection/difference (if closedintervalsp  (intervalclosure x)  x)  (if closedintervalsp  (intervalclosure y)  y))  (declare (ignore diff))  intersect)) + (and (intervalintersection/difference (if closedintervalsp + (intervalclosure x) + x) + (if closedintervalsp + (intervalclosure y) + y)) + t)) ;;; Are the two intervals adjacent? That is, is there a number ;;; between the two intervals that is not an element of either @@ 563,27 +561,44 @@ (if (listp p) (first p) (list p)))  (testnumber (p int) + (testnumber (p int bound) ;; Test whether P is in the interval.  (when (intervalcontainsp (typeboundnumber p)  (intervalclosure int))  (let ((lo (intervallow int))  (hi (intervalhigh int))) + (let ((pn (typeboundnumber p))) + (when (intervalcontainsp pn (intervalclosure int)) ;; Check for endpoints.  (cond ((and lo (= (typeboundnumber p) (typeboundnumber lo)))  (not (and (consp p) (numberp lo))))  ((and hi (= (typeboundnumber p) (typeboundnumber hi)))  (not (and (numberp p) (consp hi))))  (t t))))) + (let* ((lo (intervallow int)) + (hi (intervalhigh int)) + (lon (typeboundnumber lo)) + (hin (typeboundnumber hi))) + (cond + ;; Interval may be a point. + ((and lon hin (= lon hin pn)) + (and (numberp p) (numberp lo) (numberp hi))) + ;; Point matches the low end. + ;; [P] [P,?} => TRUE [P] (P,?} => FALSE + ;; (P [P,?} => TRUE P) [P,?} => FALSE + ;; (P (P,?} => TRUE P) (P,?} => FALSE + ((and lon (= pn lon)) + (or (and (numberp p) (numberp lo)) + (and (consp p) (eq :low bound)))) + ;; [P] {?,P] => TRUE [P] {?,P) => FALSE + ;; P) {?,P] => TRUE (P {?,P] => FALSE + ;; P) {?,P) => TRUE (P {?,P) => FALSE + ((and hin (= pn hin)) + (or (and (numberp p) (numberp hi)) + (and (consp p) (eq :high bound)))) + ;; Not an endpoint, all is well. + (t + t)))))) (testlowerbound (p int) ;; P is a lower bound of an interval. (if p  (testnumber p int) + (testnumber p int :low) (not (intervalboundedp int 'below)))) (testupperbound (p int) ;; P is an upper bound of an interval. (if p  (testnumber p int) + (testnumber p int :high) (not (intervalboundedp int 'above))))) (let ((xloiny (testlowerbound xlo y)) (xhiiny (testupperbound xhi y)) @@ 816,6 +831,24 @@ (>= (typeboundnumber (intervallow x)) (typeboundnumber (intervalhigh y))))) +;;; Return T if X = Y. +(defun interval= (x y) + (declare (type interval x y)) + (and (intervalboundedp x 'both) + (intervalboundedp y 'both) + (flet ((bound (v) + (if (numberp v) + v + ;; Open intervals cannot be = + (returnfrom interval= nil)))) + ;; Both intervals refer to the same point + (= (bound (intervalhigh x)) (bound (intervallow x)) + (bound (intervalhigh y)) (bound (intervallow y)))))) + +;;; Return T if X /= Y +(defun interval/= (x y) + (not (intervalintersectp x y))) + ;;; Return an interval that is the absolute value of X. Thus, if ;;; X = [1 10], the result is [0, 10]. (defun intervalabs (x) @@ 3353,41 +3386,44 @@ ;;; Convert to EQL if both args are rational and complexp is specified ;;; and the same for both. (deftransform = ((x y) * *) +(deftransform = ((x y) (number number) *) "open code" (let ((xtype (lvartype x)) (ytype (lvartype y)))  (if (and (csubtypep xtype (specifiertype 'number))  (csubtypep ytype (specifiertype 'number)))  (cond ((or (and (csubtypep xtype (specifiertype 'float))  (csubtypep ytype (specifiertype 'float)))  (and (csubtypep xtype (specifiertype '(complex float)))  (csubtypep ytype (specifiertype '(complex float)))))  ;; They are both floats. Leave as = so that 0.0 is  ;; handled correctly.  (giveupir1transform))  ((or (and (csubtypep xtype (specifiertype 'rational))  (csubtypep ytype (specifiertype 'rational)))  (and (csubtypep xtype  (specifiertype '(complex rational)))  (csubtypep ytype  (specifiertype '(complex rational)))))  ;; They are both rationals and complexp is the same.  ;; Convert to EQL.  '(eql x y))  (t  (giveupir1transform  "The operands might not be the same type.")))  (giveupir1transform  "The operands might not be the same type.")))) + (cond ((or (and (csubtypep xtype (specifiertype 'float)) + (csubtypep ytype (specifiertype 'float))) + (and (csubtypep xtype (specifiertype '(complex float))) + (csubtypep ytype (specifiertype '(complex float))))) + ;; They are both floats. Leave as = so that 0.0 is + ;; handled correctly. + (giveupir1transform)) + ((or (and (csubtypep xtype (specifiertype 'rational)) + (csubtypep ytype (specifiertype 'rational))) + (and (csubtypep xtype + (specifiertype '(complex rational))) + (csubtypep ytype + (specifiertype '(complex rational))))) + ;; They are both rationals and complexp is the same. + ;; Convert to EQL. + '(eql x y)) + (t + (giveupir1transform + "The operands might not be the same type."))))) ;;; If LVAR's type is a numeric type, then return the type, otherwise ;;; GIVEUPIR1TRANSFORM. (defun numerictypeorlose (lvar)  (declare (type lvar lvar))  (let ((res (lvartype lvar)))  (unless (numerictypep res) (giveupir1transform))  res)) +(labels ((maybefloatlvarp (lvar) + (neq *emptytype* (typeintersection (specifiertype 'float) + (lvartype lvar)))) + (maybeinvert (op inverted x y) + ;; Don't invert if either argument can be a float (NaNs) + (if (or (maybefloatlvarp x) (maybefloatlvarp y)) + `(or (,op x y) (= x y)) + `(if (,inverted x y) nil t)))) + (deftransform >= ((x y) (number number) *) + "invert or open code" + (maybeinvert '> '< x y)) + (deftransform <= ((x y) (number number) *) + "invert or open code" + (maybeinvert '< '> x y))) ;;; See whether we can statically determine (< X Y) using type ;;; information. If X's high bound is < Y's low, then X < Y. @@ 3395,6 +3431,7 @@ ;;; NIL). If not, at least make sure any constant arg is second. (macrolet ((def (name inverse reflexivep surelytrue surelyfalse) `(deftransform ,name ((x y)) + "optimize using intervals" (if (sameleafrefp x y) ,reflexivep (let ((ix (or (typeapproximateinterval (lvartype x)) @@ 3410,6 +3447,8 @@ `(,',inverse y x)) (t (giveupir1transform)))))))) + (def = = t (interval= ix iy) (interval/= ix iy)) + (def /= /= nil (interval/= ix iy) (interval= ix iy)) (def < > nil (interval< ix iy) (interval>= ix iy)) (def > < nil (interval< iy ix) (interval>= iy ix)) (def <= >= t (interval>= iy ix) (interval< iy ix)) @@ 3474,8 +3513,13 @@ (definesourcetransform = (&rest args) (multicompare '= args nil 'number)) (definesourcetransform < (&rest args) (multicompare '< args nil 'real)) (definesourcetransform > (&rest args) (multicompare '> args nil 'real)) (definesourcetransform <= (&rest args) (multicompare '> args t 'real)) (definesourcetransform >= (&rest args) (multicompare '< args t 'real)) +;;; We cannot do the inversion for >= and <= here, since both +;;; (< NaN X) and (> NaN X) +;;; are false, and we don't have typeinforation available yet. The +;;; deftransforms for twoargument versions of >= and <= takes care of +;;; the inversion to > and < when possible. +(definesourcetransform <= (&rest args) (multicompare '<= args nil 'real)) +(definesourcetransform >= (&rest args) (multicompare '>= args nil 'real)) (definesourcetransform char= (&rest args) (multicompare 'char= args nil 'character)) 
From: Nikodemus Siivola <demoss@us...>  20070227 21:57:30

Update of /cvsroot/sbcl/sbcl/tests In directory sc8prcvs8.sourceforge.net:/tmp/cvsserv25942/tests Modified Files: float.pure.lisp stream.impure.lisp Log Message: 1.0.3.1: fix behaviour of >= and <= with NaNs * Problem: (>= (/ 0.0 0.0) 1.0) evaluates to true. Move inversion from >= to < and from <= to > from the source transformations to new deftransforms, and make it conditional on the derived type, avoiding the inversion for potential floats. This fixes the NaN issues with >= and <=, but exposes gaps in our transformations for =, causing a constraint propagation test to fail... * Tweak the deftransform for = so that another transformation can coexist with it. Write INTERVAL= and INTERVAL/=, and deftransforms for = and /= based on them. This fixes the constant propagation issue, except for the bug it exposes elsewhere... * INTERVALINTERSECTION/DIFFERENCE returns bogus intersections  fix it. ...and all is well. * Tests. * NUMERICTYPEORLOSE is unused, deleted. * Also fix tests/stream.impure.lisp for UTF8 environments. Index: float.pure.lisp =================================================================== RCS file: /cvsroot/sbcl/sbcl/tests/float.pure.lisp,v retrieving revision 1.29 retrieving revision 1.30 diff u d r1.29 r1.30  float.pure.lisp 9 Nov 2006 21:30:21 0000 1.29 +++ float.pure.lisp 27 Feb 2007 21:57:16 0000 1.30 @@ 156,3 +156,22 @@ (+ x0 x2 x4 x6) (+ x1 x3 x5 x7) (+ x0 x3 x4 x7) (+ x1 x2 x5 x6) (+ x0 x1 x6 x7) (+ x2 x3 x4 x5))))))) + +(withtest (:name :nancomparisons) + (macrolet ((test (form) + (let ((nform (subst (/ 0.0 0.0) 'nan form))) + `(progn + (assert (not (eval ',nform))) + (assert (not (funcall (lambda () ,nform)))))))) + ;; Source transforms for >= and <= used to be too eager about + ;; inverting the test, causing NaN issues. + (test (>= nan 1.0)) + (test (>= 1.0 nan)) + (test (>= 1.0 nan 0.0)) + (test (>= 1.0 0.0 nan)) + (test (>= nan 1.0 0.0)) + (test (<= nan 1.0)) + (test (<= 1.0 nan)) + (test (<= 1.0 nan 2.0)) + (test (<= 1.0 2.0 nan)) + (test (<= nan 1.0 2.0)))) Index: stream.impure.lisp =================================================================== RCS file: /cvsroot/sbcl/sbcl/tests/stream.impure.lisp,v retrieving revision 1.18 retrieving revision 1.19 diff u d r1.18 r1.19  stream.impure.lisp 17 Jan 2007 12:40:55 0000 1.18 +++ stream.impure.lisp 27 Feb 2007 21:57:16 0000 1.19 @@ 291,6 +291,7 @@ (let ((sequence (makearray 1 :elementtype '(signedbyte 8)))) (withopenfile (stream pathname :direction :input + :externalformat :latin1 :elementtype :default) (handlercase (progn (readsequence sequence stream) @@ 299,7 +300,6 @@ (assert (eql (typeerrordatum condition) (codechar 255))) (assert (subtypep (typeerrorexpectedtype condition) '(signedbyte 8))))))))  ;;; Check WRITESEQUENCE signals a TYPEERROR when the stream can't ;;; write a sequence element. 
From: William Harold Newman <wnewman@us...>  20070227 20:03:51

Update of /cvsroot/sbcl/sbcl In directory sc8prcvs8.sourceforge.net:/tmp/cvsserv15169 Modified Files: version.lispexpr Log Message: 1.0.3: release, will be tagged as sbcl_1_0_3 Index: version.lispexpr =================================================================== RCS file: /cvsroot/sbcl/sbcl/version.lispexpr,v retrieving revision 1.3206 retrieving revision 1.3207 diff u d r1.3206 r1.3207  version.lispexpr 22 Feb 2007 20:14:13 0000 1.3206 +++ version.lispexpr 27 Feb 2007 20:03:42 0000 1.3207 @@ 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".) "1.0.2.27" +"1.0.3" 