Bug 133895

Summary:	emacs-cvs, slime-cvs, sbcl-0.9.12 error
Product:	Gentoo Linux	Reporter:	Yuan MEI <yuan.mei>
Component:	Current packages	Assignee:	Common Lisp Bugs <common-lisp>
Status:	RESOLVED NEEDINFO
Severity:	normal	CC:	emacs
Priority:	High
Version:	unspecified
Hardware:	All
OS:	Linux
Whiteboard:
Package list:		Runtime testing required:	---

Description Yuan MEI 2006-05-20 12:44:08 UTC

I got the following error in emacs
when M-x slime

(load "/usr/share/emacs/site-lisp/slime-cvs/swank-loader.lisp" :verbose t)
(swank:start-server "/tmp/slime.1126" :external-format :iso-latin-1-unix)

This is SBCL 0.9.12, an implementation of ANSI Common Lisp.
More information about SBCL is available at <http://www.sbcl.org/>.

SBCL is free software, provided as is, with absolutely no warranty.
It is mostly in the public domain; some portions are provided under
BSD-style licenses.  See the CREDITS and COPYING files in the
distribution for more information.
; in: LAMBDA NIL
;     (SB-KERNEL:FLOAT-WAIT)
; 
; note: deleting unreachable code
; 
; compilation unit finished
;   printed 1 note
CL-USER(1): 
; loading #P"/usr/share/emacs/site-lisp/slime-cvs/swank-loader.lisp"
; loading system definition from /usr/share/common-lisp/systems/swank.asd into
; #<PACKAGE "ASDF0">
; registering #<SYSTEM SWANK {A842579}> as SWANK
; loading system definition from
; /usr/lib/sbcl/sb-bsd-sockets/sb-bsd-sockets.asd into #<PACKAGE "ASDF0">
; registering #<SYSTEM SB-BSD-SOCKETS {AA2FAB1}> as SB-BSD-SOCKETS
; compiling file "/usr/share/common-lisp/source/swank/swank-backend.lisp" (written 20 MAY 2006 01:45:37 AM):
; compiling (DEFPACKAGE :SWANK-BACKEND ...)
; compiling (DEFPACKAGE :SWANK-MOP ...)
; compiling (IN-PACKAGE :SWANK-BACKEND)
; compiling (DEFPARAMETER *INTERFACE-FUNCTIONS* ...)
; compiling (DEFPARAMETER *UNIMPLEMENTED-INTERFACES* ...)
; compiling (DEFMACRO DEFINTERFACE ...)
; compiling (DEFMACRO DEFIMPLEMENTATION ...)
; compiling (DEFUN WARN-UNIMPLEMENTED-INTERFACES ...)
; compiling (DEFUN IMPORT-TO-SWANK-MOP ...)
; compiling (DEFUN IMPORT-SWANK-MOP-SYMBOLS ...)
; compiling (DEFVAR *GRAY-STREAM-SYMBOLS* ...)
; compiling (DEFUN IMPORT-FROM ...)
; compiling (DEFMACRO WITH-STRUCT ...)
; compiling (DEFINTERFACE CREATE-SOCKET ...)
; compiling (DEFINTERFACE LOCAL-PORT ...)
; compiling (DEFINTERFACE CLOSE-SOCKET ...)
; compiling (DEFINTERFACE ACCEPT-CONNECTION ...)
; compiling (DEFINTERFACE ADD-SIGIO-HANDLER ...)
; compiling (DEFINTERFACE REMOVE-SIGIO-HANDLERS ...)
; compiling (DEFINTERFACE ADD-FD-HANDLER ...)
; compiling (DEFINTERFACE REMOVE-FD-HANDLERS ...)
; compiling (DEFINTERFACE PREFERRED-COMMUNICATION-STYLE ...)
; compiling (DEFINTERFACE SET-STREAM-TIMEOUT ...)
; compiling (DEFINE-CONDITION NETWORK-ERROR ...)
; compiling (DEFINTERFACE EMACS-CONNECTED ...)
; compiling (DEFCONSTANT +SIGINT+ ...)
; compiling (DEFINTERFACE CALL-WITHOUT-INTERRUPTS ...)
; compiling (DEFINTERFACE GETPID ...)
; compiling (DEFINTERFACE LISP-IMPLEMENTATION-TYPE-NAME ...)
; compiling (DEFINTERFACE DEFAULT-DIRECTORY ...)
; compiling (DEFINTERFACE SET-DEFAULT-DIRECTORY ...)
; compiling (DEFINTERFACE CALL-WITH-SYNTAX-HOOKS ...)
; compiling (DEFINTERFACE DEFAULT-READTABLE-ALIST ...)
; compiling (DEFINTERFACE QUIT-LISP ...)
; compiling (DEFINTERFACE CALL-WITH-COMPILATION-HOOKS ...)
; compiling (DEFMACRO WITH-COMPILATION-HOOKS ...)
; compiling (DEFINTERFACE SWANK-COMPILE-STRING ...)
; compiling (DEFINTERFACE OPERATE-ON-SYSTEM ...)
; compiling (DEFINTERFACE SWANK-COMPILE-FILE ...)
; compiling (DEFTYPE SEVERITY ...)
; compiling (DEFINE-CONDITION COMPILER-CONDITION ...)
; compiling (DEFINTERFACE MAKE-FN-STREAMS ...)
; compiling (DEFINTERFACE MAKE-STREAM-INTERACTIVE ...)
; compiling (DEFINTERFACE ARGLIST ...)
; compiling (DEFINTERFACE FUNCTION-NAME ...)
; compiling (DEFINTERFACE MACROEXPAND-ALL ...)
; compiling (DEFINTERFACE COMPILER-MACROEXPAND-1 ...)
; compiling (DEFINTERFACE COMPILER-MACROEXPAND ...)
; compiling (DEFINTERFACE DESCRIBE-SYMBOL-FOR-EMACS ...)
; compiling (DEFINTERFACE DESCRIBE-DEFINITION ...)
; compiling (DEFINTERFACE INSTALL-DEBUGGER-GLOBALLY ...)
; compiling (DEFINTERFACE CALL-WITH-DEBUGGING-ENVIRONMENT ...)
; compiling (DEFINTERFACE CALL-WITH-DEBUGGER-HOOK ...)
; compiling (DEFINE-CONDITION SLDB-CONDITION ...)
; compiling (DEFINTERFACE COMPUTE-BACKTRACE ...)
; compiling (DEFINTERFACE PRINT-FRAME ...)
; compiling (DEFINTERFACE FRAME-SOURCE-LOCATION-FOR-EMACS ...)
; compiling (DEFINTERFACE FRAME-CATCH-TAGS ...)
; compiling (DEFINTERFACE FRAME-LOCALS ...)
; compiling (DEFINTERFACE FRAME-VAR-VALUE ...)
; compiling (DEFINTERFACE DISASSEMBLE-FRAME ...)
; compiling (DEFINTERFACE EVAL-IN-FRAME ...)
; compiling (DEFINTERFACE RETURN-FROM-FRAME ...)
; compiling (DEFINTERFACE RESTART-FRAME ...)
; compiling (DEFINTERFACE FORMAT-SLDB-CONDITION ...)
; compiling (DEFINTERFACE CONDITION-REFERENCES ...)
; compiling (DEFINTERFACE CONDITION-EXTRAS ...)
; compiling (DEFINTERFACE ACTIVATE-STEPPING ...)
; compiling (DEFINTERFACE SLDB-BREAK-ON-RETURN ...)
; compiling (DEFINTERFACE SLDB-BREAK-AT-START ...)
; compiling (DEFSTRUCT (:LOCATION # ...) ...)
; compiling (DEFSTRUCT (:ERROR # ...) ...)
; compiling (DEFSTRUCT (:FILE # ...) ...)
; compiling (DEFSTRUCT (:BUFFER # ...) ...)
; compiling (DEFSTRUCT (:POSITION # ...) ...)
; compiling (DEFINTERFACE FIND-DEFINITIONS ...)
; compiling (DEFINTERFACE BUFFER-FIRST-CHANGE ...)
; compiling (DEFINTERFACE WHO-CALLS ...)
; compiling (DEFINTERFACE CALLS-WHO ...)
; compiling (DEFINTERFACE WHO-REFERENCES ...)
; compiling (DEFINTERFACE WHO-BINDS ...)
; compiling (DEFINTERFACE WHO-SETS ...)
; compiling (DEFINTERFACE WHO-MACROEXPANDS ...)
; compiling (DEFINTERFACE WHO-SPECIALIZES ...)
; compiling (DEFINTERFACE LIST-CALLERS ...)
; compiling (DEFINTERFACE LIST-CALLEES ...)
; compiling (DEFINTERFACE PROFILE ...)
; compiling (DEFINTERFACE PROFILED-FUNCTIONS ...)
; compiling (DEFINTERFACE UNPROFILE ...)
; compiling (DEFINTERFACE UNPROFILE-ALL ...)
; compiling (DEFINTERFACE PROFILE-REPORT ...)
; compiling (DEFINTERFACE PROFILE-RESET ...)
; compiling (DEFINTERFACE PROFILE-PACKAGE ...)
; compiling (DEFCLASS INSPECTOR ...)
; compiling (DEFINTERFACE MAKE-DEFAULT-INSPECTOR ...)
; compiling (DEFINTERFACE INSPECT-FOR-EMACS ...)
; compiling (DEFMETHOD INSPECT-FOR-EMACS ...)
; compiling (DEFUN LABEL-VALUE-LINE ...)
; compiling (DEFMACRO LABEL-VALUE-LINE* ...)
; compiling (DEFINTERFACE DESCRIBE-PRIMITIVE-TYPE ...)
; compiling (DEFINTERFACE INITIALIZE-MULTIPROCESSING ...)
; compiling (DEFINTERFACE STARTUP-IDLE-AND-TOP-LEVEL-LOOPS ...)
; compiling (DEFINTERFACE SPAWN ...)
; compiling (DEFINTERFACE THREAD-ID ...)
; compiling (DEFINTERFACE FIND-THREAD ...)
; compiling (DEFINTERFACE THREAD-NAME ...)
; compiling (DEFINTERFACE THREAD-STATUS ...)
; compiling (DEFINTERFACE MAKE-LOCK ...)
; compiling (DEFINTERFACE CALL-WITH-LOCK-HELD ...)
; compiling (DEFINTERFACE MAKE-RECURSIVE-LOCK ...)
; compiling (DEFINTERFACE CALL-WITH-RECURSIVE-LOCK-HELD ...)
; compiling (DEFINTERFACE CURRENT-THREAD ...)
; compiling (DEFINTERFACE ALL-THREADS ...)
; compiling (DEFINTERFACE THREAD-ALIVE-P ...)
; compiling (DEFINTERFACE INTERRUPT-THREAD ...)
; compiling (DEFINTERFACE KILL-THREAD ...)
; compiling (DEFINTERFACE SEND ...)
; compiling (DEFINTERFACE RECEIVE ...)
; compiling (DEFINTERFACE TOGGLE-TRACE ...)
; compiling (DEFINTERFACE MAKE-WEAK-KEY-HASH-TABLE ...)
; compiling (DEFINTERFACE MAKE-WEAK-VALUE-HASH-TABLE ...)

; /var/cache/common-lisp-controller/1001/sbcl/swank/swank-backend.fasl written
; compilation finished in 0:00:02
WARNING: SWANK-BACKEND also exports the following symbols:
  (SWANK-BACKEND:MAKE-WEAK-VALUE-HASH-TABLE SWANK-BACKEND:FRAME-CATCH-TAGS
                                            SWANK-BACKEND:ADD-SIGIO-HANDLER
                                            SWANK-BACKEND:FORMAT-SLDB-CONDITION
                                            SWANK-BACKEND:PROFILE-PACKAGE
                                            SWANK-BACKEND:RESTART-FRAME
                                            SWANK-BACKEND:DEFAULT-DIRECTORY
                                            SWANK-BACKEND:MAKE-RECURSIVE-LOCK
                                            SWANK-BACKEND:FRAME-SOURCE-LOCATION-FOR-EMACS
                                            SWANK-BACKEND:MAKE-WEAK-KEY-HASH-TABLE
                                            SWANK-BACKEND:COMPUTE-BACKTRACE
                                            SWANK-BACKEND:CALL-WITH-DEBUGGER-HOOK
                                            SWANK-BACKEND:INITIALIZE-MULTIPROCESSING
                                            SWANK-BACKEND:LIST-CALLEES
                                            SWANK-BACKEND:RECEIVE
                                            SWANK-BACKEND:COMPILER-MACROEXPAND-1
                                            SWANK-BACKEND:REMOVE-SIGIO-HANDLERS
                                            SWANK-BACKEND:ACCEPT-CONNECTION
                                            SWANK-BACKEND:THREAD-NAME
                                            SWANK-BACKEND:CALL-WITH-RECURSIVE-LOCK-HELD
                                            SWANK-BACKEND:UNPROFILE
                                            SWANK-BACKEND:TOGGLE-TRACE
                                            SWANK-BACKEND:THREAD-ALIVE-P
                                            SWANK-BACKEND:SET-STREAM-TIMEOUT
                                            SWANK-BACKEND:CLOSE-SOCKET
                                            SWANK-BACKEND:DESCRIBE-SYMBOL-FOR-EMACS
                                            SWANK-BACKEND:SPAWN
                                            SWANK-BACKEND:MAKE-DEFAULT-INSPECTOR
                                            SWANK-BACKEND:SLDB-BREAK-AT-START
                                            SWANK-BACKEND:FIND-DEFINITIONS
                                            SWANK-BACKEND:WHO-SPECIALIZES
                                            SWANK-BACKEND:THREAD-STATUS
                                            SWANK-BACKEND:CONDITION-EXTRAS
                                            SWANK-BACKEND:FUNCTION-NAME
                                            SWANK-BACKEND:OPERATE-ON-SYSTEM
                                            SWANK-BACKEND:UNPROFILE-ALL
                                            SWANK-BACKEND:EVAL-IN-FRAME
                                            SWANK-BACKEND:FIND-THREAD
                                            SWANK-BACKEND:SLDB-BREAK-ON-RETURN
                                            SWANK-BACKEND:WHO-REFERENCES
                                            SWANK-BACKEND:LOCAL-PORT
                                            SWANK-BACKEND:CALL-WITH-DEBUGGING-ENVIRONMENT
                                            SWANK-BACKEND:PROFILED-FUNCTIONS
                                            SWANK-BACKEND:SEND
                                            SWANK-BACKEND:CALL-WITH-SYNTAX-HOOKS
                                            SWANK-BACKEND:EMACS-CONNECTED
                                            SWANK-BACKEND:WHO-BINDS
                                            SWANK-BACKEND:MAKE-LOCK
                                            SWANK-BACKEND:CREATE-SOCKET
                                            SWANK-BACKEND:BUFFER-FIRST-CHANGE
                                            SWANK-BACKEND:SET-DEFAULT-DIRECTORY
                                            SWANK-BACKEND:PROFILE-RESET
                                            SWANK-BACKEND:FRAME-VAR-VALUE
                                            SWANK-BACKEND:MACROEXPAND-ALL
                                            SWANK-BACKEND:CURRENT-THREAD
                                            SWANK-BACKEND:STARTUP-IDLE-AND-TOP-LEVEL-LOOPS
                                            SWANK-BACKEND:ACTIVATE-STEPPING
                                            SWANK-BACKEND:DISASSEMBLE-FRAME
                                            SWANK-BACKEND:SWANK-COMPILE-FILE
                                            SWANK-BACKEND:PROFILE-REPORT
                                            SWANK-BACKEND:CALL-WITH-LOCK-HELD
                                            SWANK-BACKEND:FRAME-LOCALS
                                            SWANK-BACKEND:ALL-THREADS
                                            SWANK-BACKEND:DESCRIBE-DEFINITION
                                            SWANK-BACKEND:WHO-SETS
                                            SWANK-BACKEND:CALL-WITH-COMPILATION-HOOKS
                                            SWANK-BACKEND:REMOVE-FD-HANDLERS
                                            SWANK-BACKEND:LISP-IMPLEMENTATION-TYPE-NAME
                                            SWANK-BACKEND:ARGLIST
                                            SWANK-BACKEND:RETURN-FROM-FRAME
                                            SWANK-BACKEND:LIST-CALLERS
                                            SWANK-BACKEND:PREFERRED-COMMUNICATION-STYLE
                                            SWANK-BACKEND:ADD-FD-HANDLER
                                            SWANK-BACKEND:KILL-THREAD
                                            SWANK-BACKEND:CALL-WITHOUT-INTERRUPTS
                                            SWANK-BACKEND:COMPILER-MACROEXPAND
                                            SWANK-BACKEND:CONDITION-REFERENCES
                                            SWANK-BACKEND:THREAD-ID
                                            SWANK-BACKEND:MAKE-FN-STREAMS
                                            SWANK-BACKEND:PRINT-FRAME
                                            SWANK-BACKEND:GETPID
                                            SWANK-BACKEND:DESCRIBE-PRIMITIVE-TYPE
                                            SWANK-BACKEND:PROFILE
                                            SWANK-BACKEND:SWANK-COMPILE-STRING
                                            SWANK-BACKEND:MAKE-STREAM-INTERACTIVE
                                            SWANK-BACKEND:DEFAULT-READTABLE-ALIST
                                            SWANK-BACKEND:WHO-CALLS
                                            SWANK-BACKEND:INTERRUPT-THREAD
                                            SWANK-BACKEND:INSTALL-DEBUGGER-GLOBALLY
                                            SWANK-BACKEND:WHO-MACROEXPANDS
                                            SWANK-BACKEND:CALLS-WHO)
See also:
  The ANSI Standard, Macro DEFPACKAGE
; compiling file "/usr/share/common-lisp/source/swank/nregex.lisp" (written 20 MAY 2006 01:45:37 AM):
; compiling (IN-PACKAGE :CL-USER)
; compiling (DEFPACKAGE SLIME-NREGEX ...)
; compiling (IN-PACKAGE :SLIME-NREGEX)
; compiling (DEFVAR *REGEX-DEBUG* ...)
; compiling (DEFMACRO INFO ...)
; compiling (DEFVAR *REGEX-GROUPS* ...)
; compiling (DEFVAR *REGEX-GROUPINGS* ...)
; compiling (DEFUN REGEX ...)
; compiling (DEFVAR *REGEX-SPECIAL-CHARS* ...)
; compiling (DEFMACRO ADD-EXP ...)
; compiling (DEFUN REGEX-QUOTED ...)
; compiling (DEFUN REGEX-COMPILE ...)

; /var/cache/common-lisp-controller/1001/sbcl/swank/nregex.fasl written
; compilation finished in 0:00:01
; compiling file "/usr/share/common-lisp/source/swank/swank-sbcl.lisp" (written 20 MAY 2006 01:45:37 AM):
; compiling (IN-PACKAGE :SWANK-BACKEND)
; compiling (REQUIRE (QUOTE SB-BSD-SOCKETS))
; compiling (REQUIRE (QUOTE SB-INTROSPECT))
; compiling (REQUIRE (QUOTE SB-POSIX))
; compiling (DECLAIM (OPTIMIZE #))
; compiling (IMPORT-FROM :SB-GRAY ...)
; compiling (IMPORT-SWANK-MOP-SYMBOLS :SB-MOP ...)
; compiling (DEFUN SWANK-MOP:SLOT-DEFINITION-DOCUMENTATION ...)
; compiling (DEFIMPLEMENTATION PREFERRED-COMMUNICATION-STYLE ...)
; compiling (DEFUN RESOLVE-HOSTNAME ...)
; compiling (DEFIMPLEMENTATION CREATE-SOCKET ...)
; compiling (DEFIMPLEMENTATION LOCAL-PORT ...)
; compiling (DEFIMPLEMENTATION CLOSE-SOCKET ...)
; compiling (DEFIMPLEMENTATION ACCEPT-CONNECTION ...)
; compiling (DEFVAR *SIGIO-HANDLERS* ...)
; compiling (DEFUN SIGIO-HANDLER ...)
; compiling (DEFUN SET-SIGIO-HANDLER ...)
; compiling (DEFUN ENABLE-SIGIO-ON-FD ...)
; compiling (DEFIMPLEMENTATION ADD-SIGIO-HANDLER ...)
; compiling (DEFIMPLEMENTATION REMOVE-SIGIO-HANDLERS ...)
; compiling (DEFIMPLEMENTATION ADD-FD-HANDLER ...)
; compiling (DEFIMPLEMENTATION REMOVE-FD-HANDLERS ...)
; compiling (DEFUN SOCKET-FD ...)
; compiling (DEFUN FIND-EXTERNAL-FORMAT ...)
; compiling (DEFUN MAKE-SOCKET-IO-STREAM ...)
; compiling (DEFUN ACCEPT ...)
; compiling (DEFMETHOD CALL-WITHOUT-INTERRUPTS ...)
; compiling (DEFIMPLEMENTATION GETPID ...)
; compiling (DEFIMPLEMENTATION LISP-IMPLEMENTATION-TYPE-NAME ...)
; compiling (DEFUN FEATURE-IN-LIST-P ...)
; compiling (DEFUN SHEBANG-READER ...)
; compiling (DEFVAR *SHEBANG-READTABLE* ...)
; compiling (DEFUN SHEBANG-READTABLE ...)
; compiling (DEFUN SBCL-PACKAGE-P ...)
; compiling (DEFUN SBCL-SOURCE-FILE-P ...)
; compiling (DEFUN GUESS-READTABLE-FOR-FILENAME ...)
; compiling (DEFVAR *DEBOOTSTRAP-PACKAGES* ...)
; compiling (DEFUN CALL-WITH-DEBOOTSTRAPPING ...)
; compiling (DEFMACRO WITH-DEBOOTSTRAPPING ...)
; compiling (DEFIMPLEMENTATION CALL-WITH-SYNTAX-HOOKS ...)
; compiling (DEFIMPLEMENTATION DEFAULT-READTABLE-ALIST ...)
; compiling (DEFIMPLEMENTATION ARGLIST ...)
; compiling (DEFIMPLEMENTATION FUNCTION-NAME ...)
; compiling (DEFVAR *BUFFER-NAME* ...)
; compiling (DEFVAR *BUFFER-OFFSET*)
; compiling (DEFVAR *BUFFER-SUBSTRING* ...)
; compiling (DEFVAR *PREVIOUS-COMPILER-CONDITION* ...)
; compiling (DEFUN HANDLE-NOTIFICATION-CONDITION ...)
; compiling (DEFUN SIGNAL-COMPILER-CONDITION ...)
; compiling (DEFUN REAL-CONDITION ...)
; compiling (DEFUN COMPILER-NOTE-LOCATION ...)
; compiling (DEFUN LOCATE-COMPILER-NOTE ...)
; compiling (DEFUN BRIEF-COMPILER-MESSAGE-FOR-EMACS ...)
; compiling (DEFUN LONG-COMPILER-MESSAGE-FOR-EMACS ...)
; compiling (DEFUN COMPILER-SOURCE-PATH ...)
; compiling (DEFIMPLEMENTATION CALL-WITH-COMPILATION-HOOKS ...)
; compiling (DEFUN HANDLE-FILE-COMPILER-TERMINATION ...)
; compiling (DEFVAR *TRAP-LOAD-TIME-WARNINGS* ...)
; compiling (DEFIMPLEMENTATION SWANK-COMPILE-FILE ...)
; compiling (DEFIMPLEMENTATION SWANK-COMPILE-STRING ...)
; compiling (DEFVAR *DEBUG-DEFINITION-FINDING* ...)
; compiling (DEFUN NEW-DEFINITION-SOURCE-P ...)
; compiling (DEFPARAMETER *DEFINITION-TYPES* ...)
; compiling (DEFIMPLEMENTATION FIND-DEFINITIONS ...)
; compiling (DEFUN MAKE-SOURCE-LOCATION-SPECIFICATION ...)
; compiling (DEFUN MAKE-DEFINITION-SOURCE-LOCATION ...)
; compiling (DEFUN SOURCE-HINT-SNIPPET ...)
; compiling (DEFUN FUNCTION-SOURCE-LOCATION ...)
; compiling (DEFUN SAFE-FUNCTION-SOURCE-LOCATION ...)
; compiling (DEFIMPLEMENTATION DESCRIBE-SYMBOL-FOR-EMACS ...)
; compiling (DEFIMPLEMENTATION DESCRIBE-DEFINITION ...)
; compiling (DEFIMPLEMENTATION LIST-CALLERS ...)
; compiling (DEFIMPLEMENTATION LIST-CALLEES ...)
; compiling (DEFUN FUNCTION-DSPEC ...)
; compiling (DEFIMPLEMENTATION MACROEXPAND-ALL ...)
; compiling (DEFVAR *SLDB-STACK-TOP*)
; compiling (DEFIMPLEMENTATION INSTALL-DEBUGGER-GLOBALLY ...)
; compiling (DEFIMPLEMENTATION CALL-WITH-DEBUGGING-ENVIRONMENT ...)
; compiling (DEFIMPLEMENTATION CALL-WITH-DEBUGGER-HOOK ...)
; compiling (DEFUN NTH-FRAME ...)
; compiling (DEFIMPLEMENTATION COMPUTE-BACKTRACE ...)
; compiling (DEFIMPLEMENTATION PRINT-FRAME ...)
; compiling (DEFUN CODE-LOCATION-SOURCE-LOCATION ...)
; compiling (DEFUN FILE-SOURCE-LOCATION ...)
; compiling (DEFUN FALLBACK-SOURCE-LOCATION ...)
; compiling (DEFUN LISP-SOURCE-LOCATION ...)
; compiling (DEFUN EMACS-BUFFER-SOURCE-LOCATION ...)
; compiling (DEFUN SOURCE-FILE-SOURCE-LOCATION ...)
; compiling (DEFUN CODE-LOCATION-DEBUG-SOURCE-NAME ...)
; compiling (DEFUN CODE-LOCATION-DEBUG-SOURCE-CREATED ...)
; compiling (DEFUN CODE-LOCATION-DEBUG-FUN-FUN ...)
; compiling (DEFUN CODE-LOCATION-HAS-DEBUG-BLOCK-INFO-P ...)
; compiling (DEFUN STREAM-SOURCE-POSITION ...)
; compiling (DEFUN STRING-SOURCE-POSITION ...)
; compiling (DEFUN SAFE-SOURCE-LOCATION-FOR-EMACS ...)
; compiling (DEFIMPLEMENTATION FRAME-SOURCE-LOCATION-FOR-EMACS ...)
; compiling (DEFUN FRAME-DEBUG-VARS ...)
; compiling (DEFUN DEBUG-VAR-VALUE ...)
; compiling (DEFIMPLEMENTATION FRAME-LOCALS ...)
; compiling (DEFIMPLEMENTATION FRAME-VAR-VALUE ...)
; compiling (DEFIMPLEMENTATION FRAME-CATCH-TAGS ...)
; compiling (DEFIMPLEMENTATION EVAL-IN-FRAME ...)
; compiling (DEFUN SB-DEBUG-CATCH-TAG-P ...)
; compiling (DEFIMPLEMENTATION RETURN-FROM-FRAME ...)
; compiling (DEFIMPLEMENTATION RESTART-FRAME ...)
; compiling (DEFIMPLEMENTATION FORMAT-SLDB-CONDITION ...)
; compiling (DEFIMPLEMENTATION CONDITION-REFERENCES ...)
; compiling (DEFIMPLEMENTATION PROFILE ...)
; compiling (DEFIMPLEMENTATION UNPROFILE ...)
; compiling (DEFIMPLEMENTATION UNPROFILE-ALL ...)
; compiling (DEFIMPLEMENTATION PROFILE-REPORT ...)
; compiling (DEFIMPLEMENTATION PROFILE-RESET ...)
; compiling (DEFIMPLEMENTATION PROFILED-FUNCTIONS ...)
; compiling (DEFIMPLEMENTATION PROFILE-PACKAGE ...)
; compiling (DEFCLASS SBCL-INSPECTOR ...)
; compiling (DEFIMPLEMENTATION MAKE-DEFAULT-INSPECTOR ...)
; compiling (DEFMETHOD INSPECT-FOR-EMACS ...)
; compiling (DEFMETHOD INSPECT-FOR-EMACS ...)
; compiling (DEFMETHOD INSPECT-FOR-EMACS ...)
; compiling (DEFMETHOD INSPECT-FOR-EMACS ...)
; compiling (DEFMETHOD INSPECT-FOR-EMACS ...)
; compiling (DEFVAR *THREAD-ID-COUNTER* ...)
; compiling (DEFVAR *THREAD-ID-COUNTER-LOCK* ...)
; compiling (DEFUN NEXT-THREAD-ID ...)
; compiling (DEFPARAMETER *THREAD-ID-MAP* ...)
; compiling (DEFVAR *THREAD-ID-MAP-LOCK* ...)
; compiling (DEFIMPLEMENTATION SPAWN ...)
; compiling (DEFIMPLEMENTATION STARTUP-MULTIPROCESSING ...)
; compiling (DEFIMPLEMENTATION THREAD-ID ...)
; compiling (DEFIMPLEMENTATION FIND-THREAD ...)
; compiling (DEFIMPLEMENTATION THREAD-NAME ...)
; compiling (DEFIMPLEMENTATION THREAD-STATUS ...)
; compiling (DEFIMPLEMENTATION MAKE-LOCK ...)
; compiling (DEFIMPLEMENTATION CALL-WITH-LOCK-HELD ...)
; compiling (DEFIMPLEMENTATION MAKE-RECURSIVE-LOCK ...)
; compiling (DEFIMPLEMENTATION CALL-WITH-RECURSIVE-LOCK-HELD ...)
; compiling (DEFIMPLEMENTATION CURRENT-THREAD ...)
; compiling (DEFIMPLEMENTATION ALL-THREADS ...)
; compiling (DEFIMPLEMENTATION INTERRUPT-THREAD ...)
; compiling (DEFIMPLEMENTATION KILL-THREAD ...)
; compiling (DEFIMPLEMENTATION THREAD-ALIVE-P ...)
; compiling (DEFVAR *MAILBOX-LOCK* ...)
; compiling (DEFVAR *MAILBOXES* ...)
; compiling (DECLAIM (TYPE LIST ...))
; compiling (DEFSTRUCT (MAILBOX #) ...)
; compiling (DEFUN MAILBOX ...)
; compiling (DEFIMPLEMENTATION SEND ...)
; compiling (DEFIMPLEMENTATION RECEIVE ...)
; compiling (DEFVAR *AUTO-FLUSH-STREAMS* ...)
; compiling (DEFVAR *AUTO-FLUSH-THREAD* ...)
; compiling (DEFIMPLEMENTATION MAKE-STREAM-INTERACTIVE ...)
; compiling (DEFUN FLUSH-STREAMS ...)
; compiling (DEFIMPLEMENTATION QUIT-LISP ...)
; compiling (DEFUN TOGGLE-TRACE-AUX ...)
; compiling (DEFUN PROCESS-FSPEC ...)
; compiling (DEFIMPLEMENTATION TOGGLE-TRACE ...)

; /var/cache/common-lisp-controller/1001/sbcl/swank/swank-sbcl.fasl written
; compilation finished in 0:00:05
STYLE-WARNING: redefining PREFERRED-COMMUNICATION-STYLE NIL in DEFMETHOD
STYLE-WARNING: redefining CALL-WITHOUT-INTERRUPTS (T) in DEFMETHOD
STYLE-WARNING: redefining LISP-IMPLEMENTATION-TYPE-NAME NIL in DEFMETHOD
STYLE-WARNING: redefining CALL-WITH-SYNTAX-HOOKS (T) in DEFMETHOD
STYLE-WARNING: redefining DEFAULT-READTABLE-ALIST NIL in DEFMETHOD
STYLE-WARNING: redefining ARGLIST (T) in DEFMETHOD
STYLE-WARNING: redefining NEW-DEFINITION-SOURCE-P in DEFUN
STYLE-WARNING: redefining INSTALL-DEBUGGER-GLOBALLY (T) in DEFMETHOD
STYLE-WARNING: redefining CALL-WITH-DEBUGGER-HOOK (T T) in DEFMETHOD
STYLE-WARNING: redefining FORMAT-SLDB-CONDITION (T) in DEFMETHOD
STYLE-WARNING: redefining CONDITION-REFERENCES (T) in DEFMETHOD
STYLE-WARNING: redefining UNPROFILE-ALL NIL in DEFMETHOD
STYLE-WARNING: implicitly creating new generic function STARTUP-MULTIPROCESSING
WARNING: DEFIMPLEMENTATION of undefined interface (STARTUP-MULTIPROCESSING)
STYLE-WARNING: redefining THREAD-NAME (T) in DEFMETHOD
STYLE-WARNING: redefining THREAD-STATUS (T) in DEFMETHOD
STYLE-WARNING: redefining MAKE-LOCK NIL in DEFMETHOD
STYLE-WARNING: redefining CALL-WITH-LOCK-HELD (T T) in DEFMETHOD
STYLE-WARNING: redefining MAKE-RECURSIVE-LOCK NIL in DEFMETHOD
STYLE-WARNING: redefining CALL-WITH-RECURSIVE-LOCK-HELD (T T) in DEFMETHOD
STYLE-WARNING: redefining CURRENT-THREAD NIL in DEFMETHOD
STYLE-WARNING: redefining KILL-THREAD (T) in DEFMETHOD
STYLE-WARNING: redefining THREAD-ALIVE-P (T) in DEFMETHOD
STYLE-WARNING: redefining MAKE-STREAM-INTERACTIVE (T) in DEFMETHOD
; compiling file "/usr/share/common-lisp/source/swank/swank-source-path-parser.lisp" (written 20 MAY 2006 01:45:37 AM):
; compiling (IN-PACKAGE :SWANK-BACKEND)
; compiling (LET (#) ...)
; compiling (DEFUN MAKE-SOURCE-RECORDER ...)
; compiling (DEFUN MAKE-SOURCE-RECORDING-READTABLE ...)
; compiling (DEFUN SUPPRESS-SHARP-DOT ...)
; compiling (DEFUN READ-AND-RECORD-SOURCE-MAP ...)
; compiling (DEFUN READ-SOURCE-FORM ...)
; compiling (DEFUN SOURCE-PATH-STREAM-POSITION ...)
; compiling (DEFUN CHECK-SOURCE-PATH ...)
; compiling (DEFUN SOURCE-PATH-STRING-POSITION ...)
; compiling (DEFUN SOURCE-PATH-FILE-POSITION ...)
; compiling (DEFUN SOURCE-PATH-SOURCE-POSITION ...)

; /var/cache/common-lisp-controller/1001/sbcl/swank/swank-source-path-parser.fasl written
; compilation finished in 0:00:00
; compiling file "/usr/share/common-lisp/source/swank/swank-source-file-cache.lisp" (written 20 MAY 2006 01:45:37 AM):
; compiling (IN-PACKAGE :SWANK-BACKEND)
; compiling (DEFVAR *CACHE-SOURCECODE* ...)
; compiling (DEFVAR *SOURCE-FILE-CACHE* ...)
; compiling (DEFSTRUCT (SOURCE-CACHE-ENTRY # ...) ...)
; compiling (DEFIMPLEMENTATION BUFFER-FIRST-CHANGE ...)
; compiling (DEFUN GET-SOURCE-CODE ...)
; compiling (DEFUN SOURCE-CACHE-GET ...)
; compiling (DEFUN SOURCE-CACHED-P ...)
; compiling (DEFUN READ-FILE ...)
; compiling (DEFVAR *SOURCE-SNIPPET-SIZE* ...)
; compiling (DEFUN READ-SNIPPET ...)
; compiling (DEFUN SKIP-COMMENTS-AND-WHITESPACE ...)
; compiling (DEFUN READ-UPTO-N-CHARS ...)

; /var/cache/common-lisp-controller/1001/sbcl/swank/swank-source-file-cache.fasl written
; compilation finished in 0:00:01
STYLE-WARNING: redefining BUFFER-FIRST-CHANGE (T) in DEFMETHOD
; compiling file "/usr/share/common-lisp/source/swank/swank-gray.lisp" (written 20 MAY 2006 01:45:37 AM):
; compiling (IN-PACKAGE :SWANK-BACKEND)
; compiling (DEFCLASS SLIME-OUTPUT-STREAM ...)
; compiling (DEFMETHOD STREAM-WRITE-CHAR ...)
; compiling (DEFMETHOD STREAM-LINE-COLUMN ...)
; compiling (DEFMETHOD STREAM-LINE-LENGTH ...)
; compiling (DEFMETHOD STREAM-FINISH-OUTPUT ...)
; compiling (DEFMETHOD STREAM-FORCE-OUTPUT ...)
; compiling (DEFMETHOD STREAM-FRESH-LINE ...)
; compiling (DEFCLASS SLIME-INPUT-STREAM ...)
; compiling (DEFMETHOD STREAM-READ-CHAR ...)
; compiling (DEFMETHOD STREAM-LISTEN ...)
; compiling (DEFMETHOD STREAM-UNREAD-CHAR ...)
; compiling (DEFMETHOD STREAM-CLEAR-INPUT ...)
; compiling (DEFMETHOD STREAM-LINE-COLUMN ...)
; compiling (DEFMETHOD STREAM-LINE-LENGTH ...)
; compiling (DEFMETHOD STREAM-READ-CHAR-NO-HANG ...)
; compiling (DEFMETHOD STREAM-READ-CHAR-WILL-HANG-P ...)
; compiling (DEFIMPLEMENTATION MAKE-FN-STREAMS ...)

; /var/cache/common-lisp-controller/1001/sbcl/swank/swank-gray.fasl written
; compilation finished in 0:00:01
STYLE-WARNING:
   implicitly creating new generic function STREAM-READ-CHAR-WILL-HANG-P
; compiling file "/usr/share/common-lisp/source/swank/swank.lisp" (written 20 MAY 2006 01:45:37 AM):
; compiling (DEFPACKAGE :SWANK ...)
; compiling (IN-PACKAGE :SWANK)
; compiling (DEFCONSTANT CL-PACKAGE ...)
; compiling (DEFCONSTANT KEYWORD-PACKAGE ...)
; compiling (DEFVAR *CANONICAL-PACKAGE-NICKNAMES* ...)
; compiling (DEFVAR *AUTO-ABBREVIATE-DOTTED-PACKAGES* ...)
; compiling (DEFVAR *SWANK-IO-PACKAGE* ...)
; compiling (DEFCONSTANT DEFAULT-SERVER-PORT ...)
; compiling (DEFVAR *SWANK-DEBUG-P* ...)
; compiling (DEFVAR *REDIRECT-IO* ...)
; compiling (DEFVAR *SLDB-PRINTER-BINDINGS* ...)
; compiling (DEFVAR *DEFAULT-WORKER-THREAD-BINDINGS* ...)
; compiling (DEFUN CALL-WITH-BINDINGS ...)
; compiling (DEFMACRO WITH-BINDINGS ...)
; compiling (DEFMACRO DEFSLIMEFUN ...)
; compiling (DECLAIM (FTYPE # ...))
; compiling (DEFUN MISSING-ARG ...)
; compiling (DEFMACRO ADD-HOOK ...)
; compiling (DEFUN RUN-HOOK ...)
; compiling (DEFVAR *NEW-CONNECTION-HOOK* ...)
; compiling (DEFVAR *CONNECTION-CLOSED-HOOK* ...)
; compiling (DEFVAR *PRE-REPLY-HOOK* ...)
; compiling (DEFVAR *CODING-SYSTEM* ...)
; compiling (DEFSTRUCT (CONNECTION # ...) ...)
; compiling (DEFUN PRINT-CONNECTION ...)
; compiling (DEFVAR *CONNECTIONS* ...)
; compiling (DEFVAR *EMACS-CONNECTION* ...)
; compiling (DEFVAR *SWANK-STATE-STACK* ...)
; compiling (DEFUN DEFAULT-CONNECTION ...)
; compiling (DEFSLIMEFUN STATE-STACK ...)
; compiling (DEFINE-CONDITION SLIME-PROTOCOL-ERROR ...)
; compiling (ADD-HOOK *NEW-CONNECTION-HOOK* ...)
; compiling (DEFUN NOTIFY-BACKEND-OF-CONNECTION ...)
; compiling (DEFMACRO WITH-IO-REDIRECTION ...)
; compiling (DEFUN MAYBE-CALL-WITH-IO-REDIRECTION ...)
; compiling (DEFMACRO WITH-CONNECTION ...)
; compiling (DEFUN CALL-WITH-CONNECTION ...)
; compiling (DEFMACRO WITHOUT-INTERRUPTS ...)
; compiling (DEFMACRO DESTRUCTURE-CASE ...)
; compiling (DEFMACRO WITH-TEMP-PACKAGE ...)
; compiling (DEFVAR *LOG-EVENTS* ...)
; compiling (DEFVAR *LOG-OUTPUT* ...)
; compiling (DEFVAR *EVENT-HISTORY* ...)
; compiling (DEFVAR *EVENT-HISTORY-INDEX* ...)
; compiling (DEFVAR *ENABLE-EVENT-HISTORY* ...)
; compiling (DEFUN LOG-EVENT ...)
; compiling (DEFUN EVENT-HISTORY-TO-LIST ...)
; compiling (DEFUN DUMP-EVENT-HISTORY ...)
; compiling (DEFUN DUMP-EVENT ...)
; compiling (DEFUN ESCAPE-NON-ASCII ...)
; compiling (DEFUN ASCII-STRING-P ...)
; compiling (DEFUN ASCII-CHAR-P ...)
; compiling (DEFVAR *USE-DEDICATED-OUTPUT-STREAM* ...)
; compiling (DEFVAR *DEDICATED-OUTPUT-STREAM-PORT* ...)
; compiling (DEFVAR *COMMUNICATION-STYLE* ...)
; compiling (DEFVAR *DEDICATED-OUTPUT-STREAM-BUFFERING* ...)
; compiling (DEFUN START-SERVER ...)
; compiling (DEFUN CREATE-SERVER ...)
; compiling (DEFUN CREATE-SWANK-SERVER ...)
; compiling (DEFPARAMETER *LOOPBACK-INTERFACE* ...)
; compiling (DEFUN SETUP-SERVER ...)
; compiling (DEFUN SERVE-CONNECTION ...)
; compiling (DEFUN ACCEPT-AUTHENTICATED-CONNECTION ...)
; compiling (DEFUN SLIME-SECRET ...)
; compiling (DEFUN SERVE-REQUESTS ...)
; compiling (DEFUN ANNOUNCE-SERVER-PORT ...)
; compiling (DEFUN SIMPLE-ANNOUNCE-FUNCTION ...)
; compiling (DEFUN OPEN-STREAMS ...)
; compiling (DEFUN MAKE-OUTPUT-FUNCTION ...)
; compiling (DEFUN OPEN-DEDICATED-OUTPUT-STREAM ...)
; compiling (DEFUN HANDLE-REQUEST ...)
; compiling (DEFUN CURRENT-SOCKET-IO ...)
; compiling (DEFUN CLOSE-CONNECTION ...)
; compiling (DEFMACRO WITH-READER-ERROR-HANDLER ...)
; compiling (DEFSLIMEFUN SIMPLE-BREAK ...)
; compiling (DEFVAR *ACTIVE-THREADS* ...)
; compiling (DEFUN READ-LOOP ...)
; compiling (DEFUN DISPATCH-LOOP ...)
; compiling (DEFUN REPL-THREAD ...)
; compiling (DEFUN FIND-WORKER-THREAD ...)
; compiling (DEFUN INTERRUPT-WORKER-THREAD ...)
; compiling (DEFUN THREAD-FOR-EVALUATION ...)
; compiling (DEFUN SPAWN-WORKER-THREAD ...)
; compiling (DEFUN SPAWN-REPL-THREAD ...)
; compiling (DEFUN DISPATCH-EVENT ...)
; compiling (DEFUN SPAWN-THREADS-FOR-CONNECTION ...)
; compiling (DEFUN CLEANUP-CONNECTION-THREADS ...)
; compiling (DEFUN REPL-LOOP ...)
; compiling (DEFUN PROCESS-AVAILABLE-INPUT ...)
; compiling (DEFUN INSTALL-SIGIO-HANDLER ...)
; compiling (DEFUN DEINSTALL-SIGIO-HANDLER ...)
; compiling (DEFUN INSTALL-FD-HANDLER ...)
; compiling (DEFUN DEINSTALL-FD-HANDLER ...)
; compiling (DEFUN SIMPLE-SERVE-REQUESTS ...)
; compiling (DEFUN WAIT-UNTIL-READABLE ...)
; compiling (DEFUN READ-FROM-SOCKET-IO ...)
; compiling (DEFUN SEND-TO-SOCKET-IO ...)
; compiling (DEFUN INITIALIZE-STREAMS-FOR-CONNECTION ...)
; compiling (DEFUN CREATE-CONNECTION ...)
; compiling (DEFVAR *GLOBALLY-REDIRECT-IO* ...)
; compiling (DEFMACRO SETUP-STREAM-INDIRECTION ...)
; compiling (DEFUN PREFIXED-VAR ...)
; compiling (SETUP-STREAM-INDIRECTION *STANDARD-OUTPUT*)
; compiling (SETUP-STREAM-INDIRECTION *ERROR-OUTPUT*)
; compiling (SETUP-STREAM-INDIRECTION *TRACE-OUTPUT*)
; compiling (SETUP-STREAM-INDIRECTION *STANDARD-INPUT*)
; compiling (SETUP-STREAM-INDIRECTION *DEBUG-IO*)
; compiling (SETUP-STREAM-INDIRECTION *QUERY-IO*)
; compiling (SETUP-STREAM-INDIRECTION *TERMINAL-IO*)
; compiling (DEFPARAMETER *STANDARD-OUTPUT-STREAMS* ...)
; compiling (DEFPARAMETER *STANDARD-INPUT-STREAMS* ...)
; compiling (DEFPARAMETER *STANDARD-IO-STREAMS* ...)
; compiling (DEFUN GLOBALLY-REDIRECT-IO-TO-CONNECTION ...)
; compiling (DEFUN REVERT-GLOBAL-IO-REDIRECTION ...)
; compiling (DEFVAR *GLOBAL-STDIO-CONNECTION* ...)
; compiling (DEFUN MAYBE-REDIRECT-GLOBAL-IO ...)
; compiling (DEFUN UPDATE-REDIRECTION-AFTER-CLOSE ...)
; compiling (ADD-HOOK *NEW-CONNECTION-HOOK* ...)
; compiling (ADD-HOOK *CONNECTION-CLOSED-HOOK* ...)
; compiling (DEFUN CALL-WITH-REDIRECTED-IO ...)
; compiling (DEFUN READ-FROM-EMACS ...)
; compiling (DEFUN READ-FROM-CONTROL-THREAD ...)
; compiling (DEFUN DECODE-MESSAGE ...)
; compiling (DEFUN DECODE-MESSAGE-LENGTH ...)
; compiling (DEFUN READ-FORM ...)
; compiling (DEFVAR *SLIME-FEATURES* ...)
; compiling (DEFUN SEND-TO-EMACS ...)
; compiling (DEFUN SEND-OOB-TO-EMACS ...)
; compiling (DEFUN SEND-TO-CONTROL-THREAD ...)
; compiling (DEFUN ENCODE-MESSAGE ...)
; compiling (DEFUN PRIN1-TO-STRING-FOR-EMACS ...)
; compiling (DEFUN FORCE-USER-OUTPUT ...)
; compiling (DEFUN CLEAR-USER-INPUT ...)
; compiling (DEFVAR *READ-INPUT-CATCH-TAG* ...)
; compiling (DEFUN INTERN-CATCH-TAG ...)
; compiling (DEFUN READ-USER-INPUT-FROM-EMACS ...)
; compiling (DEFUN Y-OR-N-P-IN-EMACS ...)
; compiling (DEFSLIMEFUN TAKE-INPUT ...)
; compiling (DEFUN PROCESS-FORM-FOR-EMACS ...)
; compiling (DEFUN EVAL-IN-EMACS ...)
; compiling (DEFSLIMEFUN CONNECTION-INFO ...)
; compiling (DEFSLIMEFUN IO-SPEED-TEST ...)
; compiling (DEFMACRO DEFINE-SPECIAL ...)
; compiling (DEFINE-SPECIAL *BUFFER-PACKAGE* ...)
; compiling (DEFINE-SPECIAL *BUFFER-READTABLE* ...)
; compiling (DEFMACRO WITH-BUFFER-SYNTAX ...)
; compiling (DEFUN CALL-WITH-BUFFER-SYNTAX ...)
; compiling (DEFUN TO-STRING ...)
; compiling (DEFUN FROM-STRING ...)
; compiling (DEFUN TOKENIZE-SYMBOL ...)
; compiling (DEFUN TOKENIZE-SYMBOL-THOROUGHLY ...)
; compiling (DEFUN CASIFY-CHAR ...)
; compiling (DEFUN PARSE-SYMBOL ...)
; compiling (DEFUN PARSE-SYMBOL-OR-LOSE ...)
; compiling (DEFUN PARSE-PACKAGE ...)
; compiling (DEFUN GUESS-PACKAGE-FROM-STRING ...)
; compiling (DEFVAR *READTABLE-ALIST* ...)
; compiling (DEFUN GUESS-BUFFER-READTABLE ...)
; compiling (DEFUN VALID-OPERATOR-SYMBOL-P ...)
; compiling (DEFUN VALID-OPERATOR-NAME-P ...)
; compiling (DEFSLIMEFUN ARGLIST-FOR-ECHO-AREA ...)
; compiling (DEFUN OPERATOR-DESIGNATOR-TO-FORM ...)
; compiling (DEFUN CLEAN-ARGLIST ...)
; compiling (DEFUN DECODED-ARGLIST-TO-STRING ...)
; compiling (DEFSLIMEFUN VARIABLE-DESC-FOR-ECHO-AREA ...)
; compiling (DEFSTRUCT (KEYWORD-ARG # ...) ...)
; compiling (DEFUN DECODE-KEYWORD-ARG ...)
; compiling (DEFUN ENCODE-KEYWORD-ARG ...)
; compiling (ASSERT (EQUALP # ...))
; compiling (ASSERT (EQUALP # ...))
; compiling (ASSERT (EQUALP # ...))
; compiling (ASSERT (EQUALP # ...))
; compiling (DEFSTRUCT (OPTIONAL-ARG # ...) ...)
; compiling (DEFUN DECODE-OPTIONAL-ARG ...)
; compiling (DEFUN ENCODE-OPTIONAL-ARG ...)
; compiling (ASSERT (EQUALP # ...))
; compiling (ASSERT (EQUALP # ...))
; compiling (DEFSTRUCT (ARGLIST #) ...)
; compiling (DEFINE-MODIFY-MACRO NREVERSEF ...)
; compiling (DEFUN DECODE-ARGLIST ...)
; compiling (DEFUN ENCODE-ARGLIST ...)
; compiling (DEFUN ARGLIST-KEYWORDS ...)
; compiling (DEFUN METHODS-KEYWORDS ...)
; compiling (DEFUN GENERIC-FUNCTION-KEYWORDS ...)
; compiling (DEFUN APPLICABLE-METHODS-KEYWORDS ...)
; compiling (DEFUN DECODED-ARGLIST-TO-TEMPLATE-STRING ...)
; compiling (DEFUN PRINT-DECODED-ARGLIST-AS-TEMPLATE ...)
; compiling (DEFGENERIC EXTRA-KEYWORDS ...)
; compiling (DEFMETHOD EXTRA-KEYWORDS ...)
; compiling (DEFUN CLASS-FROM-CLASS-NAME-FORM ...)
; compiling (DEFUN EXTRA-KEYWORDS/SLOTS ...)
; compiling (DEFUN EXTRA-KEYWORDS/MAKE-INSTANCE ...)
; compiling (DEFUN EXTRA-KEYWORDS/CHANGE-CLASS ...)
; compiling (DEFMACRO MULTIPLE-VALUE-OR ...)
; compiling (DEFMETHOD EXTRA-KEYWORDS ...)
; compiling (DEFMETHOD EXTRA-KEYWORDS ...)
; compiling (DEFMETHOD EXTRA-KEYWORDS ...)
; compiling (DEFMETHOD EXTRA-KEYWORDS ...)
; compiling (DEFMETHOD EXTRA-KEYWORDS ...)
; compiling (DEFMETHOD EXTRA-KEYWORDS ...)
; compiling (DEFMETHOD EXTRA-KEYWORDS ...)
; compiling (DEFUN ENRICH-DECODED-ARGLIST-WITH-EXTRA-KEYWORDS ...)
; compiling (DEFSLIMEFUN ARGLIST-FOR-INSERTION ...)
; compiling (DEFVAR *REMOVE-KEYWORDS-ALIST* ...)
; compiling (DEFUN REMOVE-ACTUAL-ARGS ...)
; compiling (DEFGENERIC FORM-COMPLETION ...)
; compiling (DEFMETHOD FORM-COMPLETION ...)
; compiling (DEFMETHOD FORM-COMPLETION ...)
; compiling (DEFUN READ-INCOMPLETE-FORM-FROM-STRING ...)
; compiling (DEFSLIMEFUN COMPLETE-FORM ...)
; compiling (DEFUN FORMAT-ARGLIST-FOR-ECHO-AREA ...)
; compiling (DEFSLIMEFUN COMPLETIONS-FOR-KEYWORD ...)
; compiling (DEFUN ARGLIST-TO-STRING ...)
; compiling (DEFUN TEST-PRINT-ARGLIST ...)
; compiling (ASSERT (TEST-PRINT-ARGLIST # ...))
; compiling (ASSERT (TEST-PRINT-ARGLIST # ...))
; compiling (ASSERT (TEST-PRINT-ARGLIST # ...))
; compiling (ASSERT (TEST-PRINT-ARGLIST # ...))
; compiling (ASSERT (TEST-PRINT-ARGLIST # ...))
; compiling (ASSERT (TEST-PRINT-ARGLIST # ...))
; compiling (DEFVAR *RECORD-REPL-RESULTS* ...)
; compiling (DEFVAR *OBJECT-TO-PRESENTATION-ID* ...)
; compiling (DEFVAR *PRESENTATION-ID-TO-OBJECT* ...)
; compiling (DEFUN CLEAR-PRESENTATION-TABLES ...)
; compiling (DEFVAR *PRESENTATION-COUNTER* ...)
; compiling (DEFUN SAVE-PRESENTED-OBJECT ...)
; compiling (DEFUN LOOKUP-PRESENTED-OBJECT ...)
; compiling (DEFSLIMEFUN GET-REPL-RESULT ...)
; compiling (DEFSLIMEFUN CLEAR-REPL-RESULTS ...)
; compiling (DEFVAR *PENDING-CONTINUATIONS* ...)
; compiling (DEFUN GUESS-BUFFER-PACKAGE ...)
; compiling (DEFUN EVAL-FOR-EMACS ...)
; compiling (DEFVAR *ECHO-AREA-PREFIX* ...)
; compiling (DEFUN FORMAT-VALUES-FOR-ECHO-AREA ...)
; compiling (DEFSLIMEFUN INTERACTIVE-EVAL ...)
; compiling (DEFSLIMEFUN EVAL-AND-GRAB-OUTPUT ...)
; compiling (DEFVAR *SLIME-REPL-ADVANCE-HISTORY* ...)
; compiling (DEFVAR *SLIME-REPL-SUPPRESS-OUTPUT* ...)
; compiling (DEFVAR *SLIME-REPL-EVAL-HOOK-PASS* ...)
; compiling (DEFVAR *SLIME-REPL-EVAL-HOOKS* ...)
; compiling (DEFSLIMEFUN REPL-EVAL-HOOK-PASS ...)
; compiling (DEFSLIMEFUN REPL-SUPPRESS-OUTPUT ...)
; compiling (DEFSLIMEFUN REPL-SUPPRESS-ADVANCE-HISTORY ...)
; compiling (DEFUN EVAL-REGION ...)
; compiling (DEFUN RUN-REPL-EVAL-HOOKS ...)
; compiling (DEFUN PACKAGE-STRING-FOR-PROMPT ...)
; compiling (DEFUN CANONICAL-PACKAGE-NICKNAME ...)
; compiling (DEFUN AUTO-ABBREVIATED-PACKAGE-NAME ...)
; compiling (DEFUN SHORTEST-PACKAGE-NICKNAME ...)
; compiling (DEFSLIMEFUN INTERACTIVE-EVAL-REGION ...)
; compiling (DEFSLIMEFUN RE-EVALUATE-DEFVAR ...)
; compiling (DEFVAR *SWANK-PPRINT-BINDINGS* ...)
; compiling (DEFUN SWANK-PPRINT ...)
; compiling (DEFSLIMEFUN PPRINT-EVAL ...)
; compiling (DEFSLIMEFUN SET-PACKAGE ...)
; compiling (DEFSLIMEFUN LISTENER-EVAL ...)
; compiling (DEFSLIMEFUN ED-IN-EMACS ...)
; compiling (DEFSLIMEFUN VALUE-FOR-EDITING ...)
; compiling (DEFSLIMEFUN COMMIT-EDITED-VALUE ...)
; compiling (DEFUN BACKGROUND-MESSAGE ...)
; compiling (DEFUN SWANK-DEBUGGER-HOOK ...)
; compiling (DEFVAR *GLOBAL-DEBUGGER* ...)
; compiling (ADD-HOOK *NEW-CONNECTION-HOOK* ...)
; compiling (DEFUN INSTALL-DEBUGGER ...)
; compiling (DEFVAR *SWANK-DEBUGGER-CONDITION* ...)
; compiling (DEFVAR *SLDB-LEVEL* ...)
; compiling (DEFVAR *SLDB-INITIAL-FRAMES* ...)
; compiling (DEFVAR *SLDB-RESTARTS* ...)
; compiling (DEFVAR *SLDB-STEPPING-P* ...)
; compiling (DEFUN DEBUG-IN-EMACS ...)
; compiling (DEFUN SLDB-LOOP ...)
; compiling (DEFUN HANDLE-SLDB-CONDITION ...)
; compiling (DEFUN SAFE-CONDITION-MESSAGE ...)
; compiling (DEFUN DEBUGGER-CONDITION-FOR-EMACS ...)
; compiling (DEFUN FORMAT-RESTARTS-FOR-EMACS ...)
; compiling (DEFUN FRAME-FOR-EMACS ...)
; compiling (DEFSLIMEFUN SLDB-BREAK-WITH-DEFAULT-DEBUGGER ...)
; compiling (DEFSLIMEFUN BACKTRACE ...)
; compiling (DEFSLIMEFUN DEBUGGER-INFO-FOR-EMACS ...)
; compiling (DEFUN NTH-RESTART ...)
; compiling (DEFSLIMEFUN INVOKE-NTH-RESTART ...)
; compiling (DEFSLIMEFUN SLDB-ABORT ...)
; compiling (DEFSLIMEFUN SLDB-CONTINUE ...)
; compiling (DEFSLIMEFUN THROW-TO-TOPLEVEL ...)
; compiling (DEFSLIMEFUN INVOKE-NTH-RESTART-FOR-EMACS ...)
; compiling (DEFUN WRAP-SLDB-VARS ...)
; compiling (DEFSLIMEFUN EVAL-STRING-IN-FRAME ...)
; compiling (DEFSLIMEFUN PPRINT-EVAL-STRING-IN-FRAME ...)
; compiling (DEFSLIMEFUN FRAME-LOCALS-FOR-EMACS ...)
; compiling (DEFSLIMEFUN FRAME-CATCH-TAGS-FOR-EMACS ...)
; compiling (DEFSLIMEFUN SLDB-DISASSEMBLE ...)
; compiling (DEFSLIMEFUN SLDB-RETURN-FROM-FRAME ...)
; compiling (DEFSLIMEFUN SLDB-BREAK ...)
; compiling (DEFSLIMEFUN SLDB-STEP ...)
; compiling (DEFVAR *COMPILER-NOTES* ...)
; compiling (DEFUN CLEAR-COMPILER-NOTES ...)
; compiling (DEFUN CANONICALIZE-FILENAME ...)
; compiling (DEFSLIMEFUN COMPILER-NOTES-FOR-EMACS ...)
; compiling (DEFUN MEASURE-TIME-INTERVAL ...)
; compiling (DEFUN RECORD-NOTE-FOR-CONDITION ...)
; compiling (DEFUN MAKE-COMPILER-NOTE ...)
; compiling (DEFUN SWANK-COMPILER ...)
; compiling (DEFSLIMEFUN COMPILE-FILE-FOR-EMACS ...)
; compiling (DEFSLIMEFUN COMPILE-STRING-FOR-EMACS ...)
; compiling (DEFSLIMEFUN OPERATE-ON-SYSTEM-FOR-EMACS ...)
; compiling (DEFUN ASDF-CENTRAL-REGISTRY ...)
; compiling (DEFSLIMEFUN LIST-ALL-SYSTEMS-IN-CENTRAL-REGISTRY ...)
; compiling (DEFUN FILE-NEWER-P ...)
; compiling (DEFUN REQUIRES-COMPILE-P ...)
; compiling (DEFSLIMEFUN COMPILE-FILE-IF-NEEDED ...)
; compiling (DEFSLIMEFUN LOAD-FILE ...)
; compiling (DEFSLIMEFUN LOAD-FILE-SET-PACKAGE ...)
; compiling (DEFVAR *MACROEXPAND-PRINTER-BINDINGS* ...)
; compiling (DEFUN APPLY-MACRO-EXPANDER ...)
; compiling (DEFSLIMEFUN SWANK-MACROEXPAND-1 ...)
; compiling (DEFSLIMEFUN SWANK-MACROEXPAND ...)
; compiling (DEFSLIMEFUN SWANK-MACROEXPAND-ALL ...)
; compiling (DEFSLIMEFUN SWANK-COMPILER-MACROEXPAND-1 ...)
; compiling (DEFSLIMEFUN SWANK-COMPILER-MACROEXPAND ...)
; compiling (DEFSLIMEFUN DISASSEMBLE-SYMBOL ...)
; compiling (DEFSLIMEFUN COMPLETIONS ...)
; compiling (DEFSLIMEFUN SIMPLE-COMPLETIONS ...)
; compiling (DEFUN COMPLETION-SET ...)
; compiling (DEFUN FIND-MATCHING-SYMBOLS ...)
; compiling (DEFUN FIND-MATCHING-SYMBOLS-IN-LIST ...)
; compiling (DEFUN SYMBOL-EXTERNAL-P ...)
; compiling (DEFUN FIND-MATCHING-PACKAGES ...)
; compiling (DEFUN PARSE-COMPLETION-ARGUMENTS ...)
; compiling (DEFUN CAREFULLY-FIND-PACKAGE ...)
; compiling (DEFUN FORMAT-COMPLETION-SET ...)
; compiling (DEFUN FORMAT-COMPLETION-RESULT ...)
; compiling (DEFUN OUTPUT-CASE-CONVERTER ...)
; compiling (DEFUN DETERMINE-CASE ...)
; compiling (DEFUN COMPOUND-PREFIX-MATCH ...)
; compiling (DEFUN PREFIX-MATCH-P ...)
; compiling (DEFUN LONGEST-COMPLETION ...)
; compiling (DEFUN TOKENIZE-COMPLETION ...)
; compiling (DEFUN UNTOKENIZE-COMPLETION ...)
; compiling (DEFUN LONGEST-COMMON-PREFIX ...)
; compiling (DEFUN TRANSPOSE-LISTS ...)
; compiling (DEFPACKAGE :SWANK-COMPLETION-TEST ...)
; compiling (LET (# #) ...)
; compiling (DEFSLIMEFUN FUZZY-COMPLETIONS ...)
; compiling (DEFUN CONVERT-FUZZY-COMPLETION-RESULT ...)
; compiling (DEFUN FUZZY-COMPLETION-SET ...)
; compiling (DEFUN FUZZY-FIND-MATCHING-SYMBOLS ...)
; compiling (DEFUN FUZZY-FIND-MATCHING-PACKAGES ...)
; compiling (DEFSLIMEFUN FUZZY-COMPLETION-SELECTED ...)
; compiling (DEFPARAMETER *FUZZY-RECURSION-SOFT-LIMIT* ...)
; compiling (DEFUN COMPUTE-HIGHEST-SCORING-COMPLETION ...)
; compiling (DEFUN COMPUTE-MOST-COMPLETIONS ...)
; compiling (DEFUN RECURSIVELY-COMPUTE-MOST-COMPLETIONS ...)
; compiling (DEFPARAMETER *FUZZY-COMPLETION-SYMBOL-PREFIXES* ...)
; compiling (DEFPARAMETER *FUZZY-COMPLETION-SYMBOL-SUFFIXES* ...)
; compiling (DEFPARAMETER *FUZZY-COMPLETION-WORD-SEPARATORS* ...)
; compiling (DEFUN SCORE-COMPLETION ...)
; compiling (DEFUN HIGHLIGHT-COMPLETION ...)
; compiling (DEFUN FORMAT-FUZZY-COMPLETIONS ...)
; compiling (DEFSLIMEFUN APROPOS-LIST-FOR-EMACS ...)
; compiling (DEFUN STRING-TO-PACKAGE-DESIGNATOR ...)
; compiling (DEFUN BRIEFLY-DESCRIBE-SYMBOL-FOR-EMACS ...)
; compiling (DEFUN MAP-IF ...)
; compiling (DEFUN LISTIFY ...)
; compiling (DEFUN PRESENT-SYMBOL-BEFORE-P ...)
; compiling (LET (#) ...)
; compiling (DEFUN APROPOS-MATCHER ...)
; compiling (DEFUN APROPOS-SYMBOLS ...)
; compiling (DEFUN CALL-WITH-DESCRIBE-SETTINGS ...)
; compiling (DEFMACRO WITH-DESCRIBE-SETTINGS ...)
; compiling (DEFUN DESCRIBE-TO-STRING ...)
; compiling (DEFSLIMEFUN DESCRIBE-SYMBOL ...)
; compiling (DEFSLIMEFUN DESCRIBE-FUNCTION ...)
; compiling (DEFSLIMEFUN DESCRIBE-DEFINITION-FOR-EMACS ...)
; compiling (DEFSLIMEFUN DOCUMENTATION-SYMBOL ...)
; compiling (DEFSLIMEFUN LIST-ALL-PACKAGE-NAMES ...)
; compiling (DEFUN TRACEDP ...)
; compiling (DEFSLIMEFUN SWANK-TOGGLE-TRACE ...)
; compiling (DEFSLIMEFUN UNTRACE-ALL ...)
; compiling (DEFSLIMEFUN UNDEFINE-FUNCTION ...)
; compiling (DEFUN PROFILEDP ...)
; compiling (DEFSLIMEFUN TOGGLE-PROFILE-FDEFINITION ...)
; compiling (DEFSLIMEFUN FIND-DEFINITIONS-FOR-EMACS ...)
; compiling (DEFUN ALISTIFY ...)
; compiling (DEFUN LOCATION-POSITION< ...)
; compiling (DEFUN PARTITION ...)
; compiling (DEFSTRUCT (XREF # ...) ...)
; compiling (DEFUN LOCATION-VALID-P ...)
; compiling (DEFUN XREF-BUFFER ...)
; compiling (DEFUN XREF-POSITION ...)
; compiling (DEFUN GROUP-XREFS ...)
; compiling (DEFSLIMEFUN XREF ...)
; compiling (DEFUN COMMON-SEPERATED-SPEC ...)
; compiling (DEFUN INSPECTOR-PRINC ...)
; compiling (DEFMETHOD INSPECT-FOR-EMACS ...)
; compiling (DEFUN INSPECT-FOR-EMACS-SIMPLE-CONS ...)
; compiling (DEFUN INSPECT-FOR-EMACS-LIST ...)
; compiling (DEFUN SAFE-LENGTH ...)
; compiling (DEFVAR *SLIME-INSPECT-CONTENTS-LIMIT* ...)
; compiling (DEFMETHOD INSPECT-FOR-EMACS ...)
; compiling (DEFMETHOD INSPECT-BIGGER-PIECE-ACTIONS ...)
; compiling (DEFMETHOD INSPECT-WHOLE-THING-ACTION ...)
; compiling (DEFMETHOD INSPECT-SHOW-MORE-ACTION ...)
; compiling (DEFMETHOD INSPECT-FOR-EMACS ...)
; compiling (DEFMETHOD INSPECT-FOR-EMACS ...)
; compiling (DEFUN DOCSTRING-ISPEC ...)
; compiling (DEFMETHOD INSPECT-FOR-EMACS ...)
; compiling (DEFMETHOD INSPECT-FOR-EMACS ...)
; compiling (DEFUN METHOD-SPECIALIZERS-FOR-INSPECT ...)
; compiling (DEFUN METHOD-FOR-INSPECT-VALUE ...)
; compiling (DEFMETHOD INSPECT-FOR-EMACS ...)
; compiling (DEFVAR *GF-METHOD-GETTER* ...)
; compiling (DEFUN SPECIALIZER< ...)
; compiling (DEFUN METHODS-BY-APPLICABILITY ...)
; compiling (DEFUN ABBREV-DOC ...)
; compiling (DEFUN ALL-SLOTS-FOR-INSPECTOR ...)
; compiling (DEFMETHOD INSPECT-FOR-EMACS ...)
; compiling (DEFMETHOD INSPECT-FOR-EMACS ...)
; compiling (DEFMETHOD INSPECT-FOR-EMACS ...)
; compiling (DEFMETHOD INSPECT-FOR-EMACS ...)
; compiling (DEFMETHOD INSPECT-FOR-EMACS ...)
; compiling (DEFMETHOD INSPECT-FOR-EMACS ...)
; compiling (DEFMETHOD INSPECT-FOR-EMACS ...)
; compiling (DEFMETHOD INSPECT-FOR-EMACS ...)
; compiling (DEFUN FORMAT-ISO8601-TIME ...)
; compiling (DEFMETHOD INSPECT-FOR-EMACS ...)
; compiling (DEFMETHOD INSPECT-FOR-EMACS ...)
; compiling (DEFMETHOD INSPECT-FOR-EMACS ...)
; compiling (DEFMETHOD INSPECT-FOR-EMACS ...)
; compiling (DEFMETHOD INSPECT-FOR-EMACS ...)
; compiling (DEFMETHOD INSPECT-FOR-EMACS ...)
; compiling (DEFVAR *INSPECTEE*)
; compiling (DEFVAR *INSPECTEE-PARTS*)
; compiling (DEFVAR *INSPECTEE-ACTIONS*)
; compiling (DEFVAR *INSPECTOR-STACK* ...)
; compiling (DEFVAR *INSPECTOR-HISTORY* ...)
; compiling (DECLAIM (TYPE VECTOR ...))
; compiling (DEFVAR *INSPECT-LENGTH* ...)
; compiling (DEFUN RESET-INSPECTOR ...)
; compiling (DEFSLIMEFUN INIT-INSPECTOR ...)
; compiling (DEFUN PRINT-PART-TO-STRING ...)
; compiling (DEFUN INSPECTOR-CONTENT-FOR-EMACS ...)
; compiling (DEFUN ASSIGN-INDEX ...)
; compiling (DEFUN VALUE-PART-FOR-EMACS ...)
; compiling (DEFUN ACTION-PART-FOR-EMACS ...)
; compiling (DEFUN INSPECT-OBJECT ...)
; compiling (DEFSLIMEFUN INSPECTOR-NTH-PART ...)
; compiling (DEFSLIMEFUN INSPECT-NTH-PART ...)
; compiling (DEFSLIMEFUN INSPECTOR-CALL-NTH-ACTION ...)
; compiling (DEFSLIMEFUN INSPECTOR-POP ...)
; compiling (DEFSLIMEFUN INSPECTOR-NEXT ...)
; compiling (DEFSLIMEFUN INSPECTOR-REINSPECT ...)
; compiling (DEFSLIMEFUN QUIT-INSPECTOR ...)
; compiling (DEFSLIMEFUN DESCRIBE-INSPECTEE ...)
; compiling (DEFSLIMEFUN PPRINT-INSPECTOR-PART ...)
; compiling (DEFSLIMEFUN INSPECT-IN-FRAME ...)
; compiling (DEFSLIMEFUN INSPECT-CURRENT-CONDITION ...)
; compiling (DEFSLIMEFUN INSPECT-FRAME-VAR ...)
; compiling (DEFVAR *THREAD-LIST* ...)
; compiling (DEFSLIMEFUN LIST-THREADS ...)
; compiling (DEFSLIMEFUN QUIT-THREAD-BROWSER ...)
; compiling (DEFUN NTH-THREAD ...)
; compiling (DEFSLIMEFUN DEBUG-NTH-THREAD ...)
; compiling (DEFSLIMEFUN KILL-NTH-THREAD ...)
; compiling (DEFSLIMEFUN START-SWANK-SERVER-IN-THREAD ...)
; compiling (DEFUN MOP-HELPER ...)
; compiling (DEFSLIMEFUN MOP ...)
; compiling (DEFUN SYNC-FEATURES-TO-EMACS ...)
; compiling (DEFUN FEATURES-FOR-EMACS ...)
; compiling (ADD-HOOK *PRE-REPLY-HOOK* ...)
; compiling (DEFVAR *CONFIGURE-EMACS-INDENTATION* ...)
; compiling (DEFSLIMEFUN UPDATE-INDENTATION-INFORMATION ...)
; compiling (DEFUN SYNC-INDENTATION-TO-EMACS ...)
; compiling (DEFUN NEED-FULL-INDENTATION-UPDATE-P ...)
; compiling (DEFUN PERFORM-INDENTATION-UPDATE ...)
; compiling (DEFUN UPDATE-INDENTATION/DELTA-FOR-EMACS ...)
; compiling (DEFUN PACKAGE-NAMES ...)
; compiling (DEFUN CL-SYMBOL-P ...)
; compiling (DEFUN KNOWN-TO-EMACS-P ...)
; compiling (DEFUN SYMBOL-INDENTATION ...)
; compiling (DEFUN MACRO-INDENTATION ...)
; compiling (DEFUN WELL-FORMED-LIST-P ...)
; compiling (DEFUN PRINT-INDENTATION-LOSSAGE ...)
; compiling (ADD-HOOK *PRE-REPLY-HOOK* ...)
; compiling (DEFVAR *PRESENTATION-ACTIVE-MENU* ...)
; compiling (DEFUN MENU-CHOICES-FOR-PRESENTATION-ID ...)
; compiling (DEFUN SWANK-IOIFY ...)
; compiling (DEFUN EXECUTE-MENU-CHOICE-FOR-PRESENTATION-ID ...)
; compiling (DEFMETHOD MENU-CHOICES-FOR-PRESENTATION ...)
; compiling (DEFMETHOD MENU-CHOICES-FOR-PRESENTATION ...)

; /var/cache/common-lisp-controller/1001/sbcl/swank/swank.fasl written
; compilation finished in 0:00:05
WARNING: SWANK also exports the following symbols:
  (SWANK:INIT-INSPECTOR SWANK:INSPECT-IN-FRAME
                        SWANK:INSPECT-NTH-PART
                        SWANK:GET-REPL-RESULT
                        SWANK:XREF
                        SWANK:TAKE-INPUT
                        SWANK:START-SWANK-SERVER-IN-THREAD
                        SWANK:INSPECT-FRAME-VAR
                        SWANK:SWANK-MACROEXPAND
                        SWANK:LOAD-FILE-SET-PACKAGE
                        SWANK:DESCRIBE-FUNCTION
                        SWANK:COMPLETE-FORM
                        SWANK:SLDB-BREAK-WITH-DEFAULT-DEBUGGER
                        SWANK:COMMIT-EDITED-VALUE
                        SWANK:INSPECTOR-POP
                        SWANK:TOGGLE-PROFILE-FDEFINITION
                        SWANK:LIST-ALL-PACKAGE-NAMES
                        SWANK:SLDB-DISASSEMBLE
                        SWANK:FUZZY-COMPLETION-SELECTED
                        SWANK:INSPECTOR-REINSPECT
                        SWANK:LISTENER-EVAL
                        SWANK:LIST-THREADS
                        SWANK:QUIT-INSPECTOR
                        SWANK:REPL-EVAL-HOOK-PASS
                        SWANK:DOCUMENTATION-SYMBOL
                        SWANK:DESCRIBE-INSPECTEE
                        SWANK:DISASSEMBLE-SYMBOL
                        SWANK:BACKTRACE
                        SWANK:COMPLETIONS-FOR-KEYWORD
                        SWANK:INVOKE-NTH-RESTART-FOR-EMACS
                        SWANK:REPL-SUPPRESS-ADVANCE-HISTORY
                        SWANK:RE-EVALUATE-DEFVAR
                        SWANK:FIND-DEFINITIONS-FOR-EMACS
                        SWANK:SLDB-RETURN-FROM-FRAME
                        SWANK:PPRINT-EVAL-STRING-IN-FRAME
                        SWANK:DESCRIBE-SYMBOL
                        SWANK:FRAME-LOCALS-FOR-EMACS
                        SWANK:DEBUGGER-INFO-FOR-EMACS
                        SWANK:REPL-SUPPRESS-OUTPUT
                        SWANK:ARGLIST-FOR-INSERTION
                        SWANK:CLEAR-REPL-RESULTS
                        SWANK:SLDB-ABORT
                        SWANK:APROPOS-LIST-FOR-EMACS
                        SWANK:FRAME-CATCH-TAGS-FOR-EMACS
                        SWANK:SWANK-TOGGLE-TRACE
                        SWANK:UNTRACE-ALL
                        SWANK:SIMPLE-COMPLETIONS
                        SWANK:KILL-NTH-THREAD
                        SWANK:EVAL-STRING-IN-FRAME
                        SWANK:OPERATE-ON-SYSTEM-FOR-EMACS
                        SWANK:THROW-TO-TOPLEVEL
                        SWANK:COMPILER-NOTES-FOR-EMACS
                        SWANK:UPDATE-INDENTATION-INFORMATION
                        SWANK:VARIABLE-DESC-FOR-ECHO-AREA
                        SWANK:INTERACTIVE-EVAL
                        SWANK:PPRINT-INSPECTOR-PART
                        SWANK:COMPILE-FILE-FOR-EMACS
                        SWANK:SWANK-COMPILER-MACROEXPAND-1
                        SWANK:SET-PACKAGE
                        SWANK:INVOKE-NTH-RESTART
                        SWANK:INSPECTOR-NEXT
                        SWANK:DEBUG-NTH-THREAD
                        SWANK:SWANK-MACROEXPAND-1
                        SWANK:SLDB-CONTINUE
                        SWANK:DESCRIBE-DEFINITION-FOR-EMACS
                        SWANK:COMPILE-FILE-IF-NEEDED
                        SWANK:INSPECTOR-CALL-NTH-ACTION
                        SWANK:SIMPLE-BREAK
                        SWANK:STATE-STACK
                        SWANK:SWANK-MACROEXPAND-ALL
                        SWANK:PPRINT-EVAL
                        SWANK:LOAD-FILE
                        SWANK:ARGLIST-FOR-ECHO-AREA
                        SWANK:CONNECTION-INFO
                        SWANK:EVAL-AND-GRAB-OUTPUT
                        SWANK:IO-SPEED-TEST
                        SWANK:UNDEFINE-FUNCTION
                        SWANK:COMPILE-STRING-FOR-EMACS
                        SWANK:MOP
                        SWANK:INTERACTIVE-EVAL-REGION
                        SWANK:SWANK-COMPILER-MACROEXPAND
                        SWANK:COMPLETIONS
                        SWANK:LIST-ALL-SYSTEMS-IN-CENTRAL-REGISTRY
                        SWANK:VALUE-FOR-EDITING
                        SWANK:INSPECT-CURRENT-CONDITION
                        SWANK:INSPECTOR-NTH-PART
                        SWANK:FUZZY-COMPLETIONS
                        SWANK:QUIT-THREAD-BROWSER)
See also:
  The ANSI Standard, Macro DEFPACKAGE
STYLE-WARNING: redefining PREFIXED-VAR in DEFUN
STYLE-WARNING:
   implicitly creating new generic function INSPECT-BIGGER-PIECE-ACTIONS
STYLE-WARNING:
   implicitly creating new generic function INSPECT-WHOLE-THING-ACTION
STYLE-WARNING: implicitly creating new generic function INSPECT-SHOW-MORE-ACTION
STYLE-WARNING:
   implicitly creating new generic function MENU-CHOICES-FOR-PRESENTATION
T
CL-USER(2): Help! 11 nested errors. SB-KERNEL:*MAXIMUM-ERROR-DEPTH* exceeded.
0: (BACKTRACE 536870911 #<SYNONYM-STREAM :SYMBOL SB-SYS:*TTY* {B7735B1}>)
1: ((LAMBDA NIL))
2: ((LAMBDA NIL))
3: (SB-IMPL::%WITH-STANDARD-IO-SYNTAX #<CLOSURE (LAMBDA NIL) {B7736CD}>)
4: (SB-IMPL::ERROR-ERROR)
5: (SB-IMPL::INFINITE-ERROR-PROTECTOR)
6: (ERROR SB-INT:SIMPLE-STREAM-ERROR)
7: (SB-IMPL::SIMPLE-STREAM-PERROR "couldn't write to ~S" #<SB-SYS:FD-STREAM for "the terminal" {A7E67A1}> 32)
8: (SB-IMPL::FLUSH-OUTPUT-BUFFER #<SB-SYS:FD-STREAM for "the terminal" {A7E67A1}>)
9: (SB-IMPL::OUTPUT-CHAR-UTF-8-LINE-BUFFERED #<SB-SYS:FD-STREAM for "the terminal" {A7E67A1}> #\Newline)
10: (WRITE-CHAR #\Newline #<SB-SYS:FD-STREAM for "the terminal" {A7E67A1}>)
11: (WRITE-CHAR #\Newline #<SYNONYM-STREAM :SYMBOL SB-SYS:*TTY* {9110989}>)
12: (TERPRI #<SYNONYM-STREAM :SYMBOL SWANK::*CURRENT-TERMINAL-IO* {A890999}>)
13: ((LAMBDA NIL))
14: ((LAMBDA NIL))
15: (SB-IMPL::%WITH-STANDARD-IO-SYNTAX #<CLOSURE (LAMBDA NIL) {B773115}>)
16: (SB-IMPL::ERROR-ERROR)
17: (SB-IMPL::INFINITE-ERROR-PROTECTOR)
18: (ERROR SB-INT:SIMPLE-STREAM-ERROR)
19: (SB-IMPL::SIMPLE-STREAM-PERROR "couldn't write to ~S" #<SB-SYS:FD-STREAM for "the terminal" {A7E67A1}> 32)
20: (SB-IMPL::FLUSH-OUTPUT-BUFFER #<SB-SYS:FD-STREAM for "the terminal" {A7E67A1}>)
21: (FORCE-OUTPUT #<SYNONYM-STREAM :SYMBOL SWANK::*CURRENT-DEBUG-IO* {A88FBE9}>)
22: (SB-INT:FLUSH-STANDARD-OUTPUT-STREAMS)
23: (INVOKE-DEBUGGER #<SB-INT:SIMPLE-STREAM-ERROR {B773001}>)
24: (ERROR SB-INT:SIMPLE-STREAM-ERROR)
25: (SB-IMPL::SIMPLE-STREAM-PERROR "couldn't write to ~S" #<SB-SYS:FD-STREAM for "the terminal" {A7E67A1}> 32)
26: (SB-IMPL::FLUSH-OUTPUT-BUFFER #<SB-SYS:FD-STREAM for "the terminal" {A7E67A1}>)
27: (FORCE-OUTPUT #<SYNONYM-STREAM :SYMBOL SWANK::*CURRENT-DEBUG-IO* {A88FBE9}>)
28: (SB-INT:FLUSH-STANDARD-OUTPUT-STREAMS)
29: (INVOKE-DEBUGGER #<SB-INT:SIMPLE-STREAM-ERROR {B772EE1}>)
30: (ERROR SB-INT:SIMPLE-STREAM-ERROR)
31: (SB-IMPL::SIMPLE-STREAM-PERROR "couldn't write to ~S" #<SB-SYS:FD-STREAM for "the terminal" {A7E67A1}> 32)
32: (SB-IMPL::FLUSH-OUTPUT-BUFFER #<SB-SYS:FD-STREAM for "the terminal" {A7E67A1}>)
33: (FORCE-OUTPUT #<SYNONYM-STREAM :SYMBOL SWANK::*CURRENT-DEBUG-IO* {A88FBE9}>)
34: (SB-INT:FLUSH-STANDARD-OUTPUT-STREAMS)
35: (INVOKE-DEBUGGER #<SB-INT:SIMPLE-STREAM-ERROR {B772DC1}>)
36: (ERROR SB-INT:SIMPLE-STREAM-ERROR)
37: (SB-IMPL::SIMPLE-STREAM-PERROR "couldn't write to ~S" #<SB-SYS:FD-STREAM for "the terminal" {A7E67A1}> 32)
38: (SB-IMPL::FLUSH-OUTPUT-BUFFER #<SB-SYS:FD-STREAM for "the terminal" {A7E67A1}>)
39: (FORCE-OUTPUT #<SYNONYM-STREAM :SYMBOL SWANK::*CURRENT-DEBUG-IO* {A88FBE9}>)
40: (SB-INT:FLUSH-STANDARD-OUTPUT-STREAMS)
41: (INVOKE-DEBUGGER #<SB-INT:SIMPLE-STREAM-ERROR {B772CA1}>)
42: (ERROR SB-INT:SIMPLE-STREAM-ERROR)
43: (SB-IMPL::SIMPLE-STREAM-PERROR "couldn't write to ~S" #<SB-SYS:FD-STREAM for "the terminal" {A7E67A1}> 32)
44: (SB-IMPL::FLUSH-OUTPUT-BUFFER #<SB-SYS:FD-STREAM for "the terminal" {A7E67A1}>)
45: (FORCE-OUTPUT #<SYNONYM-STREAM :SYMBOL SWANK::*CURRENT-DEBUG-IO* {A88FBE9}>)
46: (SB-INT:FLUSH-STANDARD-OUTPUT-STREAMS)
47: (INVOKE-DEBUGGER #<SB-INT:SIMPLE-STREAM-ERROR {B772B81}>)
48: (ERROR SB-INT:SIMPLE-STREAM-ERROR)
49: (SB-IMPL::SIMPLE-STREAM-PERROR "couldn't write to ~S" #<SB-SYS:FD-STREAM for "the terminal" {A7E67A1}> 32)
50: (SB-IMPL::FLUSH-OUTPUT-BUFFER #<SB-SYS:FD-STREAM for "the terminal" {A7E67A1}>)
51: (FORCE-OUTPUT #<SYNONYM-STREAM :SYMBOL SWANK::*CURRENT-DEBUG-IO* {A88FBE9}>)
52: (SB-INT:FLUSH-STANDARD-OUTPUT-STREAMS)
53: (INVOKE-DEBUGGER #<SB-INT:SIMPLE-STREAM-ERROR {B772A61}>)
54: (ERROR SB-INT:SIMPLE-STREAM-ERROR)
55: (SB-IMPL::SIMPLE-STREAM-PERROR "couldn't write to ~S" #<SB-SYS:FD-STREAM for "the terminal" {A7E67A1}> 32)
56: (SB-IMPL::FLUSH-OUTPUT-BUFFER #<SB-SYS:FD-STREAM for "the terminal" {A7E67A1}>)
57: (FORCE-OUTPUT #<SYNONYM-STREAM :SYMBOL SWANK::*CURRENT-DEBUG-IO* {A88FBE9}>)
58: (SB-INT:FLUSH-STANDARD-OUTPUT-STREAMS)
59: (INVOKE-DEBUGGER #<SB-INT:SIMPLE-STREAM-ERROR {B772941}>)
60: (ERROR SB-INT:SIMPLE-STREAM-ERROR)
61: (SB-IMPL::SIMPLE-STREAM-PERROR "couldn't write to ~S" #<SB-SYS:FD-STREAM for "the terminal" {A7E67A1}> 32)
62: (SB-IMPL::FLUSH-OUTPUT-BUFFER #<SB-SYS:FD-STREAM for "the terminal" {A7E67A1}>)
63: (FORCE-OUTPUT #<SYNONYM-STREAM :SYMBOL SWANK::*CURRENT-DEBUG-IO* {A88FBE9}>)
64: (SB-INT:FLUSH-STANDARD-OUTPUT-STREAMS)
65: (INVOKE-DEBUGGER #<SB-INT:SIMPLE-STREAM-ERROR {B772821}>)
66: (ERROR SB-INT:SIMPLE-STREAM-ERROR)
67: (SB-IMPL::SIMPLE-STREAM-PERROR "couldn't write to ~S" #<SB-SYS:FD-STREAM for "the terminal" {A7E67A1}> 32)
68: (SB-IMPL::FLUSH-OUTPUT-BUFFER #<SB-SYS:FD-STREAM for "the terminal" {A7E67A1}>)
69: (FORCE-OUTPUT #<SYNONYM-STREAM :SYMBOL SWANK::*CURRENT-DEBUG-IO* {A88FBE9}>)
70: (SB-INT:FLUSH-STANDARD-OUTPUT-STREAMS)
71: (INVOKE-DEBUGGER #<SB-INT:SIMPLE-STREAM-ERROR {B772701}>)
72: (ERROR SB-INT:SIMPLE-STREAM-ERROR)
73: (SB-IMPL::SIMPLE-STREAM-PERROR "couldn't write to ~S" #<SB-SYS:FD-STREAM for "the terminal" {A7E67A1}> 32)
74: (SB-IMPL::FLUSH-OUTPUT-BUFFER #<SB-SYS:FD-STREAM for "the terminal" {A7E67A1}>)
75: (FORCE-OUTPUT #<SYNONYM-STREAM :SYMBOL SWANK::*CURRENT-DEBUG-IO* {A88FBE9}>)
76: (SB-INT:FLUSH-STANDARD-OUTPUT-STREAMS)
77: (INVOKE-DEBUGGER #<SB-INT:SIMPLE-STREAM-ERROR {B7725E1}>)
78: (ERROR SB-INT:SIMPLE-STREAM-ERROR)
79: (SB-IMPL::SIMPLE-STREAM-PERROR "couldn't write to ~S" #<SB-SYS:FD-STREAM for "the terminal" {A7E67A1}> 32)
80: (SB-IMPL::FLUSH-OUTPUT-BUFFER #<SB-SYS:FD-STREAM for "the terminal" {A7E67A1}>)
81: (FORCE-OUTPUT #<SYNONYM-STREAM :SYMBOL SWANK::*CURRENT-DEBUG-IO* {A88FBE9}>)
82: (SB-INT:FLUSH-STANDARD-OUTPUT-STREAMS)
83: (INVOKE-DEBUGGER #<SB-INT:SIMPLE-STREAM-ERROR {B7722E1}>)
84: (ERROR SB-INT:SIMPLE-STREAM-ERROR)
85: (SB-IMPL::SIMPLE-STREAM-PERROR "couldn't write to ~S" #<SB-SYS:FD-STREAM for "the terminal" {A7E67A1}> 32)
86: (SB-IMPL::FLUSH-OUTPUT-BUFFER #<SB-SYS:FD-STREAM for "the terminal" {A7E67A1}>)
87: (SB-IMPL::OUTPUT-CHAR-UTF-8-LINE-BUFFERED #<SB-SYS:FD-STREAM for "the terminal" {A7E67A1}> #\Newline)
88: (WRITE-CHAR #\Newline #<SB-SYS:FD-STREAM for "the terminal" {A7E67A1}>)
89: (WRITE-CHAR #\Newline #<SYNONYM-STREAM :SYMBOL SB-SYS:*TTY* {9110989}>)
90: (WRITE-CHAR #\Newline #<SYNONYM-STREAM :SYMBOL SWANK::*CURRENT-TERMINAL-IO* {A890999}>)
91: (WRITE-CHAR #\Newline #<SYNONYM-STREAM :SYMBOL *TERMINAL-IO* {915E2A1}>)
92: (TERPRI #<SYNONYM-STREAM :SYMBOL SWANK::*CURRENT-DEBUG-IO* {A88FBE9}>)
93: (SB-FORMAT::%-FORMAT-DIRECTIVE-INTERPRETER #<SYNONYM-STREAM :SYMBOL SWANK::*CURRENT-DEBUG-IO* {A88FBE9}> #<~%> NIL #<unavailable argument> NIL)
94: (SB-FORMAT::INTERPRET-DIRECTIVE-LIST #<SYNONYM-STREAM :SYMBOL SWANK::*CURRENT-DEBUG-IO* {A88FBE9}> (#<~%>) (54924) NIL)
95: (SB-FORMAT::%FORMAT #<SYNONYM-STREAM :SYMBOL SWANK::*CURRENT-DEBUG-IO* {A88FBE9}> "~&;; Swank started at port: ~D.~%" (54924) (54924))
96: (FORMAT #<SYNONYM-STREAM :SYMBOL SWANK::*CURRENT-DEBUG-IO* {A88FBE9}> "~&;; Swank started at port: ~D.~%")
97: (SWANK::SIMPLE-ANNOUNCE-FUNCTION 54924)
98: (SWANK::SETUP-SERVER 0 #<CLOSURE (LAMBDA (SWANK::PORT)) {AF4C895}> :SPAWN NIL :ISO-LATIN-1-UNIX)
99: (SWANK:START-SERVER "/tmp/slime.1126" :STYLE NIL :DONT-CLOSE NIL :EXTERNAL-FORMAT :ISO-LATIN-1-UNIX)
100: (SB-INT:EVAL-IN-LEXENV (SWANK:START-SERVER "/tmp/slime.1126" :EXTERNAL-FORMAT :ISO-LATIN-1-UNIX) #<NULL-LEXENV>)
101: (INTERACTIVE-EVAL (SWANK:START-SERVER "/tmp/slime.1126" :EXTERNAL-FORMAT :ISO-LATIN-1-UNIX))
102: (SB-ACLREPL::REP-ONE)
103: (SB-ACLREPL::REPL :BREAK-LEVEL 0 :NOPRINT NIL :INSPECT NIL :CONTINUABLE NIL)
104: ((LAMBDA (SB-ACLREPL::NOPRINT)) NIL)
105: ((LAMBDA NIL))
106: ((LAMBDA NIL))
107: (SB-IMPL::%WITH-REBOUND-IO-SYNTAX #<CLOSURE (LAMBDA NIL) {B0E5E45}>)
108: (SB-IMPL::TOPLEVEL-REPL NIL)
109: (SB-IMPL::TOPLEVEL-INIT)
110: ((LABELS SB-IMPL::RESTART-LISP))

debugger invoked on a SIMPLE-ERROR in thread #<THREAD "initial thread" {A7E6409}>: Maximum error nesting depth exceeded

Type HELP for debugger help, or (SB-EXT:QUIT) to exit from SBCL.

restarts (invokable by number or by possibly-abbreviated name):
  0: [ABORT] Exit debugger, returning to top level.

(SB-IMPL::SIMPLE-STREAM-PERROR "couldn't write to ~S" #<SB-SYS:FD-STREAM for "the terminal" {A7E67A1}> 32)
0]

Comment 1 Jakub Moc (RETIRED) gentoo-dev

2006-05-20 12:47:36 UTC

*** Bug 133896 has been marked as a duplicate of this bug. ***

Comment 2 Jakub Moc (RETIRED) gentoo-dev

2006-05-20 12:54:04 UTC

Please, use attachments instead of pasting huge logs inline...

Comment 3 Matthew Kennedy (RETIRED) gentoo-dev

2006-05-20 13:21:55 UTC

...
loading #P"/usr/share/emacs/site-lisp/slime-cvs/swank-loader.lisp"


Try: emerge --unmerge slime-cvs; emerge slime

Comment 4 Yuan MEI 2006-05-20 14:00:34 UTC

app-emacs/slime-1.2.1.20060205

exactly the same error

> 
> Try: emerge --unmerge slime-cvs; emerge slime
>