Copyright © 1995 by O'Reilly/International Thomson Verlag

Bitte denken Sie daran: Sie dürfen zwar die Online-Version ausdrucken, aber diesen Druck nicht fotokopieren oder verkaufen.

Wünschen Sie mehr Informationen zu der gedruckten Version des Buches "Linux - Wegweiser zur Installation & Konfiguration", dann klicken Sie hier.


Kapitel 5

Der Editor Emacs

Texteditoren gehören zu den wichtigsten Anwendungen in der UNIX-Welt. Sie werden so oft benutzt, daß einige Leute mehr Zeit mit einem Editor als sonstwo in ihrem System verbringen. Das gilt auch für Linux.

Die Entscheidung für einen Editor kann eine Glaubensfrage sein. Es gibt viele Editoren, aber die Benutzer von UNIX teilen sich in zwei große Gruppen auf: die Emacs-Fraktion und die Anhänger von vi . Anscheinend nimmt die Zahl der vi -Benutzer ab; vielleicht weil es ein etwas älterer Editor mit nicht gerade intuitiver Bedienung ist. Trotzdem kommen vi -Veteranen (und diejenigen, die im Zwei-Finger-Suchsystem tippen) damit viel besser zurecht als mit einem komplexen Editor wie Emacs.

Wenn vi im Spektrum der Texteditoren das eine Ende markiert, so bildet Emacs den Gegenpol am anderen Ende. Beide folgen unterschiedlichen Philosophien und haben andere Arbeitsweisen. Emacs ist das geistige Kind von Richard Stallman, dem Gründer der Free Software Foundation und Autor eines großen Teils der GNU-Software.

Emacs ist eine sehr umfangreiche Anwendung, die mehr Möglichkeiten bietet als jedes bekannte UNIX-Programm. Emacs enthält einen eigenen LISP-Interpreter, mit dessen Hilfe Sie Erweiterungen und Makros für den Editor schreiben können. (Viele der Emacs-Funktionen sind in Emacs-LISP geschrieben.) Emacs enthält außerdem Erweiterungen für so verschiedene Dinge wie das Kompilieren und Debuggen von Programmen, die Handhabung von E-Mail sowie die Unterstützung des X Window System usw. Zu Emacs gehören außerdem ein Lernprogramm sowie die Dokumentation.

Legen Sie los mit Emacs

Emacs wird einfach mit:

$ emacs dateiname

aufgerufen. Wenn Sie z.B. den Befehl emacs wibble.txt eingeben, sollten Sie etwa folgendes sehen:

-----------------------------------------------------------------
|                                              			| 
|                                              			| 
|                                                               | 
| -----Emacs: wibble.txt    (Fundamental)----All--------------  |
-----------------------------------------------------------------

Die Statuszeile am unteren Bildschirmrand zeigt sowohl den Dateinamen als auch den Typ des Puffers an, in dem Sie sich befinden (in diesem Fall Fundamental). Emacs kennt viele verschiedene Editiermodi -- Fundamental ist die Voreinstellung für einfache Textdateien, aber es gibt auch einen Modus für das Editieren von C- und TeX-Quellcode, einen für die Arbeit mit Verzeichnissen usw. Wir werden bald sehen, daß jeder Modus seine eigenen Funktionstasten und Befehle kennt. Emacs bestimmt den Arbeitsmodus anhand der Suffixe zu den Dateinamen.

Rechts vom Puffertyp sehen Sie das Wort All -- das bedeutet, daß Sie gerade die komplette (leere) Datei im Blick haben. Normalerweise sehen Sie an dieser Stelle einen Prozentwert, der Ihnen anzeigt, an welcher Stelle in der Datei Sie sich befinden.

Wenn Sie Emacs unter dem X Window System benutzen, wird für den Editor ein neues Fenster aufgemacht, das oben eine Menüzeile enthält, dazu Laufleisten und andere Extras. Im Abschnitt » Emacs « besprechen wir die Besonderheiten von Emacs unter X.

Einfache Editierbefehle

Wenn es um grundlegende Editieraufgaben geht, ist Emacs viel einfacher in der Handhabung als vi . Mit den Pfeiltasten sollten Sie sich durch den Text bewegen können; falls nicht (weil Emacs nicht an Ihr Terminal angepaßt ist), benutzen Sie die Tastenkombinationen CTRL-P (Zeile hoch), CTRL-N (Zeile runter), CTRL-F (Zeichen vorwärts) und CTRL-B (Zeichen zurück). Beachten Sie, daß in der Emacs-Terminologie C-p für CTRL-p steht, und M-p (oder META-p) bedeutet ALT-p. Sie werden sich denken können, daß C-M-p für CTRL-ALT-p steht.

Falls Sie sich nicht an die ALT-Taste gewöhnen können, drücken Sie zunächst ESC und dann p. Das einmalige Drücken von ESC hat dieselbe Funktion wie eine festgehaltene ALT-Taste.

Schon an dieser Stelle müssen wir einen ersten Exkurs von unserer Emacs-Tour machen. Buchstäblich jeder Befehl und jede Taste innerhalb von Emacs kann verändert werden. Das heißt, daß in der »Standard«-Konfiguration von Emacs die Tastenkombination C-p die Funktion previous-line (Zeile hoch) aufruft, die den Cursor (in Emacs auch »Point« genannt) um eine Zeile nach oben bewegt. Es ist allerdings kein Problem, andere Tastenkombinationen mit solchen Funktionen zu verknüpfen; Sie können auch neue Funktionen schreiben und diesen dann Tasten zuordnen usw. Wenn wir nicht ausdrücklich auf etwas anderes hinweisen, funktionieren die hier vorgestellten Tastenkombinationen in der Standardkonfiguration von Emacs. Weiter unten werden wir Ihnen zeigen, wie Sie die Tastenbelegung für Ihre Zwecke anpassen.

Zurück zur Textbearbeitung: Mit den Pfeiltasten oder den Tastenkombinationen, die wir weiter oben bereits erwähnt haben, bewegen Sie den Cursor im aktuellen Textpuffer. Geben Sie einfach Text ein; er erscheint an der Cursorposition. Mit den Tasten BACKSPACE oder DELETE sollten Sie den Text unter dem Cursor löschen können. Für den Fall, daß das nicht funktioniert, zeigen wir Ihnen im Abschnitt » Emacs anpassen « , wie Sie dieses Problem beheben. Tippen Sie also einfach los:

-----------------------------------------------------------------
| The rain falls on the main plains in Spain.                   |
|                                              			| 
|                                              			| 
|                                                               | 
| -----Emacs: wibble.txt    (Fundamental)----All--------------  |
-----------------------------------------------------------------

Mit den Tastenkombinationen C-a und C-e bewegen Sie den Cursor an den Anfang beziehungsweise das Ende der aktuellen Zeile. C-v blättert eine Seite vor, M-v eine Seite zurück. Es gibt noch viel mehr Befehle für grundlegende Editieraufgaben, aber wir werden es der Online-Hilfe von Emacs überlassen, Sie darüber aufzuklären.

Wenn Sie Emacs verlassen wollen, geben Sie C-x C-c ein. Dies ist der erste erweiterte Befehl, den wir vorstellen; viele Emacs-Befehle erfordern mehr als eine Tastenkombination. C-x allein ist nur ein »Präfix« für andere Tasten. In diesem Fall verlassen Sie mit C-x gefolgt von C-c den Emacs, nachdem Sie zuvor noch gefragt werden, ob Sie wirklich aufhören möchten, ohne Änderungen abzuspeichern.

Mit C-x C-s speichern Sie die aktuelle Datei, und mit C-x C-f »finden« Sie eine andere Datei zum Editieren. Wenn Sie C-x C-f eingeben, werden Sie etwa folgenden Prompt sehen:

Find file: /home/loomer/mdw/" "

mit dem das aktuelle Verzeichnis angezeigt wird. Dahinter können Sie den Namen der zu öffnenden Datei eintippen. Wenn Sie an dieser Stelle die TAB-Taste drücken, werden Dateinamen in ähnlicher Weise komplettiert, wie Sie das von bash und tcsh kennen. Wenn Sie z.B. eingeben:

Find file: /home/loomer/mdw/.bash" "

und dann TAB drücken, wird ein weiterer Textpuffer geöffnet, der alle Möglichkeiten der Komplettierung enthält -- etwa so:

-----------------------------------------------------------------
| Possible completions are:                                     |
| .bash_profile                      .bashrc                    |
|                                              			| 
|                                              			| 
|                                                               | 
| --**-Emacs: *Completions* (Fundamental)----All--------------  |
-----------------------------------------------------------------

Nachdem Sie den Dateinamen komplettiert haben, wird der *Completions*-Puffer verschwinden und die gerade ausgewählte Datei ist zum Editieren geöffnet. Dies ist ein Beispiel dafür, wie Emacs temporäre Puffer benutzt, um Informationen auszugeben.

Emacs läßt Sie mit mehreren Textpuffern arbeiten; jeder Puffer kann eine andere von Ihnen bearbeitete Datei enthalten. Jedesmal, wenn Sie mit C-x C-f eine neue Datei öffnen, wird sie zum Editieren in einen neuen Puffer geladen, ohne daß die bereits vorhandenen Puffer gelöscht werden.

Mit dem Befehl C-x b wechseln Sie in einen anderen Textpuffer. Dabei werden Sie nach dem Namen des gewünschten Puffers gefragt (meist ist das der Name der Datei in diesem Puffer). Mit C-x b erhalten Sie einen Prompt wie diesen:

Switch to buffer: (default wibble.txt)

Der Puffer, in dem Sie zuletzt gearbeitet haben, wird als Voreinstellung angezeigt. Mit ENTER wechseln Sie in diesen Puffer, sonst geben Sie den Namen eines anderen Puffers ein. Mit C-x C-b erhalten Sie eine Liste der Puffer (die wiederum in einem Puffer enthalten ist); das sieht etwa so aus:

--------------------------------------------------------------------
|  MR Buffer        Size   Mode        File                         |
|  -- ------        ----   ----        ----                         |
| .   wibble.txt     44    Fundamental /home/loomer/mdw/wibble.txt  |
|     .bashrc        1763  Fundamental /home/loomer/mdw/.bashrc     |
|     *scratch*      0     Lisp Interaction                         |
|  *  *Buffer List*  265   Buffer Menu                              |
---------------------------------------------------------------------

Mit dem Erscheinen des Puffermenüs teilt sich der Emacs-Bildschirm in zwei »Fenster«, zwischen denen Sie mit C-x o hin- und herschalten. Es ist auch möglich, mehr als zwei Fenster gleichzeitig zu öffnen. Wenn Sie nur noch ein Fenster sehen möchten, wechseln Sie dorthin und geben C-x 1 ein. Damit verschwinden alle anderen Fenster, aber mit dem Befehl C-x b, den wir gerade beschrieben haben, können Sie wieder zu diesen Fenstern zurückkehren. Mit C-x k entfernen Sie einen Puffer aus dem Arbeitsspeicher von Emacs.

Das Lernprogramm und die Online-Hilfe

Schon jetzt erscheint Emacs ziemlich kompliziert; das liegt einfach daran, daß es ein dermaßen flexibles System ist. Bevor wir Emacs weiter erkunden, wollen wir seine Online-Hilfe und das Lernprogramm vorstellen. Diese Dokumente sind auch in Buchform erhältlich.

Mit dem Befehl C-h erhalten Sie in der letzten Bildschirmzeile eine Liste der Hilfe-Optionen. Wenn Sie C-h noch einmal drücken, erscheint eine genauere Übersicht über die vorhandenen Hilfe-Texte. Mit C-h, gefolgt von einem t, landen Sie im Emacs-Lernprogramm (tutorial). Dieses ist weitgehend selbsterklärend, und ein interaktives Lernprogramm sollte Ihnen viel mehr Stoff vermitteln, als wir hier möglicherweise behandeln können.

Nachdem Sie das Lernprogramm von Emacs durchlaufen haben, sollten Sie sich mit seinem Info-System vertraut machen, in dem der Rest der Emacs-Dokumentation enthalten ist. Mit C-h und i gelangen Sie in das Info-System. Eine beliebige Info-Seite könnte etwa folgendermaßen aussehen:

---------------------------------------------------------------------
| File: intercal.info,  Node: Top,  Next: Instructions,  Up: (dir)  |
|                                                                   |
|    This file documents the Intercal interpreter for Linux.        |
|                                                                   |
|    * Menu:                                                        |
|                                                                   |
|    * Instructions::        How to read this manual.               |
|    * Overview::            Preliminary information.               |
|    * Examples::            Example Intercal programs and bugs.    |
|    * Concept Index::       Index of concepts.                     |
---------------------------------------------------------------------

Wie Sie sehen, erscheint der Info-Text zusammen mit einem Menü, das auf eine Reihe von »Knoten« (nodes) verweist. Wenn Sie an dieser Stelle m und den Namen eines Knotens eingeben, wird der entsprechende Info-Text auf dem Bildschirm ausgegeben. Sie können alle Knoten der Reihe nach lesen, indem Sie mit n zum jeweils nächsten Knoten springen (die Statuszeile am oberen Bildschirmrand weist darauf hin). In diesem Beispiel ist der nächste Knoten Instructions, der erste Knoten des Menüs.

Jeder Knoten hat außerdem eine Verbindung zum übergeordneten Knoten (parent node) Up, der in diesem Fall (dir) ist; (dir) steht für das Verzeichnis mit den Info-Seiten. Mit u gelangen Sie zum Parent-Node. Zusätzlich besteht von jedem Knoten aus eine Verbindung zum vorherigen Knoten (falls vorhanden; in diesem Beispiel nicht). Mit p kehren Sie zum vorherigen Knoten zurück. Wenn Sie l drücken, gelangen Sie noch einmal zu dem Knoten, den Sie zuletzt besucht hatten.

Wenn Sie innerhalb von Info ein ? eingeben, sehen Sie eine Liste der Befehle, und mit h erhalten Sie eine kurze Einführung in das System. Da Sie Info aus Emacs heraus gestartet haben, können Sie hier auch Emacs-Befehle benutzen (z.B. mit C-x b in einen anderen Puffer wechseln).

Es gibt weitere Formen der Online-Hilfe in Emacs. Mit C-h C-h erhalten Sie eine Liste der Hilfe-Optionen. Eine davon ist C-h k; Sie haben danach die Möglichkeit, eine Taste zu drücken und sehen dann, welche Funktion mit dieser Taste verknüpft ist.

Text löschen, kopieren und verschieben

Es gibt mehrere Methoden, in Emacs Textblöcke zu verschieben und zu kopieren. Emacs benutzt dazu die Markierung (mark); das ist einfach eine »erinnerte« Cursorposition, die mit verschiedenen Befehlen gesetzt werden kann. Der Textblock zwischen der aktuellen Position des Cursors ( point ) und der Markierung wird die Region genannt.

Die Markierung können Sie mit C-@ setzen (oder, auf den meisten Systemen, mit C-SPACE). Wenn Sie den Cursor auf eine bestimmte Stelle bewegen und dort C-@ drücken, haben Sie die Markierung an diese Stelle gesetzt. Wenn Sie anschließend den Cursor auf eine andere Position bewegen, ist der Bereich zwischen der aktuellen Position und der Markierung als die Region definiert.

Viele Emacs-Befehle beziehen sich auf die Region. Die wichtigsten dieser Befehle sind diejenigen zum Löschen und Wiedereinfügen von Text. Mit C-w löschen Sie die aktuelle Region und lesen Sie gleichzeitig in den Kill-Ring ein. Der Kill-Ring besteht aus den Textblöcken, die bereits gelöscht wurden. Sie können anschließend mit C-y den gelöschten Text an anderer Stelle wieder einfügen. Mit Hilfe des Kill-Rings haben Sie die Möglichkeit, nicht nur den zuletzt gelöschten Textblock wieder einzufügen, sondern Sie können auch auf ältere Löschungen zurückgreifen.

Ein Beispiel: Geben Sie folgenden Text in einen Emacs-Puffer ein:

-----------------------------------------------------------------
| The rain falls on the main plains in Spain.                   |
|                                              			| 
| Here is a line that we wish to move.                          |
| She sells Bourne shells by the sea shore.                     | 
|                                              			| 
|                                                               | 
| --**-Emacs: wibble.txt    (Fundamental)----All--------------  |
-----------------------------------------------------------------

Gehen Sie mit dem Cursor jetzt an den Anfang der zweiten Zeile (»Here is a line...«) und setzen Sie dort mit C-@ die Markierung. Gehen Sie an das Ende der Zeile (mit C-e) und löschen Sie dann mit C-w die Region. Der Textpuffer sollte jetzt etwa so aussehen:

-----------------------------------------------------------------
| The rain falls on the main plains in Spain.                   |
|                                              			| 
| She sells Bourne shells by the sea shore.                     | 
|                                              			| 
|                                                               | 
| --**-Emacs: wibble.txt    (Fundamental)----All--------------  |
-----------------------------------------------------------------

Bewegen Sie den Cursor dann an das Ende des Textpuffers, um den gerade gelöschten Text dort mit C-y wieder einzufügen. Die Zeile sollte an der neuen Position erscheinen (siehe Abbildung auf der nächsten Seite).

-----------------------------------------------------------------
| The rain falls on the main plains in Spain.                   |
|                                              			| 
| She sells Bourne shells by the sea shore.                     | 
| Here is a line that we wish to move.                          |
|                                              			| 
|                                                               | 
| --**-Emacs: wibble.txt    (Fundamental)----All--------------  |
-----------------------------------------------------------------

Wenn Sie C-y wiederholt drücken, wird der Text mehrere Male eingefügt.

In ähnlicher Weise können Sie Texte vervielfältigen. Wenn Sie M-w statt C-w benutzen, lesen Sie die Region in den Kill-Ring ein, ohne sie aus dem Text zu löschen. (Erinnern Sie sich, daß M- entweder die gedrückte und gehaltene ALT-Taste oder die einmal gedrückte ESC-Taste bezeichnet.)

Auch Text, der mit anderen Löschbefehlen wie z.B. C-k entfernt wurde, steht im Kill-Ring. Das bedeutet, daß Sie nicht unbedingt die Markierung setzen und C-w benutzen müssen, um einen Textblock zu verschieben; Sie können dafür jeden beliebigen Löschbefehl einsetzen.

Wenn Sie vorher gelöschte Textblöcke (die im Kill-Ring gespeichert sind) wieder einfügen möchten, benutzen Sie dazu den Befehl M-y, nachdem Sie einmal Text mit C-y eingefügt haben. Mit M-y ersetzen Sie den ausgeschnittenen Text durch den vorherigen Textblock aus dem Kill-Ring. Wenn Sie M-y wiederholt drücken, bewegen Sie sich schrittweise durch den Inhalt des Kill-Rings. Dies ist eine äußerst nützliche Einrichtung, wenn Sie verschiedene Textblöcke verschieben oder kopieren möchten. Emacs kennt auch einen Register -Mechanismus ähnlich dem in vi , aber in den meisten Fällen ist der Kill-Ring flexibel genug.

Suchen und ersetzen

Die übliche Methode, in Emacs nach einer Zeichenkette zu suchen, ist der Befehl C-s. Damit starten Sie eine sogenannte inkrementelle Suche . Tippen Sie nach C-s die Zeichen des Suchbegriffs ein. Mit jedem Zeichen, das Sie tippen, sucht Emacs vorwärts nach einem Vorkommen des Suchstrings, den Sie bisher eingegeben haben. Wenn Sie sich vertippen, können Sie den Suchbegriff mit der DEL-Taste korrigieren und die korrekten Zeichen eingeben. Falls der Suchbegriff nicht gefunden wird, meldet Emacs das mit einem Piepton. Wenn der Suchbegriff einmal gefunden wurde, Sie aber nach weiteren Vorkommen suchen möchten, drükken Sie wieder C-s.

In derselben Weise können Sie mit C-r auch rückwärts suchen. Emacs kennt noch verschiedene andere Arten der Suche, darunter auch die Suche mit regulären Ausdrücken, die Sie mit M-C-s starten. Damit können Sie nach Suchbegriffen wie jo.*n suchen, mit dem solche Namen wie John, Joan und Johann gefunden werden. (Als Voreinstellung beachtet Emacs bei der Suche die Groß- und Kleinschreibung nicht.)

Wenn Sie eine Zeichenkette ersetzen möchten, geben Sie M-% ein. Sie werden zuerst nach dem String gefragt, der ersetzt werden soll, dann nach dem Ersatz dafür. Emacs zeigt alle Stellen an, an denen der gesuchte String vorkommt und fragt, ob Sie ihn an dieser Stelle ersetzen möchten. Mit SPACE führen Sie die Ersetzung durch, mit DELETE überspringen Sie diese Stelle, und mit einem Punkt beenden Sie die Suche.

Wenn Sie sicher sind, daß Sie ab der Cursorposition alle Vorkommen einer Zeichenkette ersetzen möchten, ohne daß Sie den Einzelfall bestätigen müssen, dann geben Sie M-x replace-string ein. (Die Tastenkombination M-x läßt Sie den Namen einer Emacs-Funktion angeben und die Funktion ausführen, ohne daß sie an eine Taste gebunden ist. Viele Emacs-Funktionen sind nur über M-x zu erreichen -- es sei denn, Sie binden die Funktion selbst an eine Taste.) Sie können einen regulären Ausdruck ersetzen, indem Sie M-x query-replace-regexp eingeben.

Befehle aufrufen und programmieren in Emacs

Emacs bietet Schnittstellen zu vielen Programmen, die Sie innerhalb eines Emacs-Puffers ausführen können. So gibt es z.B. einen Modus für die Bearbeitung von elektronischer Post, einen für das Lesen von USENET-News sowie Modi zum Kompilieren von Programmen und für die Kommunikation mit der Shell. Wir wollen in diesem Abschnitt einige dieser Möglichkeiten vorstellen.

Wenn Sie von Emacs aus E-Mail verschicken möchten, geben Sie C-x m ein. Sie öffnen damit einen Puffer, in dem Sie eine E-Mail schreiben und verschicken können:

--------------------------------------------------------------------
| To:                                                              |
| Subject:                                                         |
| --text follows this line--                                       |
|                                                                  |
|                                                                  |
|                                                                  |
|                                                                  |
| -----Emacs: *mail*         (Mail)----All-----------------------  |
--------------------------------------------------------------------

Geben Sie einfach Ihre Nachricht in diesen Puffer ein und drücken Sie dann C-c C-s, um sie zu verschicken. Sie können auch Text aus anderen Puffern einfügen, die Mail-Schnittstelle mit eigenen ELISP-Funktionen erweitern usw.

RMAIL ist die Emacs-Schnittstelle zum Lesen von E-Mail. Viele Benutzer arbeiten lieber mit RMAIL als mit anderen Programmen, weil sie Emacs sowohl zum Verschicken als auch zum Lesen von E-Mail benutzen können. Starten Sie RMAIL mit dem Befehl M-x rmail.

Wenn Sie RMAIL aufrufen, wird Emacs die Nachrichten in Ihrer Eingangsmailbox in ein spezielles Format wandeln, mit dessen Hilfe es die Mail-Nachrichten verwaltet. Vorhandene Nachrichten werden in die Datei RMAIL in Ihrem Home-Verzeichnis kopiert. Seien Sie also vorsichtig! Eingehende Nachrichten werden in das RMAIL-Format konvertiert, und wenn Sie diese Konvertierung rückgängig machen möchten (falls Sie Ihre E-Mail nicht mit RMAIL lesen wollen), müssen Sie die Funktion M-x unrmail aufrufen.

Wenn Sie RMAIL aufrufen, wird ein Puffer geöffnet, der die erste Nachricht aus Ihrer Eingangsmailbox enthält. Mit den Tasten n und p zeigen Sie die nächste und die vorherige Nachricht an. (Wie in allen Emacs-Modi erhalten Sie auch hier mit C-h m eine Übersicht über die gültigen Tastenkombinationen.) Während Sie eine Nachricht lesen, leiten Sie mit r eine Antwort darauf ein. Dazu wird ein Mail-Puffer geöffnet (wie bereits beschrieben), in dem die Kopfzeilen bereits teilweise ausgefüllt sind. Im Mail-Puffer können Sie mit C-c C-y die Originalnachricht einlesen.

Innerhalb von RMAIL erhalten Sie mit h eine Liste der Nachrichten in Ihrer Mailbox, etwa so:

-----------------------------------------------------------------------
|                                                                     |
|   11  17-Feb             johnsonm@sunsite  Re: Which release?       |
|                                                                     |
|   12  25-Feb                        schar  Vision Group meeting     |
|   13  26-Feb            okir@monad.swb.de  Re: Spaces in .ms?       |
|   14  26-Feb      wirzeniu@cc.helsinki.fi  Re: LDP                  |
|                                                                     |
| --%%-Emacs: RMAIL-summary  RMAIL Summary)----50%------------------  |
-----------------------------------------------------------------------

In diesem Übersichtsmodus stehen Ihnen verschiedene M-x-Befehle z.B. zum Sortieren der Liste usw. zur Verfügung. Sie können außerdem RMAIL-Befehle wie n, p und r benutzen.

Ähnlich wie RMAIL funktioniert auch GNUS, der Emacs-Newsreader, den Sie mit dem Befehl M-x gnus aufrufen. Nach dem Start (und einiger Arbeit an Ihrer .newsrc -Datei) sehen Sie eine Liste der News-Gruppen und die Anzahl der ungelesenen Artikel in jeder Gruppe:

-----------------------------------------------------------------------
|      10: comp.os.linux.development                                  |
|       0: cucs.system                                                |
|      32: alt.fan.warlord                                            |
|     195: alt.folklore.urban                                         |
|                                                                     |
| --- GNUS: List of Newsgroups (Newsgroup {cloyd.cs})--6%-----------  |
-----------------------------------------------------------------------

Mit den Pfeiltasten wählen Sie aus, welche News-Gruppe Sie lesen möchten. Mit der SPACE-Taste lesen Sie den ersten Artikel dieser Gruppe. Dazu werden zwei Textfenster geöffnet -- das eine zeigt eine Liste der Artikel, das andere den aktuellen Artikel. Mit n und p bewegen Sie sich zum nächsten oder vorherigen Artikel, mit f und F starten Sie einen Folgeartikel (follow-up; entweder mit oder ohne Einschluß des Ursprungsartikels), und mit r und R antworten Sie per E-Mail auf einen Artikel. Es gibt noch viele andere GNUS-Befehle; lassen Sie sich die Liste mit C-h m anzeigen. Wenn Sie schon mit einem anderen News-Reader wie z.B. rn gearbeitet haben, wird Ihnen GNUS irgendwie bekannt vorkommen.

Emacs bietet eine Reihe von Modi für die Bearbeitung bestimmter Dateitypen. So gibt es z.B. einen C-Modus zum Editieren von C-Quellcode und einen TEX-Modus zum Editieren von (Überraschung!) TEX-Quellen. Jeder dieser Modi verfügt über einige Besonderheiten, die das Bearbeiten des entsprechenden Dateityps wesentlich vereinfachen.

Ein Beispiel: Im C-Modus können Sie M-x compile eingeben, um (als Voreinstellung) den Befehl make -k im aktuellen Verzeichnis auszuführen und Fehlermeldungen in einen anderen Textpuffer zu leiten. Im Kompilierungspuffer könnte beispielsweise stehen:

cd /home/loomer/mdw/pgmseq/
make -k
gcc -O -O2 -I. -I../include -c stream_load.c -o stream_load.o
stream_load.c:217: syntax error before `struct'
stream_load.c:217: parse error before `struct'

Sie können den Cursor in eine Zeile bewegen, die eine Fehlermeldung enthält, dann C-c C-c drücken, und finden sich anschließend im entsprechenden Quelltextpuffer in der Zeile wieder, in der dieser Fehler auftrat. (Sollte noch kein Puffer für den Quelltext existieren, so wird er an dieser Stelle geöffnet.) Ab sofort können Sie Ihre Programme komplett innerhalb von Emacs editieren und kompilieren.

Emacs enthält außerdem eine vollständige Schnittstelle zum Debugger gdb , die wir im Abschnitt » Emacs und gdb « in Kapitel 6 beschreiben.

Normalerweise wird Emacs anhand des Dateinamensuffixes den passenden Modus für einen Textpuffer auswählen. Wenn Sie z.B. eine Datei mit dem Namenssuffix .c editieren, öffnet Emacs diesen Puffer automatisch im C-Modus.

Der Shell-Modus ist eine der beliebtesten Erweiterungen zu Emacs. Im Shell-Modus können Sie von einem Emacs-Puffer aus auf der Shell-Ebene arbeiten, indem Sie M-x shell eingeben. Sie haben dann die Möglichkeit, mit den normalen Emacs-Befehlen die Shell-Befehlszeilen zu editieren und die Command History (bereits eingegebene Befehlszeilen können wieder aufgerufen und editiert werden) zu (be)nutzen. Sie können von Emacs aus mit M-! auch einzelne Shell-Befehle ausführen lassen. Wenn Sie statt dessen M-| eingeben, wird der Inhalt der aktuellen Region in einer Pipe als Standardeingabe an den aufgerufenen Befehl geleitet. Dies ist eine nützliche Schnittstelle für den Aufruf von Unterprogrammen aus Emacs heraus.

Emacs anpassen

Die Online-Dokumentation von Emacs sollte ausreichen, um Sie auf die richtige Spur zu bringen, wenn Sie mehr über das System erfahren und sich noch besser damit vertraut machen möchten. Manchmal ist es allerdings schwierig, die wirklich hilfreichen Hinweise zu finden, die Ihnen weiterhelfen. Wir wollen hier kurz auf einige der Anpassungsmöglichkeiten eingehen, die von vielen Emacs-Benutzern zur Vereinfachung der Arbeit eingesetzt werden.

Ihre persönliche Datei mit Emacs-Anpassungen ist .emacs , die in Ihrem Home-Verzeichnis stehen sollte. Diese Datei sollte Programmcode enthalten, der in Emacs-LISP geschrieben ist und Funktionen aufruft oder definiert, die Ihre Emacs-Arbeitsumgebung bestimmen. (Falls Sie noch nie in LISP programmiert haben, brauchen Sie sich keine Sorgen zu machen -- die meisten Anpassungen sind mit LISP ziemlich einfach.)

Zu den Dingen, die von Benutzern am häufigsten geändert werden, gehören die Tastenbelegungen. Wenn Sie z.B. in Emacs Ihre E-Mail lesen möchten, können Sie die Tastenkombination C-c r mit der Funktion rmail belegen. Fügen Sie dazu folgendes in Ihre .emacs -Datei ein:

; Provide quick way to read mail.
(global-set-key "\C-cr" 'rmail)

Kommentarzeilen beginnen in Emacs-LISP mit einem Semikolon. Der Befehl in diesem Beispiel ruft die Funktion global-set-key auf. Ab sofort brauchen Sie nicht immer wieder die lange Zeichenfolge M-x rmail einzutippen, wenn Sie die kurze Nachricht Mail in der Statuszeile sehen. Drücken Sie statt dessen einfach die beiden Tasten C-c r. Diese Abkürzung funktioniert überall in Emacs -- unabhängig vom aktuellen Modus --, weil es ein »globaler« Befehl ist.

Nicht alle Tastenbelegungen sollen global wirksam sein. Wenn Sie im TEX-Modus, C-Modus oder einem anderen der Emacs-Modi arbeiten, werden Sie auf praktische Dinge stoßen, die nur in einem Modus wirksam sein sollen. Für einen solchen Fall definieren wir hier eine einfache LISP-Funktion, die einige Zeichen in C-Quellcode einfügt, und belegen dann eine Taste mit dieser Funktion:

(defun start-if-block()
  (interactive)
  (insert "if () {\n}\n")
  (backward-char 6)
)

Am Anfang der Funktion steht die Anweisung »interactive«, damit wir diese Funktion aufrufen können (sonst würde sie nur intern von anderen Funktionen benutzt werden). Dann benutzen wir die Funktion insert , um folgende Zeichen in unseren C-Puffer einzufügen:

if () {
}

In Emacs dürfen Strings die aus C bekannten ESCAPE-Zeichenfolgen enthalten. Wir haben in unserem Beispiel \n für »newline« (neue Zeile) benutzt.

Damit haben wir uns eine Schablone für einen if-Block geschaffen. Um die Sache abzurunden, bewegt unsere Funktion den Cursor auch noch um sechs Stellen zurück und plaziert ihn damit zwischen die runden Klammern, so daß wir sofort mit der Eingabe eines Ausdrucks beginnen können.

Unser Ziel war es, die Eingabe dieser Zeichenfolge möglichst einfach zu gestalten -- lassen Sie uns also eine Tastenfolge mit dieser Funktion belegen:

(define-key c-mode-map "\C-ci" 'start-if-block)

Die Anweisung define-key verknüpft eine Tastenkombination mit einer Funktion. Mit c-mode-map zeigen Sie an, daß diese Tastenkombination nur im C-Modus wirksam sein soll. Es gibt außerdem noch tex-mode-map für den TEX-Modus, lisp-mode-map usw., die Sie kennen sollten, wenn Sie vorhaben, mit Ihrer .emacs -Datei herumzuexperimentieren.

Falls Sie daran interessiert sind, eigene Emacs-LISP-Funktionen zu schreiben, lesen Sie die Info-Seiten zu elisp , die in Ihrem System vorhanden sein sollten.

Wir kommen zu einer sehr wichtigen Anpassung, die Sie vielleicht auch durchführen müssen. Auf vielen Terminals sendet die BACKSPACE-Taste den Code C-h, was Emacs als Hilfe-Taste interpretiert. Um dieses Problem zu beheben, sollten Sie die interne Tabelle mit den Emacs-Tastencodes folgendermaßen ändern:

(keyboard-translate ?\C-h ?\C-?)

Ziemlich kryptisch, das Ganze. \C-h läßt sich noch als die CONTROL-Taste zusammen mit h entziffern, was zufälligerweise denselben ASCII-Code (8) erzeugt wie die BACKSPACE-Taste. \C-? steht für die DELETE-Taste (ASCII-Code 127). Verwechseln Sie dieses Fragezeichen nicht mit den Fragezeichen vor den Backslashes. ?\C-h bedeutet: »der ASCII-Code, der \C-h entspricht«. Sie könnten genau so gut auch die 8 direkt angeben.

Jetzt wirken also BACKSPACE und C-h als Löschtaste. Sie haben damit allerdings Ihre Hilfe-Taste aufgegeben. Eine weitere sinnvolle Anpassung wäre es also, eine andere Tastenkombination mit C-h zu belegen. Wir wollen dafür C-\ benutzen, weil diese Kombination kaum jemals für irgend etwas anderes gebraucht wird. Wenn Sie den Backslash als Taste angeben wollen, müssen Sie ihn doppelt tippen:

(keyboard-translate ?\C-\\ ?\C-h)

Im X Window System gibt es die Möglichkeit, mit dem Befehl xmodmap den Code zu ändern, der von der BACKSPACE-Taste erzeugt wird. Wir wollen es aber Ihnen überlassen herauszufinden, wie das funktioniert. Es ist keine hundertprozentig portable Lösung (wir könnten also nicht garantieren, daß es bei Ihnen funktioniert), und das Ganze könnte Ihnen zu weitschweifig vorkommen. Außerdem ändern Sie damit auch die Arbeitsweise der BACKSPACE-Taste in xterm und überall sonst.

Vielleicht möchten Sie weitere Tastenbelegungen ändern. Sie könnten z.B. für das bildschirmweise Vor- und Zurückblättern die Tastenkombinationen C-f und C-b benutzen (wie in vi ). Dann sollte in Ihrer Datei .emacs stehen:

(global-set-key "\C-f" 'scroll-up)
(global-set-key "\C-b" 'scroll-down)

Auch hier müssen wir eine Warnung aussprechen: Achten Sie darauf, daß Sie keine Tastenbelegungen ändern, die schon anderweitig benutzt werden. (Eine Möglichkeit, das herauszufinden, ist der Test mit C-h k um festzustellen, was eine Tastenkombination im aktuellen Modus bewirkt. Denken Sie auch daran, daß eine Tastenkombination bereits in anderen Modi vergeben sein kann.) Die Gefahr, daß Sie den Zugriff auf einige Funktionen verlieren ist besonders groß, wenn Sie solche Präfix-Tasten wie C-x und C-c neu belegen, mit denen Befehle eingeleitet werden.

Sie können eigene Präfix-Tasten definieren, wenn Sie den aktuellen Modus wirklich mit einer Menge neuer Funktionen ausstatten wollen. Gehen Sie etwa so vor:

(global-unset-key "\C-d")
(global-set-key "\C-d\C-f" 'meine-funktion)

Zuerst müssen wir die Tastenkombination C-d freigeben (mit der das Zeichen unter dem Cursor gelöscht wird), damit wir sie als Präfix für andere Tasten benutzen können. Anschließend rufen Sie mit C-d C-f die Funktion Meine-Funktion auf.

Eventuell möchten Sie zum Editieren von »besonderen« Dateien einen anderen Modus als Fundamental oder Text benutzen. Mit dem Indented Text-Modus z.B. rücken Sie jede Textzeile relativ zur vorherigen Zeile ein (wie mit der Funktion :set ai in vi ). Schalten Sie diesen Modus mit:

; Default mode for editing text
(setq default-major-mode 'indented-text-mode)

ein. Sie sollten auch die RETURN-Taste neu belegen, so daß die nächste Zeile eingerückt wird:

(define-key indented-text-mode-map "\C-m" 'newline-and-indent)

Emacs kennt auch »Minor«-Modi -- das sind Modi, die Sie zusammen mit den Major-Modi benutzen können. Der Modus Overwrite z.B. ist ein Minor-Modus mit der Wirkung, daß neuer Text im Puffer nicht eingefügt wird, sondern den vorhandenen Text überschreibt. Wenn Sie die Tastenkombination C-r benutzen möchten, um den Overwrite-Modus ein- und auszuschalten, benutzen Sie den Befehl:

; Toggle overwrite mode.
(global-set-key "\C-r" 'overwrite-mode)

Ein weiterer Minor-Modus ist Autofill, der die Zeilen während des Tippens automatisch umbricht. Statt am Ende jeder Zeile also RETURN zu drücken, tippen Sie einfach weiter und Emacs erledigt den Zeilenumbruch für Sie. Schalten Sie den Autofill-Modus folgendermaßen ein:

(setq text-mode-hook 'automatischer Zeilenumbruch)
(setq fill-column 72)

Damit schalten Sie den Autofill-Modus immer dann ein, wenn Sie in den Text-Modus wechseln (die Funktion text-mode-hook sorgt dafür). Außerdem bestimmen Sie, daß die Zeilen in Spalte 72 umbrochen werden sollen.


Inhaltsverzeichnis Vorherige Abschnitt Nächste Abschnitt