- OT: The font in this screenshot is realy nice. Where can I get it ? -- Ignas Mikalajunas It's Bitstream Vera Sans Mono.
In standard good community spirit, everyone is invited to make corrections and improvements to the text below. When the rate of change dies down a little this page will be converted into a texinfo manual.
The SLIME Read-Eval-Print-Loop pops up in a buffer called
*slime-repl* as soon as Emacs connects to Lisp. The REPL buffer is like the traditional
*inferior-lisp* buffer, but with tighter integration between Emacs and Lisp. Parts of the top-level are written in Emacs Lisp, so Emacs always knows where the prompt is and it can tell the difference between return values and printed output. The REPL also uses the SLIME debugger automatically.
You can see the REPL in the top-right quarter of the screenshot (below the debugger). Note that separate pretty colours are used for the prompt, user input, printed output, and the results of expressions you enter.
*slime-repl* buffer has most of the
slime-mode keybindings, plus these additional ones:
Return- Either sends the current line to Lisp for evaluation or, if the line isn't complete (unmatched parens), open and indent a new line.
Control-Return- Close any unmatched parenthesis and then send the current line to Lisp for evaluation.
C-c C-c- Interrupt the Lisp process with
SIGINT. This typically signals a condition and pops you into the SLIME debugger. It does not appear to work reliably with multithreaded Lisps due to signaling ambiguity.
TAB- Complete the Lisp symbol at point.
SLIME has its own custom Emacs-integrated debugger. Any time Lisp is evaluating a request for Emacs the
*DEBUGGER-HOOK* is bound such that the Emacs debugger will be used for any errors. When the debugger is triggered an Emacs buffer pops up saying what the error is, which restarts are available, and displaying a part of the backtrace. You can see the debugger in the top-right corner of the screenshot above.
Initially only a single line from the backtrace is shown. You can fetch more blocks of frames just by moving the point down onto
--more-- at the end of the buffer.
The debugger remains active until a restart provokes it to return. However, it is possible to use regular SLIME commands from inside the debugger, and any errors in these commands will cause the debugger to be entered recursively.
The following commands invoke restarts:
0 .. 9- Invoke a restart by number.
q- Throw to the top-level.
a- Invoke the
c- Invoke the
There are also commands for poking around in the frame at point:
v- Show the current frame's source expression in a buffer.
t- Toggle verbose display of the frame at point. The verbose version includes all local variables and
l- Show local variables.
e- Evaluate an expression from inside a frame.
d- Evaluate an expression and display the result in an extra buffer.
i- Evaluate an expression and inspect the result.
:- Evaluate an expression (in the global environment).
D- Disassemble the code of the current frame.
r- Restart execution of the frame with the same arguments as it was called originally. (Not supported by all backends.)
R- Return a value from the current frame. (Not supported by all backends.)
Motion between frames:
n- Move to the next frame.
p- Move to the previous frame.
M-n- Detail-move to the next frame. This switches the current frame to a one-line summary, then moves to the next frame, displays it verbosely in the backtrace (as with
t), and shows the corresponding source expression (as with
M-p- Detail-move to the previous frame.
Many Lisps save the source location for functions. SLIME uses this information to find the definition of a specific symbol. You don't need to maintain a separate "tags table" for this feature.
SLIME pushes the current position to a stack before jumping to the
M-, pops the top element of this stack and
jumps to the saved position.
It is recommended that you install the source code of your implementation (you can learn many tricks by reading the source). For CMUCL you should set the target search list in your .cmucl-init.lisp to tell CMUCL where you installed the source, e.g.:
(setf (search-list "target:") '("/opt/cmucl/src/"))
For SBCL you should define the corresponding logical pathname translations, e.g.:
(setf (logical-pathname-translations "SYS") '(("SYS:SRC;**;*.*.*" #P"/opt/sbcl/src/**/*.*") ("SYS:CONTRIB;**;*.*.*" #P"/opt/sbcl/contrib/**/*.*")))
SLIME, like ILISP, has a version of Erik Naggum's Common Lisp Hyperspec access package. Out of box, it points to an online version of the HyperSpec. If for some reason you wish to use a locally downloaded copy of the HyperSpec, you can. Place in your .emacs: (setq common-lisp-hyperspec-root "file:/usr/local/lisp/CLHS6/HyperSpec/") replacing the local file URL with the appropriate local file URL of the downloaded and uncompressed HyperSpec for your system. [The package now picks up Map_Sym.txt location automatically, AFAIK?]
[strictly speaking, a wider emacs feature] You may or may not like the built in emacs web browser. If you wish to use an alternative one to read the HyperSpec, then the emacs customisation setting "Browse Url Browser Function" lets you pick which browser to open.
SLIME provides commands for compiling files, definitions, buffers, regions, and systems. When compiling files and systems the compiled code is stored in fasl files on disk. When compiling definitions, buffers, or regions the code is only kept in memory and not written to files.
Compiler Warnings Commands
SLIME collects the warnings generated by the compiler and provides commands to find the corresponding source location and to display the compiler messages. SLIME annotates the source code corresponding to warnings with mouse sensitive overlays. The message for the overlay is displayed in the minibuffer when the mouse pointer is above the overlay.
EvaluationEvaluation commands are useful for testing small parts of Lisp programs, without the need to type them into the REPL.
C-c : is the most basic command for evaluating a Lisp
expression interactively. Emacs reads the expression as string from
the minibuffer and sends it together with the value of
slime-buffer-package (the Lisp package associated with
the current buffer) to Lisp. Lisp reads the string in the package,
evaluates the form and sends the printed result as string back to
Emacs and Emacs displays the result in the echo area.
slime-buffer-package is a buffer local variable and
contains the name found in the nearest in-package form. If
the buffer contains no in-package form, Lisp uses the current
C-x C-e and
C-M-x commands are
C-c :, but don't read the expression from the
C-x C-e uses the sexp before point and
C-M-x the toplevel form after or around point. A
toplevel form is a sexp with the opening paren in the first
C-M-x treats forms starting
with defvar specially. The variable is reset, if it is
already bound. So
C-M-x turns a defvar
effectively into a defparameter.
C-x C-e does
not treat defvar specially.
Tip: slime-complete-symbol can be used to complete
the symbol around point. It is bound to
M-TAB in Lisp
buffers and to
TAB in the minibuffer.
slime-mode keybindings overview
Here is the summary of keybindings in
slime-mode offered by
C-h m (
describe-mode). A sensible subset of these commands is also available in the
SLIME: The Superior Lisp Interaction Mode for Emacs (minor-mode). Commands to compile the current buffer's source file and visually highlight any resulting compiler notes and warnings: C-c C-k - Compile and load the current buffer's file. C-c M-k - Compile (but not load) the current buffer's file. C-c C-c - Compile the top-level form at point. Commands for visiting compiler notes: M-n - Goto the next form with a compiler note. M-p - Goto the previous form with a compiler note. C-c M-c - Remove compiler-note annotations in buffer. Finding definitions: M-. - Edit the definition of the function called at point. M-, - Pop the definition stack to go back from a definition. Programming aids: C-c TAB - Complete the Lisp symbol at point. (Also M-TAB.) C-c RET - Macroexpand once. C-c M-m - Macroexpand all. Cross-referencing (see CMUCL manual): C-c C-w c - WHO-CALLS a function. C-c C-w r - WHO-REFERENCES a global variable. C-c C-w s - WHO-SETS a global variable. C-c C-w b - WHO-BINDS a global variable. C-c C-w m - WHO-MACROEXPANDS a macro. C-M-. - Goto the next reference source location. (Also C-c C-SPC) Documentation commands: C-c C-d - Describe symbol. C-c C-a - Apropos search. C-c M-d - Disassemble a function. Evaluation commands: C-M-x - Evaluate top-level from containing point. C-x C-e - Evaluate sexp before point. C-c C-p - Evaluate sexp before point, pretty-print result.