Custom Query (1030 matches)

./lx86cl
(load "home:quicklisp;setup")
(ql:quickload :manardb)
(in-package :manardb)
(defun junk () (lisp-object-to-mptr nil))
> Error: Compiler bug or inconsistency:
>        x862-form to freg #<ACODE nil NIL>

The presumed bug causes "Bad file descriptor (error #9) during write" and/or "Unexpected end of file" during lfarm tests. It never appears with the old ccl. Of course there might be an issue with cl-store or flexi-streams or my code depending upon an old bug.

The tests are doing highly concurrent stuff with streams, and the bug is intermittent. The changes to sockets in ccl might have introduced a concurrency problem.

If you are interested in reproducing, (ql:quickload :lfarm-test) (lfarm-test:execute) on Linux x86. (32-bit)

Using Clozure Common Lisp-Version 1.11-RC1-r16620 (DarwinX8664) to define functions within function groups, the functions defined must have unique names that can be traced back to the group in which they were defined. In the code snippet below the macro defop-environment sets up a name as a special variable that is used in defop, partly to get the intended name, partly to ensure defop was used within a defop-environment. The code below is as short as I could make it. It works in Clisp and ABCL but does not work in CCL (or SBCL for that matter).

(unless (find-package :wondering)
  (defpackage wondering
    (:use :cl)))

(in-package :wondering)

(defvar *environments*
  (make-hash-table :test 'eq))

(let ((defop-prefix "OP-FN%"))

  (defmacro defop-environment (name &rest defops)
    "(defop-environment <name> &rest <defops>)
 Define a new operator environment with name <name> and operators
 defined by <defops>."
    (let ((new-table (make-hash-table :test 'eq)))
      `(let ((*name-prefix* ,(concatenate 'string defop-prefix (string name) "%"))
	     (*operator-table* ,new-table))
	 (declare (special *environments* *operator-table* *name-prefix*))
	 (format *trace-output* "Before defop *name-prefix* ~S~%" *name-prefix*)
	 ,@defops
	 (setf (gethash ',name *environments*) *operator-table*)
	 ',name)))

  (defmacro defop (name lambda-list &body body)
    "Define an operator.  Error unless used within a
 defop-environment."
    (declare (special *name-prefix*))
    (format *trace-output* "(defwalk ~A ~A~%  ~{~S~})~%"name lambda-list body)
    (unless (and (boundp '*name-prefix*) (stringp *name-prefix*))
      (error "Only use defop inside a defop-environmemt."))
    (let ((fname (values (intern
			  (concatenate 'string *name-prefix*
				       (string (if (symbolp name) name (car name))))
			  *package*))))
      (format *trace-output* "In defop *name-prefix* ~S, fname: ~S~%"
	      *name-prefix* fname)
      `(locally
	   (declare (special *operator-table*))
	 (defun ,fname ,lambda-list ,@body)
	 (setf (gethash ',name *operator-table*) ',fname)
	 ',name))))

Evaluating (defop-environment env0 (defop fn0 (x y) (fn x y))) directly makes CCL unhappy:

Only use defop inside a defop-environmemt.

[Condition of type SIMPLE-ERROR]

Could you please look into this? A workaround is also very welcome.

Thank you very much,

Ernst van Waning