Custom Query (1030 matches)

? (defun test (name) (restart-case (cerror "foo ~s" "bar ~s" name)
			  (a-restart () nil)))
TEST
? (test 'hah)
> Error: bar HAH
> While executing: TEST, in process listener(1).
> Type :GO to continue, :POP to abort, :R for a list of available restarts.
> If continued: foo #<error printing object>

Note the #<error printing object>. The problem seems to be restart-case transforming the cerror call and losing its format args in the process.

(pprint (macroexpand-1 '(restart-case (cerror "foo ~s" "bar ~s" name)
			  (a-restart () nil))))

(BLOCK #:G672
  (LET* ((#:G673 (%CONS-RESTART 'A-RESTART NIL NIL NIL NIL))
         (#:G670 (LIST #:G673)))
    (DECLARE (DYNAMIC-EXTENT #:G673 #:G670))
    (CATCH #:G670
      (LET ((%RESTARTS% (CONS #:G670 %RESTARTS%)))
        (DECLARE (DYNAMIC-EXTENT %RESTARTS%))
        (RETURN-FROM #:G672
          (LET ((#:G671
                 (CONDITION-ARG "bar ~s" (LIST NAME) 'SIMPLE-ERROR)))
            (WITH-CONDITION-RESTARTS
              #:G671
              #:G670
              (CERROR "foo ~s" #:G671)))))))

On moving a Lisp application to a newer Linux box, we get random, whacky behaviour. This is demonstrated by the following file:

=== process-test.lisp ===
(in-package :cl-user)

(defun big-sum (n)
  (let ((total n))
    (dotimes (i n total)
      (incf total i))))

(defun test ()
  (ccl:process-run-function "25" #'big-sum 250000000)
  (ccl:process-run-function "26" #'big-sum 260000000)
  (ccl:process-run-function "27" #'big-sum 270000000)
  (ccl:process-run-function "28" #'big-sum 280000000))

and session transcript:

$ uname -a
Linux startle 2.6.32-30-generic #59-Ubuntu SMP Tue Mar 1 21:30:21 UTC 2011 i686 GNU/Linux
$ ccl
Welcome to Clozure Common Lisp Version 1.6  (LinuxX8632)!
? (load "process-test.lisp")
#P"/home/startle/startle/process-test.lisp"
? (test)
#<PROCESS 28(5) [Reset] #x1828FA76>
? 
> Error: Fault during read of memory address #x634
> While executing: CCL::*-2, in process 26(3).


;;;
;;; #<PROCESS 26(3) [Active] #x182901B6> requires access to Shared Terminal Input
;;; Type (:y 3) to yield control to this thread.
;;;
> Error: value #<BOGUS object @ #x284E4729> is not of the expected type NUMBER.
> While executing: CCL::+-2, in process 27(4).


;;;
;;; #<PROCESS 27(4) [Active] #x1828FE16> requires access to Shared Terminal Input
;;; Type (:y 4) to yield control to this thread.
;;;
> Error: value #<Unprintable CCL::IMMEDIATE : #x34D0C3> is not of the expected type NUMBER.
> While executing: CCL::*-2, in process 28(5).


;;;
;;; #<PROCESS 28(5) [Active] #x1828FA76> requires access to Shared Terminal Input
;;; Type (:y 5) to yield control to this thread.
;;;

The exact error messages are variable. Above transcript from x86 Ubuntu 10.04 box; similar behaviour from x86 Centos 5.6. However, x86 Centos 5.3 (and earlier) does not show this, nor does Darwin/PPC (CCL 1.4).

The sqrt, log and atan functions are failing over significant portions of their domain (particularly for rational or complex rational arguments), even when it is entirely reasonable that a good result should be returned. Some typical examples are:

(sqrt (expt 10 47)) => 3.1622778E+23 ;CCL errors
(sqrt (/ (expt 10 47) 3)) => 1.8257418E+23 ;CCL errors
(sqrt (complex (expt 10 46) (expt 10 47))) => #C(2.3505187E+23 2.12719E+23) ;CCL errors
(sqrt (complex most-positive-short-float most-positive-short-float)) => #C(2.0267142E+19 8.394926E+18) ;CCL errors

(log (expt 10 -66)) => -151.97063 ;CCL errors
(log (- (expt 10 66))) => #C(151.97063 3.1415927) ;CCL returns wrong type (double, not single)
(log (complex (expt 10 65) (expt 10 66))) => #C(151.9756 1.4711276) ;CCL errors
(log (complex (expt 10 -65) (expt 10 -66))) => #C(-149.66307 0.09966865) ;CCL errors
(log 8.0d0 2) => 3.0D0 ;CCL returns wildly inaccurate result
(log #C(0.0 1.0) 0) => #C(0.0 0.0) ;CCL returns wrong type (integer)

(atan (expt 10 46) (expt 10 47)) => 0.09966865 ;CCL errors
(atan (expt 10 -46) (expt 10 -47)) => 1.4711276 ;CCL returns zero

I'm attaching a file that demonstrates how these could all be fixed by making changes to CCL's sqrt, log, log-e and atan functions (but the changes may not be implemented in the most efficient way). Making these fixes would also have a knock-on effect and correct dependent infelicities in both the arg and phase functions (which aren't noted above).