Komfortables Erlang-Coding mit Distel und Emacs
Die Erlang-Shell ist zu Anfang sicherlich völlig ausreichend, um sich mit der Sprache vertraut zu machen, im weiteren Verlauf aber wird man früher oder später eine passende IDE benötigen. Für Erlang existiert zwar (glücklicherweise!) keine “Standard IDE”, jedoch hat sich Emacs als de-facto Stadard-Editor durchgesetzt. Daher wird dieser hier vorgestellt, wie auch eine Emacs-Erweiterung namens “Distel”, welche nützliche Emacs um nützliche Funktionen erweitert. So kann man nach Distel-Installation von Emacs aus die Erlang-Shells starten, Compilieren, Debuggen etc.
Als Erstes benötigen wir Emacs, welcher für verschiedene Betriebssysteme bereits vorkompiliert im Netz gefunden werden kann. Ich bevorzuge EmacsW32, wenn ich unter Windows entwickle, aber dies sich ja nur eine Geschmackssache. Auf jeden Fall wird Emacs benötigt.
Danach holen wir uns mit Subversion die Distel-Sourcen:
svn checkout http://distel.googlecode.com/svn/trunk/ distel
Diese Sourcen werden mit “make” kompiliert. Unter Unix/Linux geht dies recht einfach, für Windows muss zuerst die passende POSIX-Umgebung geschaffen werden. Mit Cygwin geht dies am besten und einfachsten. Für alle, die wenig Lust auf Cygwin und die ganzen Compile-Vorgänge haben, gibt es ein Zip-Paket zum Download, welches die ganze Distel-Verzeichnisstruktur beinhaltet (mit bereits kompilierten Dateien). Meine Erlang-Version zum Zeitpunkt der Kompilierung war 5.6.5.
Nachdem Distel-Sourcen übersetzt bzw. heruntergeladen worden sind, sollen diese im Verzeichnis ERLANG_HOME\lib\distel abgelegt werden.
Am Ende solltet ihr eine solche Struktur haben:
Jetzt müssen wir der Erlang-Umgebung einen Pfad mehr verpassen, damit die Distel-Binaries verfügbar sind. Im Verzeichnis ERLANG_HOME\usr wird eine Datei namens .erlang (Punkt nicht vergessen!) angelegt, sofern sie nicht bereits vorhanden ist. Diese erweitert man um folgenden Eintrag
code:add_pathz(”ERLANG_HOME/lib/distel/ebin”).
Jezt passen wir Emacs an und erstellen, sofern nicht vorhanden, eine Datei namens .emacs in eurem Benutzer-Homeverzeichnis. Wenn man sich nicht sicher ist, wie das Homeverzeichnis heißt, einfach auf der Kommandozeile Folgendes eingeben: echo %HOME%
Bei Unix/Linux-Usern schaut das Ganze ein bisserl anders aus. 
Dort hilft ein “env” auf der Konsole bzw. echo $HOME.
Im Home-Verzeichnis wird die zuvor erwähnte Datei um folgende Einträge erweitert:
;; Erlang Paths
(setq load-path (cons “ERLANG_HOME/lib/tools-2.6.2/emacs” load-path))
(setq erlang-root-dir “ERLANG_HOME“)
(setq exec-path (cons “ERLANG_HOME/bin” exec-path))
(require ‘erlang-start)
;; This is needed for Distel setup
(let ((distel-dir “ERLANG_HOME/lib/distel/elisp”))
(unless (member distel-dir load-path)
;; Add distel-dir to the end of load-path
(setq load-path (append load-path (list distel-dir)))))
(require ‘distel)
(distel-setup)
;; Some Erlang customizations
(add-hook ‘erlang-mode-hook
(lambda ()
;; when starting an Erlang shell in Emacs, default in the node name
(setq inferior-erlang-machine-options ‘(”-sname” “emacs”))
;; add Erlang functions to an imenu menu
(imenu-add-to-menubar “imenu”)))
;; A number of the erlang-extended-mode key bindings are useful in the shell too
(defconst distel-shell-keys
‘((”\C-\M-i” erl-complete)
(”\M-?” erl-complete)
(”\M-.” erl-find-source-under-point)
(”\M-,” erl-find-source-unwind)
(”\M-*” erl-find-source-unwind))
;; Additional keys to bind when in Erlang shell.”)
(add-hook ‘erlang-shell-mode-hook
(lambda ()
;; add some Distel bindings to the Erlang shell
(dolist (spec distel-shell-keys)
(define-key erlang-shell-mode-map (car spec) (cadr spec)))))
Ein Beispiel für ERLANG_HOME wäre C:/Programme/erl5.6.5
Und auch für diesen Schritt habe ich ein entsprechendes Download vorbereitet, falls man doch wenig Lust hat, sich in die Emacs-Lisp-Syntax einzuarbeiten.
Jedoch sollten die Pfade angepasst werden und auch muss man daraus achten, dass die eventuell vorhandenen Leerzeilen in Windows Pfaden umgangen werden.
Jetzt können wir Emacs starten und sich mit dem neue Erlang-Modus vertraut machen. Um diesen zu aktivieren, muss eine *.erl-Datei geladen werden.
Daneben ist noch ein weiteres Menü namens imenu vorhanden, welches vor allem bei umfangreichen Quellcodes recht nützlich ist, da es sämtliche Funktionen auflistet, die aktuell vorhanden sind. Diese kann man dann direkt ansteuern. Um eine Erlang-Shell zu starten, wählt man den Menüpunkt Shell/Start New Shell aus.
Als Ergebnis erhält man automatisch eine neue Shell innerhalb der Emacs-Umgebung.
In dieser kann man z.B. die über Emacs kompilierten Erlang-Quellcodes starten. Würden wir den angezeigten Code kompilieren wollen, so wäre die Vorgehensweise wie folgt:
Übrigens: das Wechseln zwischen verschiedenen “Buffers”, denn auch eine Erlang-Shell in Emacs ist “nur” ein weiterer Buffer, geschieht über den Menüpunkt “Buffers”. Dort wählt man einfach den gewünschten Buffer aus (hier den Quellcode) und anschließend startet man das Kompilieren desselben über Erlang/Compile/Compile Buffer. Wenn alles ordentlich verlaufen ist, erhält man folgendes Ergebnis:
Es wird also die zuvor geöffnete Shell benutzt, um den Quellcode zu kompilieren. Hätten wir keine Shell zuvor aufgemacht, so würde Emacs automatisch eine entsprechende starten. Jetzt können wir auch direkt in derselben Shell das Kompilat starten:
Dies wäre ein typischer Vorgang beim Entwickeln unter Emacs/Distel. Zuerst den Code im Buffer eingeben (oder Teile davon) und dann schrittweise testen. Ferner bietet Distel auch die Möglichkeit an, bestimmte Code-Skeletons automatisch einzufügen. Hier ein Beispiel mit einem einfachen Server-Skeleton:
Ein weiteres, äußerst nützliches Feature von Distel ist die Debugging-Funktionalität. Um diese zu nützen benötigt man neben einem geladenen Quellcode auch eine laufende Erlang-Shell. Sind diese vorhanden, wird aus dem Quellcode-Buffer (dieser muss über Buffer-Menü gewählt werden!) eine Connection zur bereits gestarteten Shell aufgebaut. Dazu bedient man sich des folgenden Menüpunktes:
Es ist natürlich auch möglich, all diese Optionen direkt über Tasktenkombinationen auszuwählen.
Direkt nachdem wir die Option aktiviert haben, werden wir nach dem Namen des Erlang-Nodes gefragt, welcher in der unten eingeblendeten Zeile eingegeben werden muss. Der Node-Name setzt sich immer aus Node-Name@Maschinen-Name zusammen. Am einfachsten ist es, sich über das Buffer-Menü zu vergewissern wie der Node heißt. Und falls wir mehrere haben, wählt man einen aus.
Nachdem der Node konnektiert wurde, muss natürlich der Quellcode kompiliert werden, damit das Debugging auch einen Sinn macht. Jedoch werden wir diesmal nicht den Menüpunk Erlang/Compile/Compile Buffer wählen, sondern direkt über die Erlang-Shell kompilieren. Dies hat damit zu tun, dass wir für das Debugging zusätzliche Informationen in unserem Kompilat bereitstellen müssen (sog. Debug-Infos). Deswegen brauchen wird einen leicht erweiterten Kommandoaufruf in der Zeile. Wir wählen also die Erlang-Shell und geben Folgendes ein (”func1″ wird natürlich nicht immer vorkommen müssen, sondern der Name eurer *.erl-Datei):
Danach müss das fertig kompilierte Modul neu geladen werden. Dies erfolgt über folgenden Menüpunkt:
Und auch hier muss der Name des Moduls in unten eingeblendeter Zeile eingegeben werden. Standardmäßig wird das aktuell kompilierte Modul vorgeschlagen, sodass man diesen nur noch bestätigen muss. Ist alles erfolgreich verlaufen, wird in der Zeile folgende Nachricht angezeigt (mit entsprechendem Modulnamen):
Jetzt aktivieren wir das Debugging:
Ist alles gut verlaufen, meldet sich Emacs mit folgender Meldung zurück:
Danach können wir in unserem Quellcode z.B. einen Breakpoint setzen, welcher dann zur Laufzeit die Abarbeitung anhalten wird. Dazu setzen wird den Cursor an die gewünschte Position und wählen diesen Menüpunkt aus:
Automatisch wird die ausgesuchte Zeile rot markiert. Will man den Breakpoint entfernen, muss nur derselbe Menüpunkt gewählt werden (oder, wie immer, die passende Tastenkombination eingegeben werden).
Jetzt rufen wir die markierte Funktion in der Erlang-Shell auf. Direkt nachdem sie gestartet wurde, wird ein neuer Debug-Buffer aktiviert, in welchem die Infos zu unserem Breakpoint und seiner momentanen Ausführung aufgelistet sind.
Man sieht unten, dass noch kein Ergebnis der Funktion double(12) zurückgegeben worden ist. Dies ist ein Zeichen, dass die weitere Ausführung ab jetzt auch schrittweise erfolgen kann. Um den angezeiten Prozess manuell zu debuggen, positioniert man den Cursor auf die gewünschte Zeile (in diesemFalle ist es nur eine, was aber nicht immer sein muss). Dann drück man einmal auf ENTER und automatisch wechselt Emacs zum Quellcode genau an die Stelle wo das Debugging markiert wurde. Man erkennt es auch am grünen Pfeil direkt neben der Quellcode-Zeile. In der unteren Fensterhälfte sieht man den momentanen Status der eingesetzten Variablen (in diesem Falle ist X = 12, was unserer Eingabe beim Funktionsaufruf entspricht).
Jetzt hat man die Wahl zwischen diesen Optionen, welche über die Tastatur eingegeben werden:
- h: Anzeige verfügbarer Kommandos.
- q: Debug-Anzeige beenden (der gedebuggte Prozess wird aber nicht geschlossen)
- SPC: Nächster Schritt.
- n: Über den Ausdruck hinausgehen.
- u: Nach oben zum nächsten Stack-Frame.
- d: Nach unten zum nächsten Stack-Frame.
- c: Fortsetzen bis zum (eventuell) nächsten Breakpoint.
- b: Breakpoint auf der aktuellen Zeile setzen/entfernen.
