Custom Query (1030 matches)

(handler-bind ((warning (lambda (w)
                          (declare (ignore w))
                          (invoke-restart 'eleven))))
  (restart-case (warn "foo")
    (eleven () 11)))

=>

value #<SIMPLE-CONDITION #x302000E8041D> is not of the expected type WARNING.
   [Condition of type TYPE-ERROR]

A simple-error is created by error, but a simple-warning is not created by warning :)

--- ccl/lib/macros.lisp	(revision 15001)
+++ ccl/lib/macros.lisp	(working copy)
@@ -409,7 +409,7 @@
           ((signal error warn)
            (destructuring-bind
              (cond &rest args) expansion
-             (setq condform `(condition-arg ,cond (list ,@args) ,(if (eq head 'warning)
+             (setq condform `(condition-arg ,cond (list ,@args) ,(if (eq head 'warn)
                                                                    ''simple-warning
                                                                    (if (eq head 'error)
                                                                      ''simple-error

(This is assuming ccl::conditional-store should work as a typical compare-and-swap, even though it's not exported.)

The RUN function below causes an assertion failure within 2000 iterations on my Linux-x86 machine. An svref place has the same issue. I did not see a problem on Darwin.

Removing the assertion (but keeping the conditional-store) results in a hang. Replacing that conditional-store (the second one) with setf also produces a hang.

(defstruct stack
  (head nil)
  (lock nil))

(defun call-with-spin-lock (stack fn)
  (loop :until (ccl::conditional-store
                (stack-lock stack) nil t))
  (unwind-protect
       (funcall fn)
    (assert (ccl::conditional-store
             (stack-lock stack) t nil))))

(defmacro with-spin-lock ((stack) &body body)
  `(call-with-spin-lock ,stack (lambda () ,@body)))

(defun push-stack (value stack)
  (with-spin-lock (stack)
    (push value (stack-head stack))))

(defun pop-stack (stack)
  (with-spin-lock (stack)
    (pop (stack-head stack))))

(defun test (thread-count)
  (let ((stack (make-stack)))
    (loop :repeat thread-count
          :do (ccl:process-run-function "test" #'push-stack t stack))
    (loop :repeat thread-count
          :do (loop :until (pop-stack stack)))))

(defun run ()
  (loop
     (test 1)
     (format t ".")))

I was surprised that ccl:save-application called ccl:*lisp-cleanup-functions* before saving the image. I expected a snapshot of the current image (this is the behavior of other implementations), not an image in a post-shutdown state.

I can use ccl:*save-exit-functions* to save the desired state, or restore state with ccl:*lisp-startup-functions*, but neither may be easy in general.

If it is decided that the current behavior is preferred, then at least document it in ccl:save-application or elsewhere, as it differs from other implementations.