sh(1) sh(1)
NAME
sh, bg, break, chdir, continue, fg, jobs, return, stop, suspend - Kom-
mandointerpreter und Programmiersprache Bourne-Shell
SYNTAX
sh [option ...] [datei] [argument ...]
BESCHREIBUNG
Die Beschreibung der Bourne-Shell gliedert sich in drei Teile:
⊕ Das Kommando sh
- Login-Shell und Subshell
- Optionen
⊕ Die Shell als Kommandointerpreter
- Kommandos eingeben und verknüpfen
- Sonderzeichen der Shell
- Shell-Variablen
- Umgebung
- Shell-Parameter
- Kommandos durch ihre Ausgabe ersetzen
- Eingabe und Ausgabe eines Kommandos umlenken
- Argumente durch passende Dateinamen ersetzen
- Wie bearbeitet die Shell die Kommandozeile?
⊕ Die Shell als Programmiersprache
- Kommentare in Shell-Prozeduren
- Shell-Funktionen
- Ablaufanweisungen der Shell
DAS KOMMANDO SH
Die Shell ist die Benutzerschnittstelle zum Betriebssystem-Kern. Sie
ist als Reliant UNIX Kommando implementiert und kein Bestandteil des
Kerns; die Shell und alle anderen Reliant UNIX Kommandos kommunizieren
mit dem Kern über Systemaufrufe.
Seite 1 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Die Shell sh ist eine Version der Bourne-Shell.
- Sie liest Eingaben vom Terminal oder aus einer Datei, interpretiert
sie nach bestimmten Regeln und sorgt für die Ausführung. Eine
Datei, die Eingaben für die Shell enthält, heißt Shell-Prozedur.
- Die Shell läßt sich wie eine Programmiersprache anwenden. Sie kön-
nen also mit den vorhandenen Reliant UNIX Kommandos eigene Pro-
gramme erstellen und ohne vorheriges Übersetzen ausführen.
Login-Shell
Diese Shell wird standardmäßig von login(1) gestartet, wenn Sie sich
an einem Terminal angemeldet haben. Die Login-Shell ist mit dem aufru-
fenden Terminal verbunden, d. h. die Dateikennzahlen 0 für Standard-
eingabe, 1 für Standardausgabe und 2 für Standardfehlerausgabe bezie-
hen sich auf dieses Terminal. Bevor die Login-Shell ihr Bereitzeichen
ausgibt, passiert der Reihe nach folgendes:
- Die Login-Shell weist den Shell-Standard-Variablen HOME, IFS, MAIL,
MAILCHECK, PATH, PS1, PS2 und SHELL Standardwerte zu (siehe SHELL-
VARIABLEN unten).
- Die Datei /etc/profile wird ausgeführt.
- Die Datei $HOME/.profile wird ausgeführt, falls Sie diese Datei
angelegt haben.
Sie können sich nur in einer Login-Shell mit dem eingebauten sh-Kom-
mando login(1) neu am System anmelden. Allerdings ist auch hier nur
eine Anmeldung unter der root-Kennung möglich.
Ob eine Login-Shell gestartet ist, erkennen Sie folgendermaßen: Das
Kommando echo $0 gibt den Aufrufnamen der aktuellen Shell aus. Die
Ausgabe -sh bezeichnet eine Login-Shell, die Ausgabe sh eine Subshell.
Eine Login-Shell wird als Subshell gestartet, wenn Sie sich mit
/bin/login neu am System anmelden (siehe Subshell unten).
Die Login-Shell beenden Sie mit CTRL-D. Wenn die Login-Shell keine
Subshell war, wird anschließend der Begrüßungsbildschirm ausgegeben,
Ihre Sitzung ist also beendet.
Subshell
Mit sh rufen Sie eine neue Shell, eine sogenannte Subshell, auf. Diese
Shell ist demselben Terminal zugeordnet wie die aufrufende Shell;
außerdem erbt sie alle Shell-Variablen, die Sie in einer übergeordne-
ten Shell definiert und exportiert haben [siehe export(1) und Option
-a]. Sie können Shell-Variablen von der aktuellen Shell nur an Sub-
shells weiterreichen, aber nicht an die übergeordnete Shell.
Seite 2 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Im Gegensatz zur Login-Shell führt die Subshell die Dateien
/etc/profile und $HOME/.profile nicht aus. Sie können in einer Sub-
shell Shell-Variablen definieren oder ändern bzw. das Verzeichnis
wechseln, ohne daß dies die übergeordnete Shell beeinflußt. Wenn sich
die Subshell beendet, meldet sich die vorherige Shell in dem "Zustand"
zurück, in dem sie die Subshell gestartet hat.
In einer Subshell wird das eingebaute sh-Kommando login abgewiesen.
Sie können sich nur in einer Login-Shell mit login neu am System
anmelden.
Mit sh können Sie den Ablauf der neuen Subshell steuern, entsprechend
den Optionen, die Sie beim Aufruf angeben. Wenn Sie einen Dateinamen
angeben, beendet sich die Subshell nach der Ausführung dieser Datei.
Ist kein Dateiname angegeben, ist die Subshell interaktiv, d. h. sie
liest solange die Eingaben vom Terminal, bis Sie sie mit CTRL-D been-
den. Eine Shell, die eine Shell-Prozedur ausführt, ist nicht interak-
tiv (siehe auch Option -i).
OPTIONEN
Kein Operand angegeben:
Eine Subshell mit der Option -s wird aufgerufen. Der zuvor aktu-
elle Shell-Prozeß wird zum Vater der neuen Shell. Diese Shell
können Sie mit CTRL-D beenden.
Keine Option angegeben:
Wenn Sie sh mit Operanden aufrufen, die keine Optionen sind, dann
müssen Sie als ersten Operanden datei angeben. Dabei ist datei
der Name einer Shell-Prozedur, für die Sie Leserecht haben müs-
sen.
Eine Subshell wird aufgerufen, die die Kommandos dieser Shell-
Prozedur der Reihe nach abarbeitet und sich anschließend wieder
beendet.
option steuert den Ablauf der aufgerufenen Subshell.
Wenn Sie mehrere Optionen angeben wollen, müssen Sie die entsprechen-
den Buchstaben ohne Leerzeichen aneinanderhängen. Das Minuszeichen -
darf nur vor dem ersten Buchstaben stehen.
Die Option -- können Sie nicht mit anderen Optionen kombinieren.
Die Option -c kommando kann nur als letzte Option angegeben werden,
bei den übrigen Optionen ist die Reihenfolge beliebig.
Wenn Sie den Ablauf der aktuellen Shell steuern wollen, verwenden Sie
das eingebaute sh-Kommando set(1).
Seite 3 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Es gibt zwei Arten von Optionen:
- Optionen, die Sie nur bei sh angeben können
- Optionen, die Sie auch beim eingebauten sh-Kommando set angeben
können [siehe auch set(1)].
Optionen nur für sh
-c kommando
(c - command) Die Subshell führt kommando aus und beendet sich.
Diese Option muß die letzte der beim Aufruf angegebenen Optionen
sein. Auf -c kommando darf kein weiterer Operand folgen.
Mit der Option -c kommando können Sie Kommandos innerhalb eines
C-Programms aufrufen.
Sie müssen kommando angeben, sonst erhalten Sie eine Fehlermel-
dung.
kommando
muß ein Aufrufargument sein. Enthält kommando Leer- oder
Tabulatorzeichen, müssen Sie es in Anführungszeichen "..."
oder Hochkommata '...' einschließen. Andernfalls interpre-
tiert die Shell die Eingabe nur bis zum ersten Leerzeichen.
kommando ist ein Kommando oder eine ausführbare Shell-
Prozedur, für die Sie das Lese- und Schreibrecht benötigen.
kommando wird in der aufgerufenen Subshell ausgeführt.
Wenn Sie mehrere Kommandos oder Shell-Prozeduren angeben
wollen, müssen Sie die entsprechenden Kommando-Trennzeichen
entwerten.
Wenn Sie das Kommando oder die Shell-Prozedur mit dem einfa-
chen Dateinamen aufrufen, sucht die Shell diese Datei in den
Verzeichnissen, deren absolute Pfadnamen der Variablen PATH
zugewiesen sind.
-i (i - interactive) eine interaktive Subshell (Dialog-Shell) wird
aufgerufen. Diese Shell liest Ihre Eingaben von der Standardein-
gabe, bearbeitet die Eingabe, startet die entsprechenden Komman-
dos und wartet auf deren Beendigung. Dann gibt sie ihr Bereitzei-
chen aus und bearbeitet weitere Eingaben. Auf die Signale 2 für
SIGINT, 3 für SIGQUIT und 15 für SIGTERM reagiert eine interak-
tive Shell wie folgt (PID steht im folgenden für die Prozeßnummer
der interaktiven Shell):
Seite 4 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
__________________________________________________________________
| Signal | erzeugt mit | interaktive Shell |
|_________|_______________|_______________________________________|
| | DEL | Kommando läuft: ignorieren, d. h. |
| SIGINT | kill -2 PID | eine interaktive Shell wird nicht |
| | | beendet. |
| | | Sonst: neues Bereitzeichen ausgeben |
|_________|_______________|_______________________________________|
| | CTRL-\ | Kommando läuft: ignorieren, d. h. |
| SIGQUIT | kill -3 PID | eine interaktive Shell wird nicht |
| | | beendet. |
| | | Sonst: neues Bereitzeichen ausgeben |
|_________|_______________|_______________________________________|
| SIGTERM | kill -15 PID | ignorieren |
|_________|_______________|_______________________________________|
Mit der Option -i können Sie innerhalb eines C-Programms eine
interaktive Shell aufrufen.
-i nicht angegeben:
Eine Shell ist standardmäßig interaktiv, wenn ihre Standardein-
gabe, -ausgabe und -fehlerausgabe einem Terminal zugeordnet sind.
Eine Shell, die eine Shell-Prozedur ausführt, ist hingegen nicht
interaktiv. Diese Prozedur-Shell reagiert auf die Signale SIGINT,
SIGQUIT und SIGTERM (wenn diese mit kill -2, kill -3 und kill -15
verschickt werden) wie folgt:
_________________________________________________________________
| Signal | Prozedur-Shell | Prozedur-Shell &|
|_________|___________________________________|__________________|
| SIGINT | auf Beendigung des laufenden Kom-| ignorieren |
| | mandos warten, dann abbrechen | |
|_________|___________________________________|__________________|
| SIGQUIT | auf Beendigung des laufenden Kom-| ignorieren |
| | mandos warten, dann abbrechen | |
|_________|___________________________________|__________________|
| SIGTERM | auf Beendigung des laufenden Kom-| ignorieren |
| | mandos warten, dann abbrechen | |
|_________|___________________________________|__________________|
-p (p - privileged) Die aufgerufene Shell setzt die effektive
Benutzer- und Gruppennummer nicht auf die reale Benutzer- und
Gruppennummer (also die des Aufrufers), sondern auf ihre eigene
Benutzer- und Gruppennummer.
-r (r - restricted shell) Eine eingeschränkte Subshell wird aufgeru-
fen. In dieser Shell gelten folgende Einschränkungen:
Seite 5 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
- Das eingebaute sh-Kommando cd wird abgewiesen, d. h. Sie kön-
nen Ihr aktuelles Verzeichnis nicht verlassen.
- Sie können den Wert der Variablen PATH nicht ändern.
- Kommandos werden abgewiesen, wenn der Name der zugehörigen
Kommando-Datei einen Schrägstrich / enthält. Sie können also
nur solche Kommandos ausführen, die in Ihrem aktuellen Ver-
zeichnis stehen oder in den Verzeichnissen, deren Pfade der
Shell-Variablen PATH zugewiesen wurden.
- Kommandos werden abgewiesen, wenn der Aufruf die Zeichen >
oder >> enthält. Die Ausgabe von Kommandos kann also nicht mit
> oder >> in eine Datei umgelenkt werden.
Eine eingeschränkte Subshell können Sie nur mit sh -r aufrufen.
Dagegen rufen Sie mit rsh eine Shell an einem fernen Rechner auf
und nicht, wie in früheren Versionen von UNIX, eine einge-
schränkte Shell.
Nur für den Systemverwalter
Als Systemverwalter können Sie eine Arbeitsumgebung für sol-
che Benutzer einrichten, die nur mit der eingeschränkten
Shell arbeiten sollen. Sie legen für diese Benutzer fest:
- In welchem Verzeichnis sie arbeiten sollen.
Die Benutzer sollten nicht im Login-Verzeichnis arbeiten,
sie sollten für das Login-Verzeichnis nur Leserecht
haben.
- Welche Kommandos sie ausführen dürfen.
Dazu können Sie ein Unterverzeichnis im Login-Verzeichnis
anlegen und die erlaubten Kommandos dorthin kopieren.
Es darf z. B. nicht möglich sein, eine Subshell aufzuru-
fen, denn die Subshell einer eingeschränkten Shell ist
nicht eingeschränkt.
- Die Variable PATH.
In der Datei $HOME/.profile tragen Sie die entsprechenden
Kommandos ein und rufen die eingeschränkte Shell auf. Wenn
die Login-Shell diese Datei ausgeführt hat, sollte der
Benutzer in seinem Arbeitsverzeichnis mit der eingeschränk-
ten Shell arbeiten.
-r nicht angegeben:
Für die aufgerufene Subshell gelten die beschriebenen Einschrän-
kungen nicht.
Seite 6 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
-s (s - standard input) Die aufgerufene Subshell liest von der Stan-
dardeingabe und schreibt auf die Standardfehlerausgabe. Die ein-
gebauten sh-Kommandos allerdings schreiben auf die Standardaus-
gabe.
Die aufgerufene Subshell versorgt die Stellungsparameter $1, $2,
... und $9 mit den ersten neun nach -s angegebenen Argumenten.
Die Shell-Parameter $* und $@ werden von der Subshell mit allen
nach -s angegebenen Argumenten versorgt und der Shell-Parameter
$# mit der Anzahl dieser Argumente. Sind weniger als neun Argu-
mente angegeben, werden die restlichen Stellungsparameter mit der
leeren Zeichenkette belegt.
Diese Werte sind nur der aufgerufenen Subshell bekannt. Wenn Sie
Stellungsparameter in der aktuellen Shell setzen wollen, verwen-
den Sie statt dessen das eingebaute sh-Kommando set(1).
Wenn Sie beim Aufruf außerdem datei angeben, versorgt die aufge-
rufene Subshell den Stellungsparameter $1 mit dem Aufrufargument
datei. Die in datei enthaltenen Kommandos werden also nicht aus-
geführt. Wenn Sie mit sh eine Shell-Prozedur ausführen wollen,
dürfen Sie die Option -s nicht angeben.
-s nicht angegeben:
-s wird standardmäßig gesetzt, wenn Sie sh ohne Operanden aufru-
fen.
Die Login-Shell wird immer mit -s aufgerufen.
Optionen für sh und set
-a (a - automatic) In der aufgerufenen Subshell werden automatisch
alle Shell-Variablen exportiert, die Sie neu definieren oder
denen Sie einen anderen Wert zuweisen.
In dieser Subshell setzt set +a die Option -a zurück.
-a nicht angegeben:
Neu definierte oder geänderte Shell-Variablen werden in der auf-
gerufenen Subshell nicht automatisch exportiert. Nur wenn Sie
eine Shell-Variable mit dem eingebauten sh-Kommando export(1)
exportieren, ist sie in einer weiteren Subshell bekannt.
-e (e - exit) Die aufgerufene Subshell bzw. Shell-Prozedur wird
sofort beendet, wenn ein Kommando einen Endestatus ungleich 0
zurückgibt.
In dieser Subshell setzt set +e die Option -e zurück.
Seite 7 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
-e nicht angegeben:
Ist die aufgerufene Subshell interaktiv, können Sie sie mit
CTRL-D beenden. Ist die aufgerufene Shell eine Prozedur-Shell,
wird sie nur dann vorzeitig beendet, wenn sie einen Syntaxfehler
entdeckt. Andernfalls wird die Prozedur-Shell erst beendet, wenn
das letzte Kommando ausgeführt ist, unabhängig vom Endestatus der
einzelnen Kommandos.
-f (f - file name) In der aufgerufenen Subshell bzw. Shell-Prozedur
verlieren die Zeichen Stern * sowie Fragezeichen ? sowie [...]
ihre Sonderbedeutung. Das heißt, daß die entsprechenden Zeichen-
ketten nicht durch passende Dateinamen ersetzt werden.
In dieser Subshell setzt set +f die Option -f zurück.
-f nicht angegeben:
Entsprechende Zeichenketten werden durch passende Dateinamen
ersetzt.
-h (h - hash) Die aufgerufene Subshell ändert ihr Verhalten bei der
Definition von Shell-Funktionen (siehe Beispiel 2):
Wenn Sie in der aufgerufenen Subshell eine Shell-Funktion defi-
nieren, trägt die Shell bereits alle innerhalb der Funktion ver-
wendeten Kommandos in die Hash-Tabelle ein [siehe hash(1)].
In dieser Subshell setzt set +h die Option -h zurück.
-h nicht angegeben:
Die innerhalb einer Shell-Funktion verwendeten Kommandos werden
erst dann in die Hash-Tabelle eingetragen, wenn die Shell-
Funktion ausgeführt wird.
-k (k - keyword) In der aufgerufenen Subshell können Sie Variablen-
Zuweisungen, also Angaben der Form name=wert, beim Aufruf eines
Kommandos an beliebiger Stelle in der Kommandozeile angeben. Die
aufgerufene Subshell führt die Variablen-Zuweisung aus und trägt
den entsprechenden Schlüsselwort-Parameter in die Ablauf-Umgebung
dieses Kommandos ein.
In dieser Subshell setzt set +k die Option -k zurück.
-k nicht angegeben und noch nicht gesetzt:
Variablen-Zuweisungen müssen vor dem Kommandonamen stehen. Die
Shell trägt die entsprechenden Schlüsselwort-Parameter in die
Ablauf-Umgebung dieses Kommandos ein.
Seite 8 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
-n (n - no execution) Die aufgerufene Subshell liest und interpre-
tiert alle Kommandos, führt sie aber nicht aus; d. h. der letzte
Schritt bei der Bearbeitung einer Kommandozeile entfällt (siehe
WIE BEARBEITET DIE SHELL DIE KOMMANDOZEILE? unten).
Mit -n können Sie feststellen, ob eine Shell-Prozedur Syntaxfeh-
ler enthält (siehe Beispiel 1).
Vorsicht:
Die Option -n wird nur dann zurückgesetzt, wenn sich die
Subshell beendet.
-n nicht angegeben:
Alle Kommandos werden gelesen, interpretiert und ausgeführt.
-t (t - terminate) Die aufgerufene Subshell beendet sich, wenn die
erste Kommandozeile ausgeführt ist.
Wenn Sie sh -t ohne den Operanden datei aufrufen, erwartet die
Subshell in der nächsten Zeile das Kommando, das ausgeführt wer-
den soll. Dabei wird kein Bereitzeichen ausgegeben.
-t nicht angegeben:
Eine Dialog-Shell beendet sich, wenn Sie CTRL-D drücken.
Eine Prozedur-Shell beendet sich nur dann vorzeitig, wenn sie
einen Syntaxfehler entdeckt. Andernfalls beendet sie sich, wenn
die Shell-Prozedur abgearbeitet ist.
Vorsicht:
Falls die Option -e gesetzt ist, beendet sich die Shell,
sobald ein Kommando einen Endestatus ungleich 0 zurückgibt.
-u (u - unset) Die aufgerufene Subshell gibt eine Fehlermeldung aus,
wenn sie in einer Kommandozeile auf eine Shell-Variable trifft,
die nicht definiert ist. Das entsprechende Kommando wird nicht
ausgeführt.
Shell-Prozeduren werden abgebrochen, sobald die Subshell auf eine
nicht definierte Shell-Variable trifft.
In dieser Subshell setzt set +u die Option -u zurück.
-u nicht angegeben:
Die Subshell gibt keine Fehlermeldung aus, wenn eine verwendete
Shell-Variable nicht definiert ist. Standardmäßig wird die leere
Zeichenkette als Wert eingesetzt.
Seite 9 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
-v (v - verbose) Die aufgerufene Subshell schreibt ab sofort jede
Eingabe ohne Änderungen auf die Standardfehlerausgabe. Erst dann
wird das entsprechende Kommando ausgeführt (siehe Beispiel 1).
Zusammen mit der Option -x könnnen Sie so Shell-Prozeduren
testen.
In dieser Subshell setzt set +v die Option -v zurück.
-v nicht angegeben:
Die aufgerufene Subshell protokolliert die Eingabe nicht.
-x (x - execute) Die aufgerufene Subshell interpretiert die Eingabe
und schreibt sie auf die Standardfehlerausgabe. Jedes so bearbei-
tete Kommando kennzeichnet die Shell mit einem Pluszeichen + am
Zeilenanfang. Besteht ein eingegebenes Kommando nur aus Variab-
len-Zuweisungen, so wird es ohne + auf die Standardfehlerausgabe
geschrieben. Anschließend wird das entsprechende Kommando ausge-
führt.
Im Gegensatz zur Ausgabe bei Option -v erkennen Sie mit dieser
Ausgabe, wie die Shell die angegebenen Sonderzeichen und Shell-
Variablen ersetzt hat.
Shell-Prozeduren können Sie also wie folgt testen:
- Führen Sie die entsprechende Shell-Prozedur aus mit dem Kom-
mando sh -xv prozedur, oder
- tragen Sie set -xv als erstes Kommando in die entsprechende
Shell-Prozedur ein.
In dieser Subshell setzt set +x die Option -x zurück.
-x nicht angegeben:
Die aufgerufene Subshell protokolliert die bearbeitete Eingabe
nicht.
-- Diese Option kann nicht mit anderen Optionen kombiniert werden.
Das erste Argument, das Sie nach -- angeben, interpretiert die
Shell nicht als Option, auch wenn es mit einem Minuszeichen -
beginnt. Auf diese Weise können Sie mit sh eine Shell-Prozedur
ausführen, deren Namen mit einem Minuszeichen beginnt.
Hinweis: In früheren Versionen der Shell hatte die Angabe eines
einfachen Minuszeichen denselben Effekt, den jetzt die Angabe
eines doppelten Minuszeichen hat, nämlich das Ende der Optionen-
liste zu markieren. Heutzutage kann zwar weiterhin ein einfaches
Minuszeichen angegeben werden, es hat aber keine erkennbaren Aus-
wirkungen.
Seite 10 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
datei
Name der Shell-Prozedur, die von der Subshell ausgeführt werden
soll. Für diese Datei brauchen Sie Leserecht.
Auf die Option -c kommando darf kein weiterer Operand folgen.
Auch datei darf nicht angegeben werden.
Wenn Sie sh mit der Option -s aufrufen, versorgt die aufgerufene
Subshell den Stellungsparameter $1 mit datei. Die in datei ent-
haltenen Kommandos werden also nicht ausgeführt.
datei nicht angegeben:
Die aufgerufene Subshell gibt ihr Bereitzeichen aus und liest
Ihre Eingaben von der Standardeingabe. Diese Eingaben bearbeitet
die Subshell entsprechend den gesetzten Optionen.
argument
beliebige Zeichenkette, die jeweils durch Leer- oder Tabulator-
zeichen begrenzt wird. Das letzte Argument wird durch ein
Kommando-Trennzeichen abgeschlossen.
Sie können beliebig viele Argumente angeben, jeweils getrennt
durch mindestens ein Tabulator- bzw. ein Leerzeichen.
Die aufgerufene Subshell versorgt die Stellungsparameter $1, $2,
... und $9 mit den ersten neun angegebenen Argumenten. Die
Shell-Parameter $* und $@ werden von der Subshell mit allen ange-
gebenen Argumenten versorgt und den Shell-Parameter $# mit der
Anzahl dieser Argumente. Sind weniger als neun Argumente angege-
ben, werden die restlichen Stellungsparameter mit der leeren Zei-
chenkette belegt.
Mit shift können Sie das zehnte und weitere Aufrufargumente
direkt ansprechen.
Diese Werte sind nur der aufgerufenen Subshell bekannt. Wenn Sie
Stellungsparameter in der aktuellen Shell setzen wollen, verwen-
den Sie statt dessen das eingebaute sh-Kommando set(1).
argument nicht angegeben:
Die Stellungsparameter $1, $2, ..., $9 sowie die Shell-Parameter
$@, $* und $# werden mit der leeren Zeichenkette versorgt.
Seite 11 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
ENDESTATUS
ungleich 0
Die Shell hat einen Syntaxfehler in der Eingabe entdeckt. Wenn
die Shell beim Ausführen einer Shell-Prozedur einen Syntaxfehler
entdeckt, bricht sie die Ausführung sofort ab.
In allen anderen Fällen gibt die Shell den Endestatus des zuletzt aus-
geführten Kommandos zurück.
DATEIEN
/etc/profile
Datei, die von jeder Login-Shell ausgeführt wird. Sie dient zur
Einstellung einer Shell-Umgebung.
Diese Datei erstellt der Systemverwalter.
$HOME/.profile
Shell-Prozedur, die jeder Benutzer in seinem HOME-Verzeichnis
einrichten kann. Die Datei $HOME/.profile wird von der Login-
Shell nach /etc/profile ausgeführt.
/tmp/sh*
Temporäre Dateien.
/dev/null*
Leere Datei, auf die die Standardeingabe gelenkt wird, z. B. bei
Hintergrund-Kommandos.
UMGEBUNGSVARIABLEN
Siehe Standard-Variablen der Shell unten.
INTERNATIONALE UMGEBUNG
Die Umgebungsvariable LCMESSAGES bestimmt die Sprache der Meldungs-
texte.
In Mustern zur Dateinamensgenerierung bestimmt die Umgebungsvariable
LCCOLLATE die Bedeutung von Zeichenbereichen, Äquivalenzklassen und
Zeicheneinheiten, die Umgebungsvariable LCCTYPE die Bedeutung von
Zeichenklassen. LCCTYPE bestimmt zusätzlich, welche Zeichen des aktu-
ell gültigen Zeichensatzes als Buchstaben definiert sind.
Wenn LCMESSAGES, LCCOLLATE oder LCCTYPE nicht oder als leere Zei-
chenkette definiert ist, wird der Wert von LANG als Standardwert für
die jeweils nicht gesetzte oder leere Variable herangezogen. Ist auch
LANG nicht oder als leere Zeichenkette definiert, verhält sich das
System so, als wäre es nicht internationalisiert.
Die Umgebungsvariable LCALL bestimmt die gesamte internationale Umge-
bung. LCALL hat Vorrang vor allen anderen Umgebungsvariablen im
Bereich der Internationalisierung.
Seite 12 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Hat eine der Variablen für die internationale Umgebung einen ungülti-
gen Wert, verhält sich das System so, als wäre keine Variable gesetzt.
Vorsicht:
Es hängt vom aktuellen Zeichensatz und von der aktuell gültigen
Sortierreihenfolge ab, welche Zeichen ein Bereich [c1-c2] umfaßt.
Zum Beispiel löscht das Kommando rm [a-z]* in der Umgebung
LANG=LCCOLLATE=EnUS.ASCII alle Dateien, deren Name mit einem
Kleinbuchstaben von a bis z beginnt. In manchen Umgebungen dage-
gen enthält der Bereich a-z auch Großbuchstaben; in diesem Fall
löscht das obige Kommando auch Dateien, deren Name mit einem
Großbuchstaben beginnt. Andererseits gibt es in manchen Sprachen,
wie z. B. der norwegischen, Kleinbuchstaben, die nach z einsor-
tiert sind. Stellen Sie deshalb in einer internationalen Umgebung
Zeichenklassen wie, z. B. Kleinbuchstaben, mit dem Ausdruck
[:klasse:] dar; der obige rm-Aufruf würde dann lauten: rm
[[:lower:]]*.
Shell-Prozeduren, die in nicht-internationalisierten Umgebungen
(oder in Mißachtung der geschilderten Gefahren) erstellt wurden,
sollten in einer nicht-internationalisierten Umgebung ausgeführt
werden, d. h. die NLS-Variablen LANG, LCCOLLATE usw. sollten
undefiniert oder leer sein.
BEISPIELE
Beispiel 1
In einer neu erstellten Shell-Prozedur sollen Syntaxfehler gesucht
werden, ohne daß die Kommandos ausgeführt werden. Die Shell-Prozedur
syntax hat folgenden Inhalt:
: # Aufruf mit sh syntax
set `echo *`
echo `pwd`:
ll {
ls -al $* | pg
}
Die Definition der Shell-Funktion ll ist fehlerhaft: die runden Klam-
mern fehlen. Diesen Syntaxfehler meldet die Shell bei folgendem Aufruf:
$ sh -nv syntax
set `echo *`
echo `pwd`:
ll {
ls -al $* | pg
}
syntax: syntax error at line 6: `}' unexpected
Da auch die Option -v gesetzt wird, gibt die Shell zusätzlich jede
gelesene Kommandozeile aus. Die einzelnen Kommandos werden nicht aus-
geführt.
Seite 13 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Beispiel 2
Die Kommandos einer Shell-Funktion sollen bereits bei der Definition
dieser Shell-Funktion in die Hash-Tabelle eingetragen werden:
$ sh -h
$ ll() {
ls -al $* | pg
}
$ hash
hits cost command
0 2 /usr/bin/pg
0 1 /bin/ls
.
.
.
In der aufgerufenen Subshell ist die Option -h gesetzt. Deshalb werden
die Kommandos ls und pg gleich bei der Definition der Shell-Funktion
ll in die Hash-Tabelle eingetragen [siehe hash(1)].
DIE SHELL ALS KOMMANDOINTERPRETER
Dieser Abschnitt ist wie folgt gegliedert:
⊕ Kommandos eingeben und verknüpfen
- Pipelines
- Kommandofolgen
- Kommandofolgen klammern
- Eingebaute Shell-Kommandos
⊕ Sonderzeichen der Shell
⊕ Shell-Variablen
- Eine Shell-Variable definieren
- Auf den Wert einer Variablen zugreifen
- Standard-Variablen der Shell
⊕ Die Umgebung
- Die Umgebung eines Kommandos beim Start
- Die Ablauf-Umgebung der aktuellen Shell
Seite 14 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
⊕ Shell-Parameter
- Shell-Parameter durch einen Wert ersetzen
- Standardwerte für Shell-Parameter vereinbaren
⊕ Kommandos durch ihre Ausgabe ersetzen
⊕ Eingabe und Ausgabe eines Kommandos umlenken
- Die Standardeingabe für ein Kommando umlenken
- Die Standardausgabe für ein Kommando umlenken
- Die Standardfehlerausgabe für ein Kommando umlenken
- Mehrere Umlenkungen zu einem Kommando
⊕ Argumente durch passende Dateinamen ersetzen
⊕ Wie bearbeitet die Shell die Kommandozeile?
Kommandos eingeben und verknüpfen
Kommandos können Sie entweder in einer Datei zusammenfassen und als
Shell-Prozedur ausführen oder im Dialog der Reihe nach im Anschluß an
das Bereitzeichen der Shell eingeben. Standardmäßig hat ein Kommando
folgendes Format:
kommando parameter ...CR
kommando
Name eines Reliant UNIX Kommandos, einer Shell-Prozedur, eines
eingebauten sh-Kommandos oder einer Shell-Funktion. kommando soll
ausgeführt werden.
parameter
Aufrufargument, das die Shell entweder selbst interpretiert oder
an kommando übergibt. Abhängig vom jeweiligen Kommando können Sie
auch mehrere Aufrufargumente angeben.
Der Kommandoname und die Aufrufargumente werden voneinander durch
Tabulator- oder Leerzeichen getrennt; das letzte Aufrufargument (und
damit die Eingabe des Kommandos) wird durch ein Neue-Zeile-Zeichen
abgeschlossen. Sie können aber auch meherere Kommandos in eine Zeile
schreiben. Die einzelnen Kommandos werden durch ein Kommando-Trennzei-
chen voneinander getrennt (siehe Pipelines und Kommandofolgen unten).
Der Shell-Variablen IFS sind standardmäßig als Argument-Trennzeichen
Leer-, Tabulator- und Neue-Zeile-Zeichen zugewiesen. Der Inhalt von
IFS wird in den folgenden Fällen ausgewertet:
Seite 15 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
- wenn das eingebaute sh-Kommando read die gelesene Eingabe-Zeile in
Argumente zerlegt
- wenn die Shell die inzwischen bearbeitete Kommandozeile zum zweiten
Mal in Argumente zerlegt (siehe WIE BEARBEITET DIE SHELL DIE KOM-
MANDOZEILE?, "Schritt 8" unten).
Wenn Sie den Wert der Variablen IFS ändern, verstehen read und die
Shell beim zweiten Zerlegen nur noch die jetzt gültigen Argument-
Trennzeichen.
Wenn die Shell die eingegebene Kommandozeile zum ersten Mal in Argu-
mente zerlegt (siehe WIE BEARBEITET DIE SHELL DIE KOMMANDOZEILE?,
"Schritt 3" unten), gelten Leer- und Tabulatorzeichen als Argument-
Trennzeichen, unabhängig vom Inhalt der Umgebungsvariablen IFS.
Jedes Reliant UNIX Kommando gibt an die Shell, in der es aufgerufen
wurde, seinen Endestatus zurück. Standardmäßig hat der Endestatus den
Wert:
0 bei fehlerfreiem Ablauf
ungleich 0
bei fehlerhaftem Ablauf
Die Shell versteht aber nicht nur einfache Kommandos. Mehrere Komman-
dos können Sie wie folgt aneinanderhängen:
- Mit dem Zeichen | verbinden Sie zwei Kommandos über eine Pipe zu
einer Pipeline (siehe Pipelines unten).
- Mit Strichpunkt ; bzw. mit kommerziellem Und & bzw. mit && oder ||
verbinden Sie mehrere Kommandos oder Pipelines zu einer Kommando-
folge (siehe Kommandofolgen unten).
Pipelines
Eine Pipeline ist eine Folge von zwei oder mehr Kommandos, die jeweils
durch das Pipe-Zeichen | verbunden sind. Eine solche Verbindung heißt
Pipe.
Eine Pipe zwischen zwei Kommandos lenkt die Standardausgabe des ersten
Kommandos um auf die Standardeingabe des zweiten Kommandos. Deshalb
müssen die so verbundenen Kommandos folgende Bedingung erfüllen:
- Das erste Kommando einer Pipeline muß auf die Standardausgabe
schreiben.
- Das letzte Kommando einer Pipeline muß von der Standardeingabe
lesen.
Seite 16 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
- Besteht die Pipeline aus mehr als zwei Kommandos, müssen alle Kom-
mandos nach dem ersten und vor dem letzten Kommando der Pipeline
von der Standardeingabe lesen und auf die Standardausgabe schrei-
ben. Kommandos, die von der Standardeingabe lesen und auf die Stan-
dardausgabe schreiben, heißen auch Filter.
Die Shell startet alle Kommandos der Pipeline gleichzeitig als eigen-
ständige parallele Prozesse; in einem Ein-Prozessor-System kann jedoch
pro Zeiteinheit immer nur einer dieser Prozesse vom Prozessor bearbei-
tet werden. Die einzelnen Prozesse wechseln sich am Prozessor ab.
Nur der Prozeß, der zum ersten Kommando der Pipeline gehört, erhält
seine Eingabe nicht von einem anderen Prozeß.
Nur der Prozeß, der zum letzten Kommando der Pipeline gehört, leitet
seine Ausgabe nicht an einen anderen Prozeß weiter.
Deshalb müssen die einzelnen Prozesse vom Betriebssystem-Kern synchro-
nisiert werden. Jeweils die Prozesse, die zu zwei direkt aufeinander
folgenden Kommandos in der Pipeline gehören, kommunizieren miteinander
über einen Puffer. Der lesende Prozeß wartet, bis der schreibende Pro-
zeß Daten in den Puffer geschrieben hat. Wenn der Puffer voll ist,
wartet der schreibende Prozeß, bis der lesende Prozeß Daten aus dem
Puffer gelesen hat.
Die Shell wartet, bis das letzte Kommando der Pipeline beendet ist.
Erst dann bearbeitet sie weitere Eingaben.
Endestatus einer Pipeline
Das ist der Endestatus des letzten Kommandos der Pipeline.
Kommandofolgen
Mehrere Kommandos oder Pipelines können Sie zu einer Kommandofolge
verbinden. Die einzelnen Glieder dieser Folge werden durch die Zeichen
; bzw. & bzw. && bzw. || voneinander getrennt. Das letzte Glied der
Kommandofolge wird abgeschlossen durch ein Neue-Zeile-Zeichen, durch ;
oder &. Ein Neue-Zeile-Zeichen, das nicht innerhalb von runden bzw.
geschweiften Klammern steht, veranlaßt die Shell, die Kommandofolge
auszuführen (siehe Kommandofolgen klammern unten).
So können Sie mehrere Kommandos auf einmal eingeben, ohne auf das Ende
der einzelnen Kommandos zu warten. Erst wenn alle Kommandos der Kom-
mandofolge ausgeführt sind, gibt die Shell ihr Bereitzeichen aus.
Im folgenden steht der Begriff Kommando für ein Kommando oder eine
Pipeline. Die Kommando-Trennzeichen haben folgende Wirkung:
Seite 17 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
______________________________________________________________________
| Zeichen | Wirkung |
|_________|___________________________________________________________|
| ; | Die Shell bearbeitet das nächste Kommando erst, wenn das |
| | vorausgehende beendet ist. Sie gibt aber kein Bereitzei- |
| | chen aus. |
|_________|___________________________________________________________|
| & | Die Shell startet das vorausgehende Kommando im Hinter- |
| | grund und bearbeitet sofort das nachfolgende Kommando. |
| | Hintergrund-Prozesse ignorieren die Signale SIGINT und |
| | SIGQUIT [siehe auch trap(1)]. |
| | |
| | Die Shell lenkt die Standardeingabe aller Hintergrund- |
| | Kommandos um auf die leere Datei /dev/null. Sie können |
| | aber die Standardeingabe eines Hintergrund-Kommandos |
| | umlenken auf eine andere Datei, z. B. mit < datei in der |
| | Kommandozeile. |
|_________|___________________________________________________________|
| && | Die Shell führt das nachfolgende Kommando nur aus, wenn |
| (ANDIF) | das vorausgehende Kommando als Endestatus den Wert 0 |
| | zurückgegeben hat. |
|_________|___________________________________________________________|
| || | Die Shell führt das nachfolgende Kommando nur aus, wenn |
| (ORIF) | das vorausgehende Kommando als Endestatus einen Wert |
| | ungleich 0 zurückgegeben hat. |
|_________|___________________________________________________________|
Priorität der Kommando-Trennzeichen
Die Zeichen && und || haben gleiche Priorität; die Priorität ist höher
als die der Zeichen ; und &.
Die Zeichen ; und & haben ebenfalls gleiche Priorität; die Priorität
ist niedriger als die der Zeichen && und ||.
Beispiel:
kommando1&kommando2||kommando3;kommando4 CR
Die Shell startet kommando1 im Hintergrund und bearbeitet sofort
kommando2. Wenn kommando2 als Endestatus den Wert 0 zurückgibt,
führt die Shell kommando4 aus.
Wenn kommando2 als Endestatus einen Wert ungleich 0 zurückgibt,
führt die Shell nacheinander kommando3 und kommando4 aus.
Die Angabe || bindet stärker als & und ;.
Endestatus einer Kommandofolge
Das ist der Endestatus des letzten ausgeführten Kommandos der Komman-
dofolge.
Seite 18 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Kommandofolgen klammern
Mit runden oder geschweiften Klammmern können Sie mehrere Kommandos
zusammenfassen,
- um sie gemeinsam im Hintergrund zu starten; dabei bleibt die Rei-
henfolge der Ausführung erhalten;
- um die Ausgaben aller Kommandos in eine Datei zu schreiben oder
über eine Pipe an ein anderes Kommando weiterzuleiten.
______________________________________________________________________
(kommandofolge)
______________________________________________________________________
kommandofolge
Folge von Kommandos oder Pipelines, die durch ein Kommando-
Trennzeichen voneinander getrennt sind.
Die Shell startet eine Subshell. Diese Subshell führt kommando-
folge aus und beendet sich. Die vorher gültige Shell meldet sich
zurück, die vorher gültigen Shell-Variablen und auch das vorher
gültige Verzeichnis haben sich nicht verändert.
Wenn Sie außerhalb der runden Klammern die Standardausgabe in eine
Datei umlenken, schreiben alle Kommandos bzw. Pipelines der Kommando-
folge ihre Ausgaben nacheinander in die angegebene Datei. Das entspre-
chende gilt, wenn Sie die Standardfehlerausgabe in eine Datei umlen-
ken.
Wenn Sie im Anschluß an die schließende runde Klammer ein Pipe-Zeichen
| angeben, werden die Ausgaben aller Kommandos der Kommandofolge als
Eingabe an das Kommando übergeben, das auf das Pipe-Zeichen folgt.
Wenn Sie im Anschluß an die schließende runde Klammer das Zeichen &
angeben, wird eine Subshell im Hintergrund gestartet, die der Reihe
nach alle Kommandos der Kommandofolge ausführt.
Seite 19 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Beispiel:
$ pwd;(cd /dev;pwd);pwd
/home/rosa
/dev
/home/rosa
In der aufgerufenen Subshell wird /dev zum aktuellen Verzeichnis.
Dieser Wechsel des aktuellen Verzeichnisses beeinflußt jedoch
nicht die übergeordnete Shell.
Endestatus
Endestatus ist der Endestatus des letzten ausgeführten Kommandos in
kommandofolge.
______________________________________________________________________
{ kommandofolge;}
______________________________________________________________________
kommandofolge
Folge von Kommandos oder Pipelines, die durch ein Kommando-
Trennzeichen voneinander getrennt sind.
Die aktuelle Shell führt führt kommandofolge aus. Die geschweif-
ten Klammern { } sind Schlüsselwörter der Shell, d. h. vor { und
} muß ein Kommando-Trennzeichen stehen und nach { und } ein
Argument-Trennzeichen.
In den folgenden Fällen wird kommandofolge trotz der geschweiften
Klammern in einer Subshell ausgeführt, d. h. die geschweiften Klammern
haben die gleiche Wirkung wie die runden:
- Wenn Sie außerhalb der geschweiften Klammern die Standardausgabe in
eine Datei umlenken.
Dabei schreiben alle Kommandos der Kommandofolge ihre Ausgaben
nacheinander in die angegebene Datei.
Das entsprechende gilt, wenn Sie die Standardfehlerausgabe in eine
Datei umlenken.
- Wenn Sie im Anschluß an die schließende geschweifte Klammer ein
Pipe-Zeichen | angeben.
Dabei werden die Ausgaben aller Kommandos der Kommandofolge als
Eingabe an das Kommando übergeben, das auf das Pipe-Zeichen folgt.
- Wenn Sie im Anschluß an die schließende geschweifte Klammer das
Zeichen & angeben.
Seite 20 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Die Subshell wird im Hintergrund gestartet und führt der Reihe nach
alle Kommandos der Kommandofolge aus.
Beispiele
Beispiel 1
Wenn die Datei .profile nicht vorhanden ist, soll eine entsprechende
Meldung ausgegeben und die aktuelle Shell beendet werden:
[ -f .profile ] || {
echo Datei .profile fehlt
exit 1
}
Da die Kommandos innerhalb der geschweiften Klammern von der aktuellen
Shell ausgeführt werden, beendet exit die aktuelle Shell. Wegen der
Verknüpfung mit ||, wird der Inhalt der geschweiften Klammern nur aus-
geführt, wenn das eingebaute sh-Kommando test einen Endestatus
ungleich 0 zurückliefert.
Beispiel 2
Wird die Standardausgabe der Kommandofolge auf eine Datei umgelenkt,
so wird die Kommandofolge trotz der geschweiften Klammern in einer
Subshell ausgeführt, wie bei Angabe von runden Klammern:
$ pwd;{ cd /dev; echo Terminals:; ls tty*;} > \
$HOME/ausgabe /home/rosa
$ pwd
/home/rosa
$ cat ausgabe
Terminals:
tty000
tty001
tty003
tty010
Das aktuelle Verzeichnis hat sich nicht geändert, weil die Kommando-
folge in einer Subshell ausgeführt wird. Die Shell hat die Ausgaben
der Kommandos echo und ls zusammengefaßt und in die Datei
$HOME/ausgabe geschrieben.
Endestatus
Endestatus ist der Endestatus des letzten ausgeführten Kommandos in
kommandofolge.
Seite 21 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
EINGEBAUTE SHELL-KOMMANDOS
Kommandos, die die Shell selbst ausführt, für deren Bearbeitung sie
also keinen neuen Prozeß erzeugt, heißen eingebaute sh-Kommandos. Sie
unterscheiden sich von den übrigen "externen" Kommandos in den folgen-
den Punkten:
- Sie sind als Unterprogramme Bestandteil der Binär-Datei /bin/sh.
Deshalb können Sie die Namen der eingebauten sh-Kommandos nicht
ändern. Ebenso können Sie die Zugriffsrechte nur für /bin/sh
ändern, aber nicht für ein einzelnes eingebautes sh-Kommando.
- Die Shell führt die eingebauten Kommandos bevorzugt aus (siehe WIE
BEARBEITET DIE SHELL DIE KOMMANDOZEILE? unten). Gibt es zu einem
eingebauten Kommando ein gleichnamiges externes Kommando, so führt
die Shell bei Angabe dieses Namens immer das eingebaute Kommando
aus. Das externe Kommando wird ausgeführt, wenn der Aufruf-Name
einen Schrägstrich / enthält, also z. B. bei Aufruf mit dem ent-
sprechenden absoluten Pfadnamen.
- Die eingebauten Kommandos sind schneller, weil die Shell sie selbst
ausführt.
Zu den meisten eingebauten sh-Kommandos gibt es keine externe Entspre-
chung. Zum eingebauten sh-Kommando cd kann es keine geben: Wenn zur
Ausführung von cd ein neuer Prozeß erzeugt wird, ändert sich das aktu-
elle Verzeichnis nur für diesen Prozeß. Nach der Ausführung meldet
sich die aufrufende Shell zurück, das aktuelle Verzeichnis hat sich
nicht geändert.
Das Ausgabeformat von eingebauten sh-Kommandos ist nicht standardi-
siert. Deshalb sollten Sie sich bei Ihren Programmen oder Shell-
Prozeduren nicht auf ein bestimmtes Ausgabeformat verlassen.
Da die meisten eingebauten sh-Kommandos zusammen mit den externen Kom-
mandos in alphabetischer Reihenfolge beschrieben sind (siehe SIEHE
AUCH unten), folgt hier nur eine Liste der eingebauten sh-Kommandos:
Seite 22 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
______________________________________________________________________
| eingebautes | Funktion | externes |
| sh-Kommando | | Kommando |
|_____________|_______________________________________|_______________|
| bg | einen Auftrag in den Hintergrund | |
| | schicken | |
|_____________|_______________________________________|_______________|
| break | umschließende Schleife abbrechen | |
|_____________|_______________________________________|_______________|
| cd | aktuelles Verzeichnis wechseln | |
|_____________|_______________________________________|_______________|
| chdir | aktuelles Verzeichnis wechseln | |
|_____________|_______________________________________|_______________|
| continue | mit der nächsten Iteration der | |
| | umschließenden Schleife fortfahren | |
|_____________|_______________________________________|_______________|
| echo | Aufrufargumente ausgeben | /bin/echo |
|_____________|_______________________________________|_______________|
| eval | Aufrufargumente bearbeiten und als | |
| | Kommando ausführen | |
|_____________|_______________________________________|_______________|
| exec | die aktuelle Shell überlagern | |
|_____________|_______________________________________|_______________|
| exit | Shell-Prozedur beenden | |
|_____________|_______________________________________|_______________|
| export | Shell-Variablen exportieren | |
|_____________|_______________________________________|_______________|
| fg | einen Auftrag in den Vordergrund | |
| | schicken | |
|_____________|_______________________________________|_______________|
| getopts | Argumente auf legale Optionen über- | /bin/getopts |
| | prüpfen | |
|_____________|_______________________________________|_______________|
| hash | Hash-Tabelle der Shell bearbeiten | |
|_____________|_______________________________________|_______________|
| jobs | Informationen über einen Auftrag aus-| |
| | geben | |
|_____________|_______________________________________|_______________|
| kill | Signale an Prozesse senden | /bin/kill |
|_____________|_______________________________________|_______________|
| newgrp | Gruppenzugehörigkeit ändern | /bin/newgrp |
|_____________|_______________________________________|_______________|
| pwd | Pfadnamen des aktuellen Verzeichnis- | /bin/pwd |
| | ses ausgeben | |
|_____________|_______________________________________|_______________|
| read | Argumente von Standardeingabe lesen | |
| | und Shell-Variablen zuweisen | |
|_____________|_______________________________________|_______________|
| readonly | Shell-Variablen schützen | |
|_____________|_______________________________________|_______________|
Seite 23 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
______________________________________________________________________
| eingebautes | Funktion | externes |
| sh-Kommando | | Kommando |
|_____________|_______________________________________|_______________|
| return | eine Shell-Funktion veranlassen, zur | |
| | aufrufenden Funktion zurückzukehren | |
|_____________|_______________________________________|_______________|
| set | Shell-Optionen oder Stellungsparame- | /bin/sh |
| | ter setzen | |
|_____________|_______________________________________|_______________|
| shift | die Werte der Stellungsparameter nach| |
| | links verschieben | |
|_____________|_______________________________________|_______________|
| stop | stop PID sendet ein Stopp-Signal | |
| | (= kill -23 PID) | |
|_____________|_______________________________________|_______________|
| suspend | sendet ein Stopp-Signal durch einen | |
| | Benutzer (= kill -24 oder CTRL-Z) | |
|_____________|_______________________________________|_______________|
| test | Bedingungen prüfen | /bin/test |
|_____________|_______________________________________|_______________|
| times | Gesamt-Laufzeit gestarteter Prozesse | |
|_____________|_______________________________________|_______________|
| trap | Signalbehandlung ändern | |
|_____________|_______________________________________|_______________|
| type | Typ eines Kommandos abfragen | |
|_____________|_______________________________________|_______________|
| ulimit | Dateigröße für das Schreiben begren- | |
| | zen oder aktuellen Grenzwert abfragen| |
|_____________|_______________________________________|_______________|
| umask | Standardvergabe der Zugriffsrechte | |
| | ändern | |
|_____________|_______________________________________|_______________|
| unset | Shell-Variablen oder Shell-Funktionen| |
| | aus der Umgebung löschen | |
|_____________|_______________________________________|_______________|
| wait | auf die Beendigung von Hintergrund- | |
| | Prozessen warten | |
|_____________|_______________________________________|_______________|
| : | Endestatus 0 zurückgeben, siehe | /bin/true |
| | colon(1) | |
|_____________|_______________________________________|_______________|
| . | Shell-Prozeduren in der aktuellen | |
| | Shell ausführen, siehe dot(1) | |
|_____________|_______________________________________|_______________|
| [ | Bedingungen prüfen, siehe test(1) | |
|_____________|_______________________________________|_______________|
Seite 24 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
SONDERZEICHEN DER SHELL
Dieser Abschnitt enthält eine Liste der Zeichen und Zeichenkombinatio-
nen, die für die Shell eine Sonderbedeutung haben. Die Sonderbedeutung
wird im folgenden kurz erklärt. Daneben wird auf den Abschnitt verwie-
sen, in dem dieses Zeichen beschrieben ist [siehe auch
specialchar(5)].
Die Shell wertet die in einer Kommandozeile enthaltenen Sonderzeichen
in mehreren Schritten aus (siehe auch WIE BEARBEITET DIE SHELL DIE
KOMMANDOZEILE? unten).
______________________________________________________________________
| Sonderzeichen | Bedeutung | beschrieben in |
|___________________|____________________________|____________________|
| Leerzeichen | Argument-Trennzeichen | Kommandos eingeben |
| Neue-Zeile-Zeichen| | und verknüpfen |
| Tabulatorzeichen | | |
|___________________|____________________________|____________________|
| Neue-Zeile-Zeichen| Kommando-Abschluß bzw. | Kommandofolgen |
| | | Kommando-Trennzeichen | |
| ; | | |
| & | | |
| || | | |
| && | | |
|___________________|____________________________|____________________|
| (kommandofolge) | Kommandofolgen klammern | Kommandofolgen |
| { kommandofolge;} | | klammern |
|___________________|____________________________|____________________|
| `kommando` | durch Ausgabe ersetzen | Kommando durch |
| | | seine Ausgabe |
| | | ersetzen |
|___________________|____________________________|____________________|
Seite 25 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
______________________________________________________________________
| Sonderzeichen | Bedeutung | beschrieben in |
|___________________|____________________________|____________________|
| * | ersetzen, falls Dateinamen | Argumente durch |
| ? | passen | passende Dateinamen|
| [s] | | ersetzen |
| [c1-c2] | | |
| [!s] | | |
| [!c1-c2] | | |
|___________________|____________________________|____________________|
| >datei | Standardausgabe umlenken | Eingaben und Ausga-|
| >>datei | | ben eines Kommandos|
| >&zahl | Standardausgabe schließen | umlenken |
| >&- | | |
|___________________|____________________________|____________________|
| <datei | Standardeingabe umlenken | Eingaben und Ausga-|
| <<argument | | ben eines Kommandos|
| <<-argument | | umlenken |
| <&zahl | Standardeingabe schließen | |
| <&- | | |
|___________________|____________________________|____________________|
| name=wert | Wert zuweisen | Shell-Variablen |
|___________________|____________________________|____________________|
| $name | Wert der Variablen anspre- | Shell-Parameter |
| ${name} | chen | |
|___________________|____________________________|____________________|
| ${name-wert} | bedingte Ersetzung, falls | Standardwerte für |
| ${name?wert} | Variable definiert ist | Shell-Parameter |
| ${name+wert} | | vereinbaren |
|___________________|____________________________|____________________|
| ${name=wert} | Zuweisung, falls Variable | Standardwerte für |
| | nicht definiert ist | Shell-Parameter |
| ${name:=wert} | Zuweisung, falls Variable | vereinbaren |
| | nicht definiert oder ihr | |
| | Wert die leere Zeichenkette| |
| | ist | |
|___________________|____________________________|____________________|
| ${name:-wert} | bedingte Ersetzung, falls | Standardwerte für |
| ${name:?wert} | Variable definiert und ihr | Shell-Parameter |
| ${name:+wert} | Wert nicht die leere Zei- | vereinbaren |
| | chenkette ist | |
|___________________|____________________________|____________________|
Seite 26 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
______________________________________________________________________
| Sonderzeichen | Bedeutung | beschrieben in |
|___________________|____________________________|____________________|
| $0 | 1. Argument des Aufrufs | Shell-Parameter |
| $1, $2, ... , $9 | Stellungsparameter | |
| $* | alle Aufrufargumente | |
| "$*" | wie $*, aber ein Argument | |
| $@ | alle Aufrufargumente | |
| "$@" | wie $@, aber $# Argumente | |
| $# | Anzahl Aufrufargumente | |
|___________________|____________________________|____________________|
| $$ | Parameter der Shell, die | Shell-Parameter |
| $! | nur gelesen werden können | |
| $? | | |
| $- | | |
|___________________|____________________________|____________________|
| name() | Shell-Funktion | Shell-Funktionen |
| { kommandofolge;} | | |
|___________________|____________________________|____________________|
| \ | Entwertungszeichen | Sonderzeichen für |
| '...' | | die Shell entwerten|
| "..." | | |
|___________________|____________________________|____________________|
| # | Kommentar-Zeichen | Kommentare in |
| ;; | Abschluß für Kommandofolgen| Shell-Prozeduren |
| | bei case-Anweisung | |
|___________________|____________________________|____________________|
Sonderzeichen für die Shell entwerten
Sie können jedes Sonderzeichen der Shell entwerten. Entsprechend dem
Zeichen, das Sie entwerten wollen, verwenden Sie eines der nachfolgend
beschriebenen Entwertungszeichen.
Die Entwertungszeichen selbst sind nicht Bestandteil der Aufrufargu-
mente. Die Shell entfernt diese Zeichen, bevor sie die Argumente an
das Kommando übergibt.
Entwertungszeichen
\ entwertet die Sonderbedeutung des nachfolgend angegebenen Zei-
chens. Mit dem Gegenschrägstrich \ können Sie alle Sonderzeichen
der Shell entwerten.
Durch die Angabe \ CR verliert das Neue-Zeile-Zeichen seine Son-
derbedeutung als Argument- oder Kommando-Trennzeichen. Die Shell
ignoriert diese Angabe und eliminiert nicht nur \ sondern auch
das Neue-Zeile-Zeichen aus der Kommandozeile.
Seite 27 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
'zeichenkette'
entwertet die Sonderbedeutung aller Zeichen der zeichenkette. Mit
Hochkommata entwerten Sie die Sonderzeichen der Shell mit einer
Ausnahme: das Hochkomma selbst wird durch Hochkommata nicht ent-
wertet.
Da innerhalb der Hochkommata auch Leer-, Tabulator- und Neue-
Zeile-Zeichen ihre Sonderbedeutung als Argument-Trennzeichen ver-
lieren, ist zeichenkette für die Shell ein einziges Argument.
"zeichenkette"
Nur die folgenden Zeichen behalten für die Shell ihre Sonderbe-
deutung:
$ gefolgt von einem Variablen-Namen, wird ersetzt durch den
Wert dieser Shell-Variablen.
`kommando`
wird ersetzt durch die Ausgabe dieses Kommandos (siehe KOM-
MANDOS DURCH IHRE AUSGABE ERSETZEN unten).
\ entwertet die Sonderbedeutung eines nachfolgenden Sonderzei-
chens.
Innerhalb der Anführungszeichen behalten nur die Zeichen $,
`...` und \ ihre Sonderbedeutung. Folgt auf den Gegenschräg-
strich \ keines dieser Sonderzeichen, ist er als Zeichen
Bestandteil der Zeichenkette.
Alle übrigen Sonderzeichen innerhalb der Anführungszeichen
betrachtet die Shell als entwertet.
Da innerhalb der Anführungszeichen auch Leer-, Tabulator- und
Neue-Zeile-Zeichen ihre Sonderbedeutung als Argument-Trennzeichen
verlieren, ist die Zeichenkette für die Shell ein einziges Argu-
ment. Allerdings gibt es hier eine Ausnahme: die Angabe "$@". Sie
ist gleichbedeutend zu "$1" "$2" ... "$9", die einzelnen Aufruf-
argumente bleiben als Argumente erhalten.
Seite 28 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Wirkung von Hochkommata und Anführungszeichen (und Gegenhochkommas)
______________________________________________________________________
|entwerten|Argument-|Kommando-| \ | $ | * | ? | [ | ` | " | ' |
|_________|___________________|____|____|____|____|____|____|____|____|
| | Trennzeichen | | | | | | | | |
|_________|_________|_________|____|____|____|____|____|____|____|____|
| '...' | ja | ja | ja | ja | ja | ja | ja | ja | ja | s |
|_________|_________|_________|____|____|____|____|____|____|____|____|
| "..." | ja | ja |nein|nein| ja | ja | ja |nein| s | ja |
|_________|_________|_________|____|____|____|____|____|____|____|____|
| `...` | ja | ja | ja |nein|nein|nein|nein| s |nein|nein|
|_________|_________|_________|____|____|____|____|____|____|____|____|
s bedeutet: schließendes Zeichen
SHELL-VARIABLEN
Shell-Variablen sind immer vom Typ Zeichenkette. Sie müssen nicht
deklariert werden, sondern sie sind definiert, sobald ihnen ein Wert
zugewiesen ist.
Shell-Variablen benutzen Sie, um eine Zeichenkette zu speichern, die
Sie häufig verwenden. Für den nötigen Speicherplatz sorgt die Shell
selbst.
Im folgenden erfahren Sie,
- wie Sie Variablen definieren und ihnen einen Wert zuweisen
- wie Sie auf den Wert einer Variablen zugreifen
- mit welchen Standard-Variablen die Shell arbeitet.
Seite 29 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Eine Shell-Variable definieren
Jede Shell-Variable besteht aus einem Namen und einem Wert. Sie defi-
nieren eine Shell-Variable wie folgt:
______________________________________________________________________
name=wert [name=wert] ...
______________________________________________________________________
name Name der Variablen. Ein Variablen-Name muß mit einem Buchstaben
oder mit einem Unterstrich _ beginnen. Dem ersten Zeichen dürfen
Buchstaben, Ziffern und Unterstriche in beliebiger Reihenfolge
folgen.
Eine Shell-Variable und eine Shell-Funktion dürfen in der aktuel-
len Shell nicht den gleichen Namen tragen.
Wenn eine Variable dieses Namens bereits definiert ist, geht
durch die neue Zuweisung ihr alter Wert in der aktuellen Shell
verloren.
= der Zuweisungsoperator. Er darf von name und wert nicht durch
Leerzeichen getrennt sein.
wert Wert der Variablen.
Enthält wert Leer-, Tabulator- oder Neue-Zeile-Zeichen, müssen
Sie diese entwerten. Die Shell weist der Variablen name die Zei-
chen *, $ und [...] zu, ohne sie zu interpretieren. wert wird
also nicht ersetzt durch alle passenden Dateinamen (siehe ARGU-
MENTE DURCH PASSENDE DATEINAMEN ERSETZEN unten).
Wenn Sie für wert "" oder '' oder nichts angeben, weisen Sie der
Variablen name die leere Zeichenkette zu.
Die Zuweisung geben Sie im Dialog ein oder Sie schreiben sie in eine
Shell-Prozedur. Sie können auch mehrere Zuweisungen in eine Zeile
schreiben, jeweils getrennt durch ein Argument-Trennzeichen.
Die so definierten Variablen sind standardmäßig nur in der aktuellen
Shell bekannt. Mit dem eingebauten sh-Kommando export(1) machen Sie
diese Variable auch jeder Subshell bekannt. Umgekehrt können Sie eine
Variable, die Sie in einer Subshell definiert haben, nicht an die
übergeordnete Shell zurückgeben. Weitere Informationen hierzu in DIE
UMGEBUNG unten.
Mit dem eingebauten sh-Kommando read(1) können Sie ebenfalls Shell-
Variablen definieren.
Mit dem eingebauten sh-Kommando unset(1) löschen Sie eine definierte
Shell-Variable wieder.
Seite 30 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Auf den Wert einer Variablen zugreifen
Das eingebaute sh-Kommando set(1) gibt alle Variablen und ihre Werte
aus, die in der aktuellen Shell definiert sind. Auf den Wert einer
Variablen greifen Sie aber auch folgendermaßen direkt zu:
______________________________________________________________________
$name
______________________________________________________________________
name Name der Shell-Variablen, auf deren Wert Sie zugreifen wollen.
Der Name muß ohne Leerzeichen auf das Dollar-Zeichen folgen.
name ist eine Shell-Variable, $name ist ein Schlüsselwort-Parameter.
Einer Variablen können Sie einen Wert zuweisen, aber nicht einem
Schlüsselwort-Parameter (siehe SHELL-PARAMETER unten).
Beispiel:
Wenn Sie wissen wollen, welchen Wert die Variable HOME hat, geben
Sie ein:
$ echo $HOME
Das eingebaute sh-Kommando echo(1) schreibt den Wert der Varia-
blen HOME auf die Standardausgabe.
Standard-Variablen der Shell
An die Login-Shell werden bereits beim Start einige Standard-Variablen
übergeben. Weitere Standard-Variablen definiert sie selbst, bevor sie
sich mit dem ersten Bereitzeichen meldet.
Den meisten Standard-Variablen ist ein Standardwert zugewiesen, dieser
Standardwert ist auch in jeder Subshell bekannt. Erst wenn Sie die
Werte dieser Standard-Variablen ändern, müssen Sie sie für eine Sub-
shell mit export exportieren. Sonst gilt in der Subshell wieder der
Standardwert.
Wenn Sie Shell-Variablen dauerhaft definieren wollen, können Sie die
entsprechenden Zuweisungen in die Datei $HOME/.profile eintragen. Die
Login-Shell führt diese Datei aus, bevor sie ihr Bereitzeichen aus-
gibt.
Die Shell kennt die folgenden Standard-Variablen:
______________________________________________________________________
CDPATH=verzeichnis[:verzeichnis ...]
______________________________________________________________________
Seite 31 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Sie können der Variablen CDPATH die Pfadnamen der Verzeichnisse zuwei-
sen, die cd durchsuchen soll. Die einzelnen Pfadnamen müssen Sie durch
einen Doppelpunkt : voneinander trennen. Das aktuelle Verzeichnis wei-
sen Sie zu, indem Sie einen Punkt "." oder die leere Zeichenkette,
also nichts angeben. Mit einem Doppelpunkt gleich nach dem Zuweisungs-
operator = weisen Sie das aktuelle Verzeichnis als erstes Verzeichnis
zu.
Das eingebaute sh-Kommando cd(1) greift auf CDPATH zu, um das Ver-
zeichnis zu suchen, das zum aktuellen werden soll. Die Suche beginnt
in dem Verzeichnis, dessen Pfadname vor dem ersten Doppelpunkt steht.
Von links nach rechts werden alle in CDPATH enthaltenen Pfadnamen
abgearbeitet [siehe cd(1)].
Standardwert: keiner, d. h. CDPATH ist standardmäßig nicht definiert.
Wenn CDPATH nicht definiert ist, sucht cd Verzeichnisse, die Sie mit
ihrem relativen Pfadnamen angeben, relativ zum aktuellen Verzeichnis.
______________________________________________________________________
HOME=verzeichnis
______________________________________________________________________
Der Variablen HOME wird der absolute Pfadname des HOME-Verzeichnisses
zugewiesen. Wenn Sie das eingebaute sh-Kommando cd(1) ohne Argument
aufrufen, greift cd auf HOME zu. Das HOME-Verzeichnis wird zum aktuel-
len Verzeichnis.
Die Login-Shell sucht die Datei .profile in dem Verzeichnis, das der
Variablen HOME zugewiesen ist.
Standardwert: Das Kommando login weist der Variablen HOME den absolu-
ten Pfadnamen Ihres Login-Verzeichnisses zu. Dieser Pfadname ist in
der Datei /etc/passwd für Ihre Benutzerkennung eingetragen.
______________________________________________________________________
IFS=c ...
______________________________________________________________________
Der Variablen IFS werden Argument-Trennzeichen zugewiesen. Dabei ist c
ein beliebiges Zeichen, Leer-, Tabulator- und Neue-Zeile-Zeichen müs-
sen entwertet sein. Mehrere Zeichen werden ohne Leerzeichen nacheinan-
der angegeben.
Die Shell wertet den Inhalt von IFS in den folgenden Fällen aus:
- wenn das eingebaute sh-Kommando read(1) die gelesene Eingabe-Zeile
in Argumente zerlegt
Seite 32 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
- wenn die Shell die inzwischen bearbeitete Kommandozeile zum zweiten
Mal in Argumente zerlegt (siehe Abschnitt WIE BEARBEITET DIE SHELL
DIE KOMMANDOZEILE?, Schritt 8).
Die Variable IFS können Sie nicht mit unset(1) aus der Umgebung
löschen.
Standardwert: Leerzeichen Tabulatorzeichen Neue-Zeile-Zeichen. Die
Login-Shell weist der Variablen IFS diesen Wert zu.
Wenn Sie den Wert der Variablen IFS ändern, verstehen read und die
Shell beim zweiten Zerlegen nur noch die jetzt gültigen Argument-
Trennzeichen.
______________________________________________________________________
LANG=sprache
______________________________________________________________________
Mit der NLS-Variablen LANG wird eine internationalisierte Shell-
Umgebung definiert. Der Wert von LANG ist der Name einer existierenden
Datenbasis. Die Datenbasen stehen unter dem Verzeichnis
/usr/lib/locale. Ist die Variable LCALL nicht gesetzt, dann legt LANG
sowohl die Landessprache fest als auch alles, was mit den von einem
internationalisierten Programm benutzten NLS-Variablen LCCOLLATE,
LCCTYPE, LCMONETARY, LCNUMERIC, LCTIME und LCMESSAGES einzeln
festgelegt werden kann.
Ist LANG nicht definiert oder leer oder hat LANG einen ungültigen
Wert, dann verhält sich das System, als wäre es nicht internationali-
siert.
______________________________________________________________________
LCALL=sprache
______________________________________________________________________
Die Variable LCALL überschreibt die Variablen LC* und LANG.
______________________________________________________________________
LCCOLLATE=sprache
______________________________________________________________________
Ist die Variable LCALL nicht gesetzt, dann legt die NLS-Variable
LCCOLLATE beim Sortieren von Zeichenketten die Sortierreihenfolge
fest.
Ist LCCOLLATE nicht definiert oder ist ihr die leere Zeichenkette
zugewiesen, dann gilt für diese Variable als Standardwert der Wert von
LANG. Hat LCCOLLATE einen ungültigen Wert, dann verhält sich ein
internationalisiertes Programm, als wäre es nicht internationalisiert.
Seite 33 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
______________________________________________________________________
LCCTYPE=sprache
______________________________________________________________________
Ist die Variable LCALL nicht gesetzt, dann legt die NLS-Variable
LCCTYPE für jedes Zeichen fest, zu welcher Zeichenklasse es gehört,
und definiert, wie Klein- in Großbuchstaben bzw. Groß- in Kleinbuch-
staben umgewandelt werden.
Ist LCCTYPE nicht definiert oder ist ihr die leere Zeichenkette zuge-
wiesen, dann gilt für diese Variable als Standardwert der Wert von
LANG. Hat LCCTYPE einen ungültigen Wert, dann verhält sich ein inter-
nationalisiertes Programm, als wäre es nicht internationalisiert.
______________________________________________________________________
LCMESSAGES=sprache
______________________________________________________________________
Ist die Variable LCALL nicht gesetzt, dann legt die NLS-Variable
LCMESSAGES die Sprache der Meldungen fest, die ein internationali-
siertes Programm ausgibt. Hat LCMESSAGES einen ungültigen Wert, dann
verhält sich ein internationalisiertes Programm, als wäre es nicht
internationalisiert.
______________________________________________________________________
LCMONETARY=sprache
______________________________________________________________________
Ist die Variable LCALL nicht gesetzt, dann legt die NLS-Variable
LCMONETARY Währungszeichen und Währungsformate fest.
Ist LCMONETARY nicht definiert oder ist ihr die leere Zeichenkette
zugewiesen, dann gilt für diese Variable als Standardwert der Wert von
LANG. Hat LCMONETARY einen ungültigen Wert, dann verhält sich ein
internationalisiertes Programm, als wäre es nicht internationalisiert.
______________________________________________________________________
LCNUMERIC=sprache
______________________________________________________________________
Ist die Variable LCALL nicht gesetzt, dann legt die NLS-Variable
LCNUMERIC Dezimalpunktdarstellung, Exponentzeichen und Tausender-
trennzeichen fest.
Seite 34 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Ist LCNUMERIC nicht definiert oder ist ihr die leere Zeichenkette
zugewiesen, dann gilt für diese Variable als Standardwert der Wert von
LANG. Hat LCNUMERIC einen ungültigen Wert, dann verhält sich ein
internationalisiertes Programm, als wäre es nicht internationalisiert.
______________________________________________________________________
LCTIME=sprache
______________________________________________________________________
Ist die Variable LCALL nicht gesetzt, dann legt die NLS-Variable
LCTIME das Format von Datums- und Zeitangaben fest.
Ist LCTIME nicht definiert oder ist ihr die leere Zeichenkette zuge-
wiesen, dann gilt für diese Variable als Standardwert der Wert von
LANG. Hat LCTIME einen ungültigen Wert, dann verhält sich ein inter-
nationalisiertes Programm, als wäre es nicht internationalisiert.
______________________________________________________________________
LOGNAME=benutzerkennung
______________________________________________________________________
Das Kommando login weist der Variablen LOGNAME die Benutzerkennung zu,
unter der Sie sich am System angemeldet haben.
______________________________________________________________________
MAIL=datei
______________________________________________________________________
Der Variablen MAIL wird der absolute Pfadname der Datei zugewiesen, in
die mail Ihre Post schreibt.
Wenn die Variable MAILPATH nicht definiert ist, benachrichtigt Sie die
Shell, falls mail Post in diese Datei geschrieben hat, durch folgende
Meldung:
you have mail
Standardwert: /var/mail/$USER. Das Kommando login weist MAIL diesen
Wert zu.
______________________________________________________________________
MAILCHECK=zahl
______________________________________________________________________
Der Variablen MAILCHECK wird eine ganze zahl zugewiesen. Die Shell
greift auf die Variable MAILCHECK zu. Im Abstand von zahl Sekunden prüft
sie, ob mail Post für Sie in die Datei $MAIL oder in eine der Dateien
geschrieben hat, deren Pfadnamen der Variablen MAILPATH zugewiesen sind.
Seite 35 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Wenn Sie MAILCHECK den Wert 0 zuweisen, prüft die Shell diese Dateien
jedesmal, bevor sie ihr Bereitzeichen ausgibt.
Ist Post eingetroffen, erhalten Sie die Meldung: you have mail
Die Variable MAILCHECK können Sie nicht mit unset aus der Umgebung
löschen.
Standardwert: 600, d. h. die Shell prüft alle 600 Sekunden (10 Minu-
ten), ob mail neue Post in eine der Dateien geschrieben hat, deren
Pfadnamen den Variablen MAIL oder MAILPATH zugewiesen sind.
Die Login-Shell weist MAILCHECK diesen Wert zu.
______________________________________________________________________
MAILPATH=datei[%text][:datei[%text]] ...
______________________________________________________________________
Sie weisen der Variablen MAILPATH die Pfadnamen der Dateien zu, in
denen Post eintreffen kann. Die einzelnen Pfadnamen müssen Sie durch
einen Doppelpunkt voneinander trennen. Sie brauchen Leserecht für
diese Dateien.
Im Anschluß an jeden Pfadnamen können Sie text angeben; dieser Text
muß durch ein Prozentzeichen % vom jeweiligen Pfadnamen getrennt sein.
Die Shell gibt text aus, wenn Post in der entsprechenden Datei einge-
troffen ist.
Die Shell greift auf die Variable MAILPATH zu, um festzustellen, ob in
einer der angegebenen Dateien neue Post eingetroffen ist.
Standardwert: keiner, d. h. MAILPATH ist standardmäßig nicht defi-
niert.
______________________________________________________________________
PATH=verzeichnis[:verzeichnis ...]
______________________________________________________________________
Der Variablen PATH sind die absoluten Pfadnamen der Verzeichnisse
zugewiesen, in denen die Shell nach Kommandos suchen soll. Die einzel-
nen Verzeichnisse werden durch Doppelpunkte voneinander getrennt.
Das aktuelle Verzeichnis weisen Sie zu, indem Sie einen Punkt "." oder
die leere Zeichenkette, also nichts, für verzeichnis angeben.
Aus Sicherheitsgründen sollten Sie der Variablen PATH das aktuelle
Verzeichnis immer als letztes zuweisen.
Seite 36 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Die Shell greift auf die Variable PATH zu, wenn sie ein Kommando
sucht, das Sie mit seinem einfachen Dateinamen aufgerufen haben, also
ohne Schrägstrich / im Aufruf-Namen. Die Suche beginnt in dem Ver-
zeichnis, dessen Pfadname vor dem ersten Doppelpunkt steht. Von links
nach rechts werden alle in PATH enthaltenen Pfadnamen abgearbeitet,
bis die Shell die Datei gefunden hat oder feststellt, daß die Datei in
keinem dieser Verzeichnisse steht.
Die Variable PATH können Sie nicht mit unset aus der Umgebung löschen.
Der Standardwert von PATH ist für Superuser und nichtprivilegierte
Benutzer verschieden. Die jeweiligen Werte ergeben sich aus den Ein-
trägen in /etc/default/login.
Die Login-Shell weist PATH diesen Wert standardmäßig zu.
______________________________________________________________________
PS1=zeichenkette
______________________________________________________________________
Der Variablen PS1 wird die zeichenkette zugewiesen, die die Shell als
Bereitzeichen ausgeben soll, wenn sie auf die nächste Eingabe wartet.
Leer- und Tabulatorzeichen in zeichenkette müssen entwertet sein.
Die Variable PS1 können Sie nicht mit unset aus der Umgebung löschen.
Standardwert: $
Die Login-Shell weist PS1 standardmäßig diesen Wert zu.
______________________________________________________________________
PS2=zeichenkette
______________________________________________________________________
Der Variablen PS2 wird die zeichenkette zugewiesen, die die Shell aus-
geben soll, wenn sie nach der Eingabe eines Neue-Zeile-Zeichens noch
weitere Eingaben erwartet oder wenn Sie das Neue-Zeile-Zeichen entwer-
tet haben. Leer- und Tabulatorzeichen in zeichenkette müssen entwertet
sein.
Die Variable PS2 können Sie nicht mit unset aus der Umgebung löschen.
Standardwert: >
Die Login-Shell weist PS2 standardmäßig diesen Wert zu.
Seite 37 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
______________________________________________________________________
SHELL=kommandointerpreter
______________________________________________________________________
Der Variablen SHELL wird der absolute Pfadname des Kommandointerpre-
ters zugewiesen. Jedesmal, wenn eine Subshell aufgerufen wird, prüft
die aufrufende Shell, ob der Wert von SHELL das Zeichen r enthält. Ist
dies der Fall, so ist die aufgerufene Subshell eingeschränkt.
Die Editoren ed und vi greifen auf die Variable SHELL zu, wenn Sie
während der Arbeit in einem dieser Editoren die Shell oder ein Shell-
Kommando aufrufen.
Standardwert: Das Kommando login weist dieser Variablen den absoluten
Pfadnamen des Programms zu, das für Sie nach der Anmeldung am System
gestartet werden soll. Dieser Pfadname ist in der Datei /etc/passwd
für Ihre Benutzerkennung eingetragen; standardmäßig ist das /sbin/sh.
______________________________________________________________________
TERM=typ
______________________________________________________________________
Der Systemprozeß getty weist der Variablen TERM den typ des Terminals
zu. typ ist der entsprechende Eintrag in der Datei /etc/gettytab.
Editoren greifen auf die Variable TERM zu, um festzustellen, welche
Eigenschaften das Terminal hat.
______________________________________________________________________
TZ=stdoffset1[sz[offset2][;beginn[/zeit],ende[/zeit]]] Format 1
TZ=stdoffset1[sz[offset2][,beginn[/zeit],ende[/zeit]]] Format 2
TZ=:zonenname Format 3
______________________________________________________________________
Die Variable TZ enthält Informationen über die Zeitzonen. Das Kommando
date und die meisten Bibliotheksfunktionen, die die Uhrzeit verarbei-
ten, benutzen TZ zur Bestimmung der Zeitzone bzw. zur Umrechnung der
Weltzeit UTC (Universal Time Coordinated) in die Ortszeit und umge-
kehrt.
Die einzelnen Komponenten des Wertes von TZ folgen ohne Leerzeichen
aufeinander, z. B. MET-1 (Format 1 oder Format 2) oder :US/Pacific
(Format 3). Ihre Bedeutung wird im folgenden näher erläutert:
Seite 38 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Format 1:
std Ortszeitzone. std besteht aus mindestens drei Buchstaben. Sowohl
Groß- als auch Kleinbuchstaben dürfen verwendet werden.
Hinweis:
std hat keinen Einfluß auf die Berechnung der Ortszeit (dies
ist Aufgabe von offset1). Mit std wird nur der Name der
Zeitzone festgelegt.
offset1
gibt den Wert an, den man zur Ortszeit hinzuaddieren muß, um die
Weltzeit UTC (Universal Time Coordinated, auch Greenwich Mean
Time, GMT, genannt) zu erhalten.
offset1 hat das folgende Format:
[+]hh[:mm[:ss]]
+ Steht vor der Zeitangabe ein Pluszeichen, befindet sich die
Zeitzone westlich des Null-Meridians (entspricht GMT). Steht
ein Minuszeichen davor, befindet sich die Zeitzone östlich
des Null-Meridians.
+ nicht angegeben:
wirkt wie +.
hh Stunden (0-24)
mm Minuten (0-59)
ss Sekunden (0-59)
Beispiel:
Die Mitteleuropäische Zeit (MET) entspricht Weltzeit (UTC) +
1 Stunde: MET=UTC+1, d. h. UTC=MET-1, wobei die Angabe -1
offset1 entspricht.
sz Sommerzeitzone (Format wie bei std). Wie std auch, definiert sz
nur den Namen der Sommerzeitzone.
sz nicht angegeben:
Es gibt keine Umstellung auf Sommerzeit.
offset2
gibt den Wert an, den man zur Orts-Sommerzeit hinzuaddieren muß,
um die UTC zu erhalten.
offset2 hat das gleiche Format wie offset1.
Seite 39 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
offset2 nicht angegeben:
Sommerzeit = Ortszeit + 1 Stunde
beginn[/zeit],ende[/zeit]
beginn[/zeit] gibt an, wann von Ortszeit zu Sommerzeit gewechselt
wird; ende[/zeit] gibt an, wann zurückgewechselt wird. Dabei
geben beginn und ende den Tag an, an dem gewechselt wird, und
zeit gibt die Uhrzeit (in Ortszeit) an.
beginn und ende werden als eine Zahl n angegeben, wobei n für den
n-ten Tag des Julianischen Kalenders steht und 0 <= n <= 365 ist.
Schalttage werden mitgezählt. In diesem Format können Sie also
den 29. Februar angeben.
zeit hat das Format: hh[:mm[:ss]]
(siehe offset1)
zeit nicht angegeben:
zeit = 02:00:00
beginn[/zeit],ende[/zeit] nicht angegeben:
Der Wechsel von Orts- zu Sommerzeit findet in Mitteleuropa am
letzten Sonntag im März statt; in USA und Kanada am zweiten Sonn-
tag im April. Von Sommerzeit zu Ortszeit wird am letzten Sonntag
im Oktober gewechselt (jeweils um 2 Uhr morgens).
Format 2:
Format 2 bietet zusätzlich zum Umfang von Format 1 die Möglichkeit,
Beginn und Ende der Sommerzeit mit einer flexibleren Syntax festzule-
gen. Beachten Sie bei der Syntax von Format 2, daß der Unterschied
gegenüber Format 1 nur in einem Komma anstelle eines Strichpunkts vor
beginn[/zeit],ende[/zeit] besteht.
std siehe Format 1
offset1
siehe Format 1
sz siehe Format 1
offset2
siehe Format 1
Seite 40 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
beginn[/zeit],ende[/zeit]
beginn[/zeit] gibt an, wann von Ortszeit zu Sommerzeit gewechselt
wird; ende[/zeit] gibt an, wann zurückgewechselt wird. Dabei
geben beginn und ende den Tag an, an dem gewechselt wird, und
zeit gibt die Uhrzeit (in Ortszeit) an.
beginn und ende können sein:
Jn steht für den n-ten Tag des Julianischen Kalenders, wobei 1
<= n <= 365 ist. Schalttage werden nicht mitgezählt, d. h.
der 28. Februar ist immer der 59. Tag, und der 1. März ist
immer der 60. Tag. Den 29. Februar können Sie in diesem For-
mat nicht angeben.
n n steht für den n-ten Tag des Julianischen Kalenders, wobei
0 <= n <= 365 ist. Schalttage werden mitgezählt. In diesem
Format können Sie also den 29. Februar angeben.
Mm.w.t
steht für den t-ten Tag der w-ten Woche des m-ten Monats: (1
<= m <= 12, 1 <= w <= 5, 0 <= t <= 6).
Der 0-te Tag einer Woche ist der Sonntag. Die 1. Woche eines
Monats ist die Woche, in die der erste Tag des Monats fällt.
Ist für die Woche eine 5 angegeben (Mm.5.t), so ist der
letzte t-Tag des Monats m gemeint. Zum Beispiel bezieht sich
die Angabe M9.5.6 auf den letzten Samstag im September.
zeit hat das Format: hh[:mm[:ss]]
(siehe offset1)
zeit nicht angegeben:
zeit = 02:00:00
beginn[/zeit],ende[/zeit] nicht angegeben:
Der Wechsel von Orts- zu Sommerzeit findet in Mitteleuropa am
letzten Sonntag im März statt; in USA und Kanada am zweiten Sonn-
tag im April. Von Sommerzeit zu Ortszeit wird am letzten Sonntag
im Oktober gewechselt (jeweils um 2 Uhr morgens).
Beispiel:
In Mitteleuropa wird am letzten Sonntag im März von Winter-
auf Sommerzeit umgestellt, am letzten Sonntag im Oktober
wird von Sommmer- auf Winterzeit umgestellt. Zeitpunkt ist
jeweils 2:00 Uhr. Die Variable TZ muß in diesem Fall folgen-
den Inhalt haben:
TZ=MET-1MDT,M3.5.0/02:00:00,M9.5.0/02:00:00
Seite 41 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Format 3:
zonenname
zonenname ist der Name einer vordefinierten Zeitzone, bei der die
Sommerzeit-Umstellung auch vordefiniert ist.
Gültige Werte für zonenname sind die Namen der Dateien, die sich
unter /usr/lib/locale/TZ befinden. Diese Dateien werden mit Hilfe
des Systemverwalter-Kommandos zic(1M) erzeugt.
Beispiele:
Unter /usr/lib/locale/TZ befinden sich die Einträge GMT,
Greenwich-1 sowie das Verzeichnis US mit den Einträgen
Pacific und Yukon.
$ TZ=:GMT date
Wed Oct 23 15:18:47 GMT 1991
$ TZ=Greenwich-1 date
Wed Oct 23 14:18:47 GMT-1 1991
$ TZ=:US/Pacific date
Wed Oct 23 08:18:47 PDT 1991
Hinweis:
Syntaxfehler in einer Umgebungsvariablen wie TZ dürfen nicht den
Abbruch eines Kommandos wie z. B. date verursachen, sondern müs-
sen ein Standardverhalten auslösen. Bezüglich der Umgebungsvaria-
blen TZ ergibt sich das folgende Standardverhalten:
Ist bei den Formaten 1 und 2 std oder offset1 nicht zu identifi-
zieren oder ist bei Format 3 die angegebene Datei unter
/usr/lib/locale/TZ nicht vorhanden, wird auf GMT zurückgegriffen.
Andernfalls wird immer nur der gültige Teil der Variablen berück-
sichtigt, der Rest wird ignoriert.
Beispiele:
$ TZ=invalid date
Wed Oct 23 15:27:02 GMT 1991
$ TZ=MET-1MDT,unddasistderRest
Wed Oct 23 16:27:02 MET 1991
Seite 42 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
______________________________________________________________________
USER=benutzerkennung
______________________________________________________________________
Das Kommando login weist der Variablen USER die Benutzerkennung zu,
unter der Sie sich am System angemeldet haben.
Die Variable USER ist nur noch aus Gründen der Kompatibilität zu frü-
heren Versionen vorhanden. Ihre Rolle wird jetzt von der Variablen
LOGNAME übernommen.
DIE UMGEBUNG
Jeder Prozeß - auch die Shell - erhält eine Reihe von Informationen
vom aufrufenden Prozeß, wenn er gestartet wird:
- Informationen, die für den Ablauf des Prozesses wichtig sind, d. h.
Informationen über Vater- und Sohn-Prozesse, über geöffnete
Dateien, über das aktuelle Verzeichnis, über die vereinbarte Sig-
nalbehandlung und ähnliches.
- Informationen über bestimmte Variablen und die Werte, die ihnen
zugewiesen sind.
Alle diese Informationen zusammen sind in der Umgebung eines Prozesses
enthalten. Der Prozeß selbst trägt während seines Ablaufs weitere
lokale Variablen in seine Umgebung ein oder ändert lokal den Wert von
bereits bekannten Variablen.
Nachfolgend ist beschrieben:
- welche Variablen die Shell beim Start eines Kommandos in die Umge-
bung dieses Kommandos einträgt (siehe Die Umgebung eines Kommandos
beim Start unten)
- wie Sie die Umgebung der aktuellen Shell ändern können (siehe Die
Ablauf-Umgebung der aktuellen Shell unten).
Die Umgebung eines Kommandos beim Start
Wenn Sie ein Kommando aufrufen, übergibt die Shell an dieses Kommando
- die Namen aller Shell-Variablen und ihre Werte, die Sie in der
aktuellen oder einer übergeordneten Shell exportiert und nicht mit
unset aus der Umgebung gelöscht haben, und
- die Standard-Variablen, deren Wert Sie nicht verändert und die Sie
nicht mit unset gelöscht haben. Die Standard-Variablen IFS,
MAILCHECK, PATH, PS1 und PS2 können Sie allerdings nicht löschen.
Seite 43 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Diese Variablen und ihre Werte sind die Start-Umgebung des aufgerufe-
nen Kommandos. Das Kommando erbt sie von der aufrufenden Shell. Mit
env(1) können Sie feststellen, welche Variablen die aktuelle Shell an
jedes aufgerufene Kommando weiterreicht.
Die Start-Umgebung für ein Kommando erweitern
Wenn Sie ein Kommando aufrufen, können Sie seine Umgebung erweitern,
ohne die Umgebung der aktuellen Shell und die Start-Umgebung der ande-
ren Programme, die die Shell ausführt, zu beeinflussen. Dazu geben Sie
vor dem Kommandonamen die entsprechenden Zuweisungen an.
Diese Zuweisungen werden nicht in der aktuellen Shell ausgeführt, son-
dern in dem Prozeß, den die Shell zur Ausführung des Kommandos star-
tet. Die entsprechenden Variablen werden in die Umgebung des Kommandos
eingetragen, deshalb kann das Kommando darauf zugreifen. In der aktu-
ellen Shell sind diese Variablen nicht vorhanden.
Ist in der aktuellen Shell die Option -k gesetzt [siehe set(1)], so
können Sie diese Zuweisungen an einer beliebigen Stelle innerhalb des
Kommando-Aufrufes angeben. Alle so definierten Variablen sind nur dem
aufgerufenen Kommando bekannt.
Beispiel:
Die beiden folgenden Kommandozeilen führen zum gleichen Ergebnis:
kunde=meier prozedur
(kunde=meier;export kunde; prozedur)
Die erste Zeile enthält eine Zuweisung vor dem Kommandonamen.
Diese Zuweisung wird nicht in der aktuellen Shell ausgeführt,
sondern in der Subshell, die prozedur ausführt. Die Subshell
trägt die Variable kunde in die Umgebung für die Prozedur ein.
Wenn die Prozedur ausgeführt ist, beendet sich die Subshell. In
der übergeordneten Shell ist die Variable kunde nicht bekannt.
Die zweite Zeile enthält die runden Klammern; d. h. alle einge-
schlossenen Kommandos werden in einer Subshell ausgeführt. Die
Subshell trägt die Variable kunde in die Umgebung für prozedur
ein. An die Prozedur wird diese Umgebung übergeben, also auch die
Variable kunde. Wenn die Prozedur ausgeführt ist, beendet sich
die Subshell. In der übergeordneten Shell ist die Variable kunde
nicht bekannt.
Wenn Sie in der aktuellen Shell Variablen definieren und mit export
exportieren, ändern Sie nicht nur die Umgebung der aktuellen Shell
sondern auch die Start-Umgebung für alle anschließend aufgerufenen
Kommandos (siehe nächster Abschnitt).
Seite 44 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Die Ablauf-Umgebung der aktuellen Shell
Wenn Sie eine Shell aufrufen, untersucht sie die Umgebung, die ihr
beim Aufruf übergeben wurde. Für jeden Variablen-Namen, den sie fin-
det, erzeugt sie einen Parameter mit dem dazugehörigen Wert.
Die Login-Shell, die von login gestartet wird, erbt ihre Start-Umge-
bung von login. Die Variablen IFS, MAILCHECK, PATH, PS1 und PS2
initialisiert die Login-Shell selbst.
Jede Variable, die Sie in dieser Shell neu definieren oder deren Wert
Sie ändern, wird als lokale Variable in die Ablauf-Umgebung dieser
Shell eingetragen. Lokale Variablen verändern aber nicht die Umgebung
der Kommandos, die die Shell startet. Das können Sie mit env(1) über-
prüfen.
Das eingebaute sh-Kommando set(1) gibt alle Variablen aus, die in der
aktuellen Shell definiert sind, also auch alle lokal gültigen.
Sie können die Ablauf-Umgebung der aktuellen Shell und gleichzeitig
die Start-Umgebung für alle anschließend aufgerufenen Kommandos
ändern:
- Sie erweitern die Start-Umgebung für Kommandos mit dem eingebauten
sh-Kommando export(1). Wenn Sie eine Shell-Variable exportieren,
wird sie in die Start-Umgebung eingetragen. Exportierte Variablen
sind der aktuellen Shell bekannt, ebenso allen Subshells und allen
Kommandos, die diese Shell aufruft.
- Sie löschen eine Variable aus der Start-Umgebung mit dem eingebau-
ten sh-Kommando unset(1). Die Standard-Variablen IFS, MAILCHECK,
PATH, PS1 und PS2 können Sie allerdings nicht löschen.
Eine gelöschte Variable ist auch in der Ablauf-Umgebung der aktuel-
len Shell nicht mehr vorhanden.
Wenn in der aktuellen Shell die Option -a gesetzt ist, werden automa-
tisch alle Shell-Variablen exportiert, die Sie neu definieren oder
deren Wert Sie ändern [siehe set(1)].
Sie können aber auch nur die Start-Umgebung für ein bestimmtes Kom-
mando ändern (siehe Die Start-Umgebung für ein Kommando erweitern
oben). In diesem Fall ändert sich die Ablauf-Umgebung der aktuellen
Shell nicht.
Seite 45 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
SHELL-PARAMETER
Ein Shell-Parameter wird eingeleitet durch das Dollar-Zeichen $. Die
Shell ersetzt einen Parameter in der Kommandozeile durch den Wert, der
aktuell für die entsprechende Shell-Variable gilt. Sie geben Shell-
Parameter wie folgt an:
______________________________________________________________________
$parameter
______________________________________________________________________
parameter
Name einer Shell-Variablen oder eines der folgenden Zeichen:
0 1 2 3 4 5 6 7 8 9 * @ # - ? $ !
Wenn auf den Namen eines Shell-Parameters ein Buchstabe, eine Ziffer
oder ein Unterstrich _ folgt, interpretiert die Shell dieses Zeichen
als Teil des Namens. Deshalb muß der Name von den nachfolgenden Zei-
chen abgegrenzt werden. Sie können den Namen beispielsweise in
geschweifte Klammern einschließen:
______________________________________________________________________
${parameter}
______________________________________________________________________
Beispiel:
$ datei=/home/rosa/tabellen/liste1
$ mv $datei ${datei}00
Wenn die geschweiften Klammern nicht angegeben sind, sucht die
Shell eine Variable mit dem Namen datei00, die vielleicht nicht
definiert ist.
Es gibt drei Arten von Parametern:
- Schlüsselwort-Parameter,
- Stellungsparameter und
- besondere Shell-Parameter.
Schlüsselwort-Parameter
Schlüsselwort-Parameter sind Parameter der Form $name bzw. ${name}.
Die Shell ersetzt Schlüsselwort-Parameter durch den Wert der entspre-
chenden Shell-Variablen. Ist diese Variable nicht definiert, so
ersetzt die Shell den Schlüsselwort-Parameter durch die leere Zeichen-
kette.
Seite 46 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Sie können neue Schlüsselwort-Parameter einrichten oder den Wert eines
Schlüsselwort-Parameters ändern, indem Sie die entsprechende Shell-
Variable neu definieren oder ihren Wert ändern. Das erreichen Sie mit
der folgenden Zuweisung:
name=wert
name ist eine Shell-Variable, $name ist ein Shell-Parameter. Einer
Variablen können Sie einen Wert zuweisen, aber nicht einem Shell-
Parameter (siehe dazu SHELL-VARIABLEN und DIE UMGEBUNG oben).
Sie können einen Schlüsselwort-Parameter auch in jeder Subshell
bekanntmachen, indem Sie die entsprechende Variable mit export(1) in
die Umgebung eintragen.
Stellungsparameter
Stellungsparameter sind die Parameter $1, $2, $3, $4, $5, $6, $7, $8
und $9. Diese Stellungsparameter versorgt die Shell mit den folgenden
Argumenten aus der Kommandozeile:
$1 erstes Aufrufargument für dieses Kommando
.
.
.
$9 neuntes Aufrufargument für dieses Kommando
Auf die ersten neun Aufrufargumente können Sie also direkt zugreifen.
Auf alle Aufrufargumente zusammen greifen Sie mit $* oder $@ zu. Mit
dem eingebauten sh-Kommando shift(1) sprechen Sie das zehnte sowie
alle weiteren Aufrufargumente direkt an.
In einer Dialog-Shell können Sie nur indirekt mit dem eingebauten sh-
Kommando set(1) alle Stellungsparameter auf einmal mit Werten versor-
gen. Nach dem Aufruf von set greifen Sie in der aktuellen Shell auf
diese Werte zu.
Mit sh -s versorgen Sie indirekt in der aufgerufenen Subshell alle
Stellungsparameter auf einmal mit Werten.
Im Gegensatz zu den Schlüsselwort-Parametern können Sie den Wert eines
einzelnen Stellungsparameters nicht direkt ändern und diesen Wert auch
nicht mit export in die Umgebung eintragen.
Besondere Shell-Parameter
Die besonderen Shell-Parameter und ihre Werte:
$0 Aufruf-Name des Kommandos bzw. der Shell-Prozedur; bei Shell-
Funktionen ist $0 der Aufruf-Name der aktuellen Shell oder der
Name der Shell-Prozedur, je nachdem wo Sie die Funktion aufgeru-
fen haben.
Seite 47 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
$* alle Aufrufargumente, also die Stellungsparameter $1, ... $9 und
alle weiteren Aufrufargumente.
"$*" alle Aufrufargumente als ein Argument, also "$1 ... $9 ..."
$@ alle Aufrufargumente, also die Stellungsparameter $1, ... $9 und
alle weiteren Aufrufargumente.
"$@" alle Aufrufargumente als eigenständige Argumente, also "$1"
... "$9" ...
$# die Anzahl der Aufrufargumente; dieser Wert kann größer sein als
9.
$- alle Optionen, die in der aktuellen Shell gesetzt sind
$? der Endestatus des zuletzt ausgeführten Kommandos; gilt nicht für
Hintergrund-Kommandos
$$ die Prozeß-Nummer (PID) der aktuellen Shell
$! die Prozeß-Nummer (PID) des zuletzt im Hintergrund gestarteten
Kommandos
Diese Werte vergibt die Shell automatisch. Die Parameter $*, $@ und $#
ändern Sie, wenn Sie mit set bzw. sh -s die Stellungsparameter mit
neuen Werten versorgen oder wenn Sie shift aufrufen.
Shell-Parameter durch einen Wert ersetzen
Bei der Bearbeitung der Kommandozeile ersetzt die Shell die angegebe-
nen Shell-Parameter durch ihren Wert (siehe Abschnitt WIE BEARBEITET
DIE SHELL DIE KOMMANDOZEILE?, Schritt 4). Auf den Wert eines Shell-
Parameters greifen Sie wie folgt zu:
$parameter oder ${parameter}
Ist kein Wert definiert, ersetzt die Shell diesen Parameter durch die
leere Zeichenkette.
Standardwerte für Shell-Parameter vereinbaren
Wenn Sie sicher sein wollen, daß Shell-Parameter durch einen definier-
ten Wert ersetzt werden, können Sie einen Standardwert vereinbaren.
Zusammen mit dieser Vereinbarung geben Sie die Bedingung an, unter der
die Shell diesen Standardwert einsetzen soll.
In diesem Abschnitt wird beschrieben, wie Sie diese Standardwerte ver-
einbaren können. Für parameter können Sie den Namen einer Shell-Vari-
ablen oder eines der folgenden Zeichen angeben:
0 1 2 3 4 5 6 7 8 9 * @ # - ? $ !
Seite 48 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Die Bedeutung dieser Zeichen ist im Abschnitt SHELL-PARAMETER oben
erklärt.
Für standardwert sind beliebige Zeichenketten erlaubt. Die Shell
interpretiert standardwert nur, wenn sie den entsprechenden Parameter
durch diesen Wert ersetzt (siehe Beispiel am Ende dieses Abschnitts).
Die folgenden Vereinbarungen erkennt die Shell:
______________________________________________________________________
${parameter-standardwert}
______________________________________________________________________
Die Shell prüft: ist parameter definiert, d. h. ist parameter bereits
ein Wert zugewiesen? Der zugewiesene Wert kann auch die leere Zeichen-
kette sein!
Wenn ja, setzt die Shell den definierten Wert ein.
Wenn nein, setzt die Shell standardwert ein.
Dem Parameter wird aber kein Wert zugewiesen, der Standardwert gilt
nur für diesen Zugriff.
______________________________________________________________________
${parameter:-standardwert}
______________________________________________________________________
Die Shell prüft: ist parameter definiert, d. h. ist parameter bereits
ein Wert zugewiesen? Der zugewiesene Wert darf nicht die leere Zei-
chenkette sein, der Doppelpunkt schließt die leere Zeichenkette aus.
Wenn ja, setzt die Shell den definierten Wert ein.
Wenn nein, setzt die Shell standardwert ein.
Dem Parameter wird aber kein Wert zugewiesen, der Standardwert gilt
nur für diesen Zugriff.
______________________________________________________________________
${parameter=standardwert}
______________________________________________________________________
Für parameter dürfen Sie nur den Namen einer Shell-Variablen angeben.
Die Shell prüft: ist parameter definiert, d. h. ist parameter bereits
ein Wert zugewiesen? Der zugewiesene Wert kann auch die leere Zeichen-
kette sein!
Seite 49 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Wenn ja, setzt die Shell den definierten Wert ein.
Wenn nein, weist die Shell der Variablen parameter standardwert zu
und setzt diesen Wert ein.
Nur Shell-Variablen können Sie so Werte zuweisen. Deshalb darf
$parameter kein Stellungsparameter und kein besonderer Shell-Parameter
sein.
______________________________________________________________________
${parameter:=standardwert}
______________________________________________________________________
Für parameter dürfen Sie nur den Namen einer Shell-Variablen angeben.
Die Shell prüft: ist parameter definiert, d. h. ist parameter bereits
ein Wert zugewiesen? Der zugewiesene Wert darf nicht die leere Zei-
chenkette sein, der Doppelpunkt schließt die leere Zeichenkette aus.
Wenn ja, setzt die Shell den definierten Wert ein.
Wenn nein, weist die Shell der Variablen parameter standardwert zu
und setzt diesen Wert ein.
Nur Shell-Variablen können Sie so Werte zuweisen. Deshalb darf
parameter kein Stellungsparameter und kein besonderer Shell-Parameter
sein.
______________________________________________________________________
${parameter?[standardwert]}
______________________________________________________________________
Die Shell prüft: ist parameter definiert, d. h. ist parameter bereits
ein Wert zugewiesen? Der zugewiesene Wert kann auch die leere Zeichen-
kette sein!
Wenn ja, setzt die Shell den definierten Wert ein.
Wenn die Bedingung nicht erfüllt und standardwert angegeben ist,
bricht die Shell die Ausführung des entsprechenden Kommandos oder der
Shell-Prozedur ab und schreibt die folgende Fehlermeldung auf die
Standardfehlerausgabe:
parameter: standardwert
Wenn die Bedingung nicht erfüllt und standardwert nicht angegeben
ist, bricht die Shell die Ausführung des entsprechenden Kommandos oder
der Shell-Prozedur ab und schreibt die folgende Fehlermeldung auf die
Standardfehlerausgabe:
Seite 50 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
parameter: parameter null or not set
Dem Parameter wird kein Wert zugewiesen.
______________________________________________________________________
${parameter:?standardwert}
______________________________________________________________________
Die Shell prüft: ist parameter definiert, d. h. ist parameter bereits
ein Wert zugewiesen? Der zugewiesene Wert darf nicht die leere Zei-
chenkette sein, der Doppelpunkt schließt die leere Zeichenkette aus.
Wenn ja, setzt die Shell den definierten Wert ein.
Wenn die Bedingung nicht erfüllt und standardwert angegeben ist,
bricht die Shell die Ausführung des entsprechenden Kommandos oder der
Shell-Prozedur ab und schreibt die folgende Fehlermeldung auf die
Standardfehlerausgabe:
parameter: standardwert
Wenn die Bedingung nicht erfüllt und standardwert nicht angegeben
ist, bricht die Shell die Ausführung des entsprechenden Kommandos oder
der Shell-Prozedur ab und schreibt die folgende Fehlermeldung auf die
Standardfehlerausgabe:
parameter: parameter null or not set
Dem Parameter wird kein Wert zugewiesen.
______________________________________________________________________
${parameter+standardwert}
______________________________________________________________________
Die Shell prüft: ist parameter definiert, d. h. ist parameter bereits
ein Wert zugewiesen? Der zugewiesene Wert kann auch die leere Zeichen-
kette sein!
Wenn ja, setzt die Shell standardwert ein.
Wenn nein, setzt die Shell die leere Zeichenkette ein.
Seite 51 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
______________________________________________________________________
${parameter:+standardwert}
______________________________________________________________________
Die Shell prüft: ist parameter definiert, d. h. ist parameter bereits
ein Wert zugewiesen? Der zugewiesene Wert darf nicht die leere Zei-
chenkette sein, der Doppelpunkt schließt die leere Zeichenkette aus.
Wenn ja, setzt die Shell standardwert ein.
Wenn nein, setzt die Shell die leere Zeichenkette ein.
Beispiel:
$ echo ${dvz:-`pwd`}
/home/karl/src
Die Shell führt pwd nur aus, wenn die Variable dvz nicht defi-
niert oder ihr Wert gleich der leeren Zeichenkette ist.
KOMMANDOS DURCH IHRE AUSGABE ERSETZEN
Die Shell ersetzt in der Kommandozeile ein Kommando durch seine Aus-
gabe, wenn dieses Kommando in Gegenhochkommas eingeschlossen ist:
______________________________________________________________________
`kommando`
______________________________________________________________________
kommando
Name des Kommandos, das die Shell ausführen und dessen Ausgabe
sie statt `kommando` in die Kommandozeile einsetzen soll.
Wenn in der Kommandozeile nur `kommando` angegeben ist, versucht
die Shell, die Ausgabe von kommando auszuführen.
Dabei passiert der Reihe nach folgendes:
- Die aktuelle Shell erkennt in der Kommandozeile die Gegenhochkommas
und ruft eine Subshell auf.
- Die Subshell bearbeitet kommando (siehe Abschnitt WIE BEARBEITET
DIE SHELL DIE KOMMANDOZEILE? unten) und beendet sich.
- In der Kommandozeile wird `kommando` ersetzt durch die Ausgabe von
kommando.
Seite 52 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
- Die aktuelle Shell zerlegt die durch die Ersetzung veränderte Kom-
mandozeile nochmals in Argumente. Argument-Trennzeichen sind dabei
die Zeichen, die der Variablen IFS zugewiesen sind.
- Die aktuelle Shell führt die Kommandozeile aus.
Wenn Sie innerhalb der Gegenhochkommas die Standardausgabe umgelenkt
haben, wird `kommando` ersetzt durch die leere Zeichenkette.
Innerhalb der Gegenhochkommas können auch mehrere Kommandos stehen,
jeweils getrennt durch ein Kommando-Trennzeichen.
Beispiel:
Das Bereitzeichen der Shell soll über den aktuellen Rechner
informieren:
$ PS1="<`hostname`> "
<amadeus>
Wegen der Anführungszeichen ist das Leerzeichen nach > fester
Bestandteil von $PS1.
EINGABE UND AUSGABE EINES KOMMANDOS UMLENKEN
Standardmäßig ist die Standardeingabe eines Kommandos der Tastatur
zugeordnet, die Standardausgabe und die Standardfehlerausgabe sind dem
Bildschirm zugeordnet. Die Standardeingabe, die -ausgabe und die -feh-
lerausgabe lassen sich auch mit den folgenden Datei-Kennzahlen anspre-
chen:
0 für Standardeingabe
1 für Standardausgabe
2 für Standardfehlerausgabe
Wenn die Shell ein Kommando im Hintergrund startet, lenkt sie die
Standardeingabe für dieses Kommando um auf die leere Datei /dev/null.
Aber mit der Angabe <datei können Sie die Standardeingabe eines
Hintergrund-Kommandos auf eine andere Datei umlenken.
Wenn Sie die Standardzuordnung für ein Kommando ändern wollen, geben
Sie die Umlenkung an einer beliebigen Stelle im entsprechenden Kom-
mando an. Nachfolgend ist beschrieben, wie Sie
- die Standardeingabe umlenken
- die Standardausgabe umlenken
- die Standardfehlerausgabe umlenken.
Seite 53 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Die Standardeingabe für ein Kommando umlenken
Das Kleinerzeichen < leitet die Umlenkung der Standardeingabe ein. Die
Angabe <... ist gleichbedeutend mit 0<...
<datei
lenkt die Standardeingabe des Kommandos um auf datei. Das Kom-
mando liest seine Eingabe aus dieser Datei.
datei
Name der Datei, auf die die Standardeingabe umgelenkt werden
soll. Diese Datei muß bereits existieren und für Sie lesbar
sein.
Beachten Sie, daß die Shell zu diesem Zeitpunkt die Sonder-
zeichen *, ? und [...] noch nicht interpretiert hat. Verwen-
den Sie deshalb bei der Angabe von datei diese Sonderzeichen
nicht.
<&- Für das Kommando ist die Standardeingabe geschlossen. Das Kom-
mando erhält also nur Datei-Ende (EOF) als Eingabe.
Beispiel:
$ wc -l <&-
0
<&zahl
lenkt die Standardeingabe des Kommandos um auf die Datei, die der
Dateikennzahl zahl zugewiesen ist. Das Kommando liest seine Ein-
gabe aus dieser Datei.
zahl Dateikennzahl der Datei, auf die die Standardeingabe umge-
lenkt werden soll.
Das Zeichen & nach < bedeutet also für die Shell, daß die nach-
folgende Angabe eine Dateikennzahl und nicht ein Dateiname ist.
<<[-]zeichenkette
leitet ein Here-Dokument ein. Here-Dokumente werden in Shell-
Prozeduren für Kommandos verwendet, die von der Standardeingabe
lesen.
Die Standardeingabe des Kommandos wird umgelenkt auf das Here-
Dokument. Das sind die Zeilen der Shell-Prozedur, die zwischen
der Einleitung des Here-Dokuments und der Zeile stehen, die als
erste nur zeichenkette enthält. Fehlt eine solche Zeile, so endet
das Here-Dokument mit dem Ende der Shell-Prozedur. Das Kommando
liest seine Eingabe aus dem Here-Dokument.
Seite 54 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Die Shell bearbeitet die Zeilen des Here-Dokuments: sie ersetzt
Variablen durch ihren Wert und Kommandos, die in Gegenhochkommas
eingeschlossen sind, durch ihre Ausgabe. Das entsprechende Kom-
mando erhält die Zeilen des Here-Dokuments mit diesen Ersetzungen
(siehe Abschnitt WIE BEARBEITET DIE SHELL DIE KOMMANDOZEILE?,
Schritt 5).
Wenn die Shell die Zeichen \, $ und `...` nicht interpretieren
soll, müssen Sie diese Zeichen innerhalb des Here-Dokuments mit
einem vorangestellten \ entwerten. Für das ganze Here-Dokument
können Sie die Zeichen \, $ und `...` entwerten, indem Sie nach
<< in zeichenkette ein beliebiges Zeichen entwerten, z. B. durch
einen vorangestellten \.
- Die Shell entfernt alle führenden Tabulatorzeichen aus
zeichenkette und aus dem Here-Dokument.
- nicht angegeben:
Die Shell entfernt führende Tabulatorzeichen nicht.
zeichenkette
beliebige Zeichenkette, die aber nicht innerhalb des Here-
Dokuments vorkommen darf. Die erste Zeile im Here-Dokument,
die nur zeichenkette enthält, beendet das Here-Dokument.
Fehlt eine solche Zeile, gilt das Ende der entsprechenden
Shell-Prozedur als Ende des Here-Dokuments.
Wenn in zeichenkette ein beliebiges Zeichen entwertet ist,
z. B. durch einen vorangestellten \, sind alle Sonderzeichen
der Shell im Here-Dokument für die Shell entwertet.
Als Ende-Kriterium dürfen Sie zeichenkette nur ohne Entwer-
tungszeichen angeben.
Beispiel für ein Here-Dokument:
Die Shell-Prozedur post hat folgenden Inhalt, allerdings
ohne Zeilennummern:
1 mail $* << ENDE
2 An alle Systemverwalter!!
3
4 Die nächste Besprechung zum Thema Datensicherheit findet
5 am Freitag, den 13. Dezember um 10 Uhr im Besprechungsraum
6 "Marseille" statt. Bitte nicht vergessen.
7
8 ENDE
Zum Here-Dokument gehören die Zeilen 2 bis 7, die Zeichen-
kette ENDE beendet das Here-Dokument. Die Standardeingabe
des Kommandos mail(1) wird auf das Here-Dokument umgelenkt.
Seite 55 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Die Standardausgabe für ein Kommando umlenken
Das Größerzeichen > leitet die Umlenkung der Standardausgabe ein. Die
Angabe >... ist gleichbedeutend mit 1>...
>datei
lenkt die Standardausgabe des Kommandos um auf datei. Das Kom-
mando schreibt seine Ausgabe in datei.
datei
Name der Datei, auf die die Standardausgabe umgelenkt werden
soll.
Existiert diese Datei bereits, wird ihr bisheriger Inhalt
gelöscht. Existiert diese Datei noch nicht, wird sie neu
angelegt.
Beachten Sie, daß die Shell zu diesem Zeitpunkt die Sonder-
zeichen *, ? und [...] noch nicht interpretiert hat. Verwen-
den Sie deshalb bei der Angabe von datei diese Sonderzeichen
nicht.
>&- Für das Kommando ist die Standardausgabe geschlossen. Das Kom-
mando gibt also nichts aus.
Seite 56 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Beispiel:
$ ls >&-
$
>&zahl
lenkt die Standardausgabe des Kommandos um auf die Datei, die der
Dateikennzahl zahl zugewiesen ist. Das Kommando schreibt seine
Ausgabe in diese Datei.
zahl Dateikennzahl der Datei, auf die die Standardausgabe umge-
lenkt werden soll.
Das Zeichen & nach > bedeutet also für die Shell, daß die nach-
folgende Angabe eine Dateikennzahl und nicht ein Dateiname ist.
>>datei
lenkt die Standardausgabe des Kommandos um auf datei. Das Kom-
mando schreibt seine Ausgabe in datei.
datei
Name der Datei, auf die die Standardausgabe umgelenkt werden
soll.
Existiert diese Datei bereits, wird die Ausgabe des Komman-
dos an den bisherigen Inhalt der Datei angehängt. Existiert
diese Datei noch nicht, wird sie neu angelegt.
Beachten Sie, daß die Shell zu diesem Zeitpunkt die Sonder-
zeichen *, ? und [...] noch nicht interpretiert hat. Verwen-
den Sie deshalb bei der Angabe von datei diese Sonderzeichen
nicht.
Die Standardfehlerausgabe für ein Kommando umlenken
Die Angabe 2> leitet die Umlenkung der Standardfehlerausgabe ein. Die
Dateikennzahl 2 müssen Sie angeben.
2>datei
lenkt die Standardfehlerausgabe des Kommandos um auf datei. Das
Kommando schreibt seine Fehlermeldungen in datei.
datei
Siehe Beschreibung zu >datei.
2>&1 Die Standardfehlerausgabe wird umgelenkt auf die Datei, der die
Dateikennzahl 1 zugewiesen ist (siehe Beschreibung zu >&zahl).
Die Fehlermeldungen und die Ausgaben des Kommandos werden nach-
einander in die entsprechende Datei eingetragen.
Seite 57 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
2>>datei
lenkt die Standardfehlerausgabe des Kommandos auf datei um. Das
Kommando schreibt seine Fehlermeldungen in datei.
datei
Siehe Beschreibung zu >>datei.
Mehrere Umlenkungen zu einem Kommando
Umlenkungen können Sie an beliebiger Stelle innerhalb der Kommando-
zeile angeben. Auch mehrere Umlenkungen in einer Kommandozeile sind
möglich:
- Sie können gleichzeitig die Standardeingabe und die Standardausgabe
eines Kommandos umlenken. Die beiden Dateien, in die umgelenkt
wird, sollten aber verschiedene Namen tragen. Sonst löscht die
Shell die Datei, bevor das Kommando die Eingabe lesen konnte.
Beispiel:
$ <liste sort >liste
Nach der Ausführung dieses Kommandos ist die Datei liste leer.
Die Shell lenkt die Standardeingabe und die Standardausgabe
für sort um, bevor sie sort startet. Die Angabe >liste bedeu-
tet, der alte Inhalt der Datei liste wird gelöscht. Deshalb
erhält sort keine Daten zum Sortieren und gibt auch nichts
aus.
- Sie können gleichzeitig die Standardausgabe und die Standardfehler-
ausgabe eines Kommandos umlenken. Dabei ist die Reihenfolge dieser
Umlenkungen zu beachten. Die Shell wertet die Umlenkungen von links
nach rechts aus.
Beispiel:
1>ausgabe 2>&1
Die Shell lenkt zuerst die Standardausgabe um auf die Datei
ausgabe. Dann lenkt sie die Standardfehlerausgabe um auf die
Datei, der die Dateikennzahl 1 zugewiesen ist. Das ist die
Datei ausgabe.
Die Datei ausgabe enthält also die Ausgaben und die Fehlermel-
dungen des entsprechenden Kommandos.
In anderer Reihenfolge:
2>&1 1>ausgabe
Seite 58 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Die Shell lenkt zuerst die Standardfehlerausgabe um auf die
Datei, der die Dateikennzahl 1 zugewiesen ist. Das ist stan-
dardmäßig der Bildschirm, d. h. die Datei /dev/tty. Dann lenkt
sie die Standardausgabe um auf die Datei ausgabe. Die Datei
ausgabe enthält also nur die Ausgaben, aber nicht die Fehler-
meldungen des entsprechenden Kommandos.
ARGUMENTE DURCH PASSENDE DATEINAMEN ERSETZEN
Bei der Bearbeitung der Kommandozeile sucht die Shell nach Argumenten,
die eines der folgenden Sonderzeichen enthalten (siehe Abschnitt WIE
BEARBEITET DIE SHELL DIE KOMMANDOZEILE?, Schritt 9):
* ? [
Diese Argumente vergleicht die Shell als Muster mit den Dateinamen im
entsprechenden Verzeichnis. Wenn die Shell zu einem Argument einen
passenden Dateinamen findet, ersetzt sie das Argument durch diesen
Dateinamen. Wenn mehrere Dateinamen passen, ersetzt die Shell das
Argument durch die sortierte Liste aller passenden Dateinamen. Jeder
Dateiname ist ein eigenständiges Argument.
Wenn kein Dateiname paßt, verwendet die Shell das unveränderte Muster
als Dateinamen.
Wenn das Muster keinen Schrägstrich / enthält, sucht die Shell die
passenden Dateinamen immer im aktuellen Verzeichnis. Wenn das Muster
zu Dateinamen passen soll, die mit einem Punkt "." beginnen, muß die-
ser Punkt als erstes Zeichen des Musters angegeben sein. Punkte an
beliebiger Stelle innerhalb eines Dateinamens dagegen müssen Sie im
Muster nicht angeben.
Ein Muster für Dateinamen ist eine beliebige Zeichenkette, die eines
der folgenden Sonderzeichen oder eine beliebige Kombination daraus
enthält:
* als eigenständiges Muster:
Die Shell ersetzt * durch die Namen aller Dateien im aktuellen
Verzeichnis, die nicht mit einem Punkt "." beginnen.
Ist das aktuelle Verzeichnis leer, verwendet die Shell das Zei-
chen * unverändert als Dateinamen.
als Bestandteil eines Musters:
Die Shell ersetzt * durch kein, ein oder mehrere Zeichen, ent-
sprechend den Dateinamen im aktuellen Verzeichnis, zu denen das
Muster paßt. Unter den Zeichen, die * ersetzen, kann auch ein
Punkt sein, aber nur, wenn * nicht das erste Zeichen des Musters
ist.
Seite 59 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Ist das aktuelle Verzeichnis leer oder paßt kein Dateiname zum
angegebenen Muster, verwendet die Shell das unveränderte Muster
mit dem Zeichen * als Dateinamen.
Das Sonderzeichen * wird nicht ersetzt durch:
- einen Schrägstrich "/"
- einen Punkt ".", wenn * das erste Zeichen des Musters ist.
? Die Shell ersetzt ? durch genau ein Zeichen, entsprechend den
Dateinamen im aktuellen Verzeichnis, zu denen das Muster paßt.
Das Sonderzeichen ? kann auch durch einen Punkt ersetzt werden,
aber nur, wenn ? nicht das erste Zeichen des Musters ist.
Ist das aktuelle Verzeichnis leer oder paßt kein Dateiname zum
angegebenen Muster, verwendet die Shell das unveränderte Muster
mit dem Zeichen ? als Dateinamen.
Das Sonderzeichen ? wird nicht ersetzt durch:
- einen Schrägstrich "/"
- einen Punkt ".", wenn * das erste Zeichen des Musters ist.
[s] ersetzt die Shell durch genau ein Zeichen, das in der Zeichen-
kette s enthalten ist, entsprechend den Dateinamen im aktuellen
Verzeichnis, zu denen das Muster paßt. Die eckigen Klammern müs-
sen Sie angeben.
Ist das aktuelle Verzeichnis leer oder paßt kein Dateiname zum
angegebenen Muster, verwendet die Shell das unveränderte Muster
[s] als Dateinamen.
s Zeichenkette. s darf einfache Zeichen mit Ausnahme des
Schrägstrichs / enthalten. Wenn das Muster zu Dateinamen
passen soll, die mit einem Punkt "." beginnen, darf dieser
Punkt nicht innerhalb der eckigen Klammern stehen. Beachten
Sie, daß das Ausrufezeichen ! als erstes Zeichen und das
Minuszeichen - innerhalb der eckigen Klammern eine Sonderbe-
deutung haben. Die Zeichen * und ? haben innerhalb der ecki-
gen Klammern keine Sonderbedeutung.
[!s] ersetzt die Shell durch genau ein Zeichen, das in der Zeichen-
kette s nicht enthalten ist, entsprechend den Dateinamen im aktu-
ellen Verzeichnis, zu denen das Muster paßt. Die eckigen Klammern
müssen Sie angeben.
Ist das aktuelle Verzeichnis leer oder paßt kein Dateiname zum
angegebenen Muster, verwendet die Shell das unveränderte Muster
[!s] als Dateinamen.
Seite 60 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
s wie bei [s].
[c1-c2]
ersetzt die Shell durch genau ein Zeichen aus dem innerhalb der
eckigen Klammern angegebenen Bereich, entsprechend den Dateinamen
im aktuellen Verzeichnis, zu denen das Muster paßt. Die eckigen
Klammern müssen Sie angeben.
Ist das aktuelle Verzeichnis leer oder paßt kein Dateiname zum
angegebenen Muster, verwendet die Shell das unveränderte Muster
mit den eckigen Klammern als Dateinamen.
c1-c2 legt einen Zeichenbereich fest. Zu diesem Bereich gehören
alle Zeichen, die im ASCII-Zeichensatz zwischen c1 und c2
liegen. c1 und c2 gehören zu diesem Bereich. Sie können
auch mehrere Zeichenbereiche ohne Trennzeichen angeben.
c1 c1 darf ein einfaches Zeichen außer Schrägstrich / sein.
Wenn das Muster zu Dateinamen passen soll, die mit einem
Punkt "." beginnen, muß dieser Punkt das erste Zeichen
des Musters sein, also vor der öffnenden eckigen Klammer
[ stehen.
Beachten Sie, daß das Ausrufezeichen | als erstes Zeichen
und das Minuszeichen - innerhalb der eckigen Klammern
eine Sonderbedeutung haben.
Die Zeichen * und ? haben innerhalb der eckigen Klammern
keine Sonderbedeutung.
c2 c2 darf ein einfaches Zeichen außer Schrägstrich / sein.
[!c1-c2]
ersetzt die Shell durch genau ein Zeichen, das nicht zu dem
innerhalb der eckigen Klammern angegebenen Bereich gehört, ent-
sprechend den Dateinamen im aktuellen Verzeichnis, zu denen das
Muster paßt. Die eckigen Klammern müssen Sie angeben.
Ist das aktuelle Verzeichnis leer oder paßt kein Dateiname zum
angegebenen Muster, verwendet die Shell das unveränderte Muster
mit den eckigen Klammern als Dateinamen.
c1-c2 legt einen Zeichenbereich fest (siehe Beschreibung zu
[c1-c2]).
[:klasse:]
Ausdruck für Zeichenklasse. [:klasse:] steht für alle Zeichen,
die in der Zeichenklasse klasse enthalten sind.
Ausdrücke für Zeichenklassen dürfen nur innerhalb eines zweiten
Paares von eckigen Klammern verwendet werden. z. B. [c[:digit:]].
Seite 61 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Die Zeichenklassen werden in einer internationalisierten Umgebung
durch die Umgebungsvariablen LCCTYPE bzw. LANG definiert.
klasse kann sein:
alpha alle Buchstaben
upper alle Großbuchstaben
lower alle Kleinbuchstaben
digit alle Dezimalziffern (0 bis 9)
xdigit alle Hexadezimalziffern (0 bis 9, a bis f und A bis F)
alnum alle alphanumerischen Zeichen (Buchstaben und Ziffern)
space alle Zeichen, die bei der Textdarstellung Zwischenraum
produzieren (z. B. Leer- oder Tabulatorzeichen)
punct alle Trennzeichen
print alle abdruckbaren Zeichen (einschließlich der Zeichen
in space)
graph alle sichtbaren abdruckbaren Zeichen (ohne die Zeichen
in space)
cntrl alle Steuerzeichen
[=c=]
Ausdruck für Äquivalenzklasse. [=c=] steht für alle Zeichen bzw.
Zeicheneinheiten, die in der aktuell gültigen Sortierreihenfolge
die gleiche relative Ordnung wie c haben.
Ein Zeichen bzw. eine Zeicheneinheit, die in der ASCII-Sortier-
reihenfolge die gleiche relative Ordnung wie c hat.
Ausdrücke für Äquivalenzklassen dürfen nur innerhalb eines zwei-
ten Paares von eckigen Klammern verwendet werden. z. B.
[[=a=]bc].
Die Sortierreihenfolge wird in einer internationalisierten Umge-
bung durch die Umgebungsvariable LCCOLLATE bzw. LANG definiert.
[.cc.]
Zeicheneinheits-Symbol. Zeicheneinheiten, die aus mehreren Zei-
chen bestehen, müssen in dieser Form dargestellt werden, um sie
von einfachen Zeichen zu unterscheiden. Beim Sortieren wird ein
solcher Ausdruck als ein einziges Zeichen betrachtet. cc muß in
der aktuell gültigen Sortierreihenfolge als zulässige Zeichenein-
heit definiert sein.
Seite 62 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Zeicheneinheits-Symbole dürfen nur innerhalb eines zweiten Paares
von eckigen Klammern verwendet werden, z. B. [c[.ch.]d].
Die Sortierreihenfolge wird in einer internationalisierten Umge-
bung durch die Umgebungsvariable LCCOLLATE bzw. LANG definiert.
Innerhalb der eckigen Klammern können Sie Zeichenbereiche c1-c2 und
einzelne Zeichen c bzw. Zeicheneinheits-Symbole [.cc.], Ausdrücke für
Zeichenklassen [:klasse:] und Ausdrücke für Äquivalenzklassen [=c=]
beliebig ohne Trennzeichen aneinanderhängen. Wenn Sie mit dem Ausrufe-
zeichen ! einzelne Zeichen oder Zeichenbereiche ausschließen wollen,
müssen Sie es als erstes Zeichen nach [ angeben. Ein Ausrufezeichen,
das nicht als erstes Zeichen innerhalb der eckigen Klammern angegeben
ist, hat keine Sonderbedeutung.
Vorsicht:
Es hängt vom aktuellen Zeichensatz und von der aktuell gültigen
Sortierreihenfolge ab, welche Zeichen ein Bereich [c1-c2] umfaßt.
Zum Beispiel löscht das Kommando rm [a-z]* in der Umgebung
LANG=LCCOLLATE=EnUS.ASCII alle Dateien, deren Name mit einem
Kleinbuchstaben von a bis z beginnt. In manchen Umgebungen dage-
gen enthält der Bereich a-z auch Großbuchstaben; in diesem Fall
löscht das obige Kommando auch Dateien, deren Name mit einem
Großbuchstaben beginnt. Andererseits gibt es in manchen Sprachen,
wie z. B. der norwegischen, Kleinbuchstaben, die nach z einsor-
tiert sind. Stellen Sie deshalb in einer internationalen Umgebung
Zeichenklassen wie, z. B. Kleinbuchstaben, mit dem Ausdruck
[:klasse:] dar; der obige rm-Aufruf würde dann lauten: rm
[[:lower:]]*.
Shell-Prozeduren, die in nicht-internationalisierten Umgebungen
(oder in Mißachtung der geschilderten Gefahren) erstellt wurden,
sollten in einer nicht-internationalisierten Umgebung ausgeführt
werden, d. h. die NLS-Variablen LANG, LCCOLLATE usw. sollten
undefiniert oder leer sein.
WIE BEARBEITET DIE SHELL DIE KOMMANDOZEILE?
Im Dialog schliessen Sie mit CR Ihre Eingabe ab und übergeben die Kom-
mandozeile an die Shell. In welchen Portionen die Shell die Eingabe
erhält, ist abhängig von der Einstellung des jeweiligen Terminals
[siehe stty(1)]. Eine Prozedur-Shell erhält als Eingabe den Inhalt der
entsprechenden Shell-Prozedur.
Die Kommandozeile kann mehrere Kommandos enthalten, die durch Kommando-
Trennzeichen voneinander getrennt sind. Innerhalb einer Shell-Prozedur
sind auch Neue-Zeile-Zeichen als Kommando-Trennzeichen zugelassen. Die
Shell bearbeitet der Reihe nach jedes einzelne Kommando und führt es
aus. Deshalb bezeichnet in der nachfolgenden Beschreibung der Begriff
Kommandozeile die logische Einheit, die durch ein nicht entwertetes
Kommando-Trennzeichen begrenzt ist. Erst wenn die Shell alle Kommandos
der Eingabe ausgeführt hat, gibt sie wieder ihr Bereitzeichen aus.
Seite 63 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Die Shell bearbeitet jede Kommandozeile in mehreren Schritten. Die
einzelnen Bearbeitungsschritte führt die Shell für jede Kommandozeile
einmal aus. Die Reihenfolge dieser Schritte liegt fest. Diese Reihen-
folge sollten Sie beachten, damit die Shell Ihre Eingaben wie
gewünscht bearbeiten kann.
Wie die Shell eine Kommandozeile bearbeitet, ist auch abhängig von den
Shell-Optionen, die Sie beim Aufruf dieser Shell oder nachträglich mit
set gesetzt haben.
Die einzelnen Schritte in chronologischer Reihenfolge:
1. Die Shell liest die Kommandozeile bis zum ersten Kommando-Trenn-
zeichen, das nicht entwertet ist, und sucht nach Hochkommata
Anführungszeichen und Gegenhochkommas.
2. Die Shell stellt fest, ob die Kommandozeile Eingabe- bzw. Ausga-
be-Umlenkungen oder Variablen-Zuweisungen enthält.
3. Die Shell zerlegt die Kommandozeile in einzelne Argumente.
4. Die Shell ersetzt angegebene Variablen durch ihren Wert.
5. Die Shell ersetzt Kommandos, die in Gegenhochkommas eingeschlossen
sind, durch ihre Ausgabe.
6. Die Shell lenkt die Standardeingabe, die Standardausgabe bzw. die
Standardfehlerausgabe auf die angegebenen Dateien um.
7. Die Shell führt Variablen-Zuweisungen aus.
8. Die Shell zerlegt die so bearbeitete Zeile nochmals in Argumente,
entsprechend den Argument-Trennzeichen, die der Variablen IFS
zugewiesen sind.
9. Die Shell ersetzt Argumente durch passende Dateinamen, falls sie
eines der folgenden Zeichen bzw. Zeichenketten enthalten: * ?
[...] [!...]
10. Die Shell führt das Kommando aus.
Die Bearbeitungsschritte 5, 6 und 7 werden nur dann ausgeführt, wenn
die Shell in Schritt 1 und Schritt 2 die entsprechenden Sonderzeichen
in der Kommandozeile erkannt hat.
Schritt 1: bis zum ersten Kommando-Trennzeichen lesen
Die Shell liest von der Standardeingabe oder aus einer Datei bis zum
ersten Kommando-Trennzeichen:
Neue-Zeile-Zeichen ; & | && ||
Seite 64 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Wenn Sie nach dem Bereitzeichen der Shell kein Kommando eingeben, son-
dern sofort CTRL-D drücken, beendet sich die aktuelle Shell. Wenn die
Subshell, die eine Shell-Prozedur ausführt, das letzte Kommando der
Prozedur ausgeführt hat, erhält sie Datei-Ende (EOF) und beendet sich.
Das gilt jedoch nicht, wenn Sie eine Shell-Prozedur mit dem eingebau-
ten sh-Kommando "." (Punkt) starten. Die aktuelle Shell, die diese
Prozedur ausführt, beendet sich nicht, wenn sie Datei-Ende erhält.
Dabei durchsucht die Shell die gelesenen Daten
- nach Entwertungszeichen:
\ '...' "..."
Die dadurch entwerteten Sonderzeichen sind ab jetzt vor der Inter-
pretation durch die Shell geschützt (siehe Sonderzeichen für die
Shell entwerten oben).
- nach Gegenhochkommas:
`kommando`
Dieser Ausdruck soll in Schritt 5 durch die Ausgabe von kommando
ersetzt werden (siehe Abschnitt KOMMANDOS DURCH IHRE AUSGABE ERSET-
ZEN oben). Die Shell führt diese Aktion in Schritt 5 nur aus, wenn
sie die Gegenhochkommas in Schritt 1 erkennt.
Die Shell schützt kommando vor der Bearbeitung in Schritt 3. Die
Behandlung ist so, als ob der Ausdruck in Anführungszeichen einge-
schlossen wäre: "kommando".
Wenn in der aktuellen Shell die Option -v gesetzt ist, gibt die Shell
die Kommandozeile nach dem 1. Schritt aus [siehe set(1)].
Schritt 2: die Sonderzeichen > oder < und = suchen
Die Shell sucht nach den folgenden Sonderzeichen, die in einem späte-
ren Bearbeitungsschritt Aktionen auslösen:
> oder <
in Schritt 6 soll die Standardeingabe, die Standardausgabe oder
die Standardfehlerausgabe entsprechend den weiteren Angaben umge-
lenkt werden (siehe EINGABE UND AUSGABE EINES KOMMANDOS UMLENKEN
oben).
= in Schritt 7 soll einer Variablen ein Wert zugewiesen werden
(siehe Abschnitt SHELL-VARIABLEN oben).
Die Shell führt diese Aktionen nur aus, wenn sie die angegebenen Son-
derzeichen zu diesem Zeitpunkt erkennt.
Seite 65 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Schritt 3: in Argumente zerlegen
Die Shell zerlegt die Kommandozeile in Argumente. Argument-Trennzei-
chen für diesen Bearbeitungsschritt sind:
Leerzeichen Tabulatorzeichen
Anschließend entfernt sie alle Argument-Trennzeichen aus der Kommando-
zeile. Auf die Variable IFS greift die Shell erst im achten Schritt
zu, wenn sie die Kommandozeile zum zweiten Mal in Argumente zerlegt.
Außerdem prüft die Shell, ob das erste Argument der Kommandozeile,
also das Argument, das direkt auf ein Kommando-Trennzeichen folgt,
eines der folgenden Schlüsselwörter oder Sonderzeichen ist (siehe auch
DIE SHELL ALS PROGRAMMIERSPRACHE unten):
if elif case for while until { (
Wenn ja, entfernt sie das Schlüsselwort bzw. die öffnende runde Klam-
mer aus der Kommandozeile. Dann wiederholt sie die Schritte 1 bis 3
für die nachfolgenden Kommandozeilen bis zu der Kommandozeile, die mit
dem entsprechenden abschließenden Schlüsselwort oder der schließenden
Klammer beginnt:
fi esac done } )
Stößt die Shell dabei auf einen Syntaxfehler, so gibt sie eine Fehler-
meldung aus und bricht die weitere Bearbeitung ab.
Schritt 4: Variablen durch ihren Wert ersetzen
Die Shell sucht nach dem Zeichen $ gefolgt von einem zulässigen
Variablen-Namen:
$0 $1 $2 ... $9 $* $@ $# $? $! $$ $- $name ${...}
Die entsprechenden Shell-Variablen ersetzt die Shell durch ihren Wert.
Nicht definierte Variablen ersetzt die Shell durch die leere Zeichen-
kette (siehe auch SHELL-VARIABLEN und SHELL-PARAMETER oben).
Schritt 5: Kommandos durch ihre Ausgabe ersetzen
Die Shell bearbeitet die Zeichenketten, die in Gegenhochkommas `...`
eingeschlossen sind. Allerdings gilt das nur für die Gegenhochkommas,
die die Shell bereits in Schritt 1 erkannt hat:
`kommando`
Wenn Sie innerhalb der Gegenhochkommas die Standardausgabe umgelenkt
haben, wird `kommando` ersetzt durch die leere Zeichenkette.
Seite 66 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Innerhalb der Gegenhochkommas können auch mehrere Kommandos stehen,
jeweils getrennt durch ein Kommando-Trennzeichen (siehe auch KOMMANDOS
DURCH IHRE AUSGABE ERSETZEN oben).
Schritt 6: Standardeingabe, -ausgabe bzw. -fehlerausgabe umlenken
Die Shell bearbeitet die Argumente der Kommandozeile, bei denen sie in
Schritt 2 eines der folgenden Zeichen gefunden hat:
< <&- <& << <<- > >&- >& >>
Nach der Umlenkung entfernt die Shell die dafür verantwortlichen Argu-
mente aus der Kommandozeile. Das Kommando selbst merkt nichts von der
Umlenkung (siehe auch EINGABE UND AUSGABE EINES KOMMANDOS UMLENKEN
oben).
Schritt 7: Werte an Variablen zuweisen
Die Shell bearbeitet die Stellen der Kommandozeile, an denen sie in
Schritt 2 auf ein Gleichheitszeichen = gestoßen ist (siehe auch
SHELL-VARIABLEN und DIE UMGEBUNG oben).
Die Kommandozeile kann nach den sechs vorausgegangenen Bearbeitungs-
schritten wie folgt aussehen:
name=wert ...
Wenn die Kommandozeile nur eine Zuweisung, aber keinen Kommando-
namen enthält, legt die aktuelle Shell die Variable name an und
weist ihr wert zu. Eine Kommandozeile kann auch mehrere Zuweisun-
gen enthalten.
Wenn die Shell allen angegebenen Variablen die entsprechenden
Werte zugewiesen hat, ist die Kommandozeile fertig bearbeitet.
Die Shell führt also die Schritte 8 bis 10 nicht mehr aus.
Die aktuelle Umgebung enthält ab jetzt diese neuen Variablen.
Sollen die Variablen auch in einer Subshell bekannt sein, so müs-
sen sie exportiert werden [siehe eingebautes sh-Kommando
export(1)]. Wenn die Shell-Option -a gesetzt ist, werden diese
Variablen automatisch exportiert [siehe eingebautes sh-Kommando
set(1) und sh-Optionen].
name=wert ... kommando
Wenn die Kommandozeile zusätzlich zu einer Zuweisung einen Kom-
mandonamen enthält, trägt die aktuelle Shell die angegebene
Variable nicht in die aktuelle Umgebung ein, sondern nur in die
Umgebung für kommando. Vor dem Kommandonamen können auch mehrere
Zuweisungen stehen.
Anschließend entfernt sie die Zuweisungen aus der Kommandozeile
und startet das angegebene kommando in der neuen Umgebung.
Seite 67 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Wenn Sie in der aktuellen Shell mit set die Option -k gesetzt
haben, können Sie diese Zuweisungen auch hinter den Kommandonamen
schreiben [siehe set(1)].
Schritt 8: in Argumente zerlegen
Die Shell zerlegt die Kommandozeile nochmals in Argumente. Argument-
Trennzeichen sind die Zeichen, die der Variablen IFS zugewiesen sind.
Standardmäßig sind der Variablen IFS zugewiesen:
Leerzeichen Tabulatorzeichen Neue-Zeile-Zeichen
In Schritt 8 interpretiert die Shell ein Neue-Zeile-Zeichen nicht mehr
als Kommando-Trennzeichen.
Diese zweite Zerlegung ist notwendig, weil sich die Kommandozeile seit
Schritt 3 möglicherweise verändert hat:
- Die Variablen sind durch ihre Werte ersetzt worden (Schritt 4).
- Kommandos in Gegenhochkommas sind durch ihre Ausgaben ersetzt wor-
den (Schritt 5).
- Schlüsselwörter und runde Klammern hat die Shell aus der Kommando-
zeile entfernt (Schritt 3).
- Umlenkungs- und Zuweisungsargumente hat die Shell aus der Kommando-
zeile entfernt (Schritt 6 und Schritt 7).
Anschließend entfernt die Shell alle Argument-Trennzeichen aus der
Kommandozeile. Außerdem entfernt sie die leeren Zeichenketten, die
nicht in Anführungszeichen oder Hochkommata eingeschlossen sind. Sol-
che nicht geschützten leeren Zeichenketten entstehen, wenn die Shell
nicht definierte Variablen durch die leere Zeichenkette ersetzt. Leere
Zeichenketten der Form "" oder '' bleiben als Argumente erhalten.
Nach dieser Zerlegung enthält das erste Argument den späteren Komman-
donamen, die weiteren Argumente die späteren Aufrufargumente für das
Kommando.
Schritt 9: Argumente durch passende Dateinamen ersetzen
Die Shell sucht nach Argumenten, die eines der folgenden Sonderzeichen
enthalten:
* ? [
Diese Argumente vergleicht die Shell als Muster mit den Dateinamen im
entsprechenden Verzeichnis (siehe Abschnitt ARGUMENTE DURCH PASSENDE
DATEINAMEN ERSETZEN oben).
Seite 68 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Wenn die Shell zu einem Argument einen passenden Dateinamen findet,
ersetzt sie das Argument durch diesen Dateinamen. Wenn mehrere Datei-
namen passen, ersetzt die Shell das Argument durch die sortierte Liste
aller passenden Dateinamen. Jeder Dateiname ist ein eigenständiges
Argument.
Wenn kein Dateiname paßt, verwendet die Shell das unveränderte Muster
als Dateinamen.
Wenn in der aktuellen Shell die Option -f gesetzt ist, entfällt dieser
Bearbeitungsschritt. Wenn in der aktuellen Shell die Option -n gesetzt
ist, gibt die Shell die Kommandozeile nach Schritt 9 aus. Der Schritt
10 entfällt [siehe set(1)].
Schritt 10: das Kommando ausführen
Die Kommandozeile enthält jetzt nur noch die Argumente, die für die
Ausführung des entsprechenden Kommandos nötig sind. Die Shell inter-
pretiert das erste Argument als den Namen des Kommandos, das sie aus-
führen soll. Die übrigen Argumente interpretiert die Shell als Aufru-
fargumente für dieses Kommando und übergibt sie beim Aufruf an das
Kommando.
Den Kommandonamen prüft die Shell in der folgenden Reihenfolge:
⊕ Ist das Kommando ein eingebautes sh-Kommando?
Wenn ja, führt die Shell dieses Kommando selbst aus. Wenn nein,
prüft die Shell weiter.
⊕ Ist das Kommando eine Shell-Funktion?
Wenn ja, führt die Shell diese Funktion selbst aus.
Wenn nein, nimmt die Shell an, daß es sich um ein externes Kommando
handelt. Deshalb erzeugt sie mit fork(2) einen neuen Prozeß. Dieser
Prozeß ist eine Kopie der aufrufenden Shell, der neue Prozeß erbt
also die Umgebung der aufrufenden Shell. Dieser neue Shell-Prozeß
arbeitet jetzt weiter:
⊕ Enthält der Kommandoname einen Schrägstrich / ?
Wenn ja, versucht der Shell-Prozeß, das entsprechende Kommando
unter dem angegebenen Namen mit exec(2) zu starten, ohne Zugriff
auf die Variable PATH.
Eine eingeschränkte Shell weist Kommandos sofort ab, wenn im Namen
ein Schrägstrich enthalten ist (siehe sh, Option -r).
Enthält der Kommandoname keinen /, wird der Name in der aktuellen
Hash-Tabelle [siehe hash(1)] gesucht:
Seite 69 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
- Enthält die Hash-Tabelle diesen Namen, versucht der Shell-Prozeß,
das Kommando unter dem in der Hash-Tabelle angegebenen absoluten
Pfadnamen mit exec(2) zu starten, ohne Zugriff auf die Variable
PATH.
- Steht der Kommandoname nicht in der Hash-Tabelle, wird die
Variable PATH ausgewertet. Der absolute Pfadname des Kommandos
wird zusammengesetzt aus dem ersten Pfadnamen der Variablen
PATH, einem / und dem Kommandonamen. Anschließend versucht der
Shell-Prozeß, das Kommando unter diesem absoluten Pfadnamen mit
exec(2) zu starten.
⊕ Kann der Systemaufruf exec(2) die Datei laden?
Wenn ja, wird das Kommando ausgeführt. Bei Kommandos, die im Hin-
tergrund ausgeführt werden sollen, meldet sich die aufrufende Shell
sofort mit ihrem Bereitzeichen zurück. Bei allen anderen Kommandos
wartet sie auf das Ende der Ausführung.
Bei Kommandos, die mit ihrem einfachen Dateinamen aufgerufen wur-
den, wird die Hash-Tabelle aktualisiert. Ein Kommando, das noch
nicht in der Hash-Tabelle stand, wird wie folgt eingetragen:
hits costs command
1 1 absoluter Pfadname
| | |
| | |
| | Kommandodatei
| |
| ausführbare Datei im ersten Verzeichnis aus PATH
| gefunden, also exec(2) nur einmal aufgerufen
|
in der aktuellen Shell einmal ausgeführt
War das Kommando bereits in die Hash-Tabelle eingetragen, so wird
nur in der entsprechenden Zeile der Wert in der Spalte hits um 1
erhöht [siehe hash(1)].
Wenn exec(2) die Datei nicht laden kann, hat das eine der folgenden
Ursachen:
- Die Datei dieses Namens ist keine Binär-Datei (z. B. a.out-For-
mat). Dann muß die Datei eine Shell-Prozedur sein. Der aktuelle
Shell-Prozeß liest die Datei und führt die Kommandos entspre-
chend den hier beschriebenen Schritten aus.
- Der Benutzer, der das Kommando aufgerufen hat, hat kein Ausführ-
recht für diese Datei. In diesem Fall meldet sich die aufrufende
Shell zurück mit der Fehlermeldung:
kommando: execute permission denied.
Seite 70 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
- exec(2) findet diese Datei nicht. Wenn der Aufruf-Name einen /
enthielt oder das Kommando bereits in der Hash-Tabelle eingetra-
gen war (also kein Zugriff auf die Variable PATH), meldet sich
die aufrufende Shell zurück mit der Fehlermeldung:
kommando: not found.
Andernfalls wertet der Shell-Prozeß nochmals die Variable PATH
aus. Er versucht, das Kommando mit exec(2) unter dem absoluten
Pfadnamen zu starten, der sich aus dem zweiten Pfadnamen der
Variablen PATH ergibt.
Wenn exec(2) die Datei nicht findet, wiederholt sich der Vorgang
mit dem nächsten Pfadnamen der Variablen PATH. Weitere Wiederho-
lungen sind solange möglich, bis alle Pfadnamen aus PATH ausge-
wertet sind.
Wenn exec(2) die Datei nicht findet, obwohl alle Pfadnamen der
Variablen PATH ausgewertet sind, meldet sich die aufrufende
Shell zurück mit der Fehlermeldung
kommando: not found.
DIE SHELL ALS PROGRAMMIERSPRACHE
Die Shell bietet die wesentlichen Elemente einer Programmiersprache:
- Variablen
- Parameter
- eingebaute Funktionen; das sind die eingebauten sh-Kommandos
- Kommentare
- Makros; das sind die Shell-Funktionen
- Ablaufanweisungen
Jede Kommandozeile, die Sie nach dem Bereitzeichen der Shell eingeben,
ist bereits ein kleines Shell-Programm. Die Shell interpretiert diese
Zeile nach bestimmten Regeln und führt das entsprechende Kommando aus
(siehe WIE BEARBEITET DIE SHELL DIE KOMMANDOZEILE? oben).
Größere Programme erstellen Sie mit einem Editor: Sie legen eine Datei
an und tragen dort alle Kommandos ein, die die Shell der Reihe nach
ausführen soll. Diese Shell-Prozeduren müssen nicht übersetzt werden.
Wenn Sie eine Shell-Prozedur mit sh dateiname aufrufen, erzeugt die
Shell eine Subshell, die jede Zeile der Datei liest, interpretiert und
ausführt. Sind alle Kommandos aus dieser Datei ausgeführt, beendet
sich die Subshell, und die übergeordnete Shell meldet sich zurück.
Seite 71 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Dieser Abschnitt beschreibt,
- wie Sie Shell-Prozeduren kommentieren,
- wie Sie Shell-Funktionen erstellen und aufrufen,
- und die Ablaufanweisungen der Shell in alphabetischer Reihenfolge
Kommentare in Shell-Prozeduren
Das Nummernzeichen # leitet einen Kommentar ein. Die Shell ignoriert
alle auf # folgenden Zeichen bis zum ersten Neue-Zeile-Zeichen, auch
wenn es entwertetet ist.
Beispiel:
In einer Shell-Prozedur können Kommentare wie folgt angegeben
sein:
date # Kommentar
echo \# leitet keinen Kommentar ein
pwd #Kommentar
date # ein Kommentar, der trotzdem hier endet \
echo \# ein Kommentar geht nicht über mehrere Zeilen!
Wenn Sie # entwerten, verliert es seine Sonderbedeutung als
Kommentar-Zeichen.
Es gibt aber noch eine andere Möglichkeit, Kommentare einzuleiten, und
zwar mit dem eingebauten sh-Kommando : (Doppelpunkt). Dieses Kommando
gibt nur den Endestatus 0 zurück und tut sonst nichts.
Der nachfolgende Kommentar muß vom Doppelpunkt durch ein Leer- oder
ein Tabulatorzeichen getrennt sein. Bei der Kommentierung mit : müssen
Sie folgendes beachten:
- Die Shell interpretiert die Aufrufargumente, also den Kommentar.
Insbesondere ersetzt sie darin vorkommende Shell-Parameter durch
deren Wert. Wenn Sie den Kommentar in Hochkommata einschließen,
entwerten Sie alle Sonderzeichen für die Shell.
- Der Doppelpunkt muß immer als erstes Zeichen in einer Zeile stehen
oder auf ein Kommando-Trennzeichen folgen, z. B. auf einen Strich-
punkt ;. Andernfalls erkennt die Shell den Doppelpunkt nicht als
Kommando.
Beispiel für Kommentare mit : (Doppelpunkt):
: Die Shell-Prozedur zeigt mögliche Kommentare \
sie gibt die Prozeß-Nummer der Shell und das Datum aus
echo $$; : '$$ ist die Prozeß-Nummer der aktuellen Shell'; date
Seite 72 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Mit : (Doppelpunkt) können Sie Kommentare über mehrere Zeilen
schreiben oder zwischen zwei Kommandos, die in derselben Zeile ste-
hen.
SHELL-FUNKTIONEN
Eine Shell-Funktion faßt mehrere Kommandos unter einem Namen zusammen.
Dieser Abschnitt beschreibt,
- wie Sie eine Shell-Funktion definieren,
- wie Sie eine Shell-Funktion ausführen,
- wie sich Shell-Funktionen und Shell-Prozeduren unterscheiden,
- und das eingebaute sh-Kommando return.
Eine Shell-Funktion definieren
Die Definition einer Shell-Funktion hat folgendes Format:
______________________________________________________________________
name() { kommandofolge;}
______________________________________________________________________
name Name der Shell-Funktion. Ein Funktionsname muß mit einem Buchsta-
ben oder mit einem Unterstrich _ beginnen. Dem ersten Zeichen
dürfen Buchstaben, Ziffern und Unterstriche in beliebiger Reihen-
folge folgen. Achtung: Gemäß X/Open-Spezifikation dürfen keine
Namen eingebauter Shell-Kommandos [vgl. die Liste im Kapitel EIN-
GEBAUTE SHELL-KOMMANDOS oben sowie unter ksh(1)] verwendet wer-
den.
Eine Shell-Funktion und eine Shell-Variable können nicht den
gleichen Namen tragen. Wenn Sie eine Shell-Funktion mit einem
Namen definieren, unter dem es bereits eine Shell-Variable gibt,
so geht der Wert der Shell-Variablen verloren, und umgekehrt.
kommandofolge
ein oder mehrere Kommandos, wie sie auch in Shell-Prozeduren
erlaubt sind. Die einzelnen Kommandos werden durch ein Neue-
Zeile-Zeichen oder ein anderes Kommando-Trennzeichen getrennt.
Eine Shell-Funktion kann selbst wieder Shell-Funktionen aufrufen
oder definieren.
Die Kommandos aus kommandofolge werden ausgeführt, wenn Sie die
Shell-Funktion aufrufen.
Das Leerzeichen nach der öffnenden geschweiften Klammer kann durch ein
Neue-Zeile-Zeichen ersetzt werden, ebenso wie der Strichpunkt vor der
schließenden geschweiften Klammer.
Seite 73 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Beispiel:
Im Dialog die Shell-Funktion ll definieren:
$ ll() {
> ls -l $*
> }
Mit der Shell-Funktion ll können Sie jetzt das Kommando ls -l
simulieren.
Nach der Definition ist die Shell-Funktion der aktuellen Shell
bekannt. Das eingebaute sh-Kommando set(1) schreibt alle in der aktu-
ellen Shell definierten Shell-Variablen mit ihren Werten und alle in
der aktuellen Shell definierten Funktionen auf die Standardausgabe.
Das eingebaute sh-Kommando type(1) mit einem Funktionsnamen als Argu-
ment gibt ebenfalls die Definition der Shell-Funktion aus.
Sie können Shell-Funktionen nicht exportieren, sie sind nur der Shell
bekannt, in der sie definiert wurden. Bereits definierte Shell-Funkti-
onen können Sie mit unset(1) wieder löschen.
Innerhalb einer Shell-Funktion können Sie auf alle Variablen zugrei-
fen, die der aktuellen Shell bekannt sind. Wie auch bei Shell-Prozedu-
ren können Sie beim Aufruf Stellungsparameter übergeben. Der Shell-
Parameter $0 enthält jedoch nicht den Funktionsnamen, sondern den Auf-
ruf-Namen der aktuellen Shell oder den Namen der Shell-Prozedur, je
nachdem wo Sie die Funktion aufgerufen haben.
Shell-Funktionen in einer Datei definieren
Wenn Sie eine Shell-Funktion immer wieder verwenden wollen, sollten
Sie die Definition in eine Datei schreiben. Diese Datei führen Sie mit
dem eingebauten sh-Kommando "." (Punkt) in der aktuellen Shell aus.
Anschließend können Sie auf diese Funktion in der aktuellen Shell
zugreifen. Sie können in dieser Datei auch mehrere Shell-Funktionen
sammeln.
Eine Shell-Funktion ausführen
Eine Shell-Funktion rufen Sie auf wie ein Kommando. Die aktuelle Shell
führt die Shell-Funktion aus, sie erzeugt also keine Subshell wie bei
Shell-Prozeduren.
Beispiel:
$ ll /dev
So wird die gerade definierte Shell-Funktion ll aufgerufen. Den
Shell-Parameter $* versorgt die Shell mit dem Verzeichnis /dev.
Seite 74 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Beim Aufruf können Sie wie bei Shell-Prozeduren weitere Argumente
angeben. Mit diesen Argumenten versorgt die aktuelle Shell die Stel-
lungsparameter. Sie ändern also beim Aufruf einer Shell-Funktion die
Stellungsparameter der aktuellen Shell wie mit set.
Sie können jedoch eine Shell-Funktion nur in der Shell aufrufen, in
der Sie sie definiert haben.
Variablen-Zuweisungen innerhalb einer Shell-Funktion verändern die
Umgebung der aktuellen Shell.
Unterschiede zwischen Shell-Funktionen und Shell-Prozeduren
Shell-Funktionen sind effizienter als Shell-Prozeduren. Sie werden von
der Shell wie die eingebauten Kommandos bevorzugt ausgeführt. Die
Shell erzeugt keine Subshell, und sie muß die Daten nicht erst aus
einer Datei laden.
Eine Shell-Funktion ist an die Shell gebunden, in der sie definiert
wurde.
Jeder Aufruf einer Shell-Funktion setzt alle Stellungsparameter neu.
Mit dem eingebauten sh-Kommando return(1) können Sie Shell-Funktionen
mit einem vorgegebenen Endestatus beenden. Das Kommando return kann
nur innerhalb von Shell-Funktionen aufgerufen werden. Standardmäßig
beendet sich eine Shell-Funktion, wenn alle Kommandos der Funktion
ausgeführt sind.
Der Endestatus einer Shell-Funktion
Standardmäßig ist der Endestatus einer Shell-Funktion der Endestatus
des innerhalb der Funktion zuletzt ausgeführten Kommandos. Diesen
Endestatus können Sie beispielsweise mit echo $? abfragen.
Wenn Sie eine Shell-Funktion mit einem definierten Endestatus beenden
wollen, sollten Sie das eingebaute sh-Kommando return(1) verwenden.
Dieses Kommando können Sie nur innerhalb einer Shell-Funktion aufru-
fen.
Wie in Shell-Prozeduren könnten Sie auch mit dem eingebauten sh-Kom-
mando exit(1) einen Endestatus festlegen. Das Kommando exit beendet
aber nicht nur die Shell-Prozedur bzw. die Shell-Funktion, sondern
auch die ausführende Shell.
Eine Shell-Funktion beenden
Das eingebaute sh-Kommando return(1) beendet Shell-Funktionen. Beim
Aufruf können Sie mit einer Zahl den Endestatus der entsprechenden
Shell-Funktion festlegen.
Seite 75 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Auch ohne Aufruf von return beenden sich Shell-Funktionen:
- wenn alle Kommandos der Funktion ausgeführt sind. Endestatus ist
der Endestatus des zuletzt ausgeführten Kommandos.
- wenn die ausführende Shell ein Kommando nicht findet oder Syntax-
fehler erkennt. Endestatus ist ein Wert ungleich 0.
Sie können return nur innerhalb einer Shell-Funktion aufrufen.
______________________________________________________________________
return [endestatus]
______________________________________________________________________
endestatus
Eine Zahl zwischen 0 und 256. Mit diesem Endestatus wird die
Shell-Funktion beendet. Wenn Sie eine größere Zahl angeben,
erhalten Sie als Endestatus nicht die angegebene Zahl, sondern
den entsprechenden Wert modulo 256: Die angegebene Zahl wird
durch 256 geteilt, der ganzzahlige Rest ist dann der entspre-
chende Wert modulo 256.
Mit dem Kommando echo $? können Sie den Endestatus abfragen.
endestatus nicht angegeben:
Endestatus der Shell-Funktion ist der Endestatus des Kommandos,
das vor dem Aufruf von return ausgeführt wurde.
Beispiel:
Das Kommando falsenew() läßt sich durch folgende Shell-Funktion
realisieren:
falsenew() {
return 255
}
Ablaufanweisungen der Shell
Zu einer Programmiersprache gehören Ablaufanweisungen. Die Shell bie-
tet die folgenden:
break
Schleifen steuern
case ... esac
abfragen und verzweigen
Seite 76 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
continue
Schleifen steuern
for ... do ... done
Liste in Schleifen abarbeiten
if ... then ... elif ... then ... else ... fi
Bedingungen abfragen und Kommandos ausführen
until ... do ... done
Schleife mit Abbruch-Bedingung
while ... do ... done
Schleife mit Abbruch-Bedingung
Diese Ablaufanweisungen können Sie im Dialog eingeben oder in einer
Shell-Prozedur verwenden. Die folgenden Schlüsselwörter erkennt die
Shell nur, wenn sie am Beginn eines Kommandos stehen, also nach einem
Kommando-Trennzeichen, und wenn sie nicht entwertet sind:
case for
do if
done then
elif until
else while
esac {
fi }
Die geschweiften Klammern fassen die Ausgabe der eingeschlossenen Kom-
mandos zusammen (siehe Kommandofolgen klammern oben).
Die Ablaufanweisungen if, until und while prüfen zuerst eine Bedin-
gung. Bedingungen kann man in der Shell nur durch ein Kommando oder
eine Kommandofolge (siehe Kommandofolgen oben) darstellen. Die Shell
wertet den Endestatus aus.
- Bedingung wahr Das als Bedingung angegebene Kommando oder die Kom-
mandofolge hat einen Endestatus gleich 0.
- Bedingung falsch Das als Bedingung angegebene Kommando oder die
Kommandofolge hat einen Endestatus ungleich 0.
Die Ablaufanweisungen können Sie beliebig kombinieren und schachteln.
Seite 77 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
break - Schleife abbrechen
Das eingebaute sh-Kommando break bricht die Abarbeitung der for-,
until- oder while-Schleife ab, in der es angegeben ist. Eine Shell-
Prozedur wird mit dem Kommando fortgesetzt, das hinter dem nächsten
nicht erreichten done steht.
Schleifen können beliebig tief geschachtelt sein. Wenn Sie mit break
mehrere verschachtelte Schleifen abbrechen wollen, können Sie dies
durch eine entsprechende Zahl beim Aufruf angeben
______________________________________________________________________
break [n]
______________________________________________________________________
n die Anzahl der verschachtelten for-, until- oder while-Schleifen,
die break abbrechen soll.
n nicht angegeben:
break bricht die for-, until- oder while-Schleife ab, in der es
angegeben ist; für n wird also 1 eingesetzt.
case-Anweisung - abfragen und verzweigen
Mit der case-Anweisung können Sie eine Eingabe mit vorgegebenen
Mustern vergleichen und entsprechend dem Ergebnis zu Kommandos ver-
zweigen.
______________________________________________________________________
case name in
muster[|muster ...]) [kommandofolge];;
.
.
.
muster[|muster ...]) [kommandofolge]
esac
______________________________________________________________________
name beliebige Zeichenkette, normalerweise ein Shell-Parameter. Die
Shell vergleicht name mit den angegebenen Mustern.
muster
Zeichenkette, mit der name verglichen werden soll. Diese Zeichen-
kette kann so angegeben werden wie die Argumente, die durch pas-
sende Dateinamen ersetzt werden sollen (siehe ARGUMENTE DURCH
PASSENDE DATEINAMEN ERSETZEN oben und expressions(5)]. Allerdings
werden die Sonderzeichen *,? und [...] in muster durch beliebige
Zeichen ersetzt:
Seite 78 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
_________________________________________________________________
| Sonderzeichen | Ersetzung |
|_______________|________________________________________________|
| * | wird ersetzt durch kein, ein oder mehrere |
| | beliebige Zeichen; auch durch Punkt "." oder |
| | Schrägstrich / |
|_______________|________________________________________________|
| ? | wird ersetzt durch genau ein beliebiges Zei- |
| | chen; auch durch Punkt "." oder Schrägstrich /|
|_______________|________________________________________________|
| [s] | wird ersetzt durch genau ein Zeichen, das in |
| | der Zeichenkette s (nach der Auswertung von |
| | [.cc], [=c=] und [:klasse:]) enthalten ist. s |
| | darf enthalten: |
| | |
| | - beliebige einfache Zeichen |
| | (auch Punkt "." und Schrägstrich /) |
| | - Zeicheneinheits-Symbole [.cc.] |
| | - Ausdrücke für Zeichenklassen [:klasse:] |
| | - Ausdrücke für Äquivalenzklassen [=c=] |
|_______________|________________________________________________|
| [!s] | wird ersetzt durch genau ein Zeichen, das in |
| | der Zeichenkette s (nach der Auswertung von |
| | [.cc], [=c=] und [:klasse:]) nicht enthalten |
| | ist. |
|_______________|________________________________________________|
| [c1-c2] | wird ersetzt durch genau ein Zeichen aus dem |
| | innerhalb der eckigen Klammern angegebenen |
| | Zeichenbereich; c1 und c2 gehören zum Bereich.|
| | c1 und c2 können sein: |
| | |
| | - beliebige einfache Zeichen |
| | (auch Punkt "." und Schrägstrich /) |
| | - Zeicheneinheits-Symbole [.cc.] |
| | - Ausdrücke für Äquivalenzklassen [=c=] |
|_______________|________________________________________________|
| [!c1-c2] | wird ersetzt durch genau ein Zeichen, das |
| | nicht zu dem innerhalb der eckigen Klammern |
| | angegebenen Zeichenbereich gehört. |
|_______________|________________________________________________|
Seite 79 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Wenn name zu diesem Muster paßt, führt die Shell die danach ange-
gebene Kommandofolge aus. Nach der Ausführung dieser Kommando-
folge ist die case-Anweisung beendet.
Wenn name nicht zu diesem Muster paßt, wird das nächste Muster
geprüft.
Wenn bei mehreren Mustern die gleiche Kommandofolge ausgeführt
werden soll, können Sie diese Muster vor die entsprechende Kom-
mandofolge setzen, jeweils getrennt durch einen senkrechten
Strich |.
Wenn Sie für muster das Zeichen * angeben, werden die nachfolgen-
den Muster nicht mehr überprüft. Es wird also nur die Kommando-
folge ausgeführt, die zum Muster * gehört.
kommandofolge
Folge von Kommandos, die ausgeführt werden sollen, wenn name zum
entsprechenden Muster paßt.
Jede Kommandofolge bis auf die letzte muß mit zwei Strichpunkten
;; abgeschlossen werden.
Wenn Sie kein Kommando angeben wollen, müssen Sie, abgesehen von
der letzten Kommandofolge, zumindest die beiden Strichpunkte ;;
angeben.
Das Schlüsselwort esac schließt die case-Anweisung ab.
continue - Schleife abbrechen
Die Ablaufanweisung continue beendet den aktuellen Durchlauf der for-,
until- oder while-Schleife, in der es angegeben ist. Die Abarbeitung
der entsprechenden Schleife wird mit dem nächsten Durchlauf fortge-
setzt. Eine Shell-Prozedur wird ebenfalls mit dem nächsten Durchlauf
dieser Schleife fortgesetzt.
Schleifen können beliebig tief geschachtelt sein. Wenn Sie mit
continue den Durchlauf mehrerer Schleifen abbrechen wollen, die den
Aufruf von continue umgeben, können Sie dies durch eine entsprechende
Zahl beim Aufruf angeben.
______________________________________________________________________
continue [n]
______________________________________________________________________
n Nummer der for-, until- oder while-Schleife, die den Aufruf von
continue umgibt. Mit dem Durchlauf dieser Schleife soll die
Shell-Prozedur fortgesetzt werden.
Seite 80 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
n nicht angegeben:
continue setzt die Shell-Prozedur mit dem nächsten Durchlauf der
for-, until- oder while-Schleife fort, in der es angegeben ist.
Für n wird also 1 eingesetzt.
for-Anweisung - Liste in Schleifen abarbeiten
Mit der for-Anweisung können Sie Kommandos mehrmals wiederholen. Für
jedes Argument in der angegebenen Liste wird die for-Schleife einmal
durchlaufen.
______________________________________________________________________
for name [in liste]
do kommandofolge
done
______________________________________________________________________
name Name einer Shell-Variablen. Dieser Variablen weist die Shell als
Wert nacheinander die Argumente aus liste zu. Nach jeder Zuwei-
sung wird die Kommandofolge ausgeführt. Der Schlüsselwort-Parame-
ter $name spricht den jeweils gültigen Wert der Variablen name
an.
liste
Liste von Argumenten; Argument-Trennzeichen sind die Zeichen, die
der Variablen IFS zugewiesen sind. Jedes Argument wird der Reihe
nach der Variablen name als Wert zugewiesen und kommandofolge
einmal ausgeführt. Die for-Anweisung ist beendet, wenn liste kein
weiteres Argument enthält.
Enthält ein Argument eines der Sonderzeichen *, ? oder [...], so
wird es durch passende Dateinamen ersetzt (siehe ARGUMENTE DURCH
PASSENDE DATEINAMEN ERSETZEN oben).
liste nicht angegeben:
Die Angabe in entfällt ebenfalls. Die Shell setzt $@ ein; die
for-Schleife wird also für jedes Aufrufargument einmal durchlau-
fen, das beim Aufruf der entsprechenden Shell-Prozedur angegeben
bzw. mit set in der aktuellen Shell gesetzt ist.
kommandofolge
Folge der Kommandos, die entsprechend oft ausgeführt werden soll.
Das Schlüsselwort done schließt die for-Anweisung ab.
if-Anweisung - Bedingungen abfragen und Kommandos ausführen
Mit der if-Anweisung können Sie Bedingungen abfragen und je nach
Ergebnis verschiedene Kommandos ausführen.
Seite 81 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Dazu führt die Shell die Kommandofolge aus, die Sie direkt nach if
angegeben haben:
- Die Bedingung ist wahr, wenn das letzte Kommando aus dieser Komman-
dofolge den Endestatus 0 zurückgibt.
- Die Bedingung ist falsch, wenn das letzte Kommando aus dieser Kom-
mandofolge einen Endestatus ungleich 0 zurückgibt.
______________________________________________________________________
if kommandofolge1
then kommandofolge2
[elif kommandofolge3
then kommandofolge4 ...]
[else kommandofolge5]
fi
______________________________________________________________________
kommandofolge1
Folge von Kommandos, die die Shell ausführt, um die Bedingung
abzufragen.
Wenn die Bedingung wahr ist, verzweigt die Shell zu then. Wenn
die Bedingung falsch ist, verzweigt die Shell zum nächsten elif
bzw. else.
kommandofolge2
Folge von Kommandos, die die Shell ausführen soll, wenn die
Bedingung nach if wahr ist. Nach der Ausführung dieser Kommandos
ist die if-Anweisung beendet.
kommandofolge3
Folge von Kommandos, die die Shell ausführt, um die Bedingung
abzufragen. Die Shell führt kommandofolge3 nur aus, wenn die
Bedingung nach if falsch ist.
Wenn die Bedingung wahr ist, verzweigt die Shell zum nächsten
then. Wenn die Bedingung falsch ist, verzweigt die Shell zum
nächsten elif bzw. else.
Der elif-Zweig ist optional. Wenn Sie elif nicht angeben, ent-
fällt auch das auf elif folgende then.
kommandofolge4
Folge von Kommandos, die die Shell ausführen soll, wenn die
Bedingung nach if falsch und die Bedingung nach elif wahr ist.
Nach der Ausführung dieser Kommandos ist die if-Anweisung been-
det.
Seite 82 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
kommandofolge5
Folge von Kommandos, die die Shell ausführen soll, wenn die
Bedingungen nach if und nach elif falsch waren. Nach der Ausfüh-
rung dieser Kommandos ist die if-Anweisung beendet.
Wenn der else-Zweig fehlt, führt die Shell Kommandos nur aus,
wenn eine Bedingung wahr ist.
Das Schlüsselwort fi schließt die if-Anweisung ab.
Wenn die Shell weder die Kommandos aus einem then-Zweig noch die Kom-
mandos aus dem else-Zweig ausgeführt hat, gibt die if-Anweisung als
Endestatus den Wert 0 zurück. In diesem Fall war also keine Bedingung
erfüllt.
until-Anweisung - Schleife mit Abbruch-Bedingung
In der Shell gibt es zwei Schleifen mit Abbruch-Bedingung, die until-
und die while-Schleife.
Die until-Anweisung prüft, ob die angegebene Bedingung falsch ist.
Sobald die Bedingung wahr wird, ist die until-Anweisung beendet.
______________________________________________________________________
until kommandofolge1
do kommandofolge2
done
______________________________________________________________________
kommandofolge1
Folge von Kommandos, die die Shell ausführt, um die Bedingung
abzufragen.
Wenn die Bedingung wahr ist, ist die until-Anweisung beendet. Die
Kommandos aus kommandofolge2 werden nicht ausgeführt.
Wenn die Bedingung falsch ist, führt die Shell die Kommandos aus
kommandofolge2 aus. Anschließend führt die Shell erneut die Kom-
mandos aus kommandofolge1 aus, um die Bedingung abzufragen.
kommandofolge2
Folge von Kommandos, die die Shell ausführt, solange die Bedin-
gung falsch ist.
Das Schlüsselwort done schließt die until-Anweisung ab.
Wenn die Shell die Kommandos nach dem Schlüsselwort do kein einziges
Mal ausgeführt hat, gibt die until-Anweisung als Endestatus den Wert 0
zurück. In diesem Fall war also die Bedingung bereits bei der ersten
Prüfung wahr.
Seite 83 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
while-Anweisung - Schleife mit Abbruch-Bedingung
In der Shell gibt es zwei Schleifen mit Abbruch-Bedingung, die while-
und die until-Schleife.
Die while-Anweisung prüft, ob die angegebene Bedingung wahr ist.
Sobald die Bedingung falsch wird, ist die while-Anweisung beendet.
______________________________________________________________________
while kommandofolge1
do kommandofolge2
done
______________________________________________________________________
kommandofolge1
Folge von Kommandos, die die Shell ausführt, um die Bedingung
abzufragen.
Wenn die Bedingung wahr ist, führt die Shell die Kommandos aus
kommandofolge2 aus. Anschließend führt die Shell erneut die Kom-
mandos aus kommandofolge1 aus, um die Bedingung abzufragen.
Wenn die Bedingung falsch ist, ist die while-Anweisung beendet.
Die Kommandos aus kommandofolge2 werden nicht ausgeführt.
kommandofolge2
Folge von Kommandos, die die Shell ausführt, solange die Bedin-
gung wahr ist.
Das Schlüsselwort done schließt die while-Anweisung ab.
Wenn die Shell die Kommandos nach dem Schlüsselwort do kein einziges
Mal ausgeführt hat, gibt die while-Anweisung als Endestatus den Wert 0
zurück. In diesem Fall war also die Bedingung bereits bei der ersten
Prüfung falsch.
WEITERE UNTERSCHIEDE KORN-SHELL - BOURNE-SHELL
Da das Verhalten der Bourne-Shell (sh) und der Korn-Shell (ksh) nicht
in allen Punkten gleich ist ist, kommt es auch bei Shell-Prozeduren zu
unterschiedlichen Verhalten [vgl. auch den Abschnitt "Wesentliche
Erweiterungen der Korn-Shell gegenüber der Bourne-Shell" in ksh(1)].
Zur Zeit sind folgende Unterschiede bekannt:
1. Wird in einer Schleife (for, until, while) ein exit ausgeführt und
die Eingabe aus einer Datei gelesen, so beendet die Bourne-Shell
die Schleife und die Korn-Shell beendet die Prozedur. Beispiel mit
einer while-Schleife:
Seite 84 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
while read i
do
echo $i
if [ "$i" = "ende" ]
then
exit 199
fi
done < inputfile
retflag=$?
echo $retflag
2. Das Shell-Builtin cd verhält sich bei der Verwendung von Metazei-
chen (*, ?) unterschiedlich.
Im aktuellen Verzeichnis sind die Unterverzeichnisse dircmd,
dirlib und dirhead enhalten.
cd dir*
Die Korn-Shell bringt die Fehlermeldung "bad argument count", und
die Bourne-Shell wechselt in das Verzeichnis mit der ersten Muster-
erkennung (dircmd).
3. Aufrufparameter werden unterschiedlich interpretiert.
Aufruf auf der Shell-Ebene:
((/tmp/shelltest add "-po XON") 2>&1)
Korn-Shell:
$1 = add
$2 = -po
$1 = XON
Bourne-Shell:
$1 = add
$2 = -po XON
SIEHE AUCH
cd(1), colon(1), dot(1), echo(1), eval(1), exec(1), exit(1),
export(1), hash(1), pwd(1), read(1), readonly(1), set(1), shift(1),
test(1), times(1), trap(1), type(1), ulimit(1), umask(1), unset(1),
wait(1).
csh(1), jsh(1), ksh(1), rksh(1), xpg4sh(1).
exec(2), exit(2), signal(2), ulimit(2), umask(2), wait(2).
expressions(5), specialchar(5).
Seite 85 Reliant UNIX 5.44 Gedruckt 11/98
sh(1) sh(1)
Bach, F. et al.: UNIX Handbuch zur Programmentwicklung, Kapitel 2,
"Benutzeroberflächen" und Kapitel 4, "Shell-Programmierung und
Prototyping".
Kochan, Wood: UNIX Shell Programming.
Manis, Meyer: The UNIX Shell-Programming Language.
Seite 86 Reliant UNIX 5.44 Gedruckt 11/98