SWANK compilation log from slime 2.0_p20101103 inside emacs 24.3.1

file_523936.txt (text/plain), 76.95 KB, created by Nuno Silva on 2014-09-28 11:59:41 UTC

(progn (load "/usr/share/emacs/site-lisp/slime/swank-loader.lisp" :verbose t) (funcall (read-from-string "swank:start-server") "/tmp/slime.24788" :coding-system "iso-latin-1-unix"))

This is SBCL 1.1.18, 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.
* 
; loading #P"/usr/share/emacs/site-lisp/slime/swank-loader.lisp"
; compiling file "/usr/share/common-lisp/source/swank/swank-backend.lisp" (written 28 SEP 2014 02:55:13 PM):
; compiling (DEFPACKAGE :SWANK-BACKEND ...)
; compiling (DEFPACKAGE :SWANK-MOP ...)
; compiling (IN-PACKAGE :SWANK-BACKEND)
; compiling (DEFPARAMETER *DEBUG-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 (DEFMACRO WHEN-LET ...)
; compiling (DEFUN WITH-SYMBOL ...)
; 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 GETPID ...)
; compiling (DEFINTERFACE INSTALL-SIGINT-HANDLER ...)
; compiling (DEFINTERFACE CALL-WITH-USER-BREAK-HANDLER ...)
; compiling (DEFINTERFACE QUIT-LISP ...)
; compiling (DEFINTERFACE LISP-IMPLEMENTATION-TYPE-NAME ...)
; compiling (DEFINTERFACE LISP-IMPLEMENTATION-PROGRAM ...)
; compiling (DEFINTERFACE SOCKET-FD ...)
; compiling (DEFINTERFACE MAKE-FD-STREAM ...)
; compiling (DEFINTERFACE DUP ...)
; compiling (DEFINTERFACE EXEC-IMAGE ...)
; compiling (DEFINTERFACE COMMAND-LINE-ARGS ...)
; compiling (DEFINTERFACE FILENAME-TO-PATHNAME ...)
; compiling (DEFINTERFACE PATHNAME-TO-FILENAME ...)
; compiling (DEFINTERFACE DEFAULT-DIRECTORY ...)
; compiling (DEFINTERFACE SET-DEFAULT-DIRECTORY ...)
; compiling (DEFINTERFACE CALL-WITH-SYNTAX-HOOKS ...)
; compiling (DEFINTERFACE DEFAULT-READTABLE-ALIST ...)
; compiling (DEFINTERFACE CALL-WITH-COMPILATION-HOOKS ...)
; compiling (DEFMACRO WITH-COMPILATION-HOOKS ...)
; compiling (DEFINTERFACE SWANK-COMPILE-STRING ...)
; compiling (DEFINTERFACE SWANK-COMPILE-FILE ...)
; compiling (DEFTYPE SEVERITY ...)
; compiling (DEFINE-CONDITION COMPILER-CONDITION ...)
; compiling (DEFINTERFACE FIND-EXTERNAL-FORMAT ...)
; compiling (DEFINTERFACE GUESS-EXTERNAL-FORMAT ...)
; compiling (DEFUN %SEARCH-CODING ...)
; compiling (DEFINTERFACE MAKE-OUTPUT-STREAM ...)
; compiling (DEFINTERFACE MAKE-INPUT-STREAM ...)
; compiling (DEFINTERFACE ARGLIST ...)
; compiling (DEFGENERIC DECLARATION-ARGLIST ...)
; compiling (DEFGENERIC TYPE-SPECIFIER-ARGLIST ...)
; compiling (DEFINTERFACE FUNCTION-NAME ...)
; compiling (DEFINTERFACE VALID-FUNCTION-NAME-P ...)
; compiling (DEFINTERFACE MACROEXPAND-ALL ...)
; compiling (DEFINTERFACE COMPILER-MACROEXPAND-1 ...)
; compiling (DEFINTERFACE COMPILER-MACROEXPAND ...)
; compiling (DEFINTERFACE FORMAT-STRING-EXPAND ...)
; 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-RESTARTABLE-P ...)
; compiling (DEFINTERFACE FRAME-SOURCE-LOCATION ...)
; 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 FRAME-CALL ...)
; compiling (DEFINTERFACE RETURN-FROM-FRAME ...)
; compiling (DEFINTERFACE RESTART-FRAME ...)
; compiling (DEFINTERFACE FORMAT-SLDB-CONDITION ...)
; compiling (DEFINTERFACE CONDITION-EXTRAS ...)
; compiling (DEFINTERFACE GDB-INITIAL-COMMANDS ...)
; compiling (DEFINTERFACE ACTIVATE-STEPPING ...)
; compiling (DEFINTERFACE SLDB-BREAK-ON-RETURN ...)
; compiling (DEFINTERFACE SLDB-BREAK-AT-START ...)
; compiling (DEFINTERFACE SLDB-STEPPER-CONDITION-P ...)
; compiling (DEFINTERFACE SLDB-STEP-INTO ...)
; compiling (DEFINTERFACE SLDB-STEP-NEXT ...)
; compiling (DEFINTERFACE SLDB-STEP-OUT ...)
; compiling (DEFSTRUCT (:LOCATION # ...) ...)
; compiling (DEFSTRUCT (:ERROR # ...) ...)
; compiling (DEFSTRUCT (:FILE # ...) ...)
; compiling (DEFSTRUCT (:BUFFER # ...) ...)
; compiling (DEFSTRUCT (:ETAGS-FILE # ...) ...)
; compiling (DEFSTRUCT (:POSITION # ...) ...)
; compiling (DEFSTRUCT (:TAG # ...) ...)
; compiling (DEFMACRO CONVERTING-ERRORS-TO-ERROR-LOCATION ...)
; compiling (DEFUN MAKE-ERROR-LOCATION ...)
; compiling (DEFINTERFACE FIND-DEFINITIONS ...)
; compiling (DEFINTERFACE FIND-SOURCE-LOCATION ...)
; 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 (DEFGENERIC EMACS-INSPECT ...)
; compiling (DEFMETHOD EMACS-INSPECT ...)
; compiling (DEFINTERFACE EVAL-CONTEXT ...)
; compiling (DEFUN LABEL-VALUE-LINE ...)
; compiling (DEFMACRO LABEL-VALUE-LINE* ...)
; compiling (DEFINTERFACE DESCRIBE-PRIMITIVE-TYPE ...)
; compiling (DEFINTERFACE INITIALIZE-MULTIPROCESSING ...)
; compiling (DEFINTERFACE SPAWN ...)
; compiling (DEFINTERFACE THREAD-ID ...)
; compiling (DEFINTERFACE FIND-THREAD ...)
; compiling (DEFINTERFACE THREAD-NAME ...)
; compiling (DEFINTERFACE THREAD-STATUS ...)
; compiling (DEFINTERFACE THREAD-ATTRIBUTES ...)
; compiling (DEFINTERFACE MAKE-LOCK ...)
; compiling (DEFINTERFACE CALL-WITH-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 RECEIVE-IF ...)
; compiling (DEFINTERFACE SET-DEFAULT-INITIAL-BINDING ...)
; compiling (DEFVAR *PENDING-SLIME-INTERRUPTS*)
; compiling (DEFUN CHECK-SLIME-INTERRUPTS ...)
; compiling (DEFVAR *INTERRUPT-QUEUED-HANDLER* ...)
; compiling (DEFINTERFACE WAIT-FOR-INPUT ...)
; compiling (DEFUN WAIT-FOR-STREAMS ...)
; compiling (DEFUN WAIT-FOR-ONE-STREAM ...)
; compiling (DEFUN STREAM-READABLE-P ...)
; compiling (DEFINTERFACE TOGGLE-TRACE ...)
; compiling (DEFINTERFACE MAKE-WEAK-KEY-HASH-TABLE ...)
; compiling (DEFINTERFACE MAKE-WEAK-VALUE-HASH-TABLE ...)
; compiling (DEFINTERFACE HASH-TABLE-WEAKNESS ...)
; compiling (DEFINTERFACE CHARACTER-COMPLETION-SET ...)
; compiling (DEFPARAMETER *TYPE-SPECIFIER-ARGLISTS* ...)
; compiling (DEFINTERFACE SAVE-IMAGE ...)
; compiling (DEFINTERFACE BACKGROUND-SAVE-IMAGE ...)
; compiling (DEFINTERFACE CODEPOINT-LENGTH ...)

; /home/njsg/.cache/common-lisp/sbcl-1.1.18-linux-x64/usr/share/common-lisp/source/swank/swank-backend-ASDF-TMP.fasl written
; compilation finished in 0:00:00.394
WARNING: SWANK-BACKEND also exports the following symbols:
  (SWANK-BACKEND:INTERRUPT-THREAD SWANK-BACKEND:MAKE-WEAK-VALUE-HASH-TABLE
   SWANK-BACKEND:BACKGROUND-SAVE-IMAGE SWANK-BACKEND:GETPID
   SWANK-BACKEND:FIND-SOURCE-LOCATION SWANK-BACKEND:CURRENT-THREAD
   SWANK-BACKEND:CREATE-SOCKET SWANK-BACKEND:SLDB-STEP-INTO
   SWANK-BACKEND:GUESS-EXTERNAL-FORMAT SWANK-BACKEND:FORMAT-STRING-EXPAND
   SWANK-BACKEND:FRAME-RESTARTABLE-P SWANK-BACKEND:ALL-THREADS
   SWANK-BACKEND:WHO-REFERENCES SWANK-BACKEND:SEND
   SWANK-BACKEND:FORMAT-SLDB-CONDITION SWANK-BACKEND:GDB-INITIAL-COMMANDS
   SWANK-BACKEND:CALL-WITH-COMPILATION-HOOKS
   SWANK-BACKEND:PREFERRED-COMMUNICATION-STYLE SWANK-BACKEND:THREAD-ID
   SWANK-BACKEND:REMOVE-SIGIO-HANDLERS SWANK-BACKEND:DESCRIBE-PRIMITIVE-TYPE
   SWANK-BACKEND:KILL-THREAD SWANK-BACKEND:LISP-IMPLEMENTATION-TYPE-NAME
   SWANK-BACKEND:CONDITION-EXTRAS SWANK-BACKEND:COMPILER-MACROEXPAND
   SWANK-BACKEND:FIND-DEFINITIONS SWANK-BACKEND:LIST-CALLERS
   SWANK-BACKEND:CALL-WITH-DEBUGGER-HOOK SWANK-BACKEND:INSTALL-SIGINT-HANDLER
   SWANK-BACKEND:LISP-IMPLEMENTATION-PROGRAM SWANK-BACKEND:SOCKET-FD
   SWANK-BACKEND:LOCAL-PORT SWANK-BACKEND:WHO-SPECIALIZES
   SWANK-BACKEND:ACTIVATE-STEPPING SWANK-BACKEND:PROFILED-FUNCTIONS
   SWANK-BACKEND:RECEIVE-IF SWANK-BACKEND:UNPROFILE-ALL
   SWANK-BACKEND:COMMAND-LINE-ARGS SWANK-BACKEND:SWANK-COMPILE-FILE
   SWANK-BACKEND:EXEC-IMAGE SWANK-BACKEND:SLDB-STEP-NEXT
   SWANK-BACKEND:SAVE-IMAGE SWANK-BACKEND:INSTALL-DEBUGGER-GLOBALLY
   SWANK-BACKEND:PROFILE-PACKAGE SWANK-BACKEND:SLDB-STEP-OUT
   SWANK-BACKEND:FRAME-VAR-VALUE SWANK-BACKEND:TOGGLE-TRACE
   SWANK-BACKEND:INITIALIZE-MULTIPROCESSING SWANK-BACKEND:BUFFER-FIRST-CHANGE
   SWANK-BACKEND:LIST-CALLEES SWANK-BACKEND:HASH-TABLE-WEAKNESS
   SWANK-BACKEND:DISASSEMBLE-FRAME SWANK-BACKEND:DEFAULT-READTABLE-ALIST
   SWANK-BACKEND:FILENAME-TO-PATHNAME SWANK-BACKEND:SPAWN
   SWANK-BACKEND:DESCRIBE-SYMBOL-FOR-EMACS SWANK-BACKEND:FRAME-CATCH-TAGS
   SWANK-BACKEND:CALL-WITH-USER-BREAK-HANDLER SWANK-BACKEND:WHO-SETS
   SWANK-BACKEND:CLOSE-SOCKET SWANK-BACKEND:MAKE-FD-STREAM
   SWANK-BACKEND:SET-DEFAULT-DIRECTORY SWANK-BACKEND:CHARACTER-COMPLETION-SET
   SWANK-BACKEND:FUNCTION-NAME SWANK-BACKEND:CALLS-WHO SWANK-BACKEND:MAKE-LOCK
   SWANK-BACKEND:DESCRIBE-DEFINITION SWANK-BACKEND:PRINT-FRAME
   SWANK-BACKEND:WAIT-FOR-INPUT SWANK-BACKEND:FIND-THREAD
   SWANK-BACKEND:ADD-SIGIO-HANDLER SWANK-BACKEND:MACROEXPAND-ALL
   SWANK-BACKEND:THREAD-ATTRIBUTES SWANK-BACKEND:CALL-WITH-SYNTAX-HOOKS
   SWANK-BACKEND:WHO-MACROEXPANDS SWANK-BACKEND:FIND-EXTERNAL-FORMAT
   SWANK-BACKEND:FRAME-CALL SWANK-BACKEND:MAKE-OUTPUT-STREAM
   SWANK-BACKEND:ARGLIST SWANK-BACKEND:ADD-FD-HANDLER
   SWANK-BACKEND:SWANK-COMPILE-STRING SWANK-BACKEND:SLDB-STEPPER-CONDITION-P
   SWANK-BACKEND:CALL-WITH-DEBUGGING-ENVIRONMENT
   SWANK-BACKEND:ACCEPT-CONNECTION SWANK-BACKEND:PATHNAME-TO-FILENAME
   SWANK-BACKEND:MAKE-WEAK-KEY-HASH-TABLE SWANK-BACKEND:PROFILE
   SWANK-BACKEND:THREAD-STATUS SWANK-BACKEND:RESTART-FRAME
   SWANK-BACKEND:MAKE-INPUT-STREAM SWANK-BACKEND:PROFILE-REPORT
   SWANK-BACKEND:VALID-FUNCTION-NAME-P SWANK-BACKEND:WHO-BINDS
   SWANK-BACKEND:FRAME-LOCALS SWANK-BACKEND:EVAL-IN-FRAME
   SWANK-BACKEND:EMACS-CONNECTED SWANK-BACKEND:COMPILER-MACROEXPAND-1
   SWANK-BACKEND:CALL-WITH-LOCK-HELD SWANK-BACKEND:COMPUTE-BACKTRACE
   SWANK-BACKEND:PROFILE-RESET SWANK-BACKEND:REMOVE-FD-HANDLERS
   SWANK-BACKEND:SLDB-BREAK-ON-RETURN SWANK-BACKEND:EVAL-CONTEXT
   SWANK-BACKEND:CODEPOINT-LENGTH SWANK-BACKEND:THREAD-NAME
   SWANK-BACKEND:WHO-CALLS SWANK-BACKEND:FRAME-SOURCE-LOCATION
   SWANK-BACKEND:SET-DEFAULT-INITIAL-BINDING SWANK-BACKEND:DUP
   SWANK-BACKEND:SLDB-BREAK-AT-START SWANK-BACKEND:UNPROFILE
   SWANK-BACKEND:RETURN-FROM-FRAME SWANK-BACKEND:DEFAULT-DIRECTORY
   SWANK-BACKEND:RECEIVE SWANK-BACKEND:SET-STREAM-TIMEOUT
   SWANK-BACKEND:THREAD-ALIVE-P)
See also:
  The ANSI Standard, Macro DEFPACKAGE
  The SBCL Manual, Variable *ON-PACKAGE-VARIANCE*
; compiling file "/usr/share/common-lisp/source/swank/nregex.lisp" (written 28 SEP 2014 02:55:13 PM):
; 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 ...)

; /home/njsg/.cache/common-lisp/sbcl-1.1.18-linux-x64/usr/share/common-lisp/source/swank/nregex-ASDF-TMP.fasl written
; compilation finished in 0:00:00.084
; compiling file "/usr/share/common-lisp/source/swank/swank-source-path-parser.lisp" (written 28 SEP 2014 02:55:13 PM):
; compiling (IN-PACKAGE :SWANK-BACKEND)
; compiling (LET (#) ...)
; compiling (DEFUN MAKE-SHARPDOT-READER ...)
; compiling (DEFUN MAKE-SOURCE-RECORDER ...)
; compiling (DEFUN MAKE-SOURCE-RECORDING-READTABLE ...)
; compiling (DEFUN READ-AND-RECORD-SOURCE-MAP ...)
; compiling (DEFUN SKIP-TOPLEVEL-FORMS ...)
; 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 ...)

; /home/njsg/.cache/common-lisp/sbcl-1.1.18-linux-x64/usr/share/common-lisp/source/swank/swank-source-path-parser-ASDF-TMP.fasl written
; compilation finished in 0:00:00.057
; compiling file "/usr/share/common-lisp/source/swank/swank-source-file-cache.lisp" (written 28 SEP 2014 02:55:13 PM):
; 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 READ-SNIPPET-FROM-STRING ...)
; compiling (DEFUN SKIP-COMMENTS-AND-WHITESPACE ...)
; compiling (DEFUN READ-UPTO-N-CHARS ...)

; /home/njsg/.cache/common-lisp/sbcl-1.1.18-linux-x64/usr/share/common-lisp/source/swank/swank-source-file-cache-ASDF-TMP.fasl written
; compilation finished in 0:00:00.031
; compiling file "/usr/share/common-lisp/source/swank/swank-sbcl.lisp" (written 28 SEP 2014 02:55:13 PM):
; compiling (IN-PACKAGE :SWANK-BACKEND)
; compiling (REQUIRE (QUOTE SB-BSD-SOCKETS))
; compiling (REQUIRE (QUOTE SB-INTROSPECT))
; compiling (REQUIRE (QUOTE SB-POSIX))
; compiling (REQUIRE (QUOTE SB-CLTL2))
; compiling (DECLAIM (OPTIMIZE # ...))
; file: /usr/share/common-lisp/source/swank/swank-sbcl.lisp
; in:
;      DECLAIM (OPTIMIZE (DEBUG 2) (SB-C:INSERT-STEP-CONDITIONS 0)
;           (SB-C::INSERT-DEBUG-CATCH 0) (SB-C::MERGE-TAIL-CALLS 2))
;     (DECLAIM
;      (OPTIMIZE (DEBUG 2) (SB-C:INSERT-STEP-CONDITIONS 0)
;       (SB-C::INSERT-DEBUG-CATCH 0) (SB-C::MERGE-TAIL-CALLS 2)))
; --> EVAL-WHEN 
; ==>
;   (PROCLAIM
;    '(OPTIMIZE (DEBUG 2) (SB-C:INSERT-STEP-CONDITIONS 0)
;      (SB-C::INSERT-DEBUG-CATCH 0) (SB-C::MERGE-TAIL-CALLS 2)))
; 
; caught STYLE-WARNING:
;   SB-C::MERGE-TAIL-CALLS has been deprecated as of SBCL 1.0.53.74.
;   
;   In future SBCL versions SB-C::MERGE-TAIL-CALLS will signal a full warning at
;   compile-time.

; compiling (IMPORT-FROM :SB-GRAY ...)
; compiling (DEFUN SBCL-WITH-NEW-STEPPER-P ...)
; compiling (DEFUN SBCL-WITH-WEAK-HASH-TABLES ...)
; compiling (DEFUN SBCL-WITH-XREF-P ...)
; compiling (DEFUN SBCL-WITH-RESTART-FRAME ...)
; compiling (IMPORT-SWANK-MOP-SYMBOLS :SB-MOP ...)
; compiling (DEFUN SWANK-MOP:SLOT-DEFINITION-DOCUMENTATION ...)
; compiling (DEFIMPLEMENTATION LISP-IMPLEMENTATION-TYPE-NAME ...)
; compiling (DECLAIM (FTYPE # ...))
; compiling (DEFIMPLEMENTATION GETPID ...)
; 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 (DEFIMPLEMENTATION INSTALL-SIGINT-HANDLER ...)
; 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 (DEFIMPLEMENTATION SOCKET-FD ...)
; compiling (DEFIMPLEMENTATION COMMAND-LINE-ARGS ...)
; compiling (DEFIMPLEMENTATION DUP ...)
; compiling (DEFVAR *WAIT-FOR-INPUT-CALLED*)
; compiling (DEFIMPLEMENTATION WAIT-FOR-INPUT ...)
; compiling (DEFUN INPUT-READY-P ...)
; compiling (DEFVAR *EXTERNAL-FORMAT-TO-CODING-SYSTEM* ...)
; compiling (DEFVAR *PHYSICAL-PATHNAME-HOST* ...)
; compiling (DEFIMPLEMENTATION FILENAME-TO-PATHNAME ...)
; compiling (DEFIMPLEMENTATION FIND-EXTERNAL-FORMAT ...)
; compiling (DEFUN MAKE-SOCKET-IO-STREAM ...)
; compiling (DEFUN ACCEPT ...)
; 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 (DEFMETHOD DECLARATION-ARGLIST ...)
; compiling (DEFMETHOD TYPE-SPECIFIER-ARGLIST ...)
; 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 CONDITION-REFERENCES ...)
; compiling (DEFUN COMPILER-NOTE-LOCATION ...)
; compiling (DEFUN COMPILING-FROM-BUFFER-P ...)
; compiling (DEFUN COMPILING-FROM-FILE-P ...)
; compiling (DEFUN COMPILING-FROM-GENERATED-CODE-P ...)
; compiling (DEFUN LOCATE-COMPILER-NOTE ...)
; compiling (DEFUN BRIEF-COMPILER-MESSAGE-FOR-EMACS ...)
; compiling (DEFUN COMPILER-ERROR-CONTEXT ...)
; compiling (DEFUN COMPILER-SOURCE-PATH ...)
; compiling (DEFIMPLEMENTATION CALL-WITH-COMPILATION-HOOKS ...)
; compiling (DEFVAR *TRAP-LOAD-TIME-WARNINGS* ...)
; compiling (DEFUN COMPILER-POLICY ...)
; compiling (DEFUN (SETF COMPILER-POLICY) ...)
; compiling (DEFMACRO WITH-COMPILER-POLICY ...)
; compiling (DEFIMPLEMENTATION SWANK-COMPILE-FILE ...)
; compiling (SB-ALIEN:DEFINE-ALIEN-ROUTINE ("tempnam" TEMPNAM) ...)
; compiling (DEFUN TEMP-FILE-NAME ...)
; compiling (DEFIMPLEMENTATION SWANK-COMPILE-STRING ...)
; compiling (DEFPARAMETER *DEFINITION-TYPES* ...)
; compiling (DEFUN DEFINITION-SPECIFIER ...)
; compiling (DEFUN MAKE-DSPEC ...)
; compiling (DEFIMPLEMENTATION FIND-DEFINITIONS ...)
; compiling (DEFIMPLEMENTATION FIND-SOURCE-LOCATION ...)
; compiling (DEFUN CATEGORIZE-DEFINITION-SOURCE ...)
; compiling (DEFUN DEFINITION-SOURCE-FOR-EMACS ...)
; compiling (DEFUN SOURCE-FILE-POSITION ...)
; compiling (DEFUN SOURCE-HINT-SNIPPET ...)
; compiling (DEFUN FUNCTION-SOURCE-LOCATION ...)
; compiling (DEFIMPLEMENTATION DESCRIBE-SYMBOL-FOR-EMACS ...)
; compiling (DEFIMPLEMENTATION DESCRIBE-DEFINITION ...)
; compiling (DEFMACRO DEFXREF ...)
; compiling (DEFXREF WHO-CALLS)
; compiling (DEFXREF WHO-BINDS)
; compiling (DEFXREF WHO-SETS)
; compiling (DEFXREF WHO-REFERENCES)
; compiling (DEFXREF WHO-MACROEXPANDS)
; compiling (DEFXREF WHO-SPECIALIZES ...)
; compiling (DEFUN SOURCE-LOCATION-FOR-XREF-DATA ...)
; compiling (DEFIMPLEMENTATION LIST-CALLERS ...)
; compiling (DEFIMPLEMENTATION LIST-CALLEES ...)
; compiling (DEFUN SANITIZE-XREFS ...)
; compiling (DEFUN IGNORED-XREF-FUNCTION-NAMES ...)
; compiling (DEFUN FUNCTION-DSPEC ...)
; compiling (DEFIMPLEMENTATION MACROEXPAND-ALL ...)
; compiling (DEFUN MAKE-INVOKE-DEBUGGER-HOOK ...)
; compiling (DEFUN SET-BREAK-HOOK ...)
; compiling (DEFUN CALL-WITH-BREAK-HOOK ...)
; compiling (DEFIMPLEMENTATION INSTALL-DEBUGGER-GLOBALLY ...)
; compiling (DEFIMPLEMENTATION CONDITION-EXTRAS ...)
; compiling (DEFUN EXTERNALIZE-REFERENCE ...)
; compiling (DEFVAR *SLDB-STACK-TOP*)
; compiling (DEFIMPLEMENTATION CALL-WITH-DEBUGGING-ENVIRONMENT ...)
; compiling (DEFIMPLEMENTATION ACTIVATE-STEPPING ...)
; compiling (DEFIMPLEMENTATION SLDB-STEPPER-CONDITION-P ...)
; compiling (DEFIMPLEMENTATION SLDB-STEP-INTO ...)
; compiling (DEFIMPLEMENTATION SLDB-STEP-NEXT ...)
; compiling (DEFIMPLEMENTATION SLDB-STEP-OUT ...)
; compiling (DEFIMPLEMENTATION CALL-WITH-DEBUGGER-HOOK ...)
; compiling (DEFUN NTH-FRAME ...)
; compiling (DEFIMPLEMENTATION COMPUTE-BACKTRACE ...)
; compiling (DEFIMPLEMENTATION PRINT-FRAME ...)
; compiling (DEFIMPLEMENTATION FRAME-RESTARTABLE-P ...)
; compiling (DEFIMPLEMENTATION FRAME-CALL ...)
; file: /usr/share/common-lisp/source/swank/swank-sbcl.lisp
; in: DEFIMPLEMENTATION FRAME-CALL
;     (PPRINT-LOGICAL-BLOCK (STREAM NIL :PREFIX "(" :SUFFIX ")")
;       (LET ((*PRINT-LENGTH* NIL) (*PRINT-LEVEL* NIL))
;         (PRIN1 (SB-DEBUG::ENSURE-PRINTABLE-OBJECT SWANK-BACKEND::NAME) STREAM))
;       (LET ((SWANK-BACKEND::ARGS
;              (SB-DEBUG::ENSURE-PRINTABLE-OBJECT SWANK-BACKEND::ARGS)))
;         (IF (LISTP SWANK-BACKEND::ARGS)
;             (FORMAT STREAM "~{ ~_~S~}" SWANK-BACKEND::ARGS)
;             (FORMAT STREAM " ~S" SWANK-BACKEND::ARGS))))
; --> LET LET SB-PRETTY::WITH-PRETTY-STREAM FLET LET IF 
; --> #:WITH-PRETTY-STREAM1778 
; ==>
;   STREAM
; 
; note: deleting unreachable code

; 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 (DEFIMPLEMENTATION FRAME-SOURCE-LOCATION ...)
; 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 (DEFIMPLEMENTATION RETURN-FROM-FRAME ...)
; compiling (DEFIMPLEMENTATION RESTART-FRAME ...)
; compiling (DEFIMPLEMENTATION FORMAT-SLDB-CONDITION ...)
; 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 (DEFMETHOD EMACS-INSPECT ...)
; compiling (DEFMETHOD EMACS-INSPECT ...)
; compiling (DEFMETHOD EMACS-INSPECT ...)
; compiling (DEFMETHOD EMACS-INSPECT ...)
; compiling (DEFMETHOD EMACS-INSPECT ...)
; compiling (DEFMETHOD EMACS-INSPECT ...)
; 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 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 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 (DEFUN CONDITION-TIMED-WAIT ...)
; compiling (DEFIMPLEMENTATION RECEIVE-IF ...)
; compiling (DEFIMPLEMENTATION QUIT-LISP ...)
; file: /usr/share/common-lisp/source/swank/swank-sbcl.lisp
; in: DEFIMPLEMENTATION QUIT-LISP
;     (QUIT)
; 
; caught STYLE-WARNING:
;   SB-EXT:QUIT has been deprecated as of SBCL 1.0.56.55. Use SB-EXT:EXIT or
;   SB-THREAD:ABORT-THREAD instead.
;   
;   In future SBCL versions SB-EXT:QUIT will signal a full warning at compile-time.

; compiling (DEFUN TOGGLE-TRACE-AUX ...)
; compiling (DEFUN PROCESS-FSPEC ...)
; compiling (DEFIMPLEMENTATION TOGGLE-TRACE ...)
; compiling (DEFIMPLEMENTATION MAKE-WEAK-KEY-HASH-TABLE ...)
; compiling (DEFIMPLEMENTATION MAKE-WEAK-VALUE-HASH-TABLE ...)
; compiling (DEFIMPLEMENTATION HASH-TABLE-WEAKNESS ...)
; compiling (DEFIMPLEMENTATION SAVE-IMAGE ...)
; compiling (SB-ALIEN:DEFINE-ALIEN-ROUTINE ("execv" SYS-EXECV) ...)
; compiling (DEFUN EXECV ...)
; compiling (DEFUN RUNTIME-PATHNAME ...)
; compiling (DEFIMPLEMENTATION EXEC-IMAGE ...)
; compiling (DEFIMPLEMENTATION MAKE-FD-STREAM ...)
; compiling (DEFIMPLEMENTATION BACKGROUND-SAVE-IMAGE ...)
; compiling (DEFUN DEINIT-LOG-OUTPUT ...)
; compiling (PUSHNEW (QUOTE DEINIT-LOG-OUTPUT) ...)

; /home/njsg/.cache/common-lisp/sbcl-1.1.18-linux-x64/usr/share/common-lisp/source/swank/swank-sbcl-ASDF-TMP.fasl written
; compilation finished in 0:00:00.802
WARNING:
   Lisp compilation had style-warnings while
   compiling #<CL-SOURCE-FILE "swank" "swank-sbcl">
STYLE-WARNING: SB-C::MERGE-TAIL-CALLS has been deprecated as of SBCL 1.0.53.74.

In future SBCL versions SB-C::MERGE-TAIL-CALLS will signal a full warning at
compile-time.
STYLE-WARNING: redefining EMACS-INSPECT (#<BUILT-IN-CLASS T>) in DEFMETHOD
; compiling file "/usr/share/common-lisp/source/swank/swank-gray.lisp" (written 28 SEP 2014 02:55:13 PM):
; compiling (IN-PACKAGE :SWANK-BACKEND)
; compiling (DEFCLASS SLIME-OUTPUT-STREAM ...)
; compiling (DEFMACRO WITH-SLIME-OUTPUT-STREAM ...)
; compiling (DEFMETHOD STREAM-WRITE-CHAR ...)
; compiling (DEFMETHOD STREAM-WRITE-STRING ...)
; 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-OUTPUT-STREAM ...)
; compiling (DEFIMPLEMENTATION MAKE-INPUT-STREAM ...)

; /home/njsg/.cache/common-lisp/sbcl-1.1.18-linux-x64/usr/share/common-lisp/source/swank/swank-gray-ASDF-TMP.fasl written
; compilation finished in 0:00:00.092
STYLE-WARNING:
   Implicitly creating new generic function
   SWANK-BACKEND::STREAM-READ-CHAR-WILL-HANG-P.
; compiling file "/usr/share/common-lisp/source/swank/swank-match.lisp" (written 28 SEP 2014 02:55:13 PM):
; compiling (DEFPACKAGE :SWANK-MATCH ...)
; compiling (IN-PACKAGE :SWANK-MATCH)
; compiling (DEFMACRO MATCH ...)
; compiling (DEFMACRO SELECT-MATCH ...)
; compiling (DEFUN EXPAND-SELECT-PATTERNS ...)
; compiling (DEFUN EXPAND-SELECT-PATTERNS-STYLE-1 ...)
; compiling (DEFUN EXPAND-SELECT-PATTERNS-STYLE-2 ...)
; compiling (DEFUN COMPILE-SELECT-TEST ...)
; compiling (DEFUN COMPILE-SELECT-TESTS ...)
; compiling (DEFUN COMPILE-SELECT-BINDINGS ...)
; compiling (DEFUN SELECT!-IN-TREE ...)
; compiling (DEFUN SELECT-DOUBLE-MATCH? ...)
; compiling (DEFUN SELECT-PREDICATE? ...)
; compiling (DEFUN !CS-CAR ...)
; compiling (DEFUN !CS-CDR ...)
; compiling (DEFUN !CS-CAR/CDR ...)

; /home/njsg/.cache/common-lisp/sbcl-1.1.18-linux-x64/usr/share/common-lisp/source/swank/swank-match-ASDF-TMP.fasl written
; compilation finished in 0:00:00.031
; compiling file "/usr/share/common-lisp/source/swank/swank-rpc.lisp" (written 28 SEP 2014 02:55:13 PM):
; compiling (DEFPACKAGE #:SWANK-RPC ...)
; compiling (IN-PACKAGE :SWANK-RPC)
; compiling (DEFINE-CONDITION SWANK-READER-ERROR ...)
; compiling (DEFUN READ-MESSAGE ...)
; compiling (DEFUN READ-PACKET ...)
; compiling (DEFUN READ-CHUNK ...)
; compiling (DEFPARAMETER *VALIDATE-INPUT* ...)
; compiling (DEFUN READ-FORM ...)
; compiling (DEFUN VALIDATING-READ ...)
; compiling (DEFUN SIMPLE-READ ...)
; compiling (DEFUN WRITE-MESSAGE ...)
; compiling (DEFUN PRIN1-TO-STRING-FOR-EMACS ...)

; /home/njsg/.cache/common-lisp/sbcl-1.1.18-linux-x64/usr/share/common-lisp/source/swank/swank-rpc-ASDF-TMP.fasl written
; compilation finished in 0:00:00.050
; compiling file "/usr/share/common-lisp/source/swank/swank.lisp" (written 28 SEP 2014 02:55:13 PM):
; 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 (DEFCONSTANT DEFAULT-SERVER-PORT ...)
; compiling (DEFVAR *SWANK-DEBUG-P* ...)
; compiling (DEFVAR *SLDB-STRING-LENGTH* ...)
; compiling (DEFVAR *SLDB-BITVECTOR-LENGTH* ...)
; compiling (DEFVAR *SLDB-PPRINT-DISPATCH-TABLE* ...)
; compiling (DEFVAR *SLDB-PRINTER-BINDINGS* ...)
; compiling (DEFVAR *BACKTRACE-PPRINT-DISPATCH-TABLE* ...)
; compiling (DEFVAR *BACKTRACE-PRINTER-BINDINGS* ...)
; compiling (DEFVAR *DEFAULT-WORKER-THREAD-BINDINGS* ...)
; compiling (DEFUN CALL-WITH-BINDINGS ...)
; compiling (DEFMACRO WITH-BINDINGS ...)
; compiling (DEFMACRO DEFSLIMEFUN ...)
; 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 *AFTER-INIT-HOOK* ...)
; compiling (DEFSTRUCT (CONNECTION # ...) ...)
; compiling (DEFUN PRINT-CONNECTION ...)
; compiling (DEFVAR *CONNECTIONS* ...)
; compiling (DEFVAR *EMACS-CONNECTION* ...)
; compiling (DEFUN DEFAULT-CONNECTION ...)
; compiling (DEFUN MAKE-CONNECTION ...)
; compiling (DEFUN CONNECTION.EXTERNAL-FORMAT ...)
; compiling (DEFSLIMEFUN PING ...)
; compiling (DEFUN SAFE-BACKTRACE ...)
; compiling (DEFINE-CONDITION SWANK-ERROR ...)
; compiling (DEFUN MAKE-SWANK-ERROR ...)
; compiling (DEFVAR *DEBUG-ON-SWANK-PROTOCOL-ERROR* ...)
; compiling (DEFMACRO WITH-SWANK-ERROR-HANDLER ...)
; compiling (DEFMACRO WITH-PANIC-HANDLER ...)
; compiling (ADD-HOOK *NEW-CONNECTION-HOOK* ...)
; compiling (DEFUN NOTIFY-BACKEND-OF-CONNECTION ...)
; compiling (DEFVAR *SWANK-IO-PACKAGE* ...)
; compiling (DEFVAR *LOG-EVENTS* ...)
; compiling (DEFVAR *LOG-OUTPUT* ...)
; compiling (DEFUN INIT-LOG-OUTPUT ...)
; compiling (ADD-HOOK *AFTER-INIT-HOOK* ...)
; compiling (DEFUN REAL-INPUT-STREAM ...)
; compiling (DEFUN REAL-OUTPUT-STREAM ...)
; 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 CLEAR-EVENT-HISTORY ...)
; 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 (DEFMACRO DESTRUCTURE-CASE ...)
; compiling (DEFVAR *SLIME-INTERRUPTS-ENABLED*)
; compiling (DEFMACRO WITH-INTERRUPTS-ENABLED% ...)
; compiling (DEFMACRO WITH-SLIME-INTERRUPTS ...)
; compiling (DEFMACRO WITHOUT-SLIME-INTERRUPTS ...)
; compiling (DEFUN INVOKE-OR-QUEUE-INTERRUPT ...)
; compiling (DEFMACRO WITH-IO-REDIRECTION ...)
; compiling (DEFMACRO WITH-CONNECTION ...)
; compiling (DEFUN CALL-WITH-RETRY-RESTART ...)
; compiling (DEFMACRO WITH-RETRY-RESTART ...)
; compiling (DEFMACRO WITH-STRUCT* ...)
; compiling (DEFMACRO DO-SYMBOLS* ...)
; compiling (DEFMACRO DEFINE-SPECIAL ...)
; compiling (DEFUN USE-THREADS-P ...)
; compiling (DEFUN CURRENT-THREAD-ID ...)
; compiling (DECLAIM (INLINE ENSURE-LIST))
; compiling (DEFUN ENSURE-LIST ...)
; compiling (DEFUN SYMBOL-STATUS ...)
; compiling (DEFUN SYMBOL-EXTERNAL-P ...)
; compiling (DEFUN CLASSIFY-SYMBOL ...)
; compiling (DEFUN SYMBOL-CLASSIFICATION-STRING ...)
; compiling (DEFVAR *USE-DEDICATED-OUTPUT-STREAM* ...)
; compiling (DEFVAR *DEDICATED-OUTPUT-STREAM-PORT* ...)
; compiling (DEFVAR *COMMUNICATION-STYLE* ...)
; compiling (DEFVAR *DONT-CLOSE* ...)
; compiling (DEFVAR *DEDICATED-OUTPUT-STREAM-BUFFERING* ...)
; compiling (DEFVAR *CODING-SYSTEM* ...)
; compiling (DEFVAR *LISTENER-SOCKETS* ...)
; compiling (DEFUN START-SERVER ...)
; compiling (DEFUN CREATE-SERVER ...)
; compiling (DEFUN FIND-EXTERNAL-FORMAT-OR-LOSE ...)
; compiling (DEFPARAMETER *LOOPBACK-INTERFACE* ...)
; compiling (DEFUN SETUP-SERVER ...)
; compiling (DEFUN STOP-SERVER ...)
; compiling (DEFUN RESTART-SERVER ...)
; compiling (DEFUN ACCEPT-CONNECTIONS ...)
; compiling (DEFUN AUTHENTICATE-CLIENT ...)
; 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 (DEFVAR *MAXIMUM-PIPELINED-OUTPUT-CHUNKS* ...)
; compiling (DEFVAR *MAXIMUM-PIPELINED-OUTPUT-LENGTH* ...)
; compiling (DEFUN SEND-USER-OUTPUT ...)
; compiling (DEFUN MAKE-OUTPUT-FUNCTION-FOR-TARGET ...)
; compiling (DEFUN MAKE-OUTPUT-STREAM-FOR-TARGET ...)
; compiling (DEFUN OPEN-DEDICATED-OUTPUT-STREAM ...)
; compiling (DEFUN DECODE-MESSAGE ...)
; compiling (DEFUN ENCODE-MESSAGE ...)
; compiling (DEFVAR *SLDB-QUIT-RESTART* ...)
; compiling (DEFMACRO WITH-TOP-LEVEL-RESTART ...)
; compiling (DEFUN HANDLE-REQUESTS ...)
; compiling (DEFUN PROCESS-REQUESTS ...)
; compiling (DEFUN CURRENT-SOCKET-IO ...)
; compiling (DEFUN CLOSE-CONNECTION ...)
; compiling (DEFVAR *ACTIVE-THREADS* ...)
; compiling (DEFUN READ-LOOP ...)
; compiling (DEFUN DISPATCH-LOOP ...)
; compiling (DEFVAR *AUTO-FLUSH-INTERVAL* ...)
; compiling (DEFUN AUTO-FLUSH-LOOP ...)
; compiling (DEFUN FIND-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 (DEFVAR *EVENT-QUEUE* ...)
; compiling (DEFVAR *EVENTS-ENQUEUED* ...)
; compiling (DEFUN SEND-EVENT ...)
; compiling (DEFUN SEND-TO-EMACS ...)
; compiling (DEFUN WAIT-FOR-EVENT ...)
; compiling (DEFUN WAIT-FOR-EVENT/EVENT-LOOP ...)
; compiling (DEFUN POLL-FOR-EVENT ...)
; compiling (DEFUN EVENT-MATCH-P ...)
; compiling (DEFUN SPAWN-THREADS-FOR-CONNECTION ...)
; compiling (DEFUN CONTROL-THREAD ...)
; compiling (DEFUN CLEANUP-CONNECTION-THREADS ...)
; compiling (DEFUN REPL-LOOP ...)
; compiling (DEFUN INSTALL-SIGIO-HANDLER ...)
; compiling (DEFVAR *IO-INTERUPT-LEVEL* ...)
; compiling (DEFUN PROCESS-IO-INTERRUPT ...)
; compiling (DEFUN DEINSTALL-SIGIO-HANDLER ...)
; compiling (DEFUN INSTALL-FD-HANDLER ...)
; compiling (DEFUN DISPATCH-INTERRUPT-EVENT ...)
; compiling (DEFUN DEINSTALL-FD-HANDLER ...)
; compiling (DEFUN SIMPLE-SERVE-REQUESTS ...)
; compiling (DEFINE-CONDITION END-OF-REPL-INPUT ...)
; compiling (DEFUN SIMPLE-REPL ...)
; compiling (DEFUN MAKE-REPL-INPUT-STREAM ...)
; compiling (DEFUN REPL-INPUT-STREAM-READ ...)
; compiling (DEFUN READ-NON-BLOCKING ...)
; compiling (DEFVAR *GLOBALLY-REDIRECT-IO* ...)
; compiling (DEFVAR *SAVED-GLOBAL-STREAMS* ...)
; compiling (DEFUN SETUP-STREAM-INDIRECTION ...)
; compiling (DEFUN PREFIXED-VAR ...)
; compiling (DEFVAR *STANDARD-OUTPUT-STREAMS* ...)
; compiling (DEFVAR *STANDARD-INPUT-STREAMS* ...)
; compiling (DEFVAR *STANDARD-IO-STREAMS* ...)
; compiling (DEFUN INIT-GLOBAL-STREAM-REDIRECTION ...)
; compiling (ADD-HOOK *AFTER-INIT-HOOK* ...)
; 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 *CONNECTION-CLOSED-HOOK* ...)
; compiling (DEFSLIMEFUN CREATE-REPL ...)
; compiling (DEFUN INITIALIZE-STREAMS-FOR-CONNECTION ...)
; compiling (DEFVAR *CHANNELS* ...)
; compiling (DEFVAR *CHANNEL-COUNTER* ...)
; compiling (DEFCLASS CHANNEL ...)
; compiling (DEFMETHOD INITIALIZE-INSTANCE ...)
; compiling (DEFMETHOD PRINT-OBJECT ...)
; compiling (DEFUN FIND-CHANNEL ...)
; compiling (DEFGENERIC CHANNEL-SEND ...)
; compiling (DEFMACRO DEFINE-CHANNEL-METHOD ...)
; compiling (DEFUN SEND-TO-REMOTE-CHANNEL ...)
; compiling (DEFCLASS LISTENER-CHANNEL ...)
; compiling (DEFSLIMEFUN CREATE-LISTENER ...)
; compiling (DEFUN INITIAL-LISTENER-BINDINGS ...)
; compiling (DEFUN SPAWN-LISTENER-THREAD ...)
; compiling (DEFINE-CHANNEL-METHOD :EVAL ...)
; compiling (DEFUN MAKE-LISTENER-OUTPUT-STREAM ...)
; compiling (DEFUN MAKE-LISTENER-INPUT-STREAM ...)
; compiling (DEFUN INPUT-AVAILABLE-P ...)
; compiling (DEFVAR *SLIME-FEATURES* ...)
; compiling (DEFUN SEND-OOB-TO-EMACS ...)
; compiling (DEFUN FORCE-USER-OUTPUT ...)
; compiling (ADD-HOOK *PRE-REPLY-HOOK* ...)
; compiling (DEFUN CLEAR-USER-INPUT ...)
; compiling (DEFVAR *TAG-COUNTER* ...)
; compiling (DEFUN MAKE-TAG ...)
; compiling (DEFUN READ-USER-INPUT-FROM-EMACS ...)
; compiling (DEFUN Y-OR-N-P-IN-EMACS ...)
; compiling (DEFUN READ-FROM-MINIBUFFER-IN-EMACS ...)
; compiling (DEFUN PROCESS-FORM-FOR-EMACS ...)
; compiling (DEFUN EVAL-IN-EMACS ...)
; compiling (DEFVAR *SWANK-WIRE-PROTOCOL-VERSION* ...)
; compiling (DEFSLIMEFUN CONNECTION-INFO ...)
; compiling (DEFSLIMEFUN IO-SPEED-TEST ...)
; compiling (DEFUN DEBUG-ON-SWANK-ERROR ...)
; compiling (DEFUN (SETF DEBUG-ON-SWANK-ERROR) ...)
; compiling (DEFSLIMEFUN TOGGLE-DEBUG-ON-SWANK-ERROR ...)
; compiling (DEFINE-SPECIAL *BUFFER-PACKAGE* ...)
; compiling (DEFINE-SPECIAL *BUFFER-READTABLE* ...)
; compiling (DEFMACRO WITH-BUFFER-SYNTAX ...)
; compiling (DEFUN CALL-WITH-BUFFER-SYNTAX ...)
; compiling (DEFMACRO WITHOUT-PRINTING-ERRORS ...)
; compiling (DEFUN TO-STRING ...)
; compiling (DEFUN FROM-STRING ...)
; compiling (DEFUN PARSE-STRING ...)
; compiling (DEFUN TOKENIZE-SYMBOL ...)
; compiling (DEFUN TOKENIZE-SYMBOL-THOROUGHLY ...)
; compiling (DEFUN UNTOKENIZE-SYMBOL ...)
; compiling (DEFUN CASIFY-CHAR ...)
; compiling (DEFUN FIND-SYMBOL-WITH-STATUS ...)
; compiling (DEFUN PARSE-SYMBOL ...)
; compiling (DEFUN PARSE-SYMBOL-OR-LOSE ...)
; compiling (DEFUN PARSE-PACKAGE ...)
; compiling (DEFUN UNPARSE-NAME ...)
; compiling (DEFUN GUESS-PACKAGE ...)
; compiling (DEFVAR *READTABLE-ALIST* ...)
; compiling (DEFUN GUESS-BUFFER-READTABLE ...)
; 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 (DEFMACRO VALUES-TO-STRING ...)
; compiling (DEFSLIMEFUN INTERACTIVE-EVAL ...)
; compiling (DEFSLIMEFUN EVAL-AND-GRAB-OUTPUT ...)
; compiling (DEFUN EVAL-REGION ...)
; 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 (DEFVAR *LISTENER-EVAL-FUNCTION* ...)
; compiling (DEFSLIMEFUN LISTENER-EVAL ...)
; compiling (DEFVAR *SEND-REPL-RESULTS-FUNCTION* ...)
; compiling (DEFUN REPL-EVAL ...)
; compiling (DEFUN TRACK-PACKAGE ...)
; compiling (DEFUN SEND-REPL-RESULTS-TO-EMACS ...)
; compiling (DEFUN CAT ...)
; compiling (DEFUN TRUNCATE-STRING ...)
; compiling (DEFUN CALL/TRUNCATED-OUTPUT-TO-STRING ...)
; compiling (DEFMACRO WITH-STRING-STREAM ...)
; compiling (DEFUN TO-LINE ...)
; compiling (DEFUN ESCAPE-STRING ...)
; compiling (DEFUN PACKAGE-STRING-FOR-PROMPT ...)
; compiling (DEFUN CANONICAL-PACKAGE-NICKNAME ...)
; compiling (DEFUN AUTO-ABBREVIATED-PACKAGE-NAME ...)
; compiling (DEFUN SHORTEST-PACKAGE-NICKNAME ...)
; compiling (DEFSLIMEFUN ED-IN-EMACS ...)
; compiling (DEFSLIMEFUN INSPECT-IN-EMACS ...)
; compiling (DEFSLIMEFUN VALUE-FOR-EDITING ...)
; compiling (DEFSLIMEFUN COMMIT-EDITED-VALUE ...)
; compiling (DEFUN BACKGROUND-MESSAGE ...)
; compiling (DEFUN SLEEP-FOR ...)
; compiling (DEFUN INVOKE-SLIME-DEBUGGER ...)
; compiling (DEFINE-CONDITION INVOKE-DEFAULT-DEBUGGER ...)
; compiling (DEFUN SWANK-DEBUGGER-HOOK ...)
; compiling (DEFUN INVOKE-DEFAULT-DEBUGGER ...)
; 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 (DEFVAR *SLDB-CONDITION-PRINTER* ...)
; compiling (DEFUN SAFE-CONDITION-MESSAGE ...)
; compiling (DEFUN DEBUGGER-CONDITION-FOR-EMACS ...)
; compiling (DEFUN FORMAT-RESTARTS-FOR-EMACS ...)
; compiling (DEFSLIMEFUN SLDB-BREAK-WITH-DEFAULT-DEBUGGER ...)
; compiling (DEFSLIMEFUN BACKTRACE ...)
; compiling (DEFUN FRAME-TO-STRING ...)
; compiling (DEFSLIMEFUN DEBUGGER-INFO-FOR-EMACS ...)
; compiling (DEFUN NTH-RESTART ...)
; compiling (DEFSLIMEFUN INVOKE-NTH-RESTART ...)
; compiling (DEFSLIMEFUN SLDB-ABORT ...)
; compiling (DEFSLIMEFUN SLDB-CONTINUE ...)
; compiling (DEFUN COERCE-TO-CONDITION ...)
; compiling (DEFSLIMEFUN SIMPLE-BREAK ...)
; 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-AND-CATCH-TAGS ...)
; compiling (DEFUN FRAME-LOCALS-FOR-EMACS ...)
; compiling (DEFSLIMEFUN SLDB-DISASSEMBLE ...)
; compiling (DEFSLIMEFUN SLDB-RETURN-FROM-FRAME ...)
; compiling (DEFSLIMEFUN SLDB-BREAK ...)
; compiling (DEFMACRO DEFINE-STEPPER-FUNCTION ...)
; compiling (DEFINE-STEPPER-FUNCTION SLDB-STEP ...)
; compiling (DEFINE-STEPPER-FUNCTION SLDB-NEXT ...)
; compiling (DEFINE-STEPPER-FUNCTION SLDB-OUT ...)
; compiling (DEFSTRUCT (:COMPILATION-RESULT # ...) ...)
; compiling (DEFUN MEASURE-TIME-INTERVAL ...)
; compiling (DEFUN MAKE-COMPILER-NOTE ...)
; compiling (DEFUN COLLECT-NOTES ...)
; compiling (DEFSLIMEFUN COMPILE-FILE-FOR-EMACS ...)
; compiling (DEFVAR *FASL-PATHNAME-FUNCTION* ...)
; compiling (DEFUN PATHNAME-AS-DIRECTORY ...)
; compiling (DEFUN COMPILE-FILE-OUTPUT ...)
; compiling (DEFUN FASL-PATHNAME ...)
; compiling (DEFSLIMEFUN COMPILE-STRING-FOR-EMACS ...)
; compiling (DEFSLIMEFUN COMPILE-MULTIPLE-STRINGS-FOR-EMACS ...)
; compiling (DEFUN FILE-NEWER-P ...)
; compiling (DEFUN REQUIRES-COMPILE-P ...)
; compiling (DEFSLIMEFUN COMPILE-FILE-IF-NEEDED ...)
; compiling (DEFSLIMEFUN LOAD-FILE ...)
; compiling (DEFSLIMEFUN SWANK-REQUIRE ...)
; compiling (DEFVAR *FIND-MODULE* ...)
; compiling (DEFUN MODULE-FILENAME ...)
; compiling (DEFUN MERGED-DIRECTORY ...)
; compiling (DEFVAR *LOAD-PATH* ...)
; compiling (DEFUN MODULE-CANDITATES ...)
; compiling (DEFUN FIND-MODULE ...)
; compiling (DEFUN SWANK-FASL-PATHNAME ...)
; compiling (DEFUN APPEND-DIR ...)
; compiling (DEFUN FIND-MODULE-GENTOO ...)
; 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 SWANK-EXPAND-1 ...)
; compiling (DEFSLIMEFUN SWANK-EXPAND ...)
; compiling (DEFUN EXPAND-1 ...)
; compiling (DEFUN EXPAND ...)
; compiling (DEFUN EXPAND-REPEATEDLY ...)
; compiling (DEFSLIMEFUN SWANK-FORMAT-STRING-EXPAND ...)
; compiling (DEFSLIMEFUN DISASSEMBLE-FORM ...)
; compiling (DEFSLIMEFUN SIMPLE-COMPLETIONS ...)
; compiling (DEFUN ALL-COMPLETIONS ...)
; compiling (DEFUN MATCHING-SYMBOLS ...)
; compiling (DEFUN UNPARSE-SYMBOL ...)
; compiling (DEFUN PREFIX-MATCH-P ...)
; compiling (DEFUN LONGEST-COMMON-PREFIX ...)
; compiling (DEFUN FORMAT-COMPLETION-SET ...)
; compiling (DEFSLIMEFUN OPERATOR-ARGLIST ...)
; compiling (DEFSLIMEFUN APROPOS-LIST-FOR-EMACS ...)
; compiling (DEFUN BRIEFLY-DESCRIBE-SYMBOL-FOR-EMACS ...)
; compiling (DEFUN MAP-IF ...)
; compiling (DEFUN LISTIFY ...)
; compiling (DEFUN PRESENT-SYMBOL-BEFORE-P ...)
; compiling (DEFUN MAKE-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 REDIRECT-TRACE-OUTPUT ...)
; compiling (DEFSLIMEFUN UNDEFINE-FUNCTION ...)
; compiling (DEFUN PROFILEDP ...)
; compiling (DEFSLIMEFUN TOGGLE-PROFILE-FDEFINITION ...)
; compiling (DEFSLIMEFUN PROFILE-BY-SUBSTRING ...)
; compiling (DEFSLIMEFUN FIND-DEFINITION-FOR-THING ...)
; compiling (DEFSLIMEFUN FIND-SOURCE-LOCATION-FOR-EMACS ...)
; compiling (DEFUN VALUE-SPEC-REF ...)
; compiling (DEFSLIMEFUN FIND-DEFINITIONS-FOR-EMACS ...)
; compiling (DEFGENERIC XREF-DOIT ...)
; compiling (DEFINE-XREF-ACTION :CALLS ...)
; compiling (DEFINE-XREF-ACTION :CALLS-WHO ...)
; compiling (DEFINE-XREF-ACTION :REFERENCES ...)
; compiling (DEFINE-XREF-ACTION :BINDS ...)
; compiling (DEFINE-XREF-ACTION :MACROEXPANDS ...)
; compiling (DEFINE-XREF-ACTION :SPECIALIZES ...)
; compiling (DEFINE-XREF-ACTION :CALLERS ...)
; compiling (DEFINE-XREF-ACTION :CALLEES ...)
; compiling (DEFSLIMEFUN XREF ...)
; compiling (DEFSLIMEFUN XREFS ...)
; compiling (DEFUN XREF>ELISP ...)
; compiling (DEFSTRUCT (LCONS # ...) ...)
; compiling (DEFMACRO LCONS ...)
; compiling (DEFMACRO LCONS* ...)
; compiling (DEFUN LCONS-CDR ...)
; compiling (DEFUN LLIST-RANGE ...)
; compiling (DEFUN LLIST-SKIP ...)
; compiling (DEFUN LLIST-TAKE ...)
; compiling (DEFUN ILINE ...)
; compiling (DEFVAR *INSPECTOR-VERBOSE* ...)
; compiling (DEFVAR *INSPECTOR-PRINTER-BINDINGS* ...)
; compiling (DEFVAR *INSPECTOR-VERBOSE-PRINTER-BINDINGS* ...)
; compiling (DEFSTRUCT INSPECTOR-STATE)
; compiling (DEFSTRUCT (ISTATE # ...) ...)
; compiling (DEFVAR *ISTATE* ...)
; compiling (DEFVAR *INSPECTOR-HISTORY*)
; compiling (DEFUN RESET-INSPECTOR ...)
; compiling (DEFSLIMEFUN INIT-INSPECTOR ...)
; compiling (DEFUN ENSURE-ISTATE-METADATA ...)
; compiling (DEFUN INSPECT-OBJECT ...)
; compiling (DEFUN EMACS-INSPECT/ISTATE ...)
; compiling (DEFUN ISTATE>ELISP ...)
; compiling (DEFUN PREPARE-TITLE ...)
; compiling (DEFUN PREPARE-RANGE ...)
; compiling (DEFUN PREPARE-PART ...)
; compiling (DEFUN VALUE-PART ...)
; compiling (DEFUN ACTION-PART ...)
; compiling (DEFUN ASSIGN-INDEX ...)
; compiling (DEFUN PRINT-PART-TO-STRING ...)
; compiling (DEFUN CONTENT-RANGE ...)
; compiling (DEFSLIMEFUN INSPECTOR-NTH-PART ...)
; compiling (DEFSLIMEFUN INSPECT-NTH-PART ...)
; compiling (DEFSLIMEFUN INSPECTOR-RANGE ...)
; compiling (DEFSLIMEFUN INSPECTOR-CALL-NTH-ACTION ...)
; compiling (DEFSLIMEFUN INSPECTOR-POP ...)
; compiling (DEFSLIMEFUN INSPECTOR-NEXT ...)
; compiling (DEFSLIMEFUN INSPECTOR-REINSPECT ...)
; compiling (DEFSLIMEFUN INSPECTOR-TOGGLE-VERBOSE ...)
; compiling (DEFSLIMEFUN INSPECTOR-EVAL ...)
; compiling (DEFSLIMEFUN INSPECTOR-HISTORY ...)
; 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 (DEFMETHOD EMACS-INSPECT ...)
; compiling (DEFUN INSPECT-CONS ...)
; compiling (DEFUN INSPECT-LIST ...)
; compiling (DEFUN INSPECT-LIST-AUX ...)
; compiling (DEFUN SAFE-LENGTH ...)
; compiling (DEFUN HASH-TABLE-TO-ALIST ...)
; compiling (DEFMETHOD EMACS-INSPECT ...)
; compiling (DEFMETHOD EMACS-INSPECT ...)
; compiling (DEFMETHOD EMACS-INSPECT ...)
; 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 CLEAN-ARGLIST ...)
; compiling (DEFUN WELL-FORMED-LIST-P ...)
; compiling (DEFUN PRINT-INDENTATION-LOSSAGE ...)
; compiling (ADD-HOOK *PRE-REPLY-HOOK* ...)
; compiling (DEFUN BEFORE-INIT ...)
; compiling (DEFUN INIT ...)

; /home/njsg/.cache/common-lisp/sbcl-1.1.18-linux-x64/usr/share/common-lisp/source/swank/swank-ASDF-TMP.fasl written
; compilation finished in 0:00:01.801
WARNING: SWANK also exports the following symbols:
  (SWANK:QUIT-THREAD-BROWSER SWANK:OPERATOR-ARGLIST SWANK:UNDEFINE-FUNCTION
   SWANK:INIT-INSPECTOR SWANK:INSPECTOR-REINSPECT
   SWANK:FIND-SOURCE-LOCATION-FOR-EMACS SWANK:APROPOS-LIST-FOR-EMACS
   SWANK:PPRINT-EVAL SWANK:TOGGLE-DEBUG-ON-SWANK-ERROR SWANK:INSPECTOR-RANGE
   SWANK:COMPILE-FILE-FOR-EMACS SWANK:DESCRIBE-FUNCTION
   SWANK:INVOKE-NTH-RESTART-FOR-EMACS SWANK:PPRINT-INSPECTOR-PART SWANK:PING
   SWANK:SWANK-MACROEXPAND SWANK:TOGGLE-PROFILE-FDEFINITION
   SWANK:COMMIT-EDITED-VALUE SWANK:INSPECTOR-TOGGLE-VERBOSE
   SWANK:COMPILE-STRING-FOR-EMACS SWANK:INSPECTOR-POP SWANK:IO-SPEED-TEST
   SWANK:SWANK-TOGGLE-TRACE SWANK:VALUE-FOR-EDITING SWANK:INSPECTOR-HISTORY
   SWANK:INSPECTOR-NTH-PART SWANK:DOCUMENTATION-SYMBOL
   SWANK:LIST-ALL-PACKAGE-NAMES SWANK:BACKTRACE SWANK:SWANK-EXPAND
   SWANK:DESCRIBE-DEFINITION-FOR-EMACS SWANK:FIND-DEFINITIONS-FOR-EMACS
   SWANK:LISTENER-EVAL SWANK:INTERACTIVE-EVAL SWANK:INSPECTOR-NEXT
   SWANK:CONNECTION-INFO SWANK:DESCRIBE-INSPECTEE
   SWANK:FRAME-LOCALS-AND-CATCH-TAGS SWANK:LIST-THREADS SWANK:INSPECTOR-EVAL
   SWANK:REDIRECT-TRACE-OUTPUT SWANK:SLDB-RETURN-FROM-FRAME SWANK:SWANK-REQUIRE
   SWANK:START-SWANK-SERVER-IN-THREAD SWANK:SLDB-ABORT SWANK:SLDB-NEXT
   SWANK:SET-PACKAGE SWANK:SIMPLE-BREAK SWANK:SLDB-BREAK-WITH-DEFAULT-DEBUGGER
   SWANK:SWANK-EXPAND-1 SWANK:SWANK-MACROEXPAND-1 SWANK:COMPILE-FILE-IF-NEEDED
   SWANK:INSPECT-NTH-PART SWANK:EVAL-AND-GRAB-OUTPUT SWANK:INSPECT-IN-FRAME
   SWANK:CREATE-REPL SWANK:XREFS SWANK:SIMPLE-COMPLETIONS SWANK:CREATE-LISTENER
   SWANK:XREF SWANK:RE-EVALUATE-DEFVAR SWANK:EVAL-STRING-IN-FRAME
   SWANK:FIND-DEFINITION-FOR-THING SWANK:UPDATE-INDENTATION-INFORMATION
   SWANK:PROFILE-BY-SUBSTRING SWANK:SLDB-CONTINUE
   SWANK:INSPECT-CURRENT-CONDITION SWANK:INVOKE-NTH-RESTART
   SWANK:KILL-NTH-THREAD SWANK:SWANK-FORMAT-STRING-EXPAND
   SWANK:THROW-TO-TOPLEVEL SWANK:SWANK-COMPILER-MACROEXPAND
   SWANK:PPRINT-EVAL-STRING-IN-FRAME SWANK:INTERACTIVE-EVAL-REGION
   SWANK:COMPILE-MULTIPLE-STRINGS-FOR-EMACS SWANK:SLDB-OUT
   SWANK:DESCRIBE-SYMBOL SWANK:INSPECT-FRAME-VAR SWANK:MOP
   SWANK:INSPECTOR-CALL-NTH-ACTION SWANK:SLDB-DISASSEMBLE
   SWANK:SWANK-COMPILER-MACROEXPAND-1 SWANK:UNTRACE-ALL SWANK:QUIT-INSPECTOR
   SWANK:DISASSEMBLE-FORM SWANK:SWANK-MACROEXPAND-ALL SWANK:DEBUG-NTH-THREAD
   SWANK:LOAD-FILE SWANK:DEBUGGER-INFO-FOR-EMACS)
See also:
  The ANSI Standard, Macro DEFPACKAGE
  The SBCL Manual, Variable *ON-PACKAGE-VARIANCE*
; compiling file "/usr/share/common-lisp/source/swank/contrib/swank-c-p-c.lisp" (written 28 SEP 2014 02:55:13 PM):
; compiling (IN-PACKAGE :SWANK)
; compiling (DEFSLIMEFUN COMPLETIONS ...)
; compiling (DEFUN SYMBOL-COMPLETION-SET ...)
; compiling (DEFUN PACKAGE-COMPLETION-SET ...)
; compiling (DEFUN FIND-MATCHING-SYMBOLS ...)
; compiling (DEFUN FIND-MATCHING-SYMBOLS-IN-LIST ...)
; compiling (DEFUN FIND-MATCHING-PACKAGES ...)
; compiling (DEFUN PARSE-COMPLETION-ARGUMENTS ...)
; compiling (DEFUN COMPLETION-OUTPUT-CASE-CONVERTER ...)
; compiling (DEFUN COMPLETION-OUTPUT-PACKAGE-CONVERTER ...)
; compiling (DEFUN COMPLETION-OUTPUT-SYMBOL-CONVERTER ...)
; compiling (DEFUN DETERMINE-CASE ...)
; compiling (DEFUN MAKE-COMPOUND-PREFIX-MATCHER ...)
; compiling (DEFUN LONGEST-COMPOUND-PREFIX ...)
; compiling (DEFUN TOKENIZE-COMPLETION ...)
; compiling (DEFUN UNTOKENIZE-COMPLETION ...)
; compiling (DEFUN TRANSPOSE-LISTS ...)
; compiling (DEFSLIMEFUN COMPLETIONS-FOR-CHARACTER ...)
; compiling (PROVIDE :SWANK-C-P-C)

; /home/njsg/.cache/common-lisp/sbcl-1.1.18-linux-x64/usr/share/common-lisp/source/swank/contrib/swank-c-p-c-ASDF-TMP.fasl written
; compilation finished in 0:00:00.068
; compiling file "/usr/share/common-lisp/source/swank/contrib/swank-arglists.lisp" (written 28 SEP 2014 02:55:13 PM):
; compiling (IN-PACKAGE :SWANK)
; compiling (SWANK-REQUIRE :SWANK-C-P-C)
; compiling (DEFUN COMPOSE ...)
; compiling (DEFUN LENGTH= ...)
; compiling (DECLAIM (INLINE MEMQ))
; compiling (DEFUN MEMQ ...)
; compiling (DEFUN EXACTLY-ONE-P ...)
; compiling (DEFUN VALID-OPERATOR-SYMBOL-P ...)
; compiling (DEFUN FUNCTION-EXISTS-P ...)
; compiling (DEFMACRO MULTIPLE-VALUE-OR ...)
; compiling (DEFUN ARGLIST-AVAILABLE-P ...)
; compiling (DEFMACRO WITH-AVAILABLE-ARGLIST ...)
; compiling (DEFSTRUCT (ARGLIST # ...) ...)
; compiling (DEFSTRUCT (ARGLIST-DUMMY # ...) ...)
; compiling (DEFUN EMPTY-ARG-P ...)
; compiling (DEFPARAMETER +LAMBDA-LIST-KEYWORDS+ ...)
; compiling (DEFMACRO DO-DECODED-ARGLIST ...)
; compiling (DEFUN PRINT-DECODED-ARGLIST ...)
; compiling (DEFUN PRINT-ARG ...)
; compiling (DEFUN PRINT-DECODED-ARGLIST-AS-TEMPLATE ...)
; compiling (DEFVAR *ARGLIST-PPRINT-BINDINGS* ...)
; compiling (DEFVAR *ARGLIST-SHOW-PACKAGES* ...)
; compiling (DEFMACRO WITH-ARGLIST-IO-SYNTAX ...)
; compiling (DEFUN DECODED-ARGLIST-TO-STRING ...)
; compiling (DEFUN DECODED-ARGLIST-TO-TEMPLATE-STRING ...)
; compiling (DEFUN DECODE-REQUIRED-ARG ...)
; compiling (DEFUN ENCODE-REQUIRED-ARG ...)
; 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 (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 (DEFGENERIC EXTRA-KEYWORDS ...)
; compiling (DEFMETHOD EXTRA-KEYWORDS ...)
; compiling (DEFUN MAKE-PACKAGE-COMPARATOR ...)
; compiling (DEFUN SORT-EXTRA-KEYWORDS ...)
; compiling (DEFUN KEYWORDS-OF-OPERATOR ...)
; 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 (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-KEYWORDS ...)
; compiling (DEFUN ENRICH-DECODED-ARGLIST-WITH-EXTRA-KEYWORDS ...)
; compiling (DEFGENERIC COMPUTE-ENRICHED-DECODED-ARGLIST ...)
; compiling (DEFMETHOD COMPUTE-ENRICHED-DECODED-ARGLIST ...)
; compiling (DEFMETHOD COMPUTE-ENRICHED-DECODED-ARGLIST ...)
; compiling (DEFMETHOD COMPUTE-ENRICHED-DECODED-ARGLIST ...)
; compiling (DEFUN DELETE-GIVEN-ARGS ...)
; compiling (DEFUN REMOVE-GIVEN-ARGS ...)
; compiling (DEFUN ARGLIST-FROM-FORM ...)
; compiling (EXPORT (QUOTE ARGLIST-DISPATCH))
; compiling (DEFGENERIC ARGLIST-DISPATCH ...)
; compiling (DEFMETHOD ARGLIST-DISPATCH ...)
; compiling (DEFMETHOD ARGLIST-DISPATCH ...)
; compiling (DEFMETHOD ARGLIST-DISPATCH ...)
; compiling (DEFMETHOD ARGLIST-DISPATCH ...)
; compiling (DEFMETHOD ARGLIST-DISPATCH ...)
; compiling (DEFUN ARGLIST-FOR-TYPE-DECLARATION ...)
; compiling (DEFUN DECODED-ARGLIST-FOR-DECLARATION ...)
; compiling (DEFUN DECODED-ARGLIST-FOR-TYPE-SPECIFIER ...)
; compiling (DEFSLIMEFUN AUTODOC ...)
; compiling (DEFUN BOUNDP-AND-INTERESTING ...)
; compiling (DEFUN PRINT-VARIABLE-TO-STRING ...)
; compiling (DEFSLIMEFUN COMPLETE-FORM ...)
; compiling (DEFSLIMEFUN COMPLETIONS-FOR-KEYWORD ...)
; compiling (DEFPARAMETER +CURSOR-MARKER+ ...)
; compiling (DEFUN FIND-SUBFORM-WITH-ARGLIST ...)
; compiling (DEFUN EXTRACT-CURSOR-MARKER ...)
; compiling (DEFGENERIC EXTRACT-LOCAL-OP-ARGLISTS ...)
; compiling (DEFUN %COLLECT-OP/ARGL-ALIST ...)
; compiling (DEFUN FIND-IMMEDIATELY-CONTAINING-ARGLIST ...)
; compiling (DEFUN FORM-PATH-TO-ARGLIST-PATH ...)
; compiling (DEFUN ARGLIST-INDEX ...)
; compiling (DEFUN ARGLIST-REF ...)
; compiling (DEFUN PROVIDED-ARGUMENTS-REF ...)
; compiling (DEFUN POSITIONAL-ARGS-NUMBER ...)
; compiling (DEFUN PARSE-RAW-FORM ...)
; compiling (DEFUN READ-CONVERSATIVELY ...)
; compiling (DEFUN TEST-PRINT-ARGLIST ...)
; compiling (DEFUN TEST-ARGLIST-REF ...)
; compiling (TEST-PRINT-ARGLIST)
; compiling (TEST-ARGLIST-REF)
; compiling (PROVIDE :SWANK-ARGLISTS)

; /home/njsg/.cache/common-lisp/sbcl-1.1.18-linux-x64/usr/share/common-lisp/source/swank/contrib/swank-arglists-ASDF-TMP.fasl written
; compilation finished in 0:00:00.738
; compiling file "/usr/share/common-lisp/source/swank/contrib/swank-asdf.lisp" (written 28 SEP 2014 02:55:13 PM):
; compiling (IN-PACKAGE :SWANK)
; compiling (DEFUN FIND-OPERATION ...)
; compiling (DEFUN MAP-DEFINED-SYSTEMS ...)
; compiling (DEFSLIMEFUN WHO-DEPENDS-ON ...)
; compiling (DEFMETHOD XREF-DOIT ...)
; compiling (DEFSLIMEFUN OPERATE-ON-SYSTEM-FOR-EMACS ...)
; compiling (DEFUN OPERATE-ON-SYSTEM ...)
; compiling (DEFUN ASDF-CENTRAL-REGISTRY ...)
; compiling (DEFSLIMEFUN LIST-ALL-SYSTEMS-IN-CENTRAL-REGISTRY ...)
; compiling (DEFSLIMEFUN LIST-ALL-SYSTEMS-KNOWN-TO-ASDF ...)
; compiling (DEFSLIMEFUN LIST-ASDF-SYSTEMS ...)
; compiling (DEFUN ASDF-MODULE-FILES ...)
; compiling (DEFUN ASDF-MODULE-OUTPUT-FILES ...)
; compiling (DEFSLIMEFUN ASDF-SYSTEM-FILES ...)
; compiling (DEFSLIMEFUN ASDF-SYSTEM-LOADED-P ...)
; compiling (DEFSLIMEFUN ASDF-SYSTEM-DIRECTORY ...)
; compiling (DEFUN SYSTEM-CONTAINS-FILE-P ...)
; compiling (DEFSLIMEFUN ASDF-DETERMINE-SYSTEM ...)
; compiling (DEFSLIMEFUN DELETE-SYSTEM-FASLS ...)
; compiling (DEFVAR *RECOMPILE-SYSTEM* ...)
; compiling (DEFMETHOD ASDF/ACTION:OPERATION-DONE-P ...)
; compiling (DEFSLIMEFUN RELOAD-SYSTEM ...)
; compiling (WHEN (EQL *COMMUNICATION-STYLE* ...) ...)
; compiling (PROVIDE :SWANK-ASDF)

; /home/njsg/.cache/common-lisp/sbcl-1.1.18-linux-x64/usr/share/common-lisp/source/swank/contrib/swank-asdf-ASDF-TMP.fasl written
; compilation finished in 0:00:00.062
; compiling file "/usr/share/common-lisp/source/swank/contrib/swank-clipboard.lisp" (written 28 SEP 2014 02:55:13 PM):
; compiling (DEFPACKAGE :SWANK-CLIPBOARD ...)
; compiling (IN-PACKAGE :SWANK-CLIPBOARD)
; compiling (DEFSTRUCT CLIPBOARD ...)
; compiling (DEFVAR *CLIPBOARD* ...)
; compiling (DEFSLIMEFUN ADD ...)
; compiling (DEFSLIMEFUN ENTRIES ...)
; compiling (DEFSLIMEFUN DELETE-ENTRY ...)
; compiling (DEFSLIMEFUN ENTRY-TO-REF ...)
; compiling (DEFUN CLIPBOARD-ADD ...)
; compiling (DEFUN CLIPBOARD-REF ...)
; compiling (DEFUN CLIPBOARD-ENTRY ...)
; compiling (DEFUN CLIPBOARD-DELETE-ENTRY ...)
; compiling (DEFUN ENTRY-TO-STRING ...)
; compiling (DEFUN TO-LINE ...)

; /home/njsg/.cache/common-lisp/sbcl-1.1.18-linux-x64/usr/share/common-lisp/source/swank/contrib/swank-clipboard-ASDF-TMP.fasl written
; compilation finished in 0:00:00.061
; compiling file "/usr/share/common-lisp/source/swank/contrib/swank-fancy-inspector.lisp" (written 28 SEP 2014 02:55:13 PM):
; compiling (IN-PACKAGE :SWANK)
; compiling (DEFMETHOD EMACS-INSPECT ...)
; compiling (DEFUN DOCSTRING-ISPEC ...)
; compiling (UNLESS (FIND-METHOD # ...) ...)
; compiling (DEFUN INSPECT-FUNCTION ...)
; compiling (DEFUN METHOD-SPECIALIZERS-FOR-INSPECT ...)
; compiling (DEFUN METHOD-FOR-INSPECT-VALUE ...)
; compiling (DEFMETHOD EMACS-INSPECT ...)
; compiling (DEFVAR *GF-METHOD-GETTER* ...)
; compiling (DEFUN SPECIALIZER< ...)
; compiling (DEFUN METHODS-BY-APPLICABILITY ...)
; compiling (DEFUN ABBREV-DOC ...)
; compiling (DEFSTRUCT (INSPECTOR-CHECKLIST # ...) ...)
; compiling (DEFUN MAKE-CHECKLIST ...)
; compiling (DEFUN REINITIALIZE-CHECKLIST ...)
; compiling (DEFUN MAKE-CHECKLIST-BUTTON ...)
; compiling (DEFMACRO DO-CHECKLIST ...)
; compiling (DEFUN BOX ...)
; compiling (DEFUN REF ...)
; compiling (DEFUN (SETF REF) ...)
; compiling (DEFVAR *INSPECTOR-SLOTS-DEFAULT-ORDER* ...)
; compiling (DEFVAR *INSPECTOR-SLOTS-DEFAULT-GROUPING* ...)
; compiling (DEFGENERIC ALL-SLOTS-FOR-INSPECTOR ...)
; compiling (DEFMETHOD ALL-SLOTS-FOR-INSPECTOR ...)
; compiling (DEFUN LIST-ALL-SLOTS-BY-INHERITANCE ...)
; compiling (DEFUN MAKE-SLOT-LISTING ...)
; compiling (DEFGENERIC SLOT-VALUE-FOR-INSPECTOR ...)
; compiling (DEFUN SLOT-HOME-CLASS-USING-CLASS ...)
; compiling (DEFUN STABLE-SORT-BY-INHERITANCE ...)
; compiling (DEFUN QUERY-AND-SET-SLOT ...)
; compiling (DEFMETHOD EMACS-INSPECT ...)
; compiling (DEFMETHOD EMACS-INSPECT ...)
; compiling (DEFMETHOD EMACS-INSPECT ...)
; compiling (DEFMETHOD EMACS-INSPECT ...)
; compiling (DEFSTRUCT (%PACKAGE-SYMBOLS-CONTAINER # ...) ...)
; compiling (DEFUN %MAKE-PACKAGE-SYMBOLS-CONTAINER ...)
; compiling (DEFGENERIC MAKE-SYMBOLS-LISTING ...)
; compiling (DEFMETHOD MAKE-SYMBOLS-LISTING ...)
; compiling (DEFMETHOD MAKE-SYMBOLS-LISTING ...)
; compiling (DEFMETHOD EMACS-INSPECT ...)
; compiling (DEFMETHOD EMACS-INSPECT ...)
; compiling (DEFMETHOD EMACS-INSPECT ...)
; compiling (DEFMETHOD EMACS-INSPECT ...)
; compiling (DEFMETHOD EMACS-INSPECT ...)
; compiling (DEFUN FORMAT-ISO8601-TIME ...)
; compiling (DEFMETHOD EMACS-INSPECT ...)
; compiling (DEFMETHOD EMACS-INSPECT ...)
; compiling (DEFMETHOD EMACS-INSPECT ...)
; compiling (DEFMETHOD EMACS-INSPECT ...)
; compiling (DEFUN MAKE-PATHNAME-ISPEC ...)
; compiling (DEFUN MAKE-FILE-STREAM-ISPEC ...)
; compiling (DEFMETHOD EMACS-INSPECT ...)
; compiling (DEFMETHOD EMACS-INSPECT ...)
; compiling (DEFUN COMMON-SEPERATED-SPEC ...)
; compiling (DEFUN INSPECTOR-PRINC ...)
; compiling (PROVIDE :SWANK-FANCY-INSPECTOR)

; /home/njsg/.cache/common-lisp/sbcl-1.1.18-linux-x64/usr/share/common-lisp/source/swank/contrib/swank-fancy-inspector-ASDF-TMP.fasl written
; compilation finished in 0:00:00.453
; compiling file "/usr/share/common-lisp/source/swank/contrib/swank-fuzzy.lisp" (written 28 SEP 2014 02:55:13 PM):
; compiling (IN-PACKAGE :SWANK)
; compiling (SWANK-REQUIRE :SWANK-C-P-C)
; compiling (DEFSLIMEFUN FUZZY-COMPLETIONS ...)
; compiling (DEFSTRUCT (FUZZY-MATCHING # ...) ...)
; compiling (DEFUN MAKE-FUZZY-MATCHING ...)
; compiling (DEFUN %FUZZY-EXTRACT-MATCHING-INFO ...)
; compiling (DEFUN FUZZY-FORMAT-MATCHING ...)
; compiling (DEFUN FUZZY-CONVERT-MATCHING-FOR-EMACS ...)
; compiling (DEFUN FUZZY-COMPLETION-SET ...)
; compiling (DEFUN FUZZY-GENERATE-MATCHINGS ...)
; compiling (DEFUN %GUESS-SORT-DURATION ...)
; compiling (DEFUN %MAKE-DUPLICATE-SYMBOLS-FILTER ...)
; compiling (DEFUN FUZZY-MATCHING-GREATERP ...)
; compiling (DECLAIM (FTYPE # ...))
; compiling (DEFUN GET-REAL-TIME-IN-MSECS ...)
; compiling (DEFUN FUZZY-FIND-MATCHING-SYMBOLS ...)
; compiling (DEFUN FUZZY-FIND-MATCHING-PACKAGES ...)
; compiling (DEFSLIMEFUN FUZZY-COMPLETION-SELECTED ...)
; compiling (DEFPARAMETER *FUZZY-RECURSION-SOFT-LIMIT* ...)
; compiling (DECLAIM (FIXNUM *FUZZY-RECURSION-SOFT-LIMIT*))
; compiling (DEFUN COMPUTE-HIGHEST-SCORING-COMPLETION ...)
; compiling (DEFUN COMPUTE-MOST-COMPLETIONS ...)
; compiling (DEFUN RECURSIVELY-COMPUTE-MOST-COMPLETIONS ...)
; file: /usr/share/common-lisp/source/swank/contrib/swank-fuzzy.lisp
; in: DEFUN RECURSIVELY-COMPUTE-MOST-COMPLETIONS
;     (LENGTH SWANK::*ALL-CHUNKS*)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (INCF SWANK::SHORT-INDEX)
; --> LET* SETQ 
; ==>
;   (THE FIXNUM #:NEW710)
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the first argument of CHECK-FIXNUM

; compiling (DEFVAR *FUZZY-COMPLETION-SYMBOL-PREFIXES* ...)
; compiling (DEFVAR *FUZZY-COMPLETION-SYMBOL-SUFFIXES* ...)
; compiling (DEFVAR *FUZZY-COMPLETION-WORD-SEPARATORS* ...)
; compiling (DEFUN SCORE-COMPLETION ...)
; compiling (DEFUN HIGHLIGHT-COMPLETION ...)
; compiling (DEFUN FORMAT-FUZZY-COMPLETION-SET ...)
; compiling (PROVIDE :SWANK-FUZZY)

; /home/njsg/.cache/common-lisp/sbcl-1.1.18-linux-x64/usr/share/common-lisp/source/swank/contrib/swank-fuzzy-ASDF-TMP.fasl written
; compilation finished in 0:00:00.153
; compiling file "/usr/share/common-lisp/source/swank/contrib/swank-hyperdoc.lisp" (written 28 SEP 2014 02:55:13 PM):
; compiling (IN-PACKAGE :SWANK)
; compiling (DEFSLIMEFUN HYPERDOC ...)

; /home/njsg/.cache/common-lisp/sbcl-1.1.18-linux-x64/usr/share/common-lisp/source/swank/contrib/swank-hyperdoc-ASDF-TMP.fasl written
; compilation finished in 0:00:00.005
; compiling file "/usr/share/common-lisp/source/swank/contrib/swank-indentation.lisp" (written 28 SEP 2014 02:55:13 PM):
; compiling (IN-PACKAGE :SWANK)
; compiling (DEFVAR *APPLICATION-HINTS-TABLES* ...)
; compiling (DEFUN HAS-APPLICATION-INDENTATION-HINT-P ...)
; compiling (DEFUN APPLICATION-INDENTATION-HINT ...)
; compiling (DEFUN SYMBOL-INDENTATION ...)

; /home/njsg/.cache/common-lisp/sbcl-1.1.18-linux-x64/usr/share/common-lisp/source/swank/contrib/swank-indentation-ASDF-TMP.fasl written
; compilation finished in 0:00:00.011
; compiling file "/usr/share/common-lisp/source/swank/contrib/swank-listener-hooks.lisp" (written 28 SEP 2014 02:55:13 PM):
; compiling (IN-PACKAGE :SWANK)
; 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 %LISTENER-EVAL ...)
; compiling (SETQ *LISTENER-EVAL-FUNCTION* ...)
; compiling (PROVIDE :SWANK-LISTENER-HOOKS)

; /home/njsg/.cache/common-lisp/sbcl-1.1.18-linux-x64/usr/share/common-lisp/source/swank/contrib/swank-listener-hooks-ASDF-TMP.fasl written
; compilation finished in 0:00:00.011
; compiling file "/usr/share/common-lisp/source/swank/contrib/swank-media.lisp" (written 28 SEP 2014 02:55:13 PM):
; compiling (IN-PACKAGE :SWANK)

; /home/njsg/.cache/common-lisp/sbcl-1.1.18-linux-x64/usr/share/common-lisp/source/swank/contrib/swank-media-ASDF-TMP.fasl written
; compilation finished in 0:00:00.002
; compiling file "/usr/share/common-lisp/source/swank/contrib/swank-motd.lisp" (written 28 SEP 2014 02:55:13 PM):
; compiling (IN-PACKAGE :SWANK)
; compiling (DEFUN PARSE-CHANGELOG ...)
; file: /usr/share/common-lisp/source/swank/contrib/swank-motd.lisp
; in: DEFUN PARSE-CHANGELOG
;     (WITH-OUTPUT-TO-STRING (SWANK::ENTRY-TEXT)
;       (LOOP SWANK::FOR SWANK::CHANGELOG-LINE = (READ-LINE STREAM NIL STREAM NIL)
;             WHEN (EQ SWANK::CHANGELOG-LINE STREAM)
;             DO (RETURN-FROM SWANK::READ-NEXT-ENTRY
;                  (VALUES (GET-OUTPUT-STREAM-STRING SWANK::ENTRY-TEXT) NIL))
;             WHEN (SWANK::ENTRY-LINE-P SWANK::CHANGELOG-LINE)
;             DO ...))
; --> LET GET-OUTPUT-STREAM-STRING 
; ==>
;   SWANK::ENTRY-TEXT
; 
; note: deleting unreachable code

; compiling (DEFUN READ-MOTD ...)

; /home/njsg/.cache/common-lisp/sbcl-1.1.18-linux-x64/usr/share/common-lisp/source/swank/contrib/swank-motd-ASDF-TMP.fasl written
; compilation finished in 0:00:00.021
; compiling file "/usr/share/common-lisp/source/swank/contrib/swank-package-fu.lisp" (written 28 SEP 2014 02:55:13 PM):
; compiling (IN-PACKAGE :SWANK)
; compiling (DEFSLIMEFUN PACKAGE= ...)
; compiling (DEFSLIMEFUN EXPORT-SYMBOL-FOR-EMACS ...)
; compiling (DEFSLIMEFUN UNEXPORT-SYMBOL-FOR-EMACS ...)
; compiling (DEFUN LIST-STRUCTURE-SYMBOLS ...)
; compiling (DEFUN LIST-CLASS-SYMBOLS ...)
; compiling (DEFSLIMEFUN EXPORT-STRUCTURE ...)
; compiling (PROVIDE :SWANK-PACKAGE-FU)

; /home/njsg/.cache/common-lisp/sbcl-1.1.18-linux-x64/usr/share/common-lisp/source/swank/contrib/swank-package-fu-ASDF-TMP.fasl written
; compilation finished in 0:00:00.012
; compiling file "/usr/share/common-lisp/source/swank/contrib/swank-presentations.lisp" (written 28 SEP 2014 02:55:13 PM):
; compiling (IN-PACKAGE :SWANK)
; 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 (DEFVAR *NIL-SURROGATE* ...)
; compiling (DEFUN SAVE-PRESENTED-OBJECT ...)
; compiling (DEFSLIMEFUN LOOKUP-PRESENTED-OBJECT ...)
; compiling (DEFSLIMEFUN LOOKUP-PRESENTED-OBJECT-OR-LOSE ...)
; compiling (DEFSLIMEFUN CLEAR-REPL-RESULTS ...)
; compiling (DEFUN PRESENT-REPL-RESULTS ...)
; 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 (DEFGENERIC MENU-CHOICES-FOR-PRESENTATION ...)
; compiling (DEFMETHOD MENU-CHOICES-FOR-PRESENTATION ...)
; compiling (DEFMETHOD MENU-CHOICES-FOR-PRESENTATION ...)
; compiling (DEFSLIMEFUN INSPECT-PRESENTATION ...)
; compiling (SETQ *SEND-REPL-RESULTS-FUNCTION* ...)
; compiling (PROVIDE :SWANK-PRESENTATIONS)

; /home/njsg/.cache/common-lisp/sbcl-1.1.18-linux-x64/usr/share/common-lisp/source/swank/contrib/swank-presentations-ASDF-TMP.fasl written
; compilation finished in 0:00:00.063
; compiling file "/usr/share/common-lisp/source/swank/contrib/swank-presentation-streams.lisp" (written 28 SEP 2014 02:55:13 PM):
; compiling (IN-PACKAGE :SWANK)
; compiling (SWANK-REQUIRE :SWANK-PRESENTATIONS)
; compiling (DEFVAR *ENABLE-PRESENTING-READABLE-OBJECTS* ...)
; compiling (DEFMACRO PRESENTING-OBJECT ...)
; compiling (DEFMACRO PRESENTING-OBJECT-IF ...)
; compiling (HANDLER-BIND (#) ...)
; compiling (LET (# #) ...)
; compiling (DEFUN CAN-PRESENT-READABLE-OBJECTS ...)
; compiling (DEFUN WRITE-ANNOTATION ...)
; compiling (DEFSTRUCT PRESENTATION-RECORD ...)
; compiling (DEFUN PRESENTATION-START ...)
; compiling (DEFUN PRESENTATION-END ...)
; compiling (DEFUN PRESENTING-OBJECT-1 ...)
; compiling (DEFUN PRESENT-REPL-RESULTS-VIA-PRESENTATION-STREAMS ...)
; compiling (IN-PACKAGE :SWANK)
; compiling (DEFVAR *SAVED-%PRINT-UNREADABLE-OBJECT* ...)
; compiling (SB-EXT:WITHOUT-PACKAGE-LOCKS (SETF # ...) ...)
; compiling (SETQ *SEND-REPL-RESULTS-FUNCTION* ...)
; compiling (PROVIDE :SWANK-PRESENTATION-STREAMS)

; /home/njsg/.cache/common-lisp/sbcl-1.1.18-linux-x64/usr/share/common-lisp/source/swank/contrib/swank-presentation-streams-ASDF-TMP.fasl written
; compilation finished in 0:00:00.053
; compiling file "/usr/share/common-lisp/source/swank/contrib/swank-sbcl-exts.lisp" (written 28 SEP 2014 02:55:13 PM):
; compiling (IN-PACKAGE :SWANK)
; compiling (SWANK-REQUIRE :SWANK-ARGLISTS)
; compiling (DEFMETHOD COMPUTE-ENRICHED-DECODED-ARGLIST ...)
; compiling (PROVIDE :SWANK-SBCL-EXTS)

; /home/njsg/.cache/common-lisp/sbcl-1.1.18-linux-x64/usr/share/common-lisp/source/swank/contrib/swank-sbcl-exts-ASDF-TMP.fasl written
; compilation finished in 0:00:00.012
; compiling file "/usr/share/common-lisp/source/swank/contrib/swank-snapshot.lisp" (written 28 SEP 2014 02:55:13 PM):
; compiling (DEFPACKAGE SWANK-SNAPSHOT ...)
; compiling (IN-PACKAGE SWANK-SNAPSHOT)
; compiling (DEFSLIMEFUN SAVE-SNAPSHOT ...)
; compiling (DEFSLIMEFUN RESTORE-SNAPSHOT ...)
; compiling (DEFSLIMEFUN BACKGROUND-SAVE-SNAPSHOT ...)
; compiling (IN-PACKAGE :SWANK)
; compiling (DEFUN SWANK-SNAPSHOT::RESURRECT ...)
; compiling (DEFUN READ-COMMAND-LINE-ARG ...)
; compiling (IN-PACKAGE :SWANK-SNAPSHOT)

; /home/njsg/.cache/common-lisp/sbcl-1.1.18-linux-x64/usr/share/common-lisp/source/swank/contrib/swank-snapshot-ASDF-TMP.fasl written
; compilation finished in 0:00:00.025
; compiling file "/usr/share/common-lisp/source/swank/contrib/swank-sprof.lisp" (written 28 SEP 2014 02:55:13 PM):
; compiling (IN-PACKAGE :SWANK)
; compiling (REQUIRE :SB-SPROF); 
; caught ERROR:
;   READ error during COMPILE-FILE:
;   
;     Lock on package SB-C violated when interning HAIRY-ARG-PROCESSOR while in
;     package SWANK.
;   See also:
;     The SBCL Manual, Node "Package Locks"
;   
;     (in form starting at line: 12, column: 23, file-position: 178)

; compilation aborted after 0:00:00.018

debugger invoked on a UIOP/LISP-BUILD:COMPILE-FILE-ERROR in thread
#<THREAD "main thread" RUNNING {1002C9AD33}>:
  COMPILE-FILE-ERROR while
  compiling #<NO-LOAD-FILE "swank" "contrib" "swank-sprof">

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

restarts (invokable by number or by possibly-abbreviated name):
  0: [RETRY   ] Retry compiling #<NO-LOAD-FILE "swank" "contrib" "swank-sprof">.
  1: [ACCEPT  ] Continue, treating
                compiling #<NO-LOAD-FILE "swank" "contrib" "swank-sprof"> as
                having been successful.
  2: [RETRY   ] Retry EVAL of current toplevel form.
  3: [CONTINUE] Ignore error and continue loading file "/usr/share/emacs/site-lisp/slime/swank-loader.lisp".
  4: [ABORT   ] Abort loading file "/usr/share/emacs/site-lisp/slime/swank-loader.lisp".
  5:            Exit debugger, returning to top level.

(UIOP/LISP-BUILD:CHECK-LISP-COMPILE-RESULTS NIL T T "~/asdf-action::format-action/" ((#<ASDF/LISP-ACTION:COMPILE-OP > . #<SWANK-SYSTEM::NO-LOAD-FILE "swank" "contrib" "swank-sprof">)))
0]