Home
Reading
Searching
Subscribe
Sponsors
Statistics
Posting
Contact
Spam
Lists
Links
About
Hosting
Filtering
Features Download
Marketing
Archives
FAQ
Blog
 
Gmane
From: Alex Goncharov <alex-goncharov <at> comcast.net>
Subject: Recent (two-three months) problems using CMUCL+SLIME
Newsgroups: gmane.lisp.slime.devel
Date: Wednesday 14th April 2010 03:05:19 UTC (over 7 years ago)
I am on the bleeding edge of everything here: SLIME and CMUCL built
out of CVS repositories, GNU Emacs 23.1.1.

A few months ago, SLIME and CMUCL stopped functioning for me in any
acceptable way.  I vaguely correlate this to my switching from GNU
Emacs 22 to 23, but can't be sure that the Emacs upgrade was indeed
the deciding factor.

I kept hoping that some upgrade of something would fix the situation
but this hasn't happened.

I see these three issues now:

  * SLIME' responsiveness is poor.  It used to do the evaluation and
    print results instantly, now with a noticeable delay.

    Which may be explained by the next item.

  * On every evaluation I see a message like this:

      Unexpected reply: ### (:ok "/xxx/")

  * The above two issues are an annoyance, even if not a small one.

    The real issue is that a failure to evaluate some Lisp expression
    results in a connection abort.

Below is a small demo -- the trimmed contents of various buffers.

Can anybody help me find the way out of my misery?

Thanks in advance.

============================================================
----------------------------------------
try.lisp
--------------------
(print (+ 1 0))
(print (/ 1 0))

----------------------------------------
*slime-repl cmucl*
--------------------
; SLIME 2010-04-12
1 
CL-USER>

----------------------------------------
*Messages*
--------------------
Connecting to Swank on port 31964.. [2 times]
Wrote /xxx/try.lisp
error in process filter: slime-dispatch-event: Unexpected reply: 24 (:ok
"/xxx/")
error in process filter: Unexpected reply: 24 (:ok "/xxx/")
Evaluation aborted.
Error during redisplay: (error Connection closed.) [2 times]
Lisp connection closed unexpectedly: connection broken by remote peer

----------------------------------------
*inferior-lisp*
--------------------
(progn (load "/app/lisp/slime/swank-loader.lisp" :verbose t) (funcall
(read-from-string "swank-loader:init")) (funcall (read-from-string
"swank:start-server") "/tmp/slime.22110" :coding-system "utf-8-unix"))

CMU Common Lisp 2010-04-06 (20A Unicode), running on myhost
With core: /app/lisp/cmucl/2010-04-06/lib/cmucl/lib/lisp-sse2.core
Dumped on: Tue, 2010-04-06 18:18:50-04:00 on otherhost
See <http://www.cons.org/cmucl/> for
support information.
Loaded subsystems:
    Unicode 1.7 with Unicode version 5.1.0
    Python 1.1, target Intel x86/sse2
    CLOS based on Gerd's PCL 2010-03-19 15:19:03
* 
Warning:  These Swank interfaces are unimplemented:
 (FRAME-CALL RESTART-FRAME SLDB-STEP-INTO SLDB-STEP-NEXT SLDB-STEP-OUT)
;; Swank started at port: 31964.
31964
* ; Comment: $Header:
/project/cmucl/cvsroot/src/pcl/simple-streams/external-formats/utf-8.lisp,v
1.5 2009-09-28 18:12:59 rtoy Exp $

; Compiling DEFINE-EXTERNAL-FORMAT UTF-8: 
; Compiling DEFINE-EXTERNAL-FORMAT UTF-8: 
; Byte Compiling Top-Level Form: 

;; swank:close-connection: Arithmetic error DIVISION-BY-ZERO signalled.
Operation was KERNEL::DIVISION, operands (1 0).
;; Event history start:
invoke-or-queue-interrupt: #
wait-for-event: (COMMON-LISP:OR (:EMACS-REX . SWANK::_)
(:EMACS-CHANNEL-SEND . SWANK::_)) T
READ: "(:emacs-rex (swank:autodoc (quote (\"print\" (\"/\" \"1\" \"0\")
swank::%cursor-marker%)) :print-right-margin 80) \"COMMON-LISP-USER\" t 23)
"
dispatch-event: (:EMACS-REX (SWANK:AUTODOC (QUOTE ("print" ("/" "1" "0")
SWANK::%CURSOR-MARKER%)) :PRINT-RIGHT-MARGIN 80) "COMMON-LISP-USER" T 23)
send-event: # (:EMACS-REX (SWANK:AUTODOC (QUOTE
("print" ("/" "1" "0") SWANK::%CURSOR-MARKER%)) :PRINT-RIGHT-MARGIN 80)
"COMMON-LISP-USER" 23)
dispatch-event: (:RETURN # (:OK "(print ===>
object <=== &optional stream)") 23)
WRITE: (:return (:ok "(print ===> object <=== &optional stream)") 23)
wait-for-event: (COMMON-LISP:OR (:EMACS-REX . SWANK::_)
(:EMACS-CHANNEL-SEND . SWANK::_)) T
process-io-interrupt 0 ... done 
process-io-interrupt 0 ...
invoke-or-queue-interrupt: #
wait-for-event: (COMMON-LISP:OR (:EMACS-REX . SWANK::_)
(:EMACS-CHANNEL-SEND . SWANK::_)) T
process-io-interrupt 0 ... done 
process-io-interrupt 0 ...
invoke-or-queue-interrupt: #
wait-for-event: (COMMON-LISP:OR (:EMACS-REX . SWANK::_)
(:EMACS-CHANNEL-SEND . SWANK::_)) T
READ: "(:emacs-rex (swank:set-default-directory \"/xxx/\")
\"COMMON-LISP-USER\" t 24)
"
dispatch-event: (:EMACS-REX (SWANK-BACKEND:SET-DEFAULT-DIRECTORY "/xxx/")
"COMMON-LISP-USER" T 24)
send-event: # (:EMACS-REX
(SWANK-BACKEND:SET-DEFAULT-DIRECTORY "/xxx/") "COMMON-LISP-USER" 24)
dispatch-event: (:RETURN # (:OK "/xxx/") 24)
WRITE: (:return (:ok "/xxx/") 24)
process-io-interrupt 1 ...
invoke-or-queue-interrupt: #
queue-interrupt: #process-io-interrupt 1 ... done 
process-io-interrupt 1 ...
invoke-or-queue-interrupt: #
too many queued interrupts
wait-for-event: (COMMON-LISP:OR (:EMACS-REX . SWANK::_)
(:EMACS-CHANNEL-SEND . SWANK::_)) T
wait-for-event: (COMMON-LISP:OR (:EMACS-REX . SWANK::_)
(:EMACS-CHANNEL-SEND . SWANK::_)) T
READ: "(:emacs-rex (swank:interactive-eval-region \"(print (+ 1 0))
(print (/ 1 0))
\") \"COMMON-LISP-USER\" t 25)
"
dispatch-event: (:EMACS-REX (SWANK:INTERACTIVE-EVAL-REGION "(print (+ 1 0))
(print (/ 1 0))
") "COMMON-LISP-USER" T 25)
send-event: # (:EMACS-REX
(SWANK:INTERACTIVE-EVAL-REGION "(print (+ 1 0))
(print (/ 1 0))
") "COMMON-LISP-USER" 25)
dispatch-event: (:WRITE-STRING "
1 ")
WRITE: (:write-string "
1 ")
dispatch-event: (:RETURN # (:ABORT) 25)
WRITE: (:return (:abort) 25)
close-connection: Arithmetic error COMMON-LISP:DIVISION-BY-ZERO signalled.
Operation was KERNEL::DIVISION, operands (1 0). ...
deinstall-sigio-handler...
deinstall-sigio-handler...done
;; Event history end.
;; Backtrace:
(0
 ((FLET SWANK-BACKEND:CALL-WITH-DEBUGGING-ENVIRONMENT) #))
(1 (SWANK::SAFE-BACKTRACE))
(2 ("DEFUN CALL-WITH-CONNECTION" #))
(3 (SIGNAL #))
(4 (ERROR #))
(5 ("DEFUN ENCODE-MESSAGE" #))
(6 (SIGNAL #))
(7
 (ERROR DIVISION-BY-ZERO :FUNCTION-NAME KERNEL::INTEGER-/-INTEGER
:OPERATION ...))
(8
 (KERNEL::DIVISION-BY-ZERO-ERROR-HANDLER KERNEL::INTEGER-/-INTEGER
#.(SYSTEM:INT-SAP #x47FD6878) # (19 83)))
(9 (KERNEL::INTERNAL-ERROR #.(SYSTEM:INT-SAP #x47FD6550) #))
(10 ("Foreign function call land"))
(11 ("Foreign function call land"))
(12 ("Foreign function call land"))
(13 ("Foreign function call land"))
(14 (KERNEL::INTEGER-/-INTEGER 1 0))
(15 (/ 1 0))
(16 (EVAL (PRINT (/ 1 0))))
(17 (SWANK::EVAL-REGION "(print (+ 1 0))\n(print (/ 1 0))\n"))
(18 ("DEFSLIMEFUN INTERACTIVE-EVAL-REGION"))
(19
 (SWANK::CALL-WITH-RETRY-RESTART "Retry SLIME interactive evaluation
request." #))
(20
 (SWANK::CALL-WITH-BUFFER-SYNTAX NIL #))
(21
 (SWANK::EVAL-FOR-EMACS (SWANK:INTERACTIVE-EVAL-REGION "(print (+ 1
0))\n(print (/ 1 0))\n") "COMMON-LISP-USER" 25))
(22 (SWANK::PROCESS-REQUESTS T))
(23 (SWANK-BACKEND:CHECK-SLIME-INTERRUPTS))
(24
 (SWANK::WAIT-FOR-EVENT (OR (:EMACS-REX . SWANK::_) (:EMACS-CHANNEL-SEND .
SWANK::_)) T))
(25 (SWANK::PROCESS-REQUESTS T))
(26 (SWANK-BACKEND:CHECK-SLIME-INTERRUPTS))
(27 (SWANK::PROCESS-IO-INTERRUPT #))
(28 (SWANK-BACKEND::SIGIO-HANDLER # #
#))
(29 ("Foreign function call land"))
(30 ("Foreign function call land"))
(31 ("Foreign function call land"))
(32 ("Foreign function call land"))
(33
 (LISP::DO-OUTPUT # #.(SYSTEM:INT-SAP #x281E1000)
0 57 ...))
(34 (LISP::FLUSH-OUTPUT-BUFFER #))
(35
 (LISP::FD-STREAM-MISC-ROUTINE # :FINISH-OUTPUT
NIL #))
(36 (FINISH-OUTPUT #))
(37
 (SWANK-RPC:ENCODE-MESSAGE (:RETURN (:OK "/xxx/") 24) #))
(38 ((FLET #:G0 SWANK::EVAL-FOR-EMACS))[:CLEANUP])
(39
 (SWANK::EVAL-FOR-EMACS (SWANK-BACKEND:SET-DEFAULT-DIRECTORY "/xxx/")
"COMMON-LISP-USER" 24))
(40 (SWANK::PROCESS-REQUESTS T))
(41 ("DEFUN HANDLE-REQUESTS"))
(42
 ("DEFINTERFACE CALL-WITH-DEBUGGER-HOOK" # #))
(43
 (SWANK::CALL-WITH-BINDINGS ((*STANDARD-OUTPUT* . #) (*STANDARD-INPUT* . #)
(*TRACE-OUTPUT* . #) (*ERROR-OUTPUT* . #) (*DEBUG-IO* . #) ...) ..))
(44
 (SWANK::CALL-WITH-CONNECTION # #))
(45 (SWANK::HANDLE-REQUESTS # T))
(46
 (SWANK::INVOKE-OR-QUEUE-INTERRUPT #))
(47 (SWANK::PROCESS-IO-INTERRUPT #))
(48 (SWANK-BACKEND::SIGIO-HANDLER # #
#))
(49 ("Foreign function call land"))
(50 ("Foreign function call land"))
(51 ("Foreign function call land"))
(52 ("Foreign function call land"))
(53 (SYSTEM:WAIT-UNTIL-FD-USABLE 0 :INPUT NIL))
(54 (LISP::DO-INPUT #))
(55
 ("PRECOMPILE-EF-SLOT ISO8859-1" # NIL
(LISP::*EOF*)))
(56 (LISP::SYNONYM-IN # NIL
(LISP::*EOF*)))
(57
 (LISP::TWO-WAY-IN #, Output = #> NIL
(LISP::*EOF*)))
(58
 (READ-CHAR #,
Output = #> NIL (LISP::*EOF*) NIL))
(59
 (LISP::READ-PRESERVING-WHITESPACE-INTERNAL #, Output = #> NIL (:EOF) T))
(60
 (LISP::READ-PRESERVING-WHITESPACE-INTERNAL #, Output = #> NIL (:EOF) NIL))
(61
 (LISP::READ-PRESERVING-WHITESPACE-INTERNAL 4 #, Output = #> NIL (:EOF) ...)[:EXTERNAL])
(62
 (LISP::READ-INTERNAL #, Output = #> NIL (:EOF)
NIL))
(63
 (READ #,
Output = #> NIL (:EOF) NIL))
(64 (LISP::%TOP-LEVEL))
(65 ((LABELS LISP::RESTART-LISP SAVE-LISP)))
;; Connection to Emacs lost. [
;;  condition: Arithmetic error DIVISION-BY-ZERO signalled.
Operation was KERNEL::DIVISION, operands (1 0).
;;  type: DIVISION-BY-ZERO
;;  encoding: utf-8-unix vs. UTF-8
;;  style: :SIGIO dedicated: NIL]

----------------------------------------
*slime-events*
--------------------

(:emacs-rex
 (swank:connection-info)
 "COMMON-LISP-USER" t 1)
(:indentation-update
 (("with-host" . 1)
  ("with-read-buffer" . 1)
  ("enumerate-matches" . 1)
  ("defloader" . 2)
  ("prepare-for-fast-read-char" . 1)
  ("input-wrapper" . 1)
  ("output-wrapper" . 1)
  ("with-symbol" . 1)
  ("def-output-routines" . 1)
  ("maybe-sap-maybe-string" . 1)
  ("with-pathname" . 1)
  ("with-fop-stack" . 1)
  ("prepare-for-fast-read-byte" . 1)
  ("define-function-name-syntax" . 2)
  ("with-float-traps-masked" . 1)
  ("without-package-locks" . 0)
  ("def-source-context" . 2)
  ("enumerate-search-list" . 1)
  ("do-info" . 1)
  ("with-c-strvec" . 1)
  ...))
(:return
 (:ok
  (:pid 22130 :style :sigio :encoding
	(:coding-system "utf-8-unix" :external-format "UTF-8")
	:lisp-implementation
	(:type "CMU Common Lisp" :name "cmucl" :version "2010-04-06 (20A Unicode)"
:program "/app/lisp/cmucl/2010-04-06/bin/lisp")
	:machine
	(:instance "myhost" :type "X86" :version "X86")
	:features
	(:cl-ppcre :split-sequence :asdf :gerds-pcl :pcl-structures
:portable-commonloops :pcl :cmu20 :cmu20a :python :conservative-float-type
:modular-arith :mp :x86 :sse2 :linkage-table :relative-package-names
:executable :elf :freebsd ...)
	:modules
	("ASDF" "LOOP")
	:package
	(:name "COMMON-LISP-USER" :prompt "CL-USER")
	:version "2010-04-12"))
 1)
(:emacs-rex
 (swank:swank-require
  '(:swank-package-fu :swank-presentations :swank-fuzzy
:swank-fancy-inspector :swank-c-p-c :swank-arglists))
 "COMMON-LISP-USER" t 2)
(:return
 (:ok
  ("SWANK-ARGLISTS" "SWANK-FANCY-INSPECTOR" "SWANK-FUZZY" "SWANK-C-P-C"
"SWANK-PRESENTATIONS" "SWANK-PACKAGE-FU" "ASDF" "LOOP"))
 2)
(:emacs-rex
 (swank:create-repl nil)
 "COMMON-LISP-USER" t 3)
(:return
 (:ok
  ("COMMON-LISP-USER" "CL-USER"))
 3)
(:emacs-rex
 (swank:buffer-first-change "/xxx/try.lisp")
 "COMMON-LISP-USER" t 4)
(:return
 (:ok nil)
 4)
(:emacs-rex
 (swank:autodoc
  '("foir" swank::%cursor-marker%)
  :print-right-margin 80)
 "COMMON-LISP-USER" t 5)
(:return
 (:ok :not-available)
 5)
(:emacs-rex
 (swank:autodoc
  '("for" swank::%cursor-marker%)
  :print-right-margin 80)
 "COMMON-LISP-USER" t 6)
(:return
 (:ok :not-available)
 6)
(:emacs-rex
 (swank:autodoc
  '("forma" swank::%cursor-marker%)
  :print-right-margin 80)
 "COMMON-LISP-USER" t 7)
(:return
 (:ok :not-available)
 7)
(:emacs-rex
 (swank:autodoc
  '("format" "" swank::%cursor-marker%)
  :print-right-margin 80)
 "COMMON-LISP-USER" t 8)
(:return
 (:ok "(format ===> destination <=== control-string &rest
format-arguments)")
 8)
(:emacs-rex
 (swank:autodoc
  '("print" "" swank::%cursor-marker%)
  :print-right-margin 80)
 "COMMON-LISP-USER" t 9)
(:return
 (:ok "(print ===> object <=== &optional stream)")
 9)
(:emacs-rex
 (swank:autodoc
  '("print"
    ("" swank::%cursor-marker%))
  :print-right-margin 80)
 "COMMON-LISP-USER" t 10)
(:return
 (:ok "(print ===> object <=== &optional stream)")
 10)
(:emacs-rex
 (swank:autodoc
  '("print"
    ("+" swank::%cursor-marker%))
  :print-right-margin 80)
 "COMMON-LISP-USER" t 11)
(:return
 (:ok "+ => (PROGN ..)")
 11)
(:emacs-rex
 (swank:autodoc
  '("print"
    ("+" "" swank::%cursor-marker%))
  :print-right-margin 80)
 "COMMON-LISP-USER" t 12)
(:return
 (:ok "(+ &rest ===> args <===)")
 12)
(:emacs-rex
 (swank:autodoc
  '("print"
    ("+" "1" swank::%cursor-marker%))
  :print-right-margin 80)
 "COMMON-LISP-USER" t 13)
(:return
 (:ok "(+ &rest ===> args <===)")
 13)
(:emacs-rex
 (swank:autodoc
  '("print"
    ("+" "1" "" swank::%cursor-marker%))
  :print-right-margin 80)
 "COMMON-LISP-USER" t 14)
(:return
 (:ok "(+ &rest ===> args <===)")
 14)
(:emacs-rex
 (swank:autodoc
  '("print"
    ("+" "1" "0" swank::%cursor-marker%))
  :print-right-margin 80)
 "COMMON-LISP-USER" t 15)
(:return
 (:ok "(+ &rest ===> args <===)")
 15)
(:emacs-rex
 (swank:autodoc
  '("print"
    ("+" "1" "0")
    swank::%cursor-marker%)
  :print-right-margin 80)
 "COMMON-LISP-USER" t 16)
(:return
 (:ok "(print ===> object <=== &optional stream)")
 16)
(:emacs-rex
 (swank:autodoc
  '(("/" "1" "0")
    swank::%cursor-marker%)
  :print-right-margin 80)
 "COMMON-LISP-USER" t 17)
(:return
 (:ok :not-available)
 17)
(:emacs-rex
 (swank:autodoc
  '("ri"
    ("/" "1" "0")
    swank::%cursor-marker%)
  :print-right-margin 80)
 "COMMON-LISP-USER" t 18)
(:return
 (:ok :not-available)
 18)
(:emacs-rex
 (swank:autodoc
  '("rint"
    ("/" "1" "0")
    swank::%cursor-marker%)
  :print-right-margin 80)
 "COMMON-LISP-USER" t 19)
(:return
 (:ok :not-available)
 19)
(:emacs-rex
 (swank:autodoc
  '("r"
    ("/" "1" "0")
    swank::%cursor-marker%)
  :print-right-margin 80)
 "COMMON-LISP-USER" t 20)
(:return
 (:ok :not-available)
 20)
(:emacs-rex
 (swank:autodoc
  '(("/" "1" "0")
    swank::%cursor-marker%)
  :print-right-margin 80)
 "COMMON-LISP-USER" t 21)
(:return
 (:ok :not-available)
 21)
(:emacs-rex
 (swank:autodoc
  '("pring"
    ("/" "1" "0")
    swank::%cursor-marker%)
  :print-right-margin 80)
 "COMMON-LISP-USER" t 22)
(:return
 (:ok :not-available)
 22)
(:emacs-rex
 (swank:autodoc
  '("print"
    ("/" "1" "0")
    swank::%cursor-marker%)
  :print-right-margin 80)
 "COMMON-LISP-USER" t 23)
(:return
 (:ok "(print ===> object <=== &optional stream)")
 23)
(:emacs-rex
 (swank:set-default-directory "/xxx/")
 "COMMON-LISP-USER" t 24)
(:return
 (:ok "/xxx/")
 24)
(:emacs-rex
 (swank:interactive-eval-region "(print (+ 1 0))\n(print (/ 1 0))\n")
 "COMMON-LISP-USER" t 25)
(:return
 (:ok "/xxx/")
 24)
(:write-string "\n1 ")
(:return
 (:abort)
 25)

----------------------------------------
*scratch*
--------------------
(insert (format "\n=>\n%s\n%s" slime-lisp-implementations
slime-net-coding-system))
=>
((cmucl (/app/lisp/cmucl/2010-04-06/bin/lisp) :coding-system utf-8-unix))
utf-8-unix

============================================================

-- Alex -- [email protected] --
 
CD: 2ms