Dialogregie

Nach langer Pause haben Sie nun den siebten Teil des Bash-Kurses in der Programming Corner vorliegen. Zum Abschluss beschäftigen wir uns mit den Möglichkeiten, Eingaben vom Benutzer abzufragen oder Ausgaben übersichtlich auf den Bildschirm zu bringen. Zudem werden Sie viele Problemstellungen aus den bisherigen Folgen wieder finden, die noch einmal wiederholt und in einem größeren Zusammenhang angewendet werden. Die Teile 1-6 der Programming Corner finden Sie vollständig auf der Heft-CD.

Dieser letzte Teil der Bash-Programmierung ist aber gleichzeitig der erste Teil der neuen Programming Corner: Ab jetzt werden wir uns in loser Folge mit dem Zusammenspiel der Bash mit externen Programmen beschäftigen und auch andere Programmiersprachen vorstellen.

Das Abschlussprojekt ist ein Terminwarner, der zum Beispiel zur Geburtstagserinnerung eingesetzt werden kann. Nach Einrichten des Server-Teils mittels Cron-Job erhält man tägliche Vorwarn-Mails, bis der Termin verstrichen oder gelöscht ist.

Zur Installation des Terminwarners kopieren Sie die beiden Skripte termin-client und termin-server von der Heft-CD nach /usr/local/bin. Zudem müssen Sie dialog, kdialog oder gdialog installiert haben. Wir empfehlen derzeit gdialog von Gnome, das grafische Frontend lässt sich damit am einfachsten bedienen. Wer ansonsten keine Gnome-Programme verwendet sollte bedenken, dass gdialog aus dem Paket gnome-utils einige Gnome-Bibliotheken benötigt, die gegebenenfalls zusätzlich nachinstalliert werden müssen.

Aufbau der Terminliste

Die eingegebenen Termine werden in der Datei ~/.termine im jeweiligen Heimatverzeichnis des Benutzers gespeichert. In der ersten Zeile steht die Mail-Adresse, an die Terminwarnungen verschickt werden sollen, in allen weiteren steht ein Termin pro Zeile. Jede Terminzeile hat fünf Felder, die durch Tabulatoren voneinander getrennt sind: Datum, Vorwarnzeit in Tagen, Betreff, Beschreibung und zusätzliche Mail-Adressen (CC-Adressen). Einzige Besonderheit: Das Datum wird im Format Jahr, Monat, Tag ohne Leer- oder Trennzeichen gespeichert; Weihnachten wäre in dieser Darstellung 20021224. In dieser Schreibweise braucht man die Terminzeilen lediglich numerisch sortieren zu lassen, um auch eine Sortierung in aufsteigender Datumsfolge zu erreichen.

Termin-Server einrichten

Das Programm termin-server kündigt die Termine rechtzeitig per Mail an, wenn es täglich aufgerufen wird - am Besten durch einen Cron-Job des Benutzers. Mit dem Kommando crontab können Sie einen solchen Job als normaler Benutzer eintragen. Vorher sollten Sie mittels EDITOR-Variable den von Ihnen bevorzugten Editor angeben:

export EDITOR="kedit"
crontab -e

Im Editor tragen Sie nun die Befehlszeile für Cron ein. Das folgende Beispiel zeigt einen Aufruf täglich um 12 Uhr mittags. Da der Rechner zu diesem Zeitpunkt laufen muss, damit der Cron-Job überhaupt abgearbeitet wird, sollten Sie die Uhrzeit an Ihre Gewohnheiten anpassen:

0 12 @L: * @L: * @L: *     /usr/local/bin/termin-server

Server im Detail

In Listing 1 finden Sie den termin-server aufgeschlüsselt. Aus Platzgründen haben wir die Kommentare, die in den Skripten auf der CD selbstverständlich enthalten sind, für den Abdruck entfernt und die Zeilen durchnumeriert.

Der Mail-Versand an den Benutzer erfolgt in der Funktion TerminWarnung von Zeile 3 bis 12. Die Funktion erwartet sechs Parameter. Als erstes muss die Mail-Adresse des Empfängers und dann alle fünf aufgeschlüsselten Felder der betreffenden Terminzeile übergeben werden. Der Versand erfolgt in Zeile 9 bis 11 über das Programm mail, ein rudimentäres Mail-Programm, das sich hervorragend über Skripte steuern lässt. Sind beim Termin zusätzliche Mail-Adressen angegeben, stehen diese in $6 und müssen in der Form -c Adresse,Adresse,... als Parameter an mail übergeben werden. Dementsprechend wird in Zeile 6 der Parameter für mail aufgebaut und in Zeile 9 gleich als erstes angehängt.

Die Zeilen 9 bis 11 enthalten noch weitere Besonderheiten: So wird das Datum, bei Übergabe in $2 gespeichert, mittels date-Aufruf in die in Deutschland übliche Schreibweise mit Wochentag, Tag, Monat und Jahr gebracht. Die ausführliche Beschreibung des Termins wird über den Eingabeblock "<< EOF … EOF" an mail weitergereicht. Prinzipiell ginge dies auch per echo und Pipe, beim Eingabeblock brauchen wir uns aber nicht um das Escapen von Anführungszeichen oder Trennzeichen zu kümmern.

IFS zum Ersten

Bei Aufruf von termin-server wird die Funktion zunächst übersprungen, der erste Befehl steht in Zeile 14: Falls keine Terminliste existiert oder sie nicht lesbar ist, wird die Fehlermeldung aus Zeile 15 automatisch von Cron per Mail an den User verschickt.

In den Zeilen 18 bis 22 wird die Terminliste eingelesen, wobei die oft verkannte Variable IFS eine entscheidende Rolle spielt: Mit dieser Variablen wird festgelegt, welche Zeichen die Bash als Trennung von Zeilen, Elementen oder Parametern interpretiert. Standardmäßig sind das Leerzeichen, Tabulatoren ('\t') und Zeilenumbrüche ('\n'). Dies gilt auch für das Einlesen von Arrays per read - Leerzeichen und Tabulatoren werden als Trenner der einzelnen Elemente der Zeile und Zeilenumbrüche als Abschluss einer Zeile interpretiert.

Unsere Terminliste soll zunächst komplett eingelesen und zeilenweise in Arrays gespeichert werden. Da read nur bis zum ersten Zeilenumbruch arbeitet, müssen wir die Umbrüche ersetzen - in unserem Fall durch Returns ('\r'). Dies geschieht in Zeile 21, wobei durch das grep-Kommando zusätzlich noch Kommentare mit Raute am Anfang einer Zeile entfernt werden. Damit liest read zwar die ganze Datei, jedoch zunächst in eine einzelne Variable. Um jede Terminzeile in eine eigene Variable eines Arrays gespeichert zu bekommen, verwenden wir read -a, und setzen kurzerhand die Trenner-Variable IFS auf '\r'.

… und zum Zweiten

In Zeile 24 wird die Mail-Adresse des Benutzers gewonnen - sie steht in der ersten Zeile der Terminliste und bedarf keiner weiteren Behandlung. Anders die Terminzeilen, diese müssen wir erst noch in ihre Elemente zerlegen. Nach Zerlegung muss anhand von Datum und Vorwarnzeit geprüft werden, ob das aktuelle Datum zwischen Beginn der Vorwarnzeit und dem Termin liegt und gegebenenfalls die Mail verschickt werden. Das alles passiert in den Zeilen 26 bis 39.

Die while-Schleife in Zeile 30 arbeitet der Reihe nach alle Terminzeilen ab. In Zeile 32 erfolgt die Zerlegung der Terminzeile mittels set-Anweisung: die übergebenen Parameter werden in den Parameter-Variablen ($1, $2 usw.) gespeichert. Da unsere Elemente in jeder Terminzeile durch Tabulatoren getrennt sind, wird IFS in Zeile 26 auf Tabulator ('\t') gesetzt.

Vergangenheitsbewältigung

Für den Vergleich, ob das aktuelle Datum zwischen dem Termin und dem Beginn der Vorwarnzeit liegt, müssen wir zunächst das Datum der ersten Vorwarnung berechnen. Für Weihnachten und eine Vorwarnzeit von einer Woche ist das nicht weiter schwierig: Vom Tag des Termins, hier 24, brauchen wir lediglich den Vorwarnzeitraum, also 7 Tage, abzuziehen - heraus kommt, dass wir ab dem 17. des Monats warnen müssen. Wenn wir aber einen Termin am ersten März haben, der zwei Tage vorgewarnt werden soll, wird es komplex: Neben dem Monats-Umsprung müssen wir berechnen, ob wir ein Schaltjahr haben oder nicht.

Viel einfacher ist es, das Programm date für diesen Zweck zu verwenden. date kann Datumsformate in fast beliebiger Eingabeform erkennen und damit rechnen. Für unsere Zwecke ist die umgangssprachliche Formulierung der Datumsangabe interessant: Mit der Formulierung "20021224 7 days ago" berechnet date das Datum, das sieben Tage vor dem 24. Dezember 2002 liegt - unter Berücksichtigung aller Seiteneffekte wie Monatsgrenzen und Schaltjahre. Die Ausgabe erfolgt wieder im gepackten Datumsformat mit Jahr, Monat und Tag ohne Trennzeichen.

Der Verzicht auf Trennzeichen im gepackten Datumsformat ist begründet: So wird aus jedem Datum eine achtstellige Zahl, die sich mit herkömmlichen mathematischen Operatoren vergleichen lässt. Dass es sich hier tatsächlich um ein Datum handelt, brauchen wir beim Vergleich nicht zu berücksichtigen. In Zeile 35 erfolgt schließlich der Aufruf der Funktion TerminWarnung.

Termin-Client

Programmtechnisch deutlich aufwendiger ist der Termin-Client mit über 200 Zeilen Code. Das Listing 2 teilt sich in acht logische Blöcke: Die Anfangs-Definitionen (Zeile 2), fünf Funktionen (Zeile 20 bis 132), Einlesen der Terminliste (Zeile 136) und das Hauptmenü (Zeile 159).

Abbildung 1: Ein Programm, drei Frontends: dialog (oben), gdialog (links unten) und kdialog (rechts unten) werden fast identisch angesteuert, unterscheiden sich aber in Aussehen und Bedienung

In den Zeilen 2 bis 15 wird das zu verwendende Frontend festgelegt: gdialog von Gnome, kdialog von KDE oder das Text- und ncurses-basierte dialog. Letzteres ist das Ursprungs-Tool, das gdialog und kdialog nachbilden, eine ausführliche Beschreibung finden Sie auf Seite 78 des LinuxUser 11/2001 oder unter http://www.linux-user.de/ausgabe/2001/11/078-ootb/dialog-4.html. Leider ist kdialog nicht ganz kompatibel zu dialog: Auswahlen in Menüs liefert das KDE-Pendant über die Standard-Ausgabe (stdout), während dialog und gdialog althergebracht die Standard-Fehlerdatei (stderr) verwenden. Der Unterschied scheint klein, bedeutet in der Programmierung allerdings einigen Umstand, wenn die Auswahl wie üblich per Umleitung in eine Datei geschrieben wird:

dialog … 2>datei
gdialog … 2>datei
kdialog … 1>datei

Unglücklicherweise akzeptiert die Bash keine Variable an Stelle der Umleitung. Einzig mit der eval-Anweisung ist es möglich, die Umleitung flexibel zu gestalten. Deshalb wird in den Zeilen 2 bis 11 zunächst bestimmt, welches der Programme installiert ist und dementsprechend der Programmname und die passende Umleitung in Variablen gespeichert.

Die Funktionen

Die Funktion AuswahlMenue (Zeile 20 bis 59) zeigt, wie der Name schon sagt, ein Auswahl-Menü an. Der erste Parameter ist der Titel des Menüs, im zweiten sind die Tastenkürzel als Tabulator-getrennte Liste und im dritten schließlich die Beschreibung der einzelnen Menüpunkte wiederum mit Tabulatoren getrennt. Die Tastenkürzel aus dem zweiten Parameter werden zudem als Rückgabewert genutzt, wenn ein Menüpunkt ausgewählt wurde.

Wie schon vom Server bekannt werden die beiden Tabulator-getrennten Listen in den Zeilen 26 bis 34 und 36 bis 43 mit Hilfe der IFS aufgetrennt und in Arrays gespeichert. Das ist notwendig, weil alle drei Frontends eine andere Reihenfolge erwarten: Kürzel und Beschreibung stehen dort immer paarweise zusammen. Diese Reihenfolge wird in Zeile 45 bis 48 in der Variable Menu generiert.

Die Overhead-Variable in Zeile 50 wird nur für dialog benötigt. Einer der Parameter gibt die Größe des Menü-Rahmens an, und dort müssen Dinge wie Überschrift, innere Rahmen und OK- sowie Abbruch-Schaltfläche berücksichtigt sein. Der Wert wird einfach durch Ausprobieren ermittelt.

In Zeile 56 wird nun der Parameter-String für den Dialog-Aufruf zusammengebaut und in Zeile 57 mittels eval ausgeführt. Mit read in Zeile 58 wird die Ausgabe des jeweiligen Dialog-Programms in der Variablen REPLY gespeichert.

Die Funktionen TextEingabe, JaNein und Fehler sind unspektakulär, hier wird jeweils nur ein Dialog-Aufruf ausgeführt.

Termine bearbeiten

Auch TerminBearbeiten enthält wenig Neues: In Zeile 84 und 85 werden die Parameter-Listen für AuswahlMenue angelegt, die alle zum Bearbeiten eines Termin-Eintrags notwendigen Möglichkeiten enthalten (Abbildung 2). Ab Zeile 90 erfolgt die Auswertung der Auswahl.

Abbildung 2: Anpassen eines Termins: Mit dialog lassen sich Einstellungen sehr übersichtlich ändern, die Menüführung nimmt vielen unerfahrenen Benutzern die Angst vor der Kommandozeile

Beim Löschen eines Termins wird vom Benutzer noch einmal eine Bestätigung eingeholt, das eigentliche Entfernen des Termineintrags erfolgt in Zeile 100 bis 106 durch Aufrücken der dahinter stehenden Einträge. Diese Lösung ist nicht die eleganteste, da bei langen Listen sehr viele Einträge aufgerückt werde müssen, hier bleibt Raum für Ihre Verbesserungen. Als Tipp: Auch hier lässt sich mit der Variablen IFS und Tabulator-getrennten Listen viel machen.

Eine weitere Besonderheit steckt in der Datumsänderung. Leider erkennt date das Datum in der herkömmlichen Schreibweise als Tag, Monat und Jahr mit Punkten getrennt nicht. Deshalb erfolgt die Eingabe in unserem gepackten Format mit Jahr, Monat und Tag, unterteilt mit Minus. Es wird allerdings nicht geprüft, ob die Eingabe auch tatsächlich ein Datum ist. Die Rückwandlung übernimmt wiederum date für uns, indem wir als Ausgabe-Format das gepackte Datumsformat angeben.

Hauptprogramm

Das Einlesen der Termin-Liste unterscheidet sich kaum vom termin-server. Nur werden in den Zeilen 146 bis 150 die Daten in einzelne Arrays verpackt. Lässt sich die Liste nicht öffnen, wird eine leere angelegt und die lokale Mail-Adresse des Benutzers bestimmt.

In der Endlosschleife ab Zeile 159 wird das Hauptmenü generiert. Wie schon bei TerminBearbeiten werden Tastenkürzel und Beschreibung in separaten Variablen zusammengefasst und an AuswahlMenu übergeben. Beim Speichern wird so notwendig die Termin-Liste neu angelegt; ist sie nicht beschreibbar, wird entsprechend gewarnt. Das Speichern selbst geschieht in Zeile 179 bis 185: Nach der Mail-Adresse werden die einzelnen Terminzeilen geschrieben.

Finale

In den vergangenen sechs Folgen der Programming Corner haben wir Ihnen die Grundlagen der Bash-Programmierung gezeigt. Damit sind Sie gut gerüstet, um vielseitige Skripte für den Alltag zu schreiben. Zusammen mit einem ansprechenden Design, wie es die drei Dialog-Programme bieten, lassen sich auch umfangreiche Eingaben verständlich abfragen. Doch Shell-Programmierung ist mehr als nur Bash-Scripting: Erst mit dem schier unerschöpflichen Werkzeugkasten der GNU-Tools wird sie zu einer leistungsfähigen und vielseitigen Programmiersprache.

01  #!/bin/bash
02
03  TerminWarnung ()
04  {
05    if [ "$6" != "" ]; then
06      MailParm="-c $6"
07    fi
08
09    mail $MailParm -s "Termin am `date -d \"$2\" \"+%a, %d.%m.%Y\"`: ${4}" $1 << EOF
10  $5
11  EOF
12  }
13
14  if [ ! -r ~/.termine ]; then
15    echo "termin-server: Kann Termin-Liste nicht öffnen ($HOME/.termine)"
16  fi
17
18  IFS=$'\r'
19
20  read -a TerminListe << EOF
21  `grep -v "^#" ~/.termine | tr "\n" "$IFS"`
22  EOF
23
24  MailAdresse="${TerminListe[0]}"
25
26  IFS=$'\t'
27
28  i=1
29
30  while [ "${TerminListe[$i]}" != "" ]; do
31    set – ${TerminListe[$i]}
32
33    Vorwarnung="`date -d \"$1 $2 days ago\" +%Y%m%d`"
34    if [ "$Vorwarnung" -le "`date +%Y%m%d`" -a "$1" -ge "`date +%Y%m%d`" ]; then
35      TerminWarnung $MailAdresse $@L: *
36    fi
37
38    i=$[$i+1]
39  done

001  #!/bin/bash
002  if [ -n "`which gdialog 2>/dev/null`" ]; then
003    Dialog="`which gdialog`"
004    DialogRedirect="2>~/.termine.in"
005  elif [ -n "`which kdialog 2>/dev/null`" ]; then
006    Dialog="`which kdialog`"
007    DialogRedirect="1>~/.termine.in"
008  elif [ -n "`which dialog 2>/dev/null`" ]; then
009    Dialog="`which dialog`"
010    DialogRedirect="2>~/.termine.in"
011  else
012    echo "Sie benötigen dialog, kdialog oder gdialog,"
013    echo "um dieses Programm benutzen zu können."
014    exit 1
015  fi
016
017  COLUMNS=80
018  LINES=24
019
020  AuswahlMenue ()
021  {
022    Titel="\"$1\""
023    Tasten="$2"
024    Namen="$3"
025
026    IFS=$'\t'
027    set – $Tasten
028    i=1
029    while [ "$#" -gt "0" ]; do
030      Taste[$i]="\"$1\""
031      shift
032      i=$[$i+1]
033    done
034    Elemente="$i"
035
036    IFS=$'\t'
037    set – $Namen
038    i=1
039    while [ "$#" -gt "0" ]; do
040      Name[$i]="\"$1\""
041      shift
042      i=$[$i+1]
043    done
044
045    Menu=""
046    for ((i=1; $i<$Elemente; i=$[$i+1])); do
047      Menu="${Menu}${Taste[$i]}${IFS}${Name[$i]}${IFS}"
048    done
049
050    Overhead="7"
051    if [ "$[$Elemente+$Overhead]" -lt "$LINES" ]; then
052      DisplayLines="$[$Elemente+$Overhead]"
053    else
054      DisplayLines="$LINES"
055    fi
056    DialogParms="--menu $Titel $DisplayLines $[$COLUMNS-8] $[$Elemente-1] $Menu"
057    eval $Dialog $DialogParms $DialogRedirect
058    read < ~/.termine.in
059  }
060  TextEingabe ()
061  {
062    DialogParms="--inputbox \"$1\" 8 $[$COLUMNS-8] \"$2\""
063    eval $Dialog $DialogParms $DialogRedirect
064    read < ~/.termine.in
065    if [ "$REPLY" = "" ]; then
066      REPLY="$2"
067    fi
068  }
069  JaNein ()
070  {
071    DialogParms="--yesno \"$1\" 5 $[$COLUMNS-8]"
072    eval $Dialog $DialogParms $DialogRedirect
073  }
074  Fehler ()
075  {
076    DialogParms="--msgbox \"$1\" 5 $[$COLUMNS-8]"
077    eval $Dialog $DialogParms $DialogRedirect
078  }
079  TerminBearbeiten ()
080  {
081    Nr="$1"
082
083    while true; do
084      Keys="d${IFS}v${IFS}b${IFS}t${IFS}c${IFS}l${IFS}z${IFS}"
085      Menu="Datum: `date -d ${Datum[$Nr]} +%d.%m.%Y`${IFS}Vorwarnung: ${Vorwarnzeit[$Nr]} Tage${IFS}Betreff: ${Bezeichnung[$Nr]}${IFS}Text: ${Text[$Nr]}${IFS}CCs: ${CCs[$Nr]}${IFS}Löschen${IFS}Zurück"
086
087      AuswahlMenue "Termin bearbeiten:" "$Keys" "$Menu"
088      Auswahl="$REPLY"
089
090      case $Auswahl in
091        z|"")
092          break
093          ;;
094        l)
095          JaNein "Termin löschen: Sind Sie sicher?"
096
097          if [ "$?" = "0" ]; then
098            Termine=$[$Termine-1]
099
100            for ((i=$Nr; $i < $Termine; i=$[$i+1])); do
101              Datum[$i]=${Datum[$[$i+1]]}
102              Vorwarnzeit[$i]=${Vorwarnzeit[$[$i+1]]}
103              Bezeichnung[$i]=${Bezeichnung[$[$i+1]]}
104              Text[$i]=${Text[$[$i+1]]}
105              CCs[$i]=${CCs[$[$i+1]]}
106            done
107          fi
108          break
109          ;;
110        d)
111          TextEingabe "Datum, in der Form yyyy-mm-dd:" "`date -d ${Datum[$Nr]} +%Y-%m-%d`"
112          Datum[$Nr]="`date -d $REPLY +%Y%m%d`"
113          ;;
114        v)
115          TextEingabe "Vorwarnzeit in Tagen:" "${Vorwarnzeit[$Nr]}"
116          Vorwarnzeit[$Nr]="$REPLY"
117          ;;
118        b)
119          TextEingabe "Kurze Bezeichnung des Termins:" "${Bezeichnung[$Nr]}"
120          Bezeichnung[$Nr]="$REPLY"
121          ;;
122        t)
123          TextEingabe "Ausführliche Beschreibung, Anmerkungen:" "${Text[$Nr]}"
124          Text[$Nr]="$REPLY"
125          ;;
126        c)
127          TextEingabe "Zusätzliche Empfänger der Warnung (Komma-Trennung):" "${CCs[$Nr]}"
128          CCs[$Nr]="$REPLY"
129          ;;
130      esac
131    done
132  }
133
134  ##### Hauptprogramm #####
135
136  if [ -r ~/.termine ]; then
137    IFS=$'\r'
138    read -a TerminListe << EOF
139  `grep -v "^#" ~/.termine | tr "\n" "$IFS"`
140  EOF
141
142    IFS=$'\t'
143    i=1
144    while [ "${TerminListe[$i]}" != "" ]; do
145      set – ${TerminListe[$i]}
146      Datum[$i]=$1
147      Vorwarnzeit[$i]=$2
148      Bezeichnung[$i]=$3
149      Text[$i]=$4
150      CCs[$i]=$5
151      i=$[$i+1]
152    done
153    Termine="$i"
154  else
155    MailAdresse="${LOGNAME}@localhost"
156    Termine=1
157  fi
158
159  while true; do
160    IFS=$'\t'
161    Keys="0${IFS}\$Keys${IFS}n${IFS}q${IFS}x${IFS}"
162    Menu="Adresse:  ${MailAdresse}\$Menu${IFS}Neuer Termin${IFS}Speichern und Ende${IFS}Ende ohne Speichern"
163    for ((i=1; $i < $Termine; i=$[$i+1])); do
164      Keys="${Keys/\$Keys/${IFS}$i\$Keys}"
165      Menu="${Menu/\$Menu/${IFS}`date -d ${Datum[$i]} +%d.%m.%Y`: ${Bezeichnung[$i]}\$Menu}"
166    done
167    Keys="${Keys/\$Keys}"
168    Menu="${Menu/\$Menu}"
169
170    AuswahlMenue "Hauptmenü" "$Keys" "$Menu"
171    Auswahl="$REPLY"
172
173    case $Auswahl in
174      q)
175        if [ ! -e ~/.termine ]; then
176          touch ~/.termine 2>/dev/null
177        fi
178        if [ -w ~/.termine ]; then
179          echo "$MailAdresse" > ~/.termine
180          IFS=$'\t'
181          for ((i=1; $i < $Termine; i=$[$i+1])); do
182            cat >> ~/.termine << EOF
183  ${Datum[$i]}${IFS}${Vorwarnzeit[$i]}${IFS}${Bezeichnung[$i]}${IFS}${Text[$i]}${IFS}${CCs[$i]}
184  EOF
185          done
186          break
187        else
188          Fehler "Die Termine-Datei (~/.termine) lässt sich nicht schreiben."
189        fi
190        ;;
191      x|"")
192        exit 1
193        ;;
194      n)
195        Datum[$Termine]="`date +%Y%m%d`"
196        Vorwarnzeit[$Termine]="2"
197        Bezeichnung[$Termine]=""
198        Text[$Termine]=""
199        CCs[$Termine]=""
200        Termine=$[$Termine+1]
201        TerminBearbeiten $[$Termine-1]
202        ;;
203      0)
204        TextEingabe "Ihre Email-Adresse:" "$MailAdresse"
205        MailAdresse="$REPLY"
206        ;;
207      @L: *)
208        TerminBearbeiten $Auswahl
209        ;;
210    esac
211  done