Der Editor Vim kennt vielfältige Abkürzungen, mit denen das Programmieren leichter von der Hand geht. Dieser Perl-Snapshot zeigt eine Auswahl der effektivsten Sparmaßnahmen für Perl-Hacker.

Keine Wahl, die ein Programmierer im Leben trifft, ist so entscheidend und so unwiderruflich wie die Wahl eines Editors. Wer sich einmal für Vi oder Emacs entschieden hat, bleibt normalerweise dabei und setzt alles daran, auch noch den letzten Trick aus dem ständig genutzten Werkzeug herauszufieseln. Wer effektiver mit dem Editor arbeitet, reduziert nicht nur die Gefahr, am Carpal-Tunnel-Syndrom zu erkranken, sondern programmiert erheblich schneller und mit weniger Tippfehlern.

Der Editor Vim (Vi Improved) ist seinem altersschwachen Kollegen Vi um einiges voraus. Vim wurde über lange Entwicklungsjahre für Vieltipper hochgezüchtet, lässt sich bis ins Detail konfigurieren, mit Plugins erweitern und so ganz nach Geschmack an den persönlichen Arbeitsstil anpassen. In der Konfigurationsdatei ».vimrc« kann der Benutzer in seinem Homeverzeichnis alle hier vorgestellten Tricks permanent ablegen.

Da Linux-Distributionen nicht immer den neuesten Vim enthalten, prüfe man am besten mit »vim –version« nach, welche Version installiert ist. Es sollte mindestens 6.1 sein, ansonsten empfiehlt sich ein Upgrade.

Leuchtende Schlüssel

Farblich unterlegte Schlüsselwörter erleichtern das Verstehen von komplexeren Codegebilden erheblich. Vim beherrscht das Syntax-Highlighting von vielen Programmiersprachen ganz hervorragend und produziert selbst für das schwer zu parsende Perl erstaunlich präzise Ergebnisse. Abbildung 1 zeigt, wie viel einfacher farblich herausgestellte Codekonstrukte erkennbar sind.

Abbildung 1a: Ein Stück Perl-Code im Vim, in dieser Version noch ohne Hervorhebungen.

Abbildung 1b: Hier zum Vergleich mit eingeschaltetem Syntax-Highlighting.

Voraussetzung ist lediglich, dass das benutzte Xterm Farben unterstützt. Alternativ bietet sich Gvim an. Falls es nicht schon von vornherein aktiviert ist, schaltet das Kommando »:syntax on« das Highlighting ein. Wenn Vim an der Datei-Endung (».pl« oder ».pm«) oder auch am »#!/usr/bin/perl« der Shebang-Zeile erkennt, dass es sich um Perl handelt, färbt er den Quelltext ein. Öffnet der Editor eine neue Datei, die er nicht als Perl-File erkennen kann, lässt sich der Dateityp nachträglich mit »:set filetype=perl« einstellen.

Abkürzungen

Wer oft in derselben Sprache programmiert, wiederholt ständig die gleichen Tippmuster. Als Log::Log4perl-Advokat kann ich zum Beispiel schon nicht mehr zählen, wie oft ich »use Log::Log4perl qw(:easy);« getippt habe. Zum Glück hat das jetzt ein Ende, denn das Kommando »:abbreviate ul4p use Log::Log4perl qw(:easy);<RETURN>« richtet die Abkürzung »ul4p« ein.

Sobald der Programmierer im Eingabemodus die Zeichenfolge »ul4p« tippt und mit einem Wortbegrenzer wie der Leertaste oder [Enter] abschließt, expandiert Vim die Folge automatisch zum definierten Ausdruck. Ein ausgeschriebenes »<RETURN>« am Ende der Definition simuliert das Drücken der [Enter]-Taste. Wer nach der Expansion in den Kommandomodus wechseln möchte, hängt einfach ein »<ESC>« hinten an.

Um mit Hilfe einer Abkürzung ein längeres Textstück einzufügen, kann das Makro auch eine Datei laden: »:abb ul4p <BACKSPACE><ESC>:r ~/.tmpl_l4p<RETURN>«. Tippt der Benutzer nun »ul4p« gefolgt von einem Wortbegrenzer, ersetzt Vim die Abkürzung durch den Inhalt der Datei.

Wiederkehrende Editierschritte, die Änderungen in mehreren, unzusammenhängenden Bereichen erfordern, lassen sich elegant mit Makros wiederholen. Abbildung 2 zeigt drei Funktionsköpfe, die es jeweils in Kommentarzeilen einzuranken gilt.

Keyboard-Makros

Dazu sind folgende Kommandos nötig: Erst nach »sub« suchen, dann den Makrorekorder einschalten, den ersten Funktionskopf einrahmen, den Makrorekorder ausschalten. Mit »n« nach dem nächsten »sub« suchen und mit »@a« das Makro abspielen. Das ergibt diese Befehlsfolge:

# Nach 'sub' suchen.
/sub
# Makro-Rekorder ein.
qa
# Zeile darüber einfügen,
# zurück in Kommandomodus.
O<ESC>
#Zwanzigmal '#' einfügen.
20i#<ESC>
# Zeile kopieren.
yy
# Eine Zeile nach unten fahren,
# kopierte Zeile
# unterhalb einfügen.
jp
# Makro-Rekorder aus.
q
# Nach dem nächsten 'sub' suchen.
/sub
# Makro 'a' abspielen.
@a
# ... wiederholen.

Abbildung 2a: Der Makro-Editor während der Aufnahme des Funktionskopf-Makros.

Abbildung 2b: Anschließend spielt der Nutzer das Makro einfach zweimal ab.

Wer neue Funktionen sofort mit Kommentaren einranken will, definiert sich ein neues Kommando auf [Shift]+[F] mit »:map F o<ESC>43i#<ESC>yyosub {<ENTER><ESC>Pk$i«. Drückt er danach [Shift]+[F] im Kommandomodus, fügt Vim den Funktionskopf ein und positioniert den Cursor gleich im Eingabemodus an der richtigen Stelle.

Der Buchstabensalat in der »map«-Definition besteht wieder aus den Vi-typischen Ein-Tasten-Befehlen im Kommandomodus, die jeder Vi-Enthusiast auswendig kennt. Die Anzahl der Hashmarks ist Geschmackssache, in der Definition oben wurden 43 gewählt. Bei sich häufig wiederholenden Sequenzen wie Funktionsköpfen sparen Map-Kommandos viel Zeit und Nerven. Wer möchte, kann auf dieselbe Weise auch andere Textstücke damit automatisch einfügen, so bieten sich etwa oft genutzte Parameterübergaben der Art »my(…) = @_;« an.

Häufige Aufgaben sind das Sichern des gerade bearbeiteten Skripts mit »:w« und der Aufruf »perl -c skript.pl«, der feststellt, ob sich Fehler in das Skript eingeschlichen haben. Der folgende Befehl legt die Aktionen Sichern und Syntaxcheck einfach auf [Shift]+[X] im Kommandomodus »:noremap X :w <Enter>:!perl -c %<Enter>«.

Der Befehl »:noremap« an Stelle von »:map« evaluiert das »X« niemals auf der rechten Seite eines anderen Map-Ausdrucks. Außerdem expandiert der Befehl »:noremap« die Definition nur im Kommandomodus. Vim ersetzt den Platzhalter »%« zur Laufzeit des Makros durch den Namen der aktuellen Datei.

Autoformat

Bei längeren Texten, zum Beispiel einer POD-Dokumentation, stellt sich locker fließender Erzählstil erst beim siebten oder achten Umschreiben ein. Wer dabei fleißig einfügt und wieder ausstreicht, erzeugt zerfledderte Absätze, die schwer korrekturzulesen sind. Textverarbeiter wie Word arbeiten ständig im Hintergrund, um die Absätze neu zu formatieren, echte Hacker müssen die Ecken selbst ausbügeln.

Bei Vim geht das mit nur vier Tastendrücken: »{gq}« im Kommandomodus. Zuerst fährt »{« an den Anfang des aktuellen Absatzes, das Kommando »gq« bricht die Zeilen im Flattersatz um und das abschließende »}« bestimmt die Reichweite des Kommandos – bis zum Ende des Absatzes.

Noch eleganter geht es mit dem Perl-Modul Text::Autoformat von Großmeister Damian Conway. Neben Flattersatz kennt es auch noch allerlei intelligente Umbrüche. So kann es mit Aufzählungen umgehen (rückt nachfolgende Zeilen eines Aufzählungspunkts entsprechend ein) und auch mit »>« oder »>>« oder mehr Größer-als-Zeichen eingerückte E-Mail-Zitate so behandeln, wie ein Mensch das tun würde.

Wer sich damit beispielsweise das Kommando »:map f !Gperl -MText::Autoformat -e\’autoformat\'<RETURN>« definiert, drückt im Kommandomodus einfach die Taste [F], während der Cursor irgendwo in einem Textabsatz steht – und schon wird dieser automatisch und sachgemäß formatiert.Wer die standardmäßig eingestellten Zeilen mit 72 Zeichen als zu breit (oder zu schmal) empfindet, variiert die Option »right« entsprechend: »:map f !Gperl -MText::Autoformat -e\’autoformat {right =>65}\'<RETURN>«.

Erfahrene Vim-Nutzer wissen, dass [F] im Kommandomodus schon vorbelegt ist: Der Cursor springt bis zum nächsten eingegebenen Zeichen vor, [F]+[E] führt so bis zum nächsten e im Text. Wer diese Funktion nutzt, sollte einen anderen Buchstaben wählen oder auch gerne eine Zweierkombination einstellen: »:map !f …« reagiert im Kommandomodus nur, wenn der Vim-Nutzer zuerst »!« und dann »f« eingibt.

Abbildung 3a: Eine Auflistung und ein Abschnitt aus einer E-Mail ohne Formatierung.

Abbildung 3b: Derselbe Ausschnitt nach dem Formatieren mit Text::Autoformat.

Richtig eingerückt

Über die Formatierung von Programmcode ist schon viel gestritten worden. Wo kommen die geschweiften Klammern hin? Wie tief wird verschachtelt? Mit Leerzeichen oder mit Tabs? Da jeder Programmierer seinen eigenen Geschmack hat, bietet Vim genug Optionen.

Beim Einrücken mit Tabs scheiden sich allerdings die Geister, viele lehnen sie grundsätzlich ab. Ist die Option »:set expandtab« gesetzt, wandelt Vim alle Tabs in Leerzeichen um. Die Anzahl der Leerzeichen pro Tab bestimmt die Option »:set shiftwidth=4«.

Wer allerdings »expandtab« blindlings setzt, läuft böse auf, wenn er ein Makefile editiert: Dort sind Tabs vor den Kommandos für ein Target tatsächlich notwendig. Werden sie durch Leerzeichen ersetzt, ist dies ein Syntaxfehler. Die Lösung lautet, Vim per »autocmd« den Dateityp feststellen zu lassen und nur bei Perl-Programmen die Option »expandtab« zu setzen:

:filetype on
:autocmd FileType perl :set expandtab

Eine nützliche Option, um sonst unsichtbare Zeichen sichtbar zu machen, ist »:set list«. Alle Tabs erscheinen als »^I« und das Zeilenende ist mit einem blauen »$« markiert, »:set nolist« schaltet wieder zurück in den Normalmodus.

Blöcke schieben

Die oben vorgestellte Option »shiftwidth« hat noch eine weitere Funktion: Zusammen mit der Option »cindent« lässt sich so ordentlich Tipparbeit sparen, denn sobald ein Konstrukt wie »if($really) {« eingetippt und die [Enter]-Taste gedrückt wird, rückt Vim die nächste Zeile entsprechend »shiftwidth« und »expandtabs« ein. Tippt der Benutzer dagegen »}« und ein [Enter], schiebt Vim die schließende Klammer automatisch wieder an den Zeilenanfang zurück.

Da sich dieses Verhalten ebenfalls nicht für alle Arten von Dateien eignet, empfiehlt sich gleichermaßen ein Auto-Kommando, das erst den File-Typ prüft, bevor es die Option setzt: »:autocmd FileType perl :set cindent«.

Abbildung 4a: Ein Block mit geschweiften Klammern, Cursor auf dem Blockstart.

Abbildung 4b: Das Kommando »>i{« rückt den inneren Block vier Leerzeichen ein.

Dass ein Codestück in einen Block gehört, stellt sich manchmal allerdings erst heraus, wenn es bereits getippt wurde. Dann setzt man, wie in Abbildung 4 gezeigt, einfach geschweifte Klammern darum herum und tippt im Kommandomodus die Tastenfolge »>i{«, um den inneren Block eine »shiftwidth«-Breite nach rechts einzurücken.

Die Option »:set smarttab« geht bei gesetzter »expandtab«-Option noch eins weiter: Ein Backspace im Eingabemodus auf dem ersten Zeichen einer eingerückten Zeile rückt die Zeile wieder aus, ein Druck auf die [Tab]-Taste rückt sie wieder ein, ohne dass richtige Tabulatorzeichen im Spiel sind.

Noch ein Tipp: Um von einer geschweiften Klammer zur korrespondierenden zu springen, genügt es, den Cursor auf einer Klammer zu positionieren und dann die [%]-Taste im Kommandomodus zu drücken. So lässt sich leicht feststellen, wo eine geschweifte Klammer fehlt, wenn Perl einen Syntaxfehler anzeigt. Wer mal an einem Computer mit amerikanischer Tastatur sitzt und mit Vi einen Umlaut wie Ä eintippen möchte, der kann dies mit der Sequenz [Ctrl]+[K] gefolgt von [A] und [:] im Eingabemodus tun. Eine vollständige Tabelle mit allen so verfügbaren Umlauten bringt das Kommando »:digraphs« zum Vorschein.

Guter Start

Ein neues Perl-Skript ist mit dem »tmpl«-Tool von [3] leicht zu starten. Der Aufruf »tmpl -p cooltool« legt eine neue Datei »cooltool« an. Wie Abbildung 5 zeigt, besteht das Skript-Skelett aus einigen Kopfzeilen, einigen typischen Modulen für Skriptoptionen und Manualseiten-Anzeige. »tmpl« bezieht einige Parameter aus der Datei ».tmpl« im Homeverzeichnis des Benutzers. Das Skelett »cooltool« kann schon zwei Dinge: »$ cooltool -v« zeigt die gegenwärtige Skriptversion an, die in der Variablen »$CVSVERSION« liegt und vom CVS beim Auschecken automatisch aufgefrischt wird. Weiter hilft »Pod::Usage«, dass die Option »-h« eine kurze Bedienungsanleitung ausgibt.

Abbildung 5: Ein Template wird automatisch in neue Skripte übernommen.

Den Rest muss der Skriptautor selbst ausfüllen, aber mit dieser Grundlage ist schon viel erreicht: Nun existieren ein Grundgerüst und ein Rahmen für die Dokumentation, ohne die jedes Skript bekanntermaßen wertlos ist.

Komplettierung

Vim merkt sich geschriebene Wörter automatisch und komplettiert angefangene Wörter später mit der Tastenkombination [Ctrl]+[N] im Textmodus. Wer also Variablen wie in »our $GLOBAL_SUPER_VARIABLE;« definiert und sie später wieder verwendet, muss nicht den ellenlangen Namen erneut tippen, sondern schreibt nur ein paar Buchstaben, drückt dann [Ctrl]+[N] und schon betätigt sich Vim als Gedankenleser.

Falls mehrere Möglichkeiten zur Komplettierung bestehen, kann man mit weiteren [Ctrl]+[N]-Drücken vorwärts und umgekehrt mit [Ctrl]+[P] rückwärts durch die Liste der Vorschläge blättern. Ein Feature, das im Lauf der Zeit sehr viel Zeit und Tipparbeit spart.

C-Programmierer kennen das Programm »ctags«, das eine Tags-Datei für Vim erzeugt. Wird diese eingelesen, braucht der Entwickler eines Programms einfach nur den Cursor irgendwo auf einen Funktionsaufruf zu positionieren sowie Control und eckige Klammer zu ([Ctrl]+[]]) im Kommandomodus zu drücken, dann springt Vim zur zugehörigen Funktionsdefinition.

Sprungziele

Um Vim dazu zu veranlassen, auch in Perl etwa zur Source-Datei von »LWP::UserAgent« zu springen, falls der Cursor irgendwo auf »LWP::UserAgent« steht, muss der Anwender zwei Dinge erledigen. Zuerst muss Vim verstehen, dass in Perl ein Schlüsselwort auch Doppelpunkte enthalten kann, das bewerkstelligt »:set iskeyword+= :«. Zweitens muss Vim noch eine Tags-Datei einlesen, die alle installierten Packages indiziert hat, zum Beispiel über »:set tags=/home/mschilli/.ptags.txt«. Dann springt die Kombination [Ctrl]+[]] in den Modul-Source, wenn der Cursor auf einem Modulnamen steht.

Alternativ kann man den Modulnamen auch im Kommando »:tag LWP::UserAgent« angeben. Einmal in der Bibliotheksdatei angelangt genügt ein [Ctrl]+[Shift]+[T], um wieder zurück zum Ausgangspunkt zu navigieren. Die ganze Magie steckt dabei in der Tags-Datei ».ptags.txt«, die das weiter unten vorgestellte Listing »ppitags« erzeugt.

Trotz Windowmanager ist es manchmal sinnvoll, zwei Dateien gleichzeitig in einem Fenster zu sehen. Welcher Vim-User greift schon freiwillig auf die Maus zurück, wenn die Hände auf der Tastatur bleiben können? Wer statt [Ctrl]+[]] die Kombination [Ctrl]+[W]+[]] tippt, während der Cursor auf einem Schlüsselwort steht, dessen Fenster teilt sich in zwei Hälften: In der unteren bleibt der Code der editierten Datei sichtbar, in der oberen erscheint der Code des referenzierten Moduls.

Zwischen den Fensterhälften springt man mit [Ctrl] und zweimal [W] hin und her. Das Kommando »:quit« im oberen Fenster schließt dieses. Alternativ schließt der Befehl »:only« im unteren Fenster das obere. Die Vim-Session in Abbildung 6 zeigt unten ein editiertes Testskript, das das Modul »LWP::UserAgent« verwendet, und oben die »new()«-Methode im Sourcecode des Moduls.

Abbildung 6: Vim mit gespaltenem Fenster: Unten ein Testskript, oben der Sourcecode des verwendeten Moduls »LWP::UserAgent«.

Wer den Namen eines gesuchten Moduls nicht genau weiß, gibt einen regulären Ausdruck an. Das Kommando »tselect« sucht nach allen passenden Tags und bietet eine Liste zur Auswahl: »:tselect /^LWP«. Der Benutzer muss dann nur den passenden Treffer per Nummernmenü auswählen.

Mach mir Tags

Für ein aktuelles »~/.ptags.txt«-File muss ein Skript regelmäßig alle Module der lokalen Perl-Installation durchforsten. Das Skript »ppitags« in Listing 1 klappert alle »@INC«-Pfade ab, merkt sich in »@dirs«, wo es bereits war, und durchläuft auch bei überlappenden Pfaden nicht zweimal denselben.

01 #!/usr/bin/perl -w
02 
03 use strict;
04 
05 use PPI::Document;
06 use File::Find;
07 use Sysadm::Install qw(:all);
08 use Log::Log4perl qw(:easy);
09 
10 my $outfile = "$ENV{HOME}/.ptags.txt";
11 my %dirs  = ();
12 my @found = ();
13 
14 find &file_wanted, grep {$_ ne "."} @INC;
15 
16 blurt join("n", sort @found), $outfile;
17 
18 ###########################################
19 sub file_wanted {
20 ###########################################
21     my $abs = $File::Find::name;
22 
23         # Avoid dupe dirs
24     $File::Find::prune = 1 if -d and
25         $dirs{$abs}++;
26 
27         # Only Perl modules
28     return unless /.pm$/;
29 
30     my $d = PPI::Document->load($abs);
31 
32     unless($d) {
33         WARN "Cannot load $abs ($! $@)";
34         return;
35     }
36         # Find packages and
37         # all named subroutines
38     $d->find(&document_wanted);
39 }
40 
41 ###########################################
42 sub document_wanted {
43 ###########################################
44     our $package;
45     my  $tag;
46 
47     if(ref($_[1]) eq
48            'PPI::Statement::Package') {
49         $tag = $_[1]->child(2)->content();
50         $package = $tag;
51 
52     } elsif(ref($_[1]) eq
53             'PPI::Statement::Sub' and
54             $_[1]->name()) {
55         $tag = "$package::" .
56                $_[1]->name();
57     }
58 
59     return 1 unless defined $tag;
60 
61     push @found, $tag . "t" .
62                  $File::Find::name . "t" .
63                  regex_from_node($_[1]);
64 
65     return 1;
66 }
67 
68 ###########################################
69 sub regex_from_node {
70 ###########################################
71     my($node) = @_;
72 
73     my $regex = $node->content();
74 
75     $regex =~ s/n.*//gs;
76 
77     while(my $prev =
78              $node->previous_sibling()) {
79         last if $prev =~ /n/;
80         $regex = $prev->content() .
81                  $regex;
82         $node  = $prev;
83     }
84 
85     $regex =~ s#[/.*[]^$]#\$&#g;
86     return "/^$regex/";
87 }

Um Perl-Source zu analysieren, braucht man eigentlich Perl, denn Perl ist extrem schwierig zu parsen. Allerdings hat Adam Kennedy vor kurzem das Unmögliche gewagt und einen “Good enough”-Parser für Perl geschrieben, der wirklich erstaunlich gut arbeitet. Das »PPI«-Modul vom CPAN enthält »PPI::Document«, dessen Methode »load()« ein Perl-Modul einliest, in Tokens zerlegt und in einer Baumstruktur ablegt.

Das Skript »ppitags« nutzt »File::Find«, um alle Verzeichnisse in Perls globalem Array »@INC« zu durchlaufen. Für jeden gefundenen Eintrag springt »File::Find« die Funktion »file_wanted« an. Falls der gefundene Eintrag ein Verzeichnis und keine Datei ist, frischt Zeile 25 den Hash »%dirs« auf, um festzustellen, ob das Skript den Pfad schon besucht hat. Falls ja, setzt Zeile 24 die Variable »$File::Find::prune« auf »1«, um »File::Find« mitzuteilen, dass es sich den Rest des Verzeichnisses und alle Unterverzeichnisse sparen kann. Zeile 28 weist alles außer Perl-Modulen mit der Endung ».pm« zurück. Zeile 30 parst das gefundene Perl-Modul. Falls dabei Fehler auftreten, fängt Zeile 32 sie ab, gibt eine Warnung aus und lässt das problembehaftete Modul sausen.

Konnte das Modul erfolgreich eingelesen werden, ruft Zeile 38 die »find()«-Methode des »PPI::Document«-Objekts auf, das die Tokens der Perl-Source durchläuft und für jeden gefundenen die ab Zeile 42 definierte Funktion »document_wanted« aufruft. Diese prüft, ob es sich bei dem gefundenen Token um ein Objekt vom Typ »PPI::Statement::Package« oder »PPI::Statement::Sub« handelt, also eine »package«- oder »sub«-Definition im Perl-Code.

Eine »package«-Definition besteht aus einer Zeile wie »package LWP::UserAgent;«, das sind in der PPI-Welt vier Tokens: »package«, Leerzeichen, der Modulname und der abschließende Strichpunkt. Für die Belange von »ppitags« ist nur der Modulname interessant, also das dritte Kind des Knotens, der in »$_[1]« übergeben wurde. Die Methode »child()« mit dem ab 0 gezählten Kinder-Index fördert den String »”LWP::UserAgent”« zutage: »$_[1]->child(2)«.

Paketsuche

Wird eine »package«-Definition durchlaufen, speichert »ppitags« deren Namen als aktuelles Package. Dies Verfahren würde zwar durch Package-Definitionen in Blocks leicht ausgehebelt, aber das spielt praktisch in 99,9 Prozent aller Fälle keine Rolle.

Zeile 52 stöbert Funktionsdefinitionen der Form »sub func {« auf und extrahiert den Funktions- oder Methodennamen, damit der Tag-Mechanismus Konstrukte wie »LWP::Debug::trace« erkennt und später zu jener Stelle springt, an der die Funktion »trace« im Modul »LWP::Debug« definiert ist. Der »push«-Befehl in Zeile 61 schiebt einen neuen String ans Ende des Array »@found«, der aus dem gesuchten Tag (Package- oder voll qualifizierter Funktionsname), dem absoluten Source-Dateinamen und einem regulären Ausdruck besteht, der die Package- oder Funktionsdefinition in der zugehörigen Source-Datei findet.

Hierzu bildet die ab Zeile 69 definierte Funktion »regex_from_node« einen regulären Ausdruck, der aus allen Zeichen der Trefferzeile vom Zeilenanfang bis zum gesuchten Token besteht. Bei einer Subroutine liefert »$node->content()« also sowohl den Funktionskopf als auch den Rumpf. Deswegen schneidet Zeile 75 alle Zeilen außer der ersten ab und die Zeilen 77 und 78 gehen so lange im Token-Baum zurück, bis sie den Zeilenanfang erreichen.

Nach der »while«-Schleife steht in »$regex« der Inhalt der Source-Zeile, vom Zeilenanfang bis zum Token. Daraus baut Zeile 85 einen regulären Ausdruck der Form »/^…/« mit einem Anker für den Zeilenanfang. Die Funktion »quotemeta()« stellt sicher, dass die eventuell enthaltenen Sonderzeichen nicht mit Regex-Metazeichen kollidieren, indem sie alles mit einem Backslash maskiert.

Das Skript »ppitags« erzeugt eine Liste von dreispaltigen Einträgen in »~/.ptags.txt« im Format »Package/Subroutine [tab] Dateiname [tab] Regex«, die Vim mit »:set tags=« einliest und damit elegant von Schlüsselwörtern zum entsprechenden Sourcecode springt. Das Skript sollte täglich per Cronjob aufgerufen werden, damit »~/.ptags.txt« immer auf dem neuesten Stand ist. Wer möchte, kann es noch so erweitern, dass Vim auch zur Definition voll qualifizierter »our«-Variablen springt.

Die Datei ».vimrc« im Homeverzeichnis wird von Vim beim Programmstart eingelesen und erlaubt es, eine ganze Litanei von Kommandos auszuführen, bevor der Editor die eigentliche Arbeit beginnt. Wer die Standardeinstellungen interaktiv verschraubt hat, möchte diese wahrscheinlich permanent festhalten.

Statt alle bereits eingegebenen Kommandos nochmals manuell in die Datei ».vimrc« einzutragen, genügt ein einfaches »:mkvimrc«, mit dem Vim alle zu dieser Zeit gültigen Einstellungen in seinem Preferences-File abspeichert. Auf [1] liegt eine Beispielkonfiguration mit allen im Beitrag behandelten Vorgaben. Wer beim Tippen spart, hat mehr Zeit zum Denken! (jcb)

01 version 6.0
02 :map !L iuse Log::Log4perl qw(:easy);<RETURN> Log::Log4perl->easy_init($DEBUG);<RETURN><ESC>
03 :map F o<ESC>43i#<ESC>yyosub {<ENTER><ESC>Pk$i
04 map f !Gperl -MText::Autoformat -e'autoformat{right=>70}'^V^M
05 set backspace=2
06 set fileencodings=utf-8,latin1
07 set formatoptions=tcql
08 set helplang=en
09 set history=50
10 set hlsearch
11 set ruler
12 set shiftwidth=4
13 :autocmd FileType perl :set cindent
14 :autocmd FileType perl :set expandtab
15 set smarttab
16 :nnoremap X :w<Enter>:!perl -c %<Enter>
17 :set tags=/home/mschilli/.ptags.txt
18 :set iskeyword+=: