Tcl

Kommandos und Parameter

Die Arbeit eines Tcl-Interpreters ist denkbar einfach: Er nimmt sich jeweils eine Zeile, zerlegt sie in Worte, betrachtet das erste Wort als Kommando sowie alle nachfolgenden Worte als dessen Parameter, und ruft das gegebene Kommando mit den Parametern auf. Worte werden begrenzt durch Leerzeichen, Tabulatoren oder Zeilenwechsel.

Wenn ein Zeichen, das normalerweise ein Wort beenden würde, Teil eines Wortes sein soll, kann das durch Voranstellen eines Backslashes vor das entsprechende Zeichen geschehen, durch Umklammern des gesamten Wortes durch doppelte Hochkommata oder durch geschweifte Klammern. Geschweifte Klammern schachteln, Hochkommata schachteln nicht.

Um die Sprache möglicht einfach zu halten, gibt es in Tcl nur einen Datentyp, die Zeichenfolge (ein String). Eine Folge von Buchstaben muß nicht mit Hochkommata umklammert werden, um eine Zeichenfolge zu bilden, jedenfalls solange sie keine Leerzeichen enthält. Und die umklammernden Kommata (oder auch geschweifte Klammern) sind nicht Teil der Zeichenkette. Was Tcl betrifft, macht es daher keinerlei Unterschied, ob 50 mit 10 addieren werden soll oder ,,50'' mit {10}.

Hallo Welt

Der große Moment naht, wo wir genügend wissen, um das erste Tcl-Programm auszuführen. Mit der Information, daß das Kommando puts einen String auf die Standardausgabe schreibt (ähnlich wie das Unix-Kommando echo), rufen wir also den Interpreter auf und tippen es ein:

# tclsh8.0% puts Hello Worldcan not find channel named "Hello"% puts "Hello World"Hello World% puts {Hello World}Hello World% puts Hello\ WorldHello World% #

Der erste Versuch lieferte einen Fehler, da puts den auszugebenden String als einen Parameter erwartet, wir ihn jedoch wegen des Leerzeichens als zwei Parameter übergeben haben. Bei einem Aufruf mit zwei Parametern muß der erste jedoch eine zum Schreiben geöffnete Datei (z.B. stdout) sein.

Die letzte Zeile erfordert auch noch eine Interpretation: Am Ende der Tcl-Session wurde (hinter dem zweiten Prozentzeichen, leider ohne sichtbares Echo am Bildschirm) Control-d eingegeben als Zeichen, daß keine weitere Eingabe kommt. Der Tcl-Interpreter beendete seine Arbeit und der Unix-Shell antwortete mit seinem nächsten Prompt.

Tcl-Programme

Ein Tcl-Skript wird direkt interpretiert, also nicht etwa in einem extra Lauf in Maschinencode compiliert, um dann als ausführbares Programm gestartet zu werden. Wenn ein Tcl-Skript in einer Datei vorliegt (hier z.B. hello.tcl), kann der Dateiname dem Interpreter als Argument übergeben werden. Er führt dann alle darin enthaltenen Kommandos aus und beendet sich anschließend. Hier der Inhalt von hello.tcl:

# cat hello.tclputs "Hello World"# tclsh8.0 hello.tclHello World#

Wenn wir die Ausführungsrechte des Programms setzen und am Anfang der Datei einige magische Zeilen einführen, kann hello.tcl wie jedes andere Programm durch Namensnennung aufgerufen werden.

# cat hello.tcl#!/bin/sh# the next line restarts using tclsh \\exec tclsh8.0 "$0" "$@"puts "Hello World"# chmod a+x hello.tcl# hello.tclHello World#

Ersetzungen

Bevor das Kommando (also das erste Wort) tatsächlich aufgerufen wird, führt der Tcl-Interpreter noch zwei Arten von Ersetzungen durch. Bei Dollarzeichen gefolgt von einem Namen wird der Inhalt einer Variablen mit diesem Namen ersetzt, bei eckigen Klammern wird alles zwischen den Klammern als eigenes Tcl-Kommando angesehen und das Ergebnis dieses Komamndos wird ersetzt.

Variablennamen können entweder aus einem einfachen Namen bestehen (z.B. x) oder aus zwei Namen, wobei der zweite in runden Klammern steht (z.B. x(y)). Letzteres ist der Zugriff auf ein sogenanntes assoziatives Array; d.h. x ist ein Feld, auf dessen Einträge mit Schlüsseln zugegriffen werden kann, die nicht unbedingt numerisch sein müssen.

Hier unser zweites Tcl-Programm, das beide Arten der Ersetzung vorführt.

# cat subst.tclputs "Hello $env(LOGNAME) at [pwd]"# tclsh8.0 subst.tclHello krischan at /u/krischan#

Bei Programmstart initialisiert der Interpreter eine globale Variable env mit allen Umgebungsvariablen. Mit $env(LOGNAME) greife ich also auf den Wert der Umgebungsvariable LOGNAME zu. pwd ist ein Tcl-Kommando, das wie das Shell-Kommando gleichen Namens die aktuelle Directory liefert.

Ausdrücke

Da in Tcl selbst nur der Datentyp String bekannt ist, werden vom Tcl-Interpreter selbst auch keine mathematischen Ausdrücke berechnet. Dazu gibt es das Kommando expr, welches alle übergebenen Argumente zu einer Zeichenkette aneinanderhängt und anschließend mit einer zu C identischen Syntax berechnet.

Boolesche Ausdrücke (ebenfalls identisch zu C) müssen einem numerischen Wert ergeben; 0 wird dabei als falsch betrachtet, alles andere als wahr.

Auch Zeichenketten können innerhalb eines Ausdrucks benutzt werden, z.B. in einem Vergleich. Dann müssen sie jedoch in doppelte Hochkommata gesetzt werden.

set x [expr {4*28-int(12.2)}]puts [expr {$x % 2 ? "Odd" : "Even"}]

Variablen

Durch die Dollarsubstitution kann auf den Inhalt einer Variablen bequem zugegriffen werden. Mit dem Kommando set kann einer Variablen ein Wert zugewiesen werden. Hierzu wird set mit 2 Parametern aufgerufen: dem Variablennamen und dem Wert, den die Variable annehmen soll. Bei Aufruf von set mit nur einem Parameter wird der derzeitige Wert der Variablen zurückgeliefert. Es gibt also zwei Wege, den Wert einer Variablen zu erfragen: Durch die Dollarsubstitution und durch Aufruf von set.

# cat var.tclset user $env(LOGNAME)set pwd  [pwd]puts "Hello [set user] at $pwd"# tclsh8.0 var.tclHello krischan at /u/krischan#

Kontrollstrukturen

Tcl besitzt ähnliche Kontrollkonstrukte wie C oder die Bourne-Shell. Ein (allerdings eher philosophischer) Unterschied ist, daß diese Konstrukte in Tcl auch nur normale Kommandos sind. Es gilt also z.B. ein if Kommando, daß mindestens 2 Parameter übergeben bekommt. Der 1 Parameter wird dann als ein boolescher Ausdruck berechnet und falls er wahr ergibt, wird der zweite Parameter als Tcl-Skript betrachtet und ausgeführt.

Hier ein Beispiel einer for Schleife, die (genau wie in C) aus Initialisierung, Schleifenbedingung, Inkrementanweisung und dem zu wiederholenden Skript besteht. Der zweite Parameter (Schleifenbedingung) muß ein gültiger Ausdruck sein, da er dem expr Kommando zur Abarbeitung übergeben wird. Alle anderen Parameter werden als Folgen von Tcl-Anweisungen interpretiert.

# cat for.tclfor {set i 0} {$i < 5} {incr i} {  puts "Hello $env(LOGNAME) at [pwd]"}# tclsh8.0 for.tclHello krischan at /u/krischanHello krischan at /u/krischanHello krischan at /u/krischanHello krischan at /u/krischanHello krischan at /u/krischan#

Prozeduren

Prozeduren werden mit dem proc Kommando erzeugt, welches drei Argumente erwartet, den Namen der Prozedur sowie die Parameterliste und die Anweisungssequenz. Anschließend kann die neue Prozedur genauso wie jedes vordefinierte Tcl-Kommando benutzt werden.

Fast immer wird eine Prozedur im folgenden Format definiert:

proc procName {param1 param2} {  statement1  statement2}

Wichtig ist insbesondere die öffnende Klammer am Ende der ersten Zeile. Würde sie erst auf der zweiten Zeile stehen, würde der Tcl-Interpreter das proc Kommando mit nur zwei Parametern aufrufen (Kommandoname und Parameterleite), was jedoch von diesem mit einer Fehlermeldung quittiert wird.

# cat proc.tclproc hello {count channel} {  global env  for {set i 0} {$i < $count} {incr i} {    puts $channel "Hello $env(LOGNAME) at [pwd]"  }}hello 3 stdout# tclsh8.0 proc.tclHello krischan at /u/krischanHello krischan at /u/krischanHello krischan at /u/krischan

Innerhalb einer Prozedur interpretiert Tcl Variablennamen prinzipiell als prozedurlokal. Um innerhalb einer Prozedur (sowohl lesend als auch schreibend) auf eine globale Variable zugreifen zu können, werden durch das global Kommando die angegebenen Variablen auch innerhalb der Prozedur bekannt gemacht.

Immer mal wieder vergesse ich eine global Anweisung. Beim Zugriff auf eine globale Variable wird das ja sofort durch eine Fehlermeldung (z.B. can't read ,,env(LOGNAME)'': no such variable) quittiert. Schlimmer ist es bei einer Zuweisung mittels set. Hier wird dann einer prozedurlokalen Variable der Wert zugewiesen, der Wert der globalen Variablen ändert sich jedoch nicht. Und später an einer anderen Stelle bleibt dann das Rätsel zu lösen, warum die Zuweisung anscheinend nicht ausgeführt wurde.

Listen

Wie bereits mehrfach erwähnt, besitzt Tcl nur einen Datentyp, die Zeichenfolge. Es stehen jedoch noch die Möglichkeiten des Arrays und der Liste zur Verfügung, um Daten zu strukturieren. Während Arrays bereits im Abschnitt Variablen kurz beschrieben wurden, folgt hier eine Übersicht über Listen.

Kommunikation mit der Umwelt

Um eine Datei zu öffnen, gibt es das open Kommando, welches einen Dateidesriptor zurückliefert, der in nachfolgenden Aufrufen von puts, read und close benutzt werden kann.

Mit cd, pwd und glob und file gibt es die Möglichkeit, auf das Dateisystem und einzelne Dateien zuzugreifen.

Um Kommandos auf Betriebssystemebene aufzurufen, gibt es das Kommando exec. Das Kommando wird ausgeführt und der Returnwert wird zurückgeliefert. Wenn man mit dem gestarteten Programm über seine Ein-/Ausgabe kommunizieren will, wird es (wie im folgenden Beispiel) als Kommando-Pipeline geöffnet, indem beim open statt des Dateinamens das Pipe-Symbol (|) gefolgt von dem Kommando angegeben wird.

# cat exec.tclset f [open "|ls -l /tmp"]set output [read $f]close $fset lines [split $output "\n"]puts [lindex $lines 0]# tclsh8.0 exec.tcltotal 60#

Eine Anmerkung noch zum im Beispiel verwendeten split Kommando. Es erzeugt eine Liste, indem es seinen ersten Parameter an dem als zweiten Parameter gegebenen gegebenen Zeichen auftrennt. Das dazu inverse Kommando join macht aus einer Liste wieder eine Zeichenfolge.

Tk

Tk ist wohl die bekannteste Erweiterung von Tcl. Sie stammt ebenfalls von John Ousterhout und wird auch vom Tcl-Team bei Sun weiterentwickelt. Es ist ein platformübergreifendes Toolkit (deshalb Tk) zum Entwickeln von Applikationen mit graphischer Benutzeroberfläche.

Wer jemals ein Programm für eine graphische Benutzeroberfläche in C mit z.B. dem Xt-Toolkit programmiert hat, weiß, daß das ein recht komplexes Unterfangen ist. Es müssen die entsprechenden Objekte erzeugt und mit Hilfe eines Geometrie-Managers angeordet werden; außerdem sind entsprechenden Events (z.B. Mausklicks oder Tastendrücke) Prozeduren zuzuordnen, die jeweils aufgerufen werden sollen. Am Ende des Programms wird dann in eine Endlosschleife eingetreten, in deren Rumpf jeweils ein Event abgearbeitet wird.

In Tcl/Tk muß das auch alles geleistet werden, um eine Applikation zu erstellen. Nur kann es durch eine Vielzahl von mächtigen Widgets mit einer Unzahl von Konfigurationsoptionen leichter und kompakter formuliert werden. Auch zum Geometrie-Managment stehen drei verschiedenen Manager zur Auswahl, jeder spezialisiert auf sein Einsatzgebiet. Und die genannte Endlosschleife ist implizit, d.h., der Tk-Interpreter (wish genannt für WIndowing SHell) arbeitet permanent eintreffende Events ab, wenn keine Befehle von seiner Standardeingabe kommen.

Widgets

Durch Tk werden eine Menge von Tcl-Kommandos definiert, die jeweils ein Element der graphischen Oberfläche kreieren. Diese Elemente werden im allgemeinen Widgets genannt; dieser Ausdruck stammt aus der Unix-Welt und ist eine Verkürzung von Window Gadget, was soviel wie Fenster-Dingsbums heißt. Ein Widget entspricht ungefähr einem Control aus der Windows-Welt.

Es gibt in Tk 15 verschiedene Widgets, aus denen die Oberfläche zusammengesetzt werden kann. Dabei hat selbst das wohl simpelste Widget, das Label zum Darstellen eines Textes, bereits 22 Konfigurationsparameter. Da Tk für die meisten Parameter bereits vernünftige Defaultwerte vorgibt, werden jedoch normalerweise nur ein paar Parameter tatsächlich angegeben: beim Label wird wohl immer der Text spezifiziert, der angezeigt werden soll.

Der erste Parameter eines Widget-Kommandos ist der Name des zu erzeugenden Widgets. Aus dem Namen kann die Position innerhalb der Widget-Hierarchie ersehen werden ähnlich einem Dateisystem. Als Trenner der einzelnen Elemente dient hier allerding der Punkt und nicht ein Schrägstrich. Das oberste Fenster einer Applikation heißt also ., ein darin befindliches Buttonleiste könnte .buts heißen, und der Exit-Button darin würde dann .buts.exit genannt.

Konfigurationsparameter von Widget-Kommandos werden grundsätzlich in zwei Worten hingeschrieben: der Name des Parameters mit einem führenden Strich und anschließend der Wert des Parameters. Hier als Beispiel ein Label, welches ob seiner wichtigen Botschaft eine rote Hintergrundfarbe erhält:

label .lab -text "Press F3 to exit" -background red

Zusätzlich zu dem Objekt auf dem Bildschirm wird ein neues Tcl-Kommando erzeugt mit dem Namen des Widgets. Diese Widget-Kommandos haben prinzipiell als ersten Parameter ein Unterkommando, das auf dem Widget ausgeführt werden soll. Das Unterkommando entspricht ungefähr dem Aufruf einer Methode in C++.

Mit Hilfe des Widget-Kommandos kann das erzeugte Widget z.B. noch rekonfiguriert werden kann. Um obiges Label noch auffälliger zu gestalten, bekommt es nun noch einen Rand.

.lab configure -relief groove -borderwidth 2

Hallo nochmals

Auch bei graphischen Applikationen wird gern das ,,Hallo Welt'' Programm als erstes Beispiel genommen. Da in Tcl/Tk solche Sachen wirklich sehr einfach und kompakt formuliert werden können, schrauben wir die Anforderungen hoch: Es soll nicht nur ein Fenster mit der freundlichen Begrüßung erscheinen, sondern bei einem Mausklick soll die Begrüßung auch noch auf die Standardausgabe geschrieben werden. Außerdem soll ein Exit-Knopf zum Verlassen der Applikation vorhanden sein.

Das Tcl-Programm ist jedenfalls kürzer als die obige Anforderungsdefinition.

# cat button.tclbutton .b -text "Hello world" -command {puts "Hello $env(LOGNAME)"}button .q -text "Exit"        -command exitpack .b .q -side top -fill x# wish8.0 button.tclHello krischan#

Durch Verwendung des -command Parameters wird ein Tcl-Skript definiert, welches ausgeführt werden soll, falls der Benutzer den Button mit der Maus anklickt. Diese Skripte werden dann später auf globalem Level ausgeführt; daher ist kein global Kommando nötig.

Das pack Kommando ruft einen der drei Geometrie-Manager auf. Der Packer positioniert die übergebenen Widgets immer an eine der vier Seiten des übergeordneten Fensters (in unserem Beispiel an die obere Seite des Toplevels mit dem Namen ., welches vom wish automatisch angelegt wird).

Events

Wie im letzten Beispiel ersichtlich, besitzt das Label einen -command Parameter, mit dessen Hilfe ein Tcl-Kommando als Antwort auf ein bestimmtes Ereignis festgelegt werden kann.

Normalerweise geschieht das mit dem bind Kommando, welches drei Parameter bekommt: ein Widget, ein Event und ein Tcl-Skript. Nach Aufruf des Kommandos wird immer, wenn das genannte Event im gegebenen Widget eintritt, das Tcl-Skript abgearbeitet. Hier ein Beispiel.

bind .  {puts "Bye bye"; exit}

Scrollbars

Scrollbars sind Widgets, die dem Benutzer die Möglichkeit geben, den Inhalt eines anderen Fensters so zu verschieben, daß der von ihm gewünschte Ausschnitt sichtbar ist. Scrollbars sind also horizontal oder vertikal einem Fenster zugeordnet; dieses Fenster muß Scrollen unterstützen (das tun die entry, listbox, text und canvas Widgets).

Ein Scrollbar und das anzusteuernde Widget werden über Konfigurationsparameter verknüpft (wie sonst?). Das dabei zugrundeliegende Protokoll wird am einfachsten durch ein Beispiel deutlich.

entry .e -xscrollcommand ".s set"scrollbar .s -orient horizontal -command ".e xview"

Geometrie-Manager

Um die ganzen erzeugten Widgets auch in einer sinnvollen Anordnung auf dem Bildschirm präsentieren zu können, werden sie von einem Geometrie-Manager verwaltet. Es gibt in Tk drei verschiedene Manager: place, pack und grid.

Mittels place kann ein Widget an bestimmte Stellen des übergeordneten Fensters positioniert werden. Dafür stehen die -x und -y Parameter zum absoluten und die -relx und -rely Parameter zum relativen Positionieren zur Verfügung. Die folgenden Kommandos zeigen jeweil ein Label an der Stelle 1 cm unterhalb und 1 cm rechts der linken oberen Ecke sowie in der Mitte an.

place .hallo -x 1c -y 1cplace .welt  -relx 0.5 -rely 0.5

Mit dem pack Kommando kann ein Widget an eine der vier Seiten des übergeordneten Fensters positioniert werden. Ein Beispiel hierfür wurde ja bereits im Hallo-Welt-Beispiel gezeigt.

Das grid Kommando verwaltet die Widgets in einer zweidimensionalen Tabelle (dem Gitter), in dem mit Hilfe der -row und -column Parameter eine Position innerhalb der Tabelle spezifiziert wird. Durch den -sticky Parameter kann eine Reihe von Himmelsrichtungen angegeben werden, zu denen das Widget seinen in der Tabelle zur Verfügung stehenden Platz ausdehnt. Durch grid rowconfigure bzw. grid columnconfigure kann bestimmt werden, welche Zeilen/Spalten zusätzlichen Platz zugesprochen bekommen, falls das Fenster durch den Benutzer vergrößert wird.

Ein Beispiel für den grid Geometrie-Manager findet sich im nächsten Abschnitt.

Das Text-Widget zum Beispiel

Die Stärke von Tk ist wohl zum Großteil darin begründet, daß es (neben den simplen Widgets wie button oder label) mit text und canvas zwei sehr mächtige Widgets besitzt, mit deren Hilfe auch komplexe Aufgaben leicht gelöst werden können. Mit dem text Widget kann z.B. mit wenig Aufwand ein HTML-Browser implementiert werden.

Das durch den Aufruf von text erzeugte Widget-Kommando (in unserem Beispiel mit dem Namen .t) besitzt eine Vielzahl von Unterkommandos, mit deren Hilfe der Inhalt des Text-Widgets erfragt oder modifiziert werden kann.

Im Beispiel wird als Reaktion auf den Druck der F5-Taste das Resultat des Aufrufs von .t get 1.0 end auf die Standardausgabe gegeben. Das get Unterkommando liefert den Inhalt des text Widgets in den genannten Grenzen zurück.

# cat text.tclproc CommandText {w} {  text $w -width 40 -height 5 -wrap word \\    -xscrollcommand ".h set" -yscrollcommand ".v set"  scrollbar .h -orient horizontal -command "$w xview"  scrollbar .v -orient vertical   -command ".v yview"  grid $w -row 0 -column 0 -sticky news  grid .v -row 0 -column 1 -sticky ns  grid .h -row 1 -column 0 -sticky ew  grid rowconfigure    . 0 -weight 1  grid columnconfigure . 0 -weight 1}CommandText .tbind .t  exitbind .t  {puts -nonewline [.t get 1.0 end]}# wish8.0 text.tclSELECT nummer, name, wert  FROM artikel  WHERE wert = (SELECT MIN (wert)                  FROM artikel)#ENDE
Wie siehts aus? Jetzt vielleicht LUST auf mehr ??Gruß, CNC-Master