common-lisp
Mit SLIME arbeiten

Installation

Es ist am besten, den neuesten SLIME von Emacs MELPA-Repository zu verwenden: Die Pakete sind möglicherweise etwas instabil, aber Sie erhalten die neuesten Funktionen.

Portale und Multiplattform für Emacs, Slime, Quicklisp, SBCL und Git

Sie können eine portable und Multiplattform-Version von Emacs25 herunterladen, die bereits mit Slime, SBCL, Quicklisp und Git: Portacle konfiguriert ist . Es ist ein schneller und einfacher Weg, um loszulegen. Wenn Sie erfahren möchten, wie Sie alles selbst installieren, lesen Sie weiter.

Manuelle Installation

In der Initialisierungsdatei von GNU Emacs (> = 24.5) ( ~/.emacs oder ~/.emacs.d/init.el ) fügen Sie Folgendes hinzu:

;; Use Emacs package system
(require 'package)
;; Add MELPA repository
(add-to-list 'package-archives
             '("melpa" . "http://melpa.milkbox.net/packages/") t)
;; Reload package list
(package-initialize)
(unless package-archive-contents
  (package-refresh-contents))
;; List of packages to install:
(setq package-list
      '(magit                    ; git interface (OPTIONAL)
        auto-complete            ; auto complete (RECOMMENDED)
        auto-complete-pcmp       ; programmable completion
        idle-highlight-mode      ; highlight words in programming buffer (OPTIONAL)
        rainbow-delimiters       ; highlight parenthesis (OPTIONAL)
        ac-slime                 ; auto-complete for SLIME
        slime                    ; SLIME itself
        eval-sexp-fu             ; Highlight evaluated form (OPTIONAL)
        smartparens              ; Help with many parentheses (OPTIONAL)
        ))

;; Install if are not installed
(dolist (package package-list)
  (unless (package-installed-p package)
    (package-install package)))

;; Parenthesis - OPTIONAL but recommended
(show-paren-mode t)
(require 'smartparens-config)
(sp-use-paredit-bindings)
(sp-pair "(" ")" :wrap "M-(")
(define-key smartparens-mode-map (kbd "C-<right>") 'sp-forward-slurp-sexp)
(define-key smartparens-mode-map (kbd "C-<left>") 'sp-backward-slurp-sexp)
(define-key smartparens-mode-map (kbd "C-S-<right>") 'sp-forward-barf-sexp)
(define-key smartparens-mode-map (kbd "C-S-<left>") 'sp-backward-barf-sexp)

(define-key smartparens-mode-map (kbd "C-)") 'sp-forward-slurp-sexp)
(define-key smartparens-mode-map (kbd "C-(") 'sp-backward-slurp-sexp)
(define-key smartparens-mode-map (kbd "C-}") 'sp-forward-barf-sexp)
(define-key smartparens-mode-map (kbd "C-{") 'sp-backward-barf-sexp)

(sp-pair "(" ")" :wrap "M-(")
(sp-pair "[" "]" :wrap "M-[")
(sp-pair "{" "}" :wrap "M-{")

;; MAIN Slime setup
;; Choose lisp implementation:
;; The first option uses roswell with default sbcl
;; the second option - uses ccl directly
(setq slime-lisp-implementations
      '((roswell ("ros" "-L" "sbcl-bin" "run"))
        (ccl ("ccl64"
              "-K" "utf-8"))))
;; Other settings...

SLIME alleine ist in Ordnung, funktioniert aber mit dem Quicklisp- Paketmanager besser. Befolgen Sie zur Installation von Quicklisp die Anweisungen auf der Website (wenn Sie roswell verwenden , folgen Sie den Anweisungen von roswell). Einmal installiert, rufen Sie in Ihrem Lisp auf:

(ql:quickload :quicklisp-slime-helper)

und fügen Sie der Emacs-Init-Datei die folgenden Zeilen hinzu:

;; Find where quicklisp is installed to
;; Add your own location if quicklisp is installed somewhere else
(defvar quicklisp-directories
  '("~/.roswell/lisp/quicklisp/"           ;; default roswell location for quicklisp
    "~/quicklisp/")                        ;; default quicklisp location
  "Possible locations of QUICKLISP")

;; Load slime-helper
(let ((continue-p t)
      (dirs quicklisp-directories))
  (while continue-p
    (cond ((null dirs) (message "Cannot find slime-helper.el"))
          ((file-directory-p (expand-file-name (car dirs)))
           (message "Loading slime-helper.el from %s" (car dirs))
           (load (expand-file-name "slime-helper.el" (car dirs)))
           (setq continue-p nil))
          (t (setq dirs (cdr dirs))))))

;; Autocomplete in SLIME
(require 'slime-autoloads)
(slime-setup '(slime-fancy))

;; (require 'ac-slime)
 (add-hook 'slime-mode-hook 'set-up-slime-ac)
 (add-hook 'slime-repl-mode-hook 'set-up-slime-ac)
 (eval-after-load "auto-complete"
   '(add-to-list 'ac-modes 'slime-repl-mode))

(eval-after-load "auto-complete"
  '(add-to-list 'ac-modes 'slime-repl-mode))

;; Hooks
(add-hook 'lisp-mode-hook (lambda ()
                            (rainbow-delimiters-mode t)
                            (smartparens-strict-mode t)
                            (idle-highlight-mode t)
                            (auto-complete-mode)))

(add-hook 'slime-mode-hook (lambda ()
                             (set-up-slime-ac)
                             (auto-complete-mode)))

(add-hook 'slime-repl-mode-hook (lambda ()
                                  (rainbow-delimiters-mode t)
                                  (smartparens-strict-mode t)
                                  (set-up-slime-ac)
                                  (auto-complete-mode)))

Nach dem Neustart installiert und konfiguriert GNU Emacs alle erforderlichen Pakete.

Starten und Beenden von SLIME, speziellen (Komma) REPL-Befehlen

In Emacs Mx slime wird Schleim mit der standardmäßigen (ersten) Common Lisp-Implementierung gestartet. Wenn mehrere Implementierungen bereitgestellt werden (über variable slime-lisp-implementations ), kann auf andere Implementierungen über M-- Mx slime zugegriffen werden, was die Wahl der verfügbaren Implementierungen in Mini-Puffer bietet.

Mx slime öffnet den REPL-Puffer, der wie folgt aussieht:

; SLIME 2016-04-19
CL-USER> 

Der SLIME REPL-Puffer akzeptiert einige spezielle Befehle. Beginnen alle von ihnen mit , . Einmal , eingegeben wird , wird die Liste der Optionen in Mini-Puffer angezeigt. Sie beinhalten:

• ,quit
• ,restart-inferior-lisp
• ,pwd - druckt das aktuelle Verzeichnis, in dem Lisp ausgeführt wird
• ,cd - ändert das aktuelle Verzeichnis

REPL verwenden

CL-USER> (+ 2 3)
5
CL-USER> (sin 1.5)
0.997495
CL-USER> (mapcar (lambda (x) (+ x 2)) '(1 2 3))
(3 4 5)

Das Ergebnis, das nach der Auswertung gedruckt wird, ist nicht nur eine Zeichenfolge: Hinter dem Objekt befindet sich ein vollwertiges Lisp-Objekt, das durch Klicken mit der rechten Maustaste und Auswahl von Inspect geprüft werden kann.

Mehrzeilige Eingabe ist ebenfalls möglich: Verwenden Sie Cj , um eine neue Zeile zu setzen. Enter bewirkt, dass das eingegebene Formular ausgewertet wird. Wenn das Formular nicht abgeschlossen ist, wird wahrscheinlich ein Fehler ausgegeben:

CL-USER> (mapcar (lambda (x y)
                   (declare (ignore y))
                   (* x 2))
                 '(1 2 3)
                 '(:a :b :c))
(2 4 6)

Fehlerbehandlung

Wenn die Auswertung einen Fehler verursacht:

CL-USER> (/ 3 0)

Dadurch wird ein Debugger-Puffer mit folgendem Inhalt (in SBCL-lisp) angezeigt:

arithmetic error DIVISION-BY-ZERO signalled
Operation was /, operands (3 0).
   [Condition of type DIVISION-BY-ZERO]

Restarts:
 0: [RETRY] Retry SLIME REPL evaluation request.
 1: [*ABORT] Return to SLIME's top level.
 2: [ABORT] abort thread (#<THREAD "repl-thread" RUNNING {1004FA8033}>)

Backtrace:
  0: (SB-KERNEL::INTEGER-/-INTEGER 3 0)
  1: (/ 3 0)
  2: (SB-INT:SIMPLE-EVAL-IN-LEXENV (/ 3 0) #<NULL-LEXENV>)
  3: (EVAL (/ 3 0))
  4: (SWANK::EVAL-REGION "(/ 3 0) ..)
  5: ((LAMBDA NIL :IN SWANK-REPL::REPL-EVAL))
--- more ---

Bewegen des Cursors nach unten weitergegeben --- more --- die Backtrace verursachen weiter auszubauen.

In jeder Zeile des Backtraces werden durch Drücken der Enter weitere Informationen zu einem bestimmten Anruf angezeigt (falls verfügbar).

Durch Drücken der Enter in der Reihe der Neustarts wird ein bestimmter Neustart ausgelöst. Alternativ kann der Neustart über die Nummer 0 , 1 oder 2 (entsprechende Taste an beliebiger Stelle im Puffer drücken). Der voreingestellte Neustart ist durch einen Stern markiert und kann durch Drücken der Taste q (für "quit") aufgerufen werden. Durch Drücken von q wird der Debugger geschlossen und in REPL Folgendes angezeigt

; Evaluation aborted on #<DIVISION-BY-ZERO {10064CCE43}>.
CL-USER> 

Schließlich ist es ziemlich selten, aber Lisp kann auf einen Fehler stoßen, der vom Lisp-Debugger nicht behandelt werden kann. In diesem Fall wird er in den Low-Level-Debugger verschoben oder abnormal beendet. Um die Ursache für diese Art von Fehlern zu sehen, wechseln Sie zu *inferior-lisp* buffer.

Einrichten eines SWANK-Servers über einen SSH-Tunnel.

1. Installieren Sie eine Common Lisp-Implementierung auf dem Server. (ZB sbcl , clisp , etc ...)
2. Installieren Sie quicklisp auf dem Server.
3. Laden Sie SWANK mit (ql:quickload :swank)
4. Starten Sie den Server mit (swank:create-server) . Der Standardport ist 4005 .
5. [Auf Ihrem lokalen Computer] Erstellen Sie einen SSH-Tunnel mit ssh -L4005:127.0.0.1:4005 [remote machine]
6. Stellen Sie mit Mx slime-connect Connect eine Verbindung zum laufenden Remote-Server her. Der Host sollte 127.0.0.1 und der Port 4005 .