Nachdem Sie im ersten Teil dieses Programmierkurses einen ersten Einblick in den Umgang mit Tcl/Tk gewinnen konnten, werden Sie diesmal tiefer in die Strukturen von Tcl eintauchen. Die dabei gewonnenen Fähigkeiten können Sie dazu verwenden, Kommandozeilenprogrammen eine intuitivere, auf Ihre persönlichen Bedürfnisse zugeschnittene Benutzerschnittstelle zu spendieren.

Viele Programme unter Unix lassen sich wunderbar von der Kommandozeile aus bedienen, aber leider muss man sich dafür oft eine Menge merken und hat nach ein paar Tagen seine mühsam erlernten Kommandos schon wieder vergessen. Da kann es hilfreich sein, sich ein kleines Progrämmchen zu stricken, das interaktiv die gewünschten Einstellungen abfragt und die lästige Kommandozeile selbst zusammen baut.

Ein hervorragender Kandidat für ein solches vorgeschaltetes Frontend ist Povray, ein Programm zur Erzeugung photorealistischer Bilder [1,2]. Es ist sehr mächtig und beherrscht eine unübersehbare Anzahl von Optionen. Wer damit jedoch – wie ich – nur ab und zu selbst gestaltete 3D-Bilder erzeugt, hat jedesmal wieder seine liebe Not, heraus zu bekommen, wie Povray zu bedienen ist.

Im Dschungel der Optionen

Zwar hilft man povray weiter, trotzdem dauert es geraume Zeit, bis man selbst die allereinfachsten Optionen nachgeschlagen hat.

Wollen Sie Povray auffordern, Ihre Datei mit der Szenenbeschreibung zu rendern, so tun Sie das durch die Eingabe von

povray +Iszenenbeschreibungsdatei +Obilddatei

Falls Sie nicht die von Povray gewählte Bildgröße übernehmen, sondern eine andere festlegen möchten, können Sie das mit

povray +Iszenenbeschreibungsdatei +Obilddatei +Wbildbreite +Hbildhöhe

Das interaktive Zusammenstellen dieser Kommandozeile mit Hilfe von Tcl und die Übergabe an das Programm povray zum Rendern lernen Sie im heutigen Teil dieser Tcl-Einführung.

Am Anfang war der Interpreter

In Teil 1 [7] haben Sie den Interpreter für Tcl/Tk auf der Kommandozeile gestartet und ihm dann Ihre Programmdatei zur Ausführung übergeben. Diesmal geht es eleganter zu: Der Interpreter soll vom Programm selbst gestartet werden. Dazu geben Sie dem Betriebssystem, also dem Linux-Kernel, in der ersten Zeile Ihres Programmcodes den Auftrag.

Dies geht allerdings nicht so einfach wie in einem Terminal. Dort läuft nämlich schon ein Interpreter – unter Linux ist es im Regelfall die bash. Übergeben Sie ihr einen Befehl zur Ausführung, so sucht sie in ihrem Pfad, also in den ihr bekannten Verzeichnissen ausführbarer Programme, nach einem Programm mit dem Namen, den Sie eingegeben haben. Erst wenn sie alle Verzeichnisse durchsucht und immer noch nichts gefunden hat, wird sie eine Fehlermeldung ausgeben.

Der Betriebssystemkern hat diese Möglichkeit der Suche nach ausführbaren Programmen nicht. Er ist daher darauf angewiesen, dass Sie ihm die genaue Stelle des auszuführenden Programms angeben.

Da diesmal keine Fensterelemente wie Buttons u.a. benötigt werden, brauchen Sie Tk, die Widget-Library von Tcl/Tk nicht. Statt der wish aus Teil 1 können Sie deshalb direkt die Tcl-Shell tclsh (sprich: “Tickelschell“), den Interpreter für Ihre Tcl-Befehle, starten.

Um die genaue Schreibweise und den Fundort der tclsh zu ermitteln, tippen Sie am besten in einem Terminal

which tclsh

ein, wobei Sie tclsh gegebenenfalls durch einen genaueren Namen wie z.B. tclsh8.0 ersetzen müssen, je nachdem, wie Sie (oder Ihr Distributor) sie installiert haben.

Prüfen können Sie dies, indem Sie tclsh gefolgt von einem Doppeldruck auf die Tab(ulator)-Taste eingeben. Die Antwort der bash werden alle möglichen Befehle sein, die mit tclsh beginnen: Eventuell haben Sie verschiedene Versionen der tclsh installiert. Das erkennen Sie an unterschiedlichen Versionsnummern am Ende von tclsh. Die aktuelle Version ist 8.3, aber die Beispiele in diesem Text sind alle mit wesentlich älteren Tcl-Versionen wie z.B. tclsh7.4 lauffähig.

which gibt den genauen Pfad des danach stehenden Programms aus. War die Antwort auf which tclsh z.B. /usr/bin/tclsh, so lautet die erste Zeile Ihres Programms

#!/usr/bin/tclsh

Diese Zeile, die den Interpreter starten soll, schreiben Sie in eine Datei und speichern diese unter dem Namen poff.tcl (für “povray für Faule”). Die Dateiendung .tcl ist zwar nicht nötig, hilft Ihnen aber zu erkennen, dass es sich um ein von Tcl zu interpretierendes Programm handelt.

Um Ihre Datei in ein Programm zu verwandeln, müssen Sie sie ausführbar machen. Das erreichen Sie durch folgende Eingabe in einem Terminal:

chmod +x poff.tcl

Sie könnten poff.tcl jetzt starten, es täte allerdings nichts, außer den Interpreter aufzurufen und sofort wieder zu beenden. Geben Sie ihm also Futter.

Was darf’s denn sein?

Um ein Programm zu schreiben, ist es hilfreich, sich zunächst in den späteren Nutzer zu versetzen und einen Plan zu machen, was die zu erstellende Software können soll. In unserem Beispiel hat der Nutzer eine Szenenbeschreibungsdatei für Povray erstellt und möchte diese gerendert bekommen sowie gegebenenfalls die Bildgröße einstellen.

Er soll sich dabei nicht mit der komplizierten Povray-Syntax abplagen, sondern komfortabel nach seinen Wünschen gefragt werden. So möchte er angeben können, welches Bild er gern gerendert hätte, und ob er eventuell auch die Bildgröße einstellen möchte. Falls ja, will er auch nach den Abmessungen gefragt werden. Dann soll povray starten.

Zur besseren Übersicht sind noch einmal alle Schritte im Kasten “Der Plan zum Programm poff” zusammen gestellt. Damit werden Sie zur Programmiererin, die diesen Plan nun umsetzt.

Um Ihr Programm dazu zu bringen, etwas zu tun, müssen Sie ihm einen Befehl dazu erteilen. Befehle werden in Tcl an den Anfang einer Zeile geschrieben. Alles, was danach bis zum Zeilenende steht, sieht der Interpreter als Bestandteil dieses Befehls an. Die einzelnen Bestandteile werden jeweils durch mindestens ein Leerzeichen getrennt. Braucht der Befehl unbedingt solcherart “Zusatzinformationen” um zu funktionieren, so werden sie Argumente genannt. Können sie zusätzlich angegeben, aber auch weg gelassen werden, so heißen sie Optionen.

Der erste Punkt auf der Liste ist eine Mitteilung des Frontends an den Nutzer, die ihm zu verstehen gibt, wofür es gut ist. Da es ja selbst (zumindest in diesem Teil der Einführung) ein Kommandozeilenprogramm ist, kann das Frontend Mitteilungen nur in dem Terminal ausgeben, in dem es aufgerufen wurde (im Gegensatz zu grafischen Frontends, denen Buttons, Beschriftungen, Menüs oder ähnliches zur Verfügung stehen).

Der Befehl, der Ihr Programm dazu bringt, dort etwas auszugeben, lautet puts. Als Argument benötigt puts die Zeichenkette, die auf dem Terminal erscheinen soll.

Enthält die Zeichenkette Leerzeichen, so würden diese als Trennung von Befehlsbestandteilen interpretiert – plötzlich hätten wir es mit mehreren Argumenten zu tun. Um das zu verhindern, wird die Zeichenkette in Anführungszeichen eingeschlossen. Diese kaschieren die Leerzeichen, und der Interpreter erhält nur ein einziges Argument zum Befehl puts.

Schreiben Sie beispielsweise folgende zusätzliche Zeile in Ihre Datei:

puts "Willkommen bei poff, dem interaktiven Povray-Frontend"

… und schon haben Sie ein echtes Programm geschrieben. Es startet selbstständig seinen eigenen Interpreter und lässt ihn einen Begrüßungstext ausgeben. Speichern Sie Ihre Programmdatei, rufen Sie sie in einem Terminal auf, und sehen Sie nach, ob alles geklappt hat:

billi@ratschni > poff.tcl
Willkommen bei poff, dem interaktiven Povray-Frontend
billi@ratschni >

Damit wäre Punkt 1 im Programmablaufplan erledigt.

Als Zweites fordern Sie den Nutzer auf, den Namen der zu rendernden Datei einzugeben. Nichts leichter als das – einfach eine entsprechende Zeile an das Programm dran gehängt, vielleicht mit einer leeren Zeile von der Begrüßung abgesetzt – macht zwei zusätzliche Zeilen.

Eine Leerzeile wird von einem puts erzeugt, das eine leere Zeichenkette ausgibt. Das lässt sich durch zwei zusammenhängende Anführungszeichen erreichen:

puts ""
puts "Geben Sie bitte den Namen der zu rendernden Datei ein"

So, und nun? Nun haut der Nutzer in die Tasten, aber wie kommt das Frontend an die Tastatureingaben?

Dazu gibt’s bei Tcl den Befehl gets, der Daten von verschiedenen Quellen wie Dateien oder Terminals einlesen kann.

Dieser Befehl allein bringt allerdings nicht viel, da Sie die Information ja auch noch behalten, also speichern müssen. Schließlich brauchen Sie sie, um damit die Kommandozeile zu basteln. Hier also zunächst ein Exkurs, wie Informationen innerhalb eines Programms gespeichert werden, bevor es mit dem Befehl gets weiter geht.

Was sagten Sie?

Beim Programmieren werden Daten, die während des Programmablaufs benötigt werden, in Variablen abgelegt. Variablen sind wie Einkaufskörbe, in die Daten hinein gepackt werden können, die später wieder gebraucht werden. Sie können sich so viele Variableneinkaufskörbe erfinden (auf Fachdeutsch: “deklarieren”), wie Sie möchten. Wichtig ist, dass alle Variablen unterschiedliche Namen bekommen, damit sie nicht verwechselt werden. Dabei hat es sich eingebürgert, Variablennamen klein zu schreiben und “sprechende” Namen zu verwenden.

Eine Variable deklarieren Sie folgendermaßen:

set meinname Sibylle

Bei Tcl müssen Sie Variablen bei der Deklaration auch gleich einen Inhalt mitgeben. Der Variableninhalt ist beliebig. Enthält er allerdings Leerzeichen, so bleibt Ihnen nichts anderes übrig, als diese wieder durch Anführungsstriche zu kaschieren (oder neuhochdeutsch zu quoten).

Um sich das Konzept der Variablen besser klar zu machen, können Sie die Möglichkeit von Tcl nutzen, direkt mit dem Interpreter zu interagieren. Starten Sie dazu in einem Terminal den Tcl-Interpreter mit tclsh oder dem Namen, unter dem er auf Ihrem System installiert ist (siehe oben). Sie können Ihre Eingaben nun direkt machen und die Reaktionen des Interpreters sehen. Hatte der Befehl ein Ergebnis, so gibt die tclsh dieses zunächst aus, bevor sie Ihnen wieder ihren Prompt% zur Verfügung stellt.

Zum besseren Verständnis der Eingaben habe ich diese kommentiert. Kommentarzeilen sind Zeilen, die nicht vom Interpreter ausgeführt werden, sondern nur der Verdeutlichung für die Programmiererin und zur Dokumentation dienen. Sie beginnen (nicht nur) bei Tcl mit einem #-Zeichen.

billi@ratschni > tclsh
%
% # Deklaration der Variablen meinname:
% set meinname Sibylle
Sibylle
% # Ausgabe des Variableninhalts:
% puts "Mein Name lautet: $meinname"
Mein Name lautet: Sibylle
%
% # Ändern des Variableninhalts:
% set meinname Luzie
Luzie
%
% # Vergessene Anführungszeichen machen Ärger...
% set meinname Sibylle Luzie
wrong # args: should be "set varName ?newValue?"
%
% # Jetzt nochmal richtig:
% set meinname "Sibylle Luzie"
Sibylle Luzie
% puts "Mein Name lautet: $meinname"
Mein Name lautet: Sibylle Luzie
%
% # Verlassen des Interpreters
% exit
billi@ratschni >

Nun wenden Sie sich dem Befehl gets zu. Er bietet Ihnen die Möglichkeit, Tastatureingaben ohne den Umweg über das set in einer Variable zu speichern. Wenn Sie ihm außer dem Einlesekanal ein zweites Wort mit auf sein Befehlsleben geben, versteht er dies als Variablennamen und wird die Tastatureingaben des Nutzers in dieser Variable speichern. Um Eingaben von der Standardeingabe, also dem momentan aktiven Terminal, einzulesen und in einer Variablen abzulegen, lautet die Befehlssyntax:

gets stdin meinevariable

Wenn dieser Befehl ausgeführt wird, wartet das Programm so lange, bis der Nutzer die Enter-Taste gedrückt hat. Alles bis dahin Eingegebene wird in der Variablen gespeichert.

Wenn Sie dies im Interpreter testen, gibt er zunächst die Anzahl der eingegebenen Zeichen aus, bevor er Ihnen wieder den Prompt serviert.

billi@ratschni > tclsh
%
% # Speichern der Tastatureingaben
% # in der Variablen "eingabe":
% gets stdin eingabeEine Rose ist eine Rose ist eine Rose.
38
%
% # Ausgabe des Variableninhalts:
% puts $eingabe
Eine Rose ist eine Rose ist eine Rose.
%

Durch die Eingabe des Befehls exit könnten Sie den Interpreter jetzt wieder beenden. Lassen Sie ihn aber ruhig weiter im Terminal laufen, da er im Laufe dieses Artikels noch gebraucht wird, und wenden Sie sich jetzt wieder Ihrem Programm poff.tcl zu.

Mit dem frisch erworbenen Wissen können Sie den Programmcode im Editor folgendermaßen ergänzen:

#!/usr/bin/tclsh
# Vorstellung des Frontends
puts "Willkommen bei poff, dem interaktiven Povray-Frontend"
# Aufforderung an den Nutzer
puts ""
puts "Geben Sie bitte den Namen der zu rendernden Datei ein"
# Einlesen der Nutzer-Eingabe
gets stdin dateiname

Wenn Sie poff.tcl in einem Terminal aufrufen, sollten Sie folgende Ausgabe erhalten:

billi@ratschni > poff.tcl
Willkommen bei poff, dem interaktiven Povray-Frontend
Geben Sie bitte den Namen der zu rendernden Datei einbild.pov
billi@ratschni >

Wir hätten da noch…

Und schon geht es weiter mit dem Povray-Aufruf. Wie oben schon erwähnt, benötigt dieser sowohl den Namen einer Eingabedatei, als auch den einer von ihm zu erzeugenden Bilddatei. Der Name der Bilddatei unterscheidet sich von dem der Eingabedatei lediglich durch die Dateiendung: Die Szenenbeschreibungsdatei endet auf .pov, die Bilddatei mit .tga. Es ist also ganz nützlich, sich von Tcl die Endung .pov durch .tga ersetzen zu lassen.

Da hilft der Befehl file weiter. Mit dem Argument rootname schneidet file die Dateiendung des angegebenen Dateinamens weg. Probieren Sie es doch wieder im tclsh-Interpreter aus:

%
% # Abschneiden der Dateiendung
% file rootname bild.pov
bild
%

Um das Ergebnis des Befehls weiter zu verwenden und in einer Variablen zu speichern, müssen Sie ihn in eckige Klammern schreiben. Tcl wertet zunächst den eingeklammerten Befehl aus, ersetzt die Klammern und den Befehl durch das Befehlsergebnis und weist dieses der Variablen zu.

% # Deklaration der Variablen testname
% set testname [ file rootname bild.pov ]
bild
%

Nachdem Sie den “Rumpf” des Dateinamens in der Variablen testname gespeichert haben, können Sie ihn um die gewünschte Dateiendung erweitern. Dazu hängen Sie die Endung einfach an den Variableninhalt an und speichern das Ergebnis wieder unter dem selben Variablennamen.

%
% # Ergänzen von testname durch eine neue Endung
% set testname $testname.tga
bild.tga
%

Der zusätzliche Code für Ihre Programmdatei lautet somit:

set bildname [ file rootname $dateiname ]
set bildname $bildname.tga

Wenn das Wörtchen “wenn” nicht wär’…

Mit dem vierten Punkt auf der Liste wollen Sie den Nutzer fragen, ob er die Bildgröße einstellen möchte. Das sollte jetzt kein Problem mehr sein, auch nicht, die Eingaben des Nutzers in einer neuen Variablen zu speichern. Von da an müssen Sie Ihren Programmablauf abhängig von der Eingabe des Nutzers gestalten.

In normalem Deutsch gesprochen hört sich das so an:

• Wenn der Nutzer die Bildgröße eingeben möchte,
• wird er aufgefordert, die Bildgröße einzugeben,
• die Bildgröße wird gespeichert
• und das Programm povray mit den Größenangaben aufgerufen.
• Ansonsten wird povray ohne Maßangaben aufgerufen.

Deutsch nach Tcl übersetzt macht aus Wenn ein if. Die Kontrollstruktur if stellt eine Ja-Nein-Frage. Ist die Antwort darauf ein Ja, so wird eine Folge von Aktionen – ein kleines Skript – ausgeführt, sonst nicht. Die erste Klammer enthält die Abfrage, die zweite das Skript. Im Interpreter sieht das so aus:

%
% # Ein if, dessen Skript ausgeführt wird
% if { 1 < 2 } { puts "Stimmt" }
Stimmt
%
% # Ein if, dessen Skript nicht ausgeführt wird
% if { 1 > 2 } { puts "Stimmt" }
%

Wenn Sie ein Entweder-Oder programmieren möchten, können Sie das mit einer if-else-Konstruktion. Das else stellt eine mögliche Option für if dar, deren Skript ausgeführt wird, wenn die Abfrage mit Nein beantwortet wird.

%
% # Entweder-oder:
% # Ja, 1 ist kleiner als 2
% if { 1 < 2 } { puts "Stimmt" } else { puts "Stimmt nicht" }
Stimmt
%
% # Nein, 1 ist nicht größer als 2
% if { 1 > 2 } { puts "Stimmt" } else { puts "Stimmt nicht" }
Stimmt nicht
%

Darf’s auch etwas mehr sein?

Nun brauchen Sie eine Möglichkeit, die Eingabe des Nutzers mit einem von Ihnen gewählten Wert zu vergleichen. Dies können Sie mit dem Befehl string. Mit dem Argument match vergleicht er zwei Zeichenketten, die danach angegeben werden. Sind die Zeichenketten gleich, so ist sein Ergebnis eine 1, sind sie ungleich, so liefert er eine 0 zurück. Die genaue Befehlssyntax lautet:

string match erste_Zeichenkette zweite_Zeichenkette

Probieren Sie auch das beim Trockenschwimmen mit dem Interpreter aus:

%
% # zwei gleiche Zeichenketten
% string match j j
1
% string match ja ja
1
%
% # zwei ungleiche Zeichenketten
% string match j n
0
% string match ja j
0
%

Um den Befehl string in der if-Kontrollstruktur als Abfrage zu verwenden, müssen Sie ihn in eckige Klammern schreiben. Der Interpreter wertet zunächst den zwischen den Klammern stehenden Befehl aus und reicht dann das Ergebnis an if weiter. War es eine 1, so interpretiert das if dies als ja, kam eine 0 heraus, so wertet if das als nein.

Nun können Sie den Quellcode Ihres poff-Programms um die Abfrage erweitern. Die öffnende Klammer des Skripts, {, muss dabei in der selben Zeile wie das if stehen. Nur so erkennt der Interpreter das Skript als zweites Argument für if an. Das else wiederum muss sich mit der schließenden Klammer } auf einer Zeile befinden, um als Option von if akzeptiert zu werden.

puts "Möchten Sie die Bildgröße eingeben (j/n)?"
gets stdin bildgroesse
if { [ string match j $bildgroesse ] } {
   puts "Geben Sie bitte die Breite des Bildes ein"
   gets stdin bildbreite
   puts "Geben Sie bitte die Höhe des Bildes ein"
   gets stdin bildhoehe
   # Aufruf von povray mit Groessenangabe
} else {
   # Aufruf von povray ohne explizite Groessenangabe
}

Das macht dann …

Nun bleibt nur noch Punkt 5 auf der Liste: das Starten von povray – entweder mit Angabe der Bildgröße oder ohne.

Der Befehl exec kann alle ausführbaren Programme aufrufen, also auch das Programm povray. Als erstes Argument benötigt exec den Namen des auszuführenden Programms. Tcl startet dieses dann mit den restlichen Optionen. Der korrekte Aufruf lautet:

# Mit Groessenangaben:
exec povray +I$dateiname +O$bildname +W$bildbreite +H$bildhoehe &
# Ohne explizite Groessenangaben:
exec povray +I$dateiname +O$bildname &

Wenn Sie die if– und else-Skripte noch um den jeweiligen Povray-Aufruf ergänzen, haben Sie Ihr komplettes Programm fertig! Sie finden es vollständig in Listing 1 abgedruckt, die gelernten Befehle sind in Tabelle 1 noch einmal beschrieben. Experimentieren Sie damit, bevor Sie in Heft 08/2000 die letzte Folge unserer kleinen Programmierreihe erwartet.

#!/usr/bin/tclsh
# Vorstellung des Frontends
puts "Willkommen bei poff, dem interaktiven Povray-Frontend"
# Aufforderung an den Nutzer
puts ""
puts "Geben Sie bitte den Namen der zu rendernden Datei ein"
# Einlesen der Nutzer-Eingabe
gets stdin dateiname
# Erstellen des Namens für die Bilddatei
set bildname [ file rootname $dateiname ]
set bildname $bildname.tga
# Erfragen, ob Bildgroesse gewuenscht
puts "Möchten Sie die Bildgröße eingeben (j/n)?"
gets stdin bildgroesse
# Wenn Bildgroesse gewuenscht, dann erfragen
if { [ string match j $bildgroesse ] } {
   puts "Geben Sie bitte die Breite des Bildes ein"
   gets stdin bildbreite
   puts "Geben Sie bitte die Höhe des Bildes ein"
   gets stdin bildhoehe
   # Aufruf von povray mit Groessenangabe
   exec povray +I$dateiname +O$bildname +W$bildbreite +H$bildhoehe &
} else {
   # Aufruf von povray ohne Groessenangabe
   exec povray +I$dateiname +O$bildname &
}