home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Dream 51
/
Amiga_Dream_51.iso
/
Atari
/
Desktops
/
nodsk302.lzh
/
DOKU
/
CLI.TXT
next >
Wrap
Text File
|
1995-01-19
|
69KB
|
1,462 lines
,--------------------------------------------------------------------.
| 18.12.1994 |
| CLI.TXT |
| |
| Beschreibung des Command Line Interpreter (CLI) im noDesktop V3.00 |
| |
| Copyright ╜1994 by no|Software GmbH |
| |
| Autoren: |
| Ralph Mertens |
| Andreas Fahrig |
| Christian Stamm |
| Marco Zahnen |
| |
`--------------------------------------------------------------------'
Inhalt
======
1 ......................................................... Einleitung
2 ........................ Direkte Tastatureingabe / Die Shell des CLI
3 ............................................... Die Command-Language
3.1 ........................................... Aufbau eines Kommandos
3.2 ........................................ Schalterargumente (flags)
3.3 ................................... Umlenkung der Ein- und Ausgabe
3.4 ...................................................... Metazeichen
3.5 ......................................................... Modifier
3.5.1 ............................................. Execution-Modifier
3.5.2 .................................................. Path-Modifier
3.6 ........................................ Ausgabe von Sonderzeichen
3.7 ........................................................ Variablen
3.8 ............................................. Bedingte Anweisungen
3.9 .......................................................... Aliases
3.10 ................................................. History - Liste
4 ........................................... Parsing und Substitution
4.1 ............................................. History-Substitution
4.1.1 ............................................. Zeilensubstitution
4.1.2 ............................................... Wortsubstitution
4.2 ............................................... Alias-Substitution
4.3 .................................... Parsing und Makrosubstitution
4.4 ............................................ Variablensubstitution
4.4 .................................. Verhinderung von Substitutionen
4.6 ....................................... Ausführung eines Kommandos
5 ............................................................ Scripte
6 ................................................... Die WCON-Fenster
6.1 ....................................... Öffnen eines WCON-Fensters
6.2 ...................... Programmunterbrechung in einem WCON-Fenster
6.3 .......................... VT52-Funktionalität eines WCON-Fensters
6.4 ...................... Primitive Terminal-Fenster (WAUX und WTALK)
7 .................................................. Interne Kommandos
7.1 ....................................... Graphikmodus und Textmodus
7.2 ...................................... Ausgabe von Fehlermeldungen
8 ..................................................... Fensternummern
Anhang
A1 ............................. Übersicht über die internen Variablen
A2 .............................. besondere CLI-Anweisungen:
return
goto
if, then, else, elif, endif
foreach, end, break, continue
while, wend, break, continue
1 Einleitung
=============
Der CLI des no|Desktop bildet die zentrale Schnittstelle zwischen der
Desktop-Oberfläche und dem Benutzer. Ähnlich dem 'csh' unter UNIX dient
der CLI der Übersetzung von Befehlen oder Programmen und deren
Bearbeitung.
Der CLI tritt in drei verschiedenen Fällen in Aktion:
1. im Dialog mit dem Benutzer bei der direkten Eingabe über die Tastatur
(im WSH-Fenster)
2. bei der Bearbeitung von Scripten (Dateien, die eine Befehlsliste
enthalten [*.NDS])
3. bei der Bearbeitung von Befehlssequenzen, die in der Definitionsdatei
für Desktop-Ereignisse abgelegt sind.
Die Funktionsweise des CLI, Namenskonventionen und Syntax sind dem 'csh'
angelehnt. Im Folgenden wird die Benutzerschnittstelle des CLI als die
'shell' (Muschel) bezeichnet.
2 Direkte Tastatureingabe / Die Shell des CLI
==============================================
Um zur direkten Eingabe zu gelangen, drückt man gleichzeitig [SHIFT] und
[ENTER](auf der Zehnertastatur) oder wählt per RECHTS-KLICK im Dropdown-
Menü des Desktop den Punkt 'no|Desktop-CLI'.
Die Shell des CLI dient als 'Medium', um vor allem Programme aufzurufen
und Kommandos auszuführen.
no|Desktop hat eine Reihe von internen Kommandos, die häufig benutzte Aktionen
steueren, wie z.B. Kopieren (cp) oder Auflisten (ls) von Dateien. Durch
Eingabe von 'help' werden alle verfügbaren internen Kommandos aufgelistet.
Als 'externe' Kommandos werden Programme verstanden, die durch den Aufruf
ausgeführt werden.
Die Shell arbeitet zeilenorientiert, das heißt, eine Kommandozeile darf über
Tastatureingabe nur eine Zeilenbreite betragen, jedoch maximal 128 Zeichen.
Um in der Zeile bequem editieren zu können, bietet die shell einige
Tastaturkombinationen:
[BACKSPACE], [CTRL]+H - löscht das Zeichen links vom Cursor
[DELETE] - löscht das Zeichen unter dem Cursor
[CTRL]+W - löscht ein Wort
[CTRL]+U - löscht die ganze Zeile
[CLR/HOME] - löscht den Bildschirm
[CTRL]+B - Sprung zum vorigen Wort (backward skip)
[CTRL]+F - Sprung zum nächsten Wort (forward skip)
[CTRL]+[Pfeil rechts] - Sprung zum Ende der Zeile
[CTRL]+[Pfeil links] - Sprung zum Anfang der Zeile
[Pfeil hoch] - vorige Zeile in der Historieliste
[Pfeil runter] - nächste Zeile in der Historieliste
[HELP] - expandiert das 1. Wort auf das interne Kommando,
das mit der Buchstabenkombination beginnt
- expandiert jedes weitere Wort auf den Dateinamen
im aktuellen Verzeichnis, das mit der Buchstaben-
kombination beginnt
- jedes weiter Drücken von HELP sucht das
nächstmögliche passende Kommando/Argument
[UNDO] - zeigt die für HELP eingegebene Zeichenkette
[INSERT] - wechselt zwischen Überschreibe- und Einfügemodus
[RETURN] - beendet die Eingabe und führt das Kommando aus
[SHIFT]+[ENTER] - schließt das WSH-Fenster bzw. wechselt in den
Graphikmodus
Nach der Ausführung des Kommandos gibt die shell einen 'prompt' auf dem
Bildschirm aus und signalisiert damit die Eingabebereitschaft. Die
Zeichenkette, die durch 'prompt' ausgegeben wird, ist auf den aktuellen
Benutzerpfad eingestellt:
Beispiel: C:\NODESK\USR> _
3 Die Command-Language
=======================
3.1 Aufbau eines Kommandos
---------------------------
Die Kommandos des CLI bestehen aus einer Liste von Zeichenketten oder
auch Worten, die durch Leerzeichen voneinander getrennt sind, wobei das
erste Wort das eigentliche Kommando darstellt. Die übrigen Worte (falls
vorhanden) sind Argumente oder Parameter des Kommandos.
Das Kommando
cat beispiel.txt
besteht aus zwei Worten. Das interne Kommando 'cat' erhält bei Ausführung
das Argument 'beispiel.txt'. 'cat' gibt den Inhalt der Datei 'beipiel.txt'
über das Standardausgabe-Medium (ist in der Regel wohl der Bildschirm) aus.
Die Ausgabe kann durch die Tastenkombination [CTRL]+C abgebrochen werden.
Dateinamen werden intern immer in Großbuchstaben konvertiert. Anders ist
dies bei Schalterargumenten (flags, s.u.). Der CLI unterscheidet hier
Groß- und Kleinschreibung.
Mehrere Kommandos in einer Zeile werden durch ';' voneinander getrennt und
werden nacheinander abgearbeitet.
Beispiel: ls -l > liste.txt; cat liste.txt; rm liste.txt
Zunächst wird eine ausführliche Liste aller Dateinamen im aktuellen
Verzeichnis in die Datei 'liste.txt' geschrieben. Anschließend wird die
Datei auf den Bildschirm ausgegeben und zum Schlu₧ gelöscht.
3.2 Schalterargumente (flags)
------------------------------
Durch optionale Schalterargumente (flags) läßt sich die Ausführung eines
Kommandos verändern. Ein flag beginnt immer mit einem '-' (Bindestrich),
gefolgt von mindestens einem weiteren Zeichen. GRO₧- UND KLEINSCHREIBUNG
WERDEN UNTERSCHIEDEN!!!!
Beispiele: (1) ls
(2) ls -l
(3) ls -R
Kommado (1) gibt die Dateinamen im aktuellen Arbeitsverzeichnis aus. Durch
Zusatz des flags '-l' [Kommando (2)] werden zum Dateinamen zusätzliche
Informationen wie Dateigröße und Erstellungsdatum und -uhrzeit ausgegeben.
Durch die Angabe das flags '-R' [Kommando (3)] werden auch alle im
aktuellen Verzeichnis enthaltene Unterverzeichnisse durchsucht und deren
Inhalt ausgegeben.
Die verschiedenen flags können auch kombiniert werden, wobei die
Reihenfolge der flags egal ist:
ls -l -R
oder ls -lR
oder ls -Rl
Das interne Kommandos ls hat noch weitere wichtige und interessante flags.
Andere Kommandos haben keine oder nur wenige flags, wie z.B. 'echo' mit dem
einzigen optionalen flag '-n', das nach Ausgabe einer Zeile das newline
unterdrückt.
Durch Eingabe von 'help' gefolgt von einem internen Kommando kann man sich
die flags für dieses Kommando anschauen.
3.3 Umlenkung der Ein- und Ausgabe
-----------------------------------
Kommandos, die ihre Eingabe normalerweise von der Tastatur lesen und auf
den Bildschirm schreiben, können auch so ausgeführt werden, daß die
Eingabe/Ausgabe über Dateien abläuft.
Das Kommando 'ls' schreibt die gefundenen Dateinamen normalerweise direkt
auf den Bildschirm, Durch Eingabe von
ls > liste.txt
wird das Ergebnis in die Datei 'liste.txt' geschrieben, nachdem diese Datei
neu angelegt wurde. Für das Kommando selbst ist es unwesentlich, wohin es
seine Ausgabe schreibt. Die Standard-Ausgabe ist der Bildschirm, die
Umlenkung (redirection) der Standard-Ausgabe in eine Datei (und der
Standard-Eingabe, der Tastatur, von einer Datei) erledigt die shell.
Die Standard-Ein- und Ausgabe können in folgender Weise umgelenkt werden:
< Dateiname öffnet die Datei 'Dateiname' als Standard-
Eingabe. 'Dateiname' muß vorhanden sein!
> Dateiname erzeugt die Datei 'Dateiname' und verwendet
sie als Ausgabedatei. Ist sie bereits
vorhanden, wird sie überschrieben.
>> Dateiname die Datei 'Dateiname' wird wie bei '>' als
Ausgabedatei benutzt. Die Ausgabe wird an
das Ende einer vorhandenen Datei gehängt.
Existiert die Datei nicht, wird sie erzeugt,
es sei denn, die Variable 'noclobber' ist
gesetzt, dann erscheint eine Fehlermeldung.
Anstelle eines Dateinamens kann die Ein-/Ausgabe auch auf einige Standard-
geräte umgelenkt werden:
PRT: Druckerschnittstelle
PRN: Druckerschnittstelle
AUX: serielle Schnittstelle (wie im Kontrollfeld eingestellt)
Die Anweisungsfolge
cat CLI.TXT > PRN:
würde also den Inhalt der Datei CLI.TXT auf die Druckerschnittstelle
ausgeben.
Werden Kommandos durch '|' voneinander getrennt, so wird die Ausgabe eines
Kommandos mit der Eingabe des nächsten Kommandos verknüpft.
Die Anweisungsfolge
ls -l | cat -n
leitet die Ausgabe von 'ls -l' an das Kommando 'cat -n' weiter, welches
das Ergebnis auf dem Bildschirm ausgibt und zusätzlich nach jeder Zeile
eine Leerzeile einfügt.
3.4 Metazeichen
----------------
Es existiert eine Reihe von Zeichen (wie '>' oder '|'), die eine besondere
Funktion haben. Diese 'Metazeichen' haben eine semantische (inhaltliche)
und syntaktische Bedeutung für die shell. Allgemein haben fast alle
Zeichen, die nicht Buchstaben oder Ziffern sind, eine spezielle Bedeutung.
Sollen diese Zeichen in einer Zeichenkette als darstellbares Zeichen
ausgegeben werden, so müssen sie bzw. die Zeichenkette 'quotiert' werden,
z.B. würde
echo 3 > 2
die Zeichenkette '3' in eine Datei namens '2' schreiben.
echo '3 > 2'
gäbe die Zeichenkette '3 > 2' auf dem Bildschirm aus.
Eine Kommandozeile wird normalerweise dort in Wörter aufgeteilt, wo
Leerzeichen oder Tabulatoren stehen, mit folgenden Ausnahmen:
Die Zeichen '|' ';' '<' '>' '(' ')' führen ebenfalls zur Aufteilung
in einzelne Wörter. Diese Metazeichen können dadurch Teil von Wörtern
werden (d.h ihre Funktion verlieren), da₧ ihnen ein '`' vorangestellt wird.
Zeichenketten, die durch Anführungszeichen (' oder ") eingeschlossen sind,
werden als Teile von Wörtern interpretiert. Leerzeichen und die oben
aufgeführten Metazeichen trennen innerhalb dieser Anführungszeichen dann
nicht einzelne Wörter.
Beispiele: echo 3 > 2 erzeugt 4 Wörter
echo 3 `> 2 erzeugt 4 Wörter ('>' wird nicht interpretiert)
echo '3 > 2' erzeugt 2 Wörter
3.5 Modifier
-------------
Nach der Variablensubstitution und unmittelbar vor der Ausführung des
Kommandos wird die Kommandozeile daraufhin geprüft, ob am Kommando
oder an den Argumenten noch Modifier stehen. Diese werden zuletzt
bearbeitet.
Es existieren zwei verschiedene Arten von Modifiern:
1. Execution-Modifier
2. Path-Modifier
Modifier dienen dazu, die Art der Kommandoausführung (Execution) oder
Pfadnamen (Path) zu verändern (modifizieren).
3.5.1 Execution-Modifier
-------------------------
Diese Modifier betreffen die Ausführung eines Kommandos, Execution-Modifier
werden mit einem '@' an den Kommandonamen angehängt.
Folgende Modifier existieren:
Klasse A:
@W Die Standard-Ausgabe wird auf das Texteingabefenster
geleitet, sofern die Variable noWcon nicht gesetzt ist.
Erfolgt eine Ausgabe, wird das Fenster geöffnet bzw.
zum aktuellen Fenster. Unter Mint wird das Kommando im
singletask-Modus gestartet.
@W<n> Die Standardausgabe wird auf das Textfenster mit
n = 0 bis 3 umgeleitet, sonst wie @W
@w wie oben, nur daß ein bereits offenes Text-
@w<n> Ausgabefenster nicht zum aktuellen Fenster wird.
Unter Mint wird ein 'externes' Kommando im Hintergrund
gestartet, no|Desktop wartet nicht auf die Beendigung des
Kommandos.
@T Die Textausgabe erfolgt nicht im Fenster
@t wie @T, nach Beendigung des Kommandos wird auf einen
Tastendruck gewartet
@G Das Kommando wird im 'Graphikmodus' ausgeführt.
Interne Kommandos, die diese Option bieten, werden im
Fensterdialog ausgeführt. Die Textausgabe erfolgt in
ein Textfenster, wenn verfügbar.
Klasse B (nur für externe Kommandos):
@x vor Ausführung wird no|Desktop ausgelagert, um mehr freien
Speicher zu Verfügung zu stellen
@X wie @x, es wird der Arbeitspfad auf den Ordner gesetzt,
in dem sich das Programm befindet
@s, @S no|Desktop wird nicht ausgelagert, sonst wie @x, @X
@c, @C no|Desktop entscheidet anhand der Programmgrö₧e, ob ausgelagert
werden soll, sonst wie @x, @X bzw. @s, @S
@n, @N no|Desktop wird nicht ausgelagert, es werden keine Fenster
geschlossen, sonst wie @x, @X
Modifier der Klasse A und der Klasse B können zusammen angegeben werden,
aber jeweils nur einer der Klasse A und einer der Klasse B, wobei die
A-Option vor der B-Option stehen mu₧:
test@TX
Die Klasse A - Modifier W1-W3 haben nur Sinn in Verbindung mit den Klasse
B - Modifiers N bzw n! Wenn Modifier nicht angegeben werden, gelten die
entsprechenden Einstellungen der NDQ-Datei!
3.5.2 Path-Modifier
--------------------
Durch Modifikationen an Pfadangaben ist es möglich, nur den benötigten Teil
aus dem Pfadnamen zu extrahieren. Die Modifier folgen unmittelbar auf ein
Argument und werden durch ':' eingeleitet. Eine Modifikationen innerhalb
von Zeichenketten, die durch " eingeschlossen sind, findet nicht statt.
Steht das ':' im ersten Wort (eigentliches Kommando) oder folgt auf ein ':'
ein '\', dann erfolgt keine Modifikation. Stehen mehrere jeweils durch ':'
eingeleitete Modifier hintereinander, wird von links nach rechts das
Erebnis jeweils erneut modifiziert. Variablen, die Doppelpunkte enthalten
(z.B. shareend) müssen bei Variablen-Substitution in " gesetzt werden.
Folgende Modifier stehen zur Verfügung:
:h Pfadangabe ohne Dateinamen (head)
:r Pfad und Dateinamen ohne Dateiextension (root)
:e nur Dateiextension (extension)
:t nur Dateinamen (tail)
:n wie -t, bei Ordnernamen '\' am Ende
:d Laufwerksangabe (drive)
:l<n> Zeile in Datei n = Zeilennummer
:w<n> Wort in Zeile n = Wortnummer
:D Dieser Modifier ersetzt den Dateinamen durch
deren Erstellungsdatum im Format:<Djjmmddhhmmss>
:U Alle Kleinbuchstaben in Gro₧buchstaben umwandeln
:L Alle Gro₧buchstaben in Kleinbuchstaben umwandeln
:/ Alle '\' in '/' umwandeln
Hinweis:
Der Modifier >:D< ist besonders sinnvoll, um Abhängigkeiten von Dateien zu
testen. So lä₧t sich mittels dieses Modifiers ein Makefile für die TURBO-C
Kommandozeilenversion entwickeln!
Nach der Anwendung des Modifiers ':/' ist es nicht mehr möglich, einen Pfad
mittels der anderen Modifier zu manipulieren; er sollte deshalb bei multipler
Verwendung von Modiefiern immer als letzter stehen. Beispiel:
set xy = "C:\OTTO\LOLA\FRANZ.TXT"
echo $deskfile:h:L:/ --> c:/otto/lola
3.6 Ausgabe von Sonderzeichen
------------------------------
Wird einem beliebigen Zeichen ein '`' vorangestellt, so wird es als
normales Zeichen ausgegeben und nicht mehr interpretiert. Auf diese Weise
können z.B. Metazeichen als druckbare Zeichen ausgegeben werden. Die
Ausgabe nicht-druckbarer Zeichen ist ebenfalls möglich.
`" -> " Anführungszeichen
`? -> ? Fragezeichen
`\ -> \ Backslash (umgek. Schrägstrich)
`a -> BEL Bell (Systemglocke)
`b -> BS Backspace
`f -> FF Formfeed (Seitenvorschub)
`n -> LF Linefeed (Newline)
`r -> CR Carriage return (Wagenrücklauf)
`t -> HT Tabulator (horizontal)
`v -> VT Tabulator (vertikal)
`DDD -> oktal DDD = 1 bis 3 Oktalziffen
`xHH -> hexadezimal HH = 1 bis 2 Hexadezimalziffern
3.7 Variablen
--------------
Der CLI verwaltet eine Reihe von Variablen. Der Inhalt von Variablen kann
mit den Kommandos 'set' angezeigt oder verändert, mit 'unset' die Variable
gelöscht werden. Variablennamen dürfen maximal 12 Zeichen lang sein, sie
müssen mit einem Buchstaben beginnen und dürfen ansonsten nur Ziffern und
Buchstaben enthalten. Der Inhalt von Variablen wird intern immer als
Zeichenkette verwaltet. Einige Kommandos (z.B. eval) interpretieren den
Inhalt von Variablen numerisch, eine Variable ohne Inhalt wird in diesem
Fall als '0' interpretiert. Enthält eine Variable mehrere Worte, so wird
bei numerischer interpretation immer nur das erste Wort interpretiert.
Einige Variablen werden von no|Desktop bereitgestellt (sogenannte 'interne'
Variablen). Interne Variablen haben unterschiedliche Eigenschaften:
Solche Variablen, die die Hardwareeigenschaften des System beschreiben,
sind nur lesbar und nicht lösch- oder veränderbar. Andere interne
Variablen beinhalten sehr wichtige Informationen für den no|Desktop und werden
während des Ladens der Desktopscripte initialisiert (Eine komplette
Liste der internen Variablen und ihrer Bedeutung steht am Ende dieser
Datei!).
Bei anderen Variablen (externen) interessiert no|Desktop nur, ob diese gesetzt
(definiert) sind oder nicht, der Inhalt dieser Variablen ist unwichtig.
Der Inhalt von Variablen kann mit den Kommandos 'set' angezeigt oder
verändert, mit 'unset' die Variable gelöscht werden.
Beispiele:
set gibt alle 'sichtbaren' Variablen aus
set -i gibt interne und gesetzte Variablen aus
set -ia zeigt alle internen Variablen, auch die
nicht gesetzen
set i setzt die Variable i
set i = hallo setzt die Variable i auf den Wert 'hallo'
set i = ( a b $i ) setzt i auf die Wortliste 'a b hallo', eine
Wortliste muß in runde Klammern gerahmt sein
Um das Ergebnis einer Berechnung einer Variablen zuzuweisen, ist folgende
Schreibweise notwendig:
set <Variablenname> @ <Berechnung>
Beispiele:
set i @ 1+2*3 setzt i auf den Wert '7', zuerst wird die
Berechnung ausgeführt, dann das Ergebnis
zugewiesen
set i @ -wd test.c zählt alle Wörter in test.c und weist das
Ergebnis der Variablen i zu
3.8 Bedingte Anweisungen
-------------------------
Bedingungen sind für den CLI Berechnungen, deren Ergebnis nur wahr oder
falsch sein kann. Eine Bedingung ist erfüllt (oder wahr), wenn das Ergebnis
ungleich '0' (Null) ist, sonst ist sie nicht erfüllt oder falsch. Bei der
Überprüfung einer Bedingung (z.B. im 'if'-Kommando) wird nur auf die
führenden Zahlen im Ergebnis geachtet, es werden immer Wörter als Zahlen
interpretiert. So können auch Variableninhalte als Bedingung interpretiert
werden. Die Syntax von Bedingungen (Berechnungen) und die Priorität der
Operatoren entspricht der Schreibweise in 'C'. Innerhalb von Bedingungen
dürfen keine Kommandos stehen (im Gegensatz zum 'csh' in Unix). Zusätzlich
zu rein algebraischen und logischen Operatoren existieren solche, die
Zeichenketten miteinander vergleichen oder Dateiattribute interpretieren.
Die Klammerung '(...)' von Ausdrücken ist erlaubt. Sogenannte 'unäre'
Operatoren stehen vor einem Ausdruck, 'binäre' zwischen zwei Ausdrücken.
Im Folgenden werden alle verfügbaren Operatoren beschrieben:
Schreibweise Beispiel Bescheibung
||, .or. a || b logisches 'OR'
.and. a .and. b logisches 'AND'
|, .bor. a | b bitweises 'OR'
^, .xor. a ^ b bitweises 'EXOR'
.band. a .band. b bitweises 'AND'
==, .eq. a == b Prüfung auf numerische Gleichheit
!=, .ne. a != b Prüfung auf numerische Ungleichheit
=~ strA =~ strB Prüfung auf Gleichheit in Strings
!~ strA !~ strB Prüfung auf Ungleichheit in Strings
<=, .le. a <= b numerisches kleiner oder gleich
>=, .ge. a >= b numerisches größer oder gleich
<, .lt. a < b numerisches kleiner
>, .gt. a > b numerisches größer
<<, .shl. a << b bit-Shift links um b Einheiten
>>, .shr. a >> b bit-Shift rechts um b Einheiten
+, -, *, / Grundrechenarten
%, .mod. a % b Rest der Division a / b (modulo)
!, .not. ! a logisches 'NOT'
~, .bnot. ~ a binäres 'NOT'
-r -r a Datei a ist nur lesbar (readonly)
-w -w a Datei a ist les- und schreibbar
-x -x a Datei a ist ein ausführbares Programm
-e -e a Datei a ist vorhanden
-o -o a Datei a gehört Benutzer (z.Zt. dummy)
-z -z a die Dateilänge von a ist '0'
-d -d a Datei a ist ein Ordner
-wd -wd a Anzahl der Wörter in Datei a
-ln -ln a Anzahl der Zeilen in Datei a
-p -p x Proze₧ x existiert
-c -c x Cookie x existiert
3.9 Aliases
-------------
Die shell verwaltet eine Liste mit aliases, die durch die Kommandos 'alias'
und 'unalias' erzeugt, angezeigt oder verändert werden können. Aliasnamen
dürfen vorhandene Kommandonamen sein. Mit einem alias kann z.B. für eine
ganze Kommandosequenz eine 'Name' definiert werden (spart Tipparbeit!):
1 alias ll 'ls -l' ersetzt ll durch ls -l
2 ll tmp -> ls -l tmp
3 alias gibt alle aliases als Liste aus
4 unalias ll löscht das alias 'll' aus der Liste
3.10 History - Liste
---------------------
Die shell verwaltet eine History-Liste, in welcher sie zuvor eingegebene
Kommandozeilen aufbewahrt. Dies ist nützlich, um Kommandos zu wiederholen
oder kleine Schreibfehler in Kommandos zu korrigieren. Die Anzahl der
Einträge wird durch die Variable 'history' bestimmt. Sie kann durch
echo $history
angezeigt werden und durch
set history = n (n = Zahl zwischen 1 und 999)
verändert werden. Die letzte Kommandozeile wird immer gespeichert. Es
werden normalerweise nur Kommandos, die direkt eingegeben werden in die
Liste aufgenommen.
Durch Eingabe von
history
wird die History-Liste ausgegeben, die z.B. so aussehen könnte:
9 ls -l
10 cat otto
11 cp liste.txt liste.bak
12 diff liste.txt liste.new
Die Kommandos erscheinen mit ihrer Ereignisnummer (Event-Nummer). Diese
Nummer kann für die History-Substitution (siehe unten) verwendet werden.
4 Parsing und Substitution
===========================
Nachdem eine Kommandozeile vom CLI gelesen wurde, wird die Zeile, wenn
durch ';' oder '|' getrennt, in Einzelkommandos unterteilt. Diese Kommandos
werden nun übersetzt, d.h. in eine ausführbare Form gebracht. Dabei werden
bestimmte Zeichensequenzen ausgetauscht (substituiert), so wird eine
Variable z.B. durch ihren Inhalt ersetzt.
Im folgenden wird beschrieben, in welcher Reihenfolge der CLI bei der
Übersetzung der Kommandozeile in eine ausführbare Form vorgeht.
4.1 History-Substitution
-------------------------
Es ist möglich, zuvor ausgeführte Kommandos und selbst Teile von Kommandos
in ein neues Kommando zu integrieren. Dazu bedient man sich der History-
Substitution. Sie beginnt immer mit einem '!' und kann mehrfach und an
beliebiger Position in der Eingabezeile vorkommen. Steht hinter dem '!' ein
Leerzeichen, Tabulator, '=' oder '(' wird keine Substitution durchgeführt.
History-Substitutionen beginnen auch, wenn die Eingabezeile mit einem '^'
beginnt. Jede Eingabezeile, die History-Substitutionen enthält, wird nach
der Substitution auf dem Bildschirm ausgegeben.
Die Beispiele in den folgenden Abschnitten beziehen sich auf den folgenden
Ausschnitt aus einer history-list:
9 ls -l
10 cat otto
11 cp liste.txt liste.bak
12 diff liste.txt liste.new
4.1.1 Zeilensubstitution
-------------------------
Um eine komplette Zeile zu substituieren, stehen folgende Möglichkeiten zur
Verfügung:
!n Substituiert Eventzeile n
!-n Substituiert die Zeile mit der Nummer
[aktuelle Eventnummer]-n
!! Substituiert die komplette letzte Zeile und ist
gleichbedeutend mit einer Wiederholung des
letzten Kommandos.
!t für t kann gibt man die Anfangsbuchstaben einer
Kommandozeile ein, die history-list wird dann
nach einer Kommandozeile mit diesen
Anfangsbuchstaben abgesucht, die Suche beginnt
beim neuesten Kommando
!?t? der Text kann an beliebiger Position mit dem
Wildcard '?' versehen werden, es wird dann
nach der ersten 'passenden' Kommandozeile
gesucht
Beispiele:
!11 -> cp liste.txt liste.bak
!-2 -> cp liste.txt liste.bak
!d -> diff liste.txt liste.new
!di -> diff liste.txt liste.new
!?ot? -> cat otto
!! -> diff liste.txt liste.new
4.1.2 Wortsubstitution
-----------------------
Um einzelne Wörter aus einer Event-Zeile zu extrahieren, können wir nach
der Zeilenspezifikation ein ':' setzen und dann eine (Zahlen-)Angabe für
das gewünschte Wort. Das erste Wort einer Zeile (der Kommandoname) hat die
Nummer 0, das zweite Wort (also das erste Argument) die Nummer 1 usw.
Mit folgenden Angaben kann ein Wort aus einer Zeile extrahiert werden:
:0 erstes Wort (Kommandoname)
:n n-tes Argument
:^ erstes Argument
:$ letztes Argument
:%?...? Wort, welches die Zeichen zwischen den
Fragezeichen enthält
:x-y x-tes bis y-tes Wort
:-y entspricht 0-y
:* entspricht 1-y
:x* entspricht x-$
:x- entspricht x-'vorletztes Argument'
Beispiele:
mv !12:* -> mv liste.txt liste.new
cp !12:%?te.n? !10:$ -> cp liste.new otto
rm !11:2 -> rm liste.bak
!10:0 !12:2 -> cat liste.new
Ist das erste Zeichen einer Kommandozeile ein '^', so wird die
Zeichenfolge, die zwischen diesem Zeichen und einem weiteren '^' steht,
durch die danach folgende Zeichenfolge in der vorigen Zeile ersetzt. Damit
kann man Schreibfehler leicht verbessern.
cb otto.1 otto.bak (vorige Zeile)
^cb^cp -> cp otto.1 otto.bak
4.2 Alias-Substitution
-----------------------
Das erste Wort jedes Einzelkommandos einer Kommandozeile wird daraufhin
untersucht, ob es ein alias ist. Wenn dem so ist, so wird das alias durch
den Text, für den es steht, ersetzt und das Kommando erneut History-
substituiert, so, als wäre die eingegebene Zeile die vorige Eingabezeile.
Dies hat den Vorteil, da₧ ein alias History-Substitution enthalten darf
und es damit möglich ist, Argumente des Einzelkommandos zu nehmen und an
eine beliebige Stelle im Ersetzungstext zu setzen. Die substituierte Zeile
ersetzt das Kommando und die Argumente. Wird keine History-Substitution im
aliastext verwendet, so bleiben die Argumente unverändert. Wird im
aliastext wiederum ein alias verwendet, so wird die alias-Substitution
erneut durchgeführt. Ist das erste Wort der substituierten Zeile dasselbe
wie in der alten, so wird eine erneute Substitution verhindert, um eine
endlose Ersetzung zu verhindern. Andere 'Endlosschleifen' erzeugen eine
Fehlermeldung.
Beispiel: alias lookup 'grep !^ test.c'
ersetzt lookup durch grep und das 1. Argument der
eingegebenen Zeile. Die Zeichenkette steht in '...',
um die History-Substitution bei Eingabe zu verhindern.
lookup cli.c -> grep cli.c test.c
4.3 Parsing und Makrosubstitution
----------------------------------
Nach der alias-Substitution wird jedes Einzelkommando parsiert, d.h. auf
korrekte Schreibweise hin geprüft und in eine interne Form gebracht.
Gleichzeitig werden Makros substituiert. Makros können ausschließlich in
der Objektdefinitionsdatei (.NDQ) verwendet werden. Ein Einsatz in der
shell oder in Scripten ist nicht möglich. Mehr zu Objektdefinitionsdateien
und Makros -> OBJECTS.TXT.
4.4 Variablensubstitution
--------------------------
Nachdem die Kommandozeile parsiert wurde, findet die Variablensubstitution
statt. Damit eine Variable substituiert wird, mu₧ ihr ein '$' vorangestellt
werden (bis auf zwei Ausnahmen: '~' und '~~') . In Zeichenketten, die in
>'< eingeschlossen sind, findet ebenfalls Variablensubstitution statt.
Besteht der Inhalt einer Variablen aus mehreren Wörtern, so werden diese
als einzelne Argumente substituiert, innerhalb von >"< nur als Sequenz
einer Zeichenkette.
Es existieren mehrere Varianten der Variablenubstitution:
$Variable
oder ${Variable} wird ersetzt durch den Wert der Variablen
'{}' trennt eindeutig den Variablennamen
von einer nachfolgenden Zeichenkette
$Variable[Bereich]
oder ${Variable[Bereich]} wird benutzt, um nur einzelne Wörter des
Variableninhaltes zu substituieren. Enthält
die Variable nur ein Wort, so wird ein
Buchstabenbereich substituiert. Der Bereich
hat die Form: x, x-y, x- oder -y,
wobei x und y Bereichszahlen sind, eine
Variablensubstitution findet hier nicht
statt. >*< selektiert alle Wörter, das
erste Wort hat die Nummer 1
$#Variable
oder ${#Variable} Anzahl der Wörter einer Variablen
$0 Scriptname, wenn in einem Script benutzt,
sonst Fehlermeldung
$zahl
oder ${zahl} -> $argv[zahl]
$* -> $argv[*]
argv enthält die Argumente, die einem
Script übergeben wurden
$?Variable
oder ${?Variable} substituiert '1', wenn die Variable
gesetzt (vorhanden) ist, sonst '0'
$$ substituiert die Schachtelungstiefe von
Scripten als Zahl
$< forciert die Eingabe einer Zeile über die
Tastatur, diese wird als Wert eingefügt.
~ Benutzerverzeichnis, entspricht $HOME
~~ Verzeichnis von no|Desktop, entspricht $NDHOME
Nach der Variablensubstitution und unmittelbar vor der Ausführung des
Kommandos wird die Kommandozeile daraufhin geprüft, ob am Kommando oder an
den Argumenten noch Modifier stehen. Diese werden zuletzt bearbeitet.
4.5 Verhinderung von Substitutionen
------------------------------------
Die Einrahmung von Zeichenketten in der Form '...' oder "..." dient dazu,
alle bzw. einen Teil der Substitutionen in diesem Bereich zu verhindern.
Zeichenketten, die durch >'< eingeschlossen sind, sind vor einer weiteren
Interpretation durch den CLI geschützt - es findet also in diesem Bereich
keine Substitution statt. Zeichenketten, die durch >"< eingeschlossen sind,
werden nur teilweise substituiert.
4.6 Ausführung eines Kommandos
-------------------------------
Sind alle Substitutionen erfolgt, wird das Kommando ausgeführt; sei es ein
'internes', ein 'externes' (also ein Programm) oder ein Script. Nach
Ausführung des Kommandos wird als Beendigungsstatus eine Zahlenangabe in
die Variable 'status' geschrieben und kann z.B. mit
echo $status
direkt im Anschluß an das letzte Kommando abgefragt werden.
Definitionsgemäß wird bei fehlerfreier Ausführung eines Kommandos eine '0'
zurückgeliefert. Werte ungleich '0' zeigen meist einen Fehler an.
5 Scripte
==========
Scripte unter no|Desktop sind Textdateien (*.NDS), die Kommandozeilen
enthalten. Zusätzlich zu der direkten Kommandoeingabe bietet das Schreiben
von Scripten die Möglichkeit, komplexe Dateioperationen zu automatisieren.
Hierfür stehen in Scripten komfortable Programmiertechniken, wie bedingte
Ausführung, Sprünge, Sprungmarken und Programmschleifen, zur Verfügung.
Mehrere Scripte können auch ineinander geschachtelt werden.
no|Desktop selbst verwendet beim Programmstart Scripte und schreibt beim
Auslagern ein temporäres Script mit allen wichtigen Desktopinformationen.
Diese Datei wird nach Rückkehr zum no|Desktop gelesen und anschließend
gelöscht. Der Aufruf eines Scriptes ist der gleiche, wie der eines
Kommandos, bei Namensgleichheit mit anderen Kommandos oder Programmnamen
empfiehlt sich der Zusatz der Endung .NDS .
Einem Script können Argumente mitgegeben werden. Vor Aufruf des Scriptes
wird eine neue (lokale) Variable 'argv' erzeugt, die eine Liste der
übergebenen Argumente enthält. Im Script kann z.B. auf das 1. Argument mit
$1 oder $argv[1] zugegriffen werden. Die Anzahl der übergebenen Argumente
erhält man durch $#argv.
Werden in einem Script neue Variablen definiert, so existieren diese nur
solange, wie die Bearbeitung des Scriptes dauert. Ausnahme bildet der Aufruf
eines Scriptes durch
source <Scriptname> ...
Nur in diesem Falle werden alle im Script definierten Variablen global
definiert und sind auch nach Beendigung des Scriptes verfügbar. Ein
Spezialfall ist folgender Aufruf:
source -h <Scriptname>
In diesem Falle werden alle im Script enthaltenen Zeilen in die
Historyliste kopiert, das Script selbst wird aber nicht ausgeführt.
Alle in einem Script definierten Variablen sind bei einem Scriptaufruf in
diesem Script ebenfalls verfügbar, allerdings nur lesbar. Die Definition
einer Variablen in einer tieferen Script-Ebene mit dem gleichen Namen wie
eine Variable in einer höheren (übergeordneten) Script-Ebene führt zur
Neudefinition einer lokalen Variablen für die untergeordnete Ebene. Der
Inhalt der Variablen der übergeordneten Script-Ebene kann nicht verändert
werden. Nach Beendigung des untergeordneten Scriptes werden die lokal
definierten Variablen wieder gelöscht. Die Verschachtelungstiefe der
Scriptebenen kann durch
echo $$
abgefragt werden.
Beginnt eine Zeile innerhalb eines Scriptes mit einem '#', so wird der Rest
dieser Zeile vom CLI als Kommentar gewertet und ignoriert.
Wird während der Bearbeitung des Scriptes ein Kommando mit einem Status
ungleich '0' beendet (es ist also aller Wahrscheinlichkeit nach ein Fehler
aufgetreten), so wird die Bearbeitung des Scriptes abgebrochen und der letzte
(Fehler-)Status zurückgeliefert. Der Abbruch eines Scriptes im Fehlerfall
kann durch Setzen der internen Variablen 'ignoreerr' verhindert werden:
set ignoreerr
Das Script wird in diesem Fall nur noch bei fatalen Fehlern abgebrochen.
In Scripten sind Kommandos möglich, die definitionsgemäß mehrere Zeilen
umfassen. Im Gegensatz dazu sind im Eingabefenster nur einzeilige Kommandos
erlaubt.
6 Die WCON-Fenster
===================
no|Desktop bietet die Möglichkeit, die Standardeingabe und -ausgabe (s.o.) auf
Fenster umzulenken. Diese Option gilt zunächst nur für die Normalversion
und das Mint-System, unter Mag!X ist nur das WSH-Fenster (Kommandoeingabe)
verfügbar, um dort interne Kommandos auszuführen.
Die Anzahl der Textfenster, auf die die Ein- und Ausgabe erfolgen soll,
wird im Startskript DESK.NDS im Kommando 'newdesk' definiert, indem jedes
einzelne Fenster am Ende des Befehls beschrieben wird:
newdesk ..... ..... ..... STD STD,100x200 STD,80x30 STD,80x5
In diesem Beispiel werden 4 Fenster definiert. Es können maximal 10
WCON-Fenster definiert werden (WCON0 - WCON9). Für jedes einzelne Fenster
muß die Zeichenkette 'STD' (= Standard) eingetragen werden, optional kann
die Zeilenlänge und Zeilenanzahl definiert werden. Sie muß durch ein ','
eingeleitet werden und dann müssen zwei Zahlenangaben, durch 'x' getrennt
folgen. Die erste Zahl definiert die Zeilenbreite des Fnsters, die Zweite
die Zeilenanzahl. Werden keine Werte angegeben, wird die Zeilenbreite auf
80 Zeichen, die Zeilenanzahl auf 25 Zeilen gesetzt. Diese Angaben bleiben
aktiv, solange no|Desktop arbeitet und können nicht geändert werden.
Das erste Fenster (WCON0) ist immer für die shell reserviert und heißt
WSH-Fenster.
Die Ausgabe über ein WCON-Fenster wird über die interne Variable 'noWcon'
gesteuert. Solange sie nicht gesetzt ist, sind die WCON-Fenster aktiv; wird
sie gesetzt, so schaltet no|Desktop bei Standardausgabe auf den Textbildschirm
um. Ist kein Fenster über 'newdesk' definiert, so ist 'noWcon' gesetzt und
kann nicht verändert werden, die Standardein- und ausgabe erfolgt auf dem
Textbildschirm. Einige Programme, die ihre eigene Textausgabe haben,
arbeiten nicht mit den WCON-Fenstern zusammen. In diesem Fall sollte über
das Popupmenü des Desktops die Ausgabe auf den Textbildschirm eingestellt
werden oder beim Programmaufruf der Modifier '@T' bzw. '@t' an den
Programmnamen gehängt werden.
Beispiel: TLDU.TOS@T
Die Ausgabe eines Kommandos erfolgt normalerweise immer im WSH-Fenster. Die
Ausgabe auf andere WCON-Fenster gelingt mit den Modifizierern '@Wn'. Möchte
man ein Textprogramm z.B. im 2. WCON-Fenster (WCON2) laufen lassen, so muß
man direkt an den Programmnamen den Modifier '@W2' oder '@w2' hängen:
Beispiel: LHARC@W2
Im Multitaskingbetrieb (unter MINT, MTOS) ist es auf diese Weise möglich,
ein Programm im Hintergrund zu starten, d.h. no|Desktop wartet nicht auf die
Beendigung des Programmes sondern teilt dem Programm nur ein Fenster zu.
Die Ausgabe erfolgt dann in regelmäßigen Abständen.
Beispiel: LHARC@w2 startet das Programm unter MTOS/MINT im Hintergrund
im WCON2-Fenster
Man sollte sich davor hüten, ein Programm, das im Hintergrund gestartet
wurde, im WSH-Fenster ausgeben zu lassen, da in diesem Falle eine
Kommandoeingabe erst dann wieder möglich ist, wenn das Programm beendet
wurde.
6.1 Öffnen eines WCON-Fensters
-------------------------------
Im Normalfall wird ein WCON-Fenster geöffnet, sobald ein Eingabe oder
Ausgabe in dieses Fenster stattfindet. Erfolgt eine Eingabe, wird das
Fenster zum aktuellen Fenster, d.h. es wird 'getoppt'. Vom WSH-Fenster hat
man über das Kommando 'wcon' die Möglichkeit, ein Fenster explizit zu
öffnen:
wcon -3 öffnet das WCON3-Fenster
Der erste optionale Parameter bestimmt die Fensternummer. Der aktuelle
Inhalt eines Fensters bleibt erhalten.
6.2 Programmunterbrechung in einem WCON-Fenster
------------------------------------------------
Durch Eingabe der Tastenkombination '[CTRL]+C' kann in der Regel jedes
externe Programm und interne Kommando abgebrochen werden. Um ein laufendes
externes Programm zu unterbrechen klickt man einfach mit einer Maustaste.
Der Programmname in der Titelzeile des WCON-Fensters wird durch '<...>'
eingerahmt. Nun ist es möglich, das Fenster zu verschieben, dessen Größe zu
verändern und sich den gesamten Inhalt des Fensters anzuschauen. Klickt man
mit der Maus auf den linken oberen Fensterknopf (Closerbutton) so wird nach
Rückfrage die Ausführung des Programms abgebrochen. Ebenso ist an dieser
Stelle das Drücken von '[CTRL]-C' möglich. Zum Fortsetzen des
Progammablaufs klickt man mit der Maus auf den Ausgabebereich des Fensters.
Eine Programmunterbrechung durch '[CTRL]-S' ist bei WCON-Fenstern NICHT
möglich!
6.3 VT52-Funktionalität eines WCON-Fensters
--------------------------------------------
Die Ausgabe auf ein WCON-Fenster durchläuft einen VT52-Emulator. Enhält die
Ausgabe VT52-Steuerbefehle, so werden diese interpretiert. So ist es z.B.
möglich, Texte, die VT52-Steuerbefehle enthalten, mit allen Textattributen
auszugeben. Weiterhin versteht jedes WCON-Fenster einem minimalen VT100-
Steuerbefehlssatz, allerdings nur die Befehle, die sich auf die
Textattribute und Textfarben beziehen.
Über die Tastatur können die verfügbaren Steuerbefehle auch direkt
eingegeben werden. Die Tastenkombination 'ALT-ESC' schaltet in den
Steuerbefehlsmodus. Die Eingabe von 'ESC' wird nun als Steuerzeichen
interpretiert (hex 0x1B). Unbekannte Steuerbefehle werden ignoriert. Dieser
Modus wird durch erneutes Drücken von 'ALT-ESC' wieder verlassen.
6.4 Primitive Terminal-Fenster (WAUX und WTALK)
------------------------------------------------
Durch Setzen der internen Variablen 'wauxwin' wird ein WCON-Fenster zu
einem Terminal-Fenster. Jede Eingabe von der seriellen Schnittstelle geht
auf das WAUX-Fenster, jede Eingabe im Fenster wird auf die serielle Ausgabe
geleitet.
set wauxwin setzt das Terminalfenster WAUX auf WCON1
set wauxwin = 3 setzt WAUX auf WCON3
unset wauxwin löscht die Terminalfunktion
waux öffnet das WAUX-Fenster
Durch Setzen der Variablen 'wtalkwin' wird ein WTALK-Fenster definiert.
Jede Eingabe in dieses Fenster erscheint im Fenster und wird auf die
serielle Ausgabe geleitet. Bei Kommunikation mit einem entfernten Computer
per Tastatur sieht man also das, was man schreibt, auch auf dem Bildschirm.
set wtalkwin setzt das Talkfenster WTALK auf WCON1
set wtalkwin = 3 setzt WTALK auf WCON3
unset wtalkwin löscht die Talkfunktion
wtalk öffnet das WTALK-Fenster
Es ist nicht möglich, das WTALK-Fenster zu öffnen oder die Variable
'wtalkwin' zu setzen, ohne daß ein WAUX-Fenster existiert.
Die Variablen 'wauxicrnl' und 'wauxocrnl' definieren die Behandlung der
RETURN-Taste (bzw. des Wagenrücklaufs (cr)). Ist 'wauxicrnl' gesetzt, so
wird jeder Wagenrücklauf (cr), der über die serielle Eingabe kommt in einen
Zeilenvorschub (nl) und Wagenrücklauf (cr) umgesetzt. Ist 'wauxocrnl'
gesetzt, so wird bei Drücken der RETURN-Taste (cr) ein Wagenrücklauf (cr)
und Zeilenvorschub (nl) gesendet.
Das WAUX-Fenster stellt die primitivste Form eines Terminals dar und dient
lediglich dem direkten Ansteuern der seriellen Schnittstelle über die
Tastatur. Die Einstellungen der seriellen Schnittstelle (Baudrate usw.)
wird anderen Progammen überlassen.
7 Interne Kommandos
====================
no|Desktop besitzt eine große Anzahl von internen Kommandos. Ein Teil dieser
Kommandos entspricht den unter anderen Betriebssystemen bekannten Kommandos
zum Anzeigen und Manipulieren von Dateien, zur Verwaltung von Variablen
u.a. Ein Großteil der Kommandos dient der Manipulation und Gestaltung von
no|Desktop- eigenen Fenstern und anderen Objekten, sowie deren Interaktion.
Viele dieser Kommandos werden in der Objektdefinitionsdatei verwendet, um
einen individuellen Desktop zu ermöglichen. Jede Aktion auf dem Desktop,
jede Bewegung einer Datei in einen Ordner oder woanders hin, jedes Klicken,
Doppelklicken, jede Tastatureingabe beruht auf einer sinnvollen
Zusammenstellung von internen Kommandos. Einerseits kann man durch Ändern
der Objektdefinitionsdatei seinen individuellen Desktop schreiben,
andererseits benötigt man viele der beschriebenen Kommandos nur dort und
wird sie beim normalen Arbeiten kaum verwenden.
7.1 Graphikmodus und Textmodus
-------------------------------
Viele der beschriebenen Kommandos liegen in zwei verschiedenen
Darstellungsformen vor: Im 'Graphikmodus' erscheint bei Ausführung des
Kommandos ein benutzergeführter Dialog und die Paramter werden in den
Dialogfenstern festgelegt; im 'Textmodus' erfolgt die Eingabe der Parameter
über die Kommandozeile in der shell. Die Darstellungsform ist davon
abhängig, ob das WSH-Fenster offen ist, bzw. die shell im Textbildschirm
läuft oder nicht. Im ersten Fall wird die Eingabe (und in der Regel die
Ausgabe) im Textfenster oder -bildschirm vorgenommen. Andernfalls wird das
Kommando als Dialog ausgeführt.
Zu diesen Kommandos zählt z.B.
cp
Andere Kommandos sind für den Text- und Graphikmodus durch unterschiedliche
Kommandonamen definiert. Das liegt vor allem an den unterschiedlichen
Parametern in beiden Modi aber auch an einer teilweise unterschiedlichen
Funktionalität. Zum Anzeigen von Dateinamen dient im Textmodus das Kommando
ls
Im Graphikmodus arbeitet man mit dem Kommando
wls
Ähnlich verhält es sich mit den Kommandos 'echo' und 'gecho'.
7.2 Ausgabe von Fehlermeldungen
--------------------------------
Tritt bei der Kommandoausführung ein Fehler auf, so wird die Fehlermeldung
in einem Dialogfenster ausgegeben, sofern kein WSH-Fenster offen ist oder
der Textbildschirm aktiv ist. In diesen Fälllen wird die Fehlermeldung über
die Standardausgabe geschrieben.
8 Fensternummern
=================
Jedem geöffneten Fenster im no|Desktop wird automatisch eine eindeutige Nummer
zugeordnet. Diese erscheint im Kopfbalken des Fensters, und zwar
mit einem abschlie₧enden Doppelpunkt (':'). Somit ist es möglich, z.B.
Kopieroperationen von einem Fenster in ein anderes über die Fensternummern
zu steuern. Hat man z.B. in einem Fenster mit der Nummer '1:' einige
Dateien selektiert, um sie in den Pfad des Fensters mit der Nummer '3:' zu
kopieren, so drückt man Cntrl-K (für Kopieren) und gibt dann als Zielpfad
in der erscheinenden Dialogbox einfach '3:' - also nur die Fensternummer -
an. Die Expandierung der Nummern auf die entsprechenden Pfade übernimmt
no|Desktop dann von selbst.
Anhang
======
A1 Übersicht über die internen Variablen
-----------------------------------------
Im folgenden wird jede interne Variable genauer beschrieben.
Jede interne Variable hat zusätzlich zu ihrem Inhalt noch
individuelle Eigenschaften, so werden einige bei Eingabe des 'set'-
Kommandos mit angezeigt, andere nicht. Einige werden beim Auslagern
von no|Desktop in einer temporären Datei mit abgespeichert und stehen
nach Rückkehr wieder zur Verfügung. Viele der internen Variablen
werden beim 'Desktop Speichern' in der DESK.NDS gesichert.
Die folgenden Abkürzungen beschreiben die individuellen Attribute
einer internen Variable:
v (visible) wird beim 'set'- Kommando mitangezeigt
r (readonly) nur lesbar, nicht löschbar
n (nounset) nicht löschbar
d (d_save) wird beim Sichern des Desktops gespeichert
x (x_save) wird beim Auslagern von no|Desktop gespeichert
i (index) primär indizierte Variable
s (state) ist bei Programmstart gesetzt
Name |Attribute| Bedeutung
-----------+---------+-----------------------------------------------
NDHOME | vrns | HOME-Pfad von no|Desktop (entspricht ~~)
| | (z.B. 'C:\NODESK')
HOME | vrns | HOME-Pfad des Benuters (entspricht '~')
| | (z.B. 'G:\USR\ANDI')
PATH | vnx | Suchpfade, durch ';' getrennt, die no|Desktop vor
| | Starten eines Programms ohne Pfadangabe
| | durchsucht
TEMPDIR | vx | Ordner, in dem no|Desktop Temporärdateien ablegt
TEMPFILE | vnxs | Name der Temporärdatei, die beim Auslagern
| | erzeugt wird
SYSDIR | vnxs | Ordner, der no|Desktop-Systemdateien enthält
| | (z.B. '$NDHOME\NDSYS')
deskfile | vnxs | Name des Skriptes, das den Aufbau des Desktops
| | enthält (z.B. 'CNF\640X480\DESK.NDS' -
| | relativ zu $HOME)
initfile | vnds | Name des Skriptes, das Bildschirmauflösungs-
| | abhängige Variablendefinitionen, etc. enthält
| | (z.B. 'CNF\640X480\INIT.NDS' - relativ zu $HOME)
globfile | vds | Name des Skriptes für globale (Bildschirm-
| | auflösungsunabhängige) Variablendefinnitionen,
| | aliase, etc.
| | (z.B. 'CNF\GLOBALS.NDS' - relativ zu $HOME)
etcfile | vds | Name der optionalen Skriptdatei, die am Ende
| | des Scriptes $deskfile ausgeführt wird
nddfile | vrns | Name der Objektdefinitionsdatei
ndifile | vrns | Name der ICON-Zuordnungsdatei
rscfile | v | Name der ICON-Recourcedatei
| |
wfindcmd | x | enthält eine interne Information für das
| | Kommando wfind
filekeys | dx | wenn gesetzt, dann wird der Dateicursor in
| | Fenstern dargestellt
forceslider| dx | wenn gesetzt, dann werden grundsätzlich alle
| | Slider eines Fensters gezeichnet
wlsnoalign | dx | wenn gesetzt, dann wird KEIN Raster für die
| | Grö₧e eines LS-Fensters verwendet
notestdrv | x | wenn gesetzt, dann wird vor Auslagern von
| | no|Desktop NICHT überprüft, ob noch genug Platz
| | zum Sichern der temporären Scriptdatei
| | ($TEMPFILE) verfügbar ist
checkobts | x | enthält die Objekttypen, die beim Laden des
| | Desktops auf ihre Existenz überprüft werden
| | sollen
toptxt | x | dieser Text erscheint rechtsbündig in der
| | Menüleiste (z.B. 'set toptxt = $UNAME', dann
| | steht dort immer der aktuelle Benutzername')
msgcolor | nxs | die Farbe, in der der Inhalt von 'toptxt'
| | dargestellt wird
popdelay | ndxs | Wert zum Steuern der Scrollgeschwindigkeit
| | von PopUp-Menüs
| |
LINE | ns | in dieser Variable steht der Inhalt einer
| | Dialogeingabe, der Inhalt wird erneut parsiert
| | (s.o.)
| | (z.B. legt das interne Kommando getline hier
| | seinen String ab)
prompt | vx | Zeichenkette, die am Beginn einer Kommando-
| | zeile im shell steht. Folgende Kürzel werden
| | interpretiert:
| | $h Historyeintrag
| | $d aktuelles Laufwerk
| | $p aktueller Arbeitspfad
| | $s Anzeige von '#', wenn die shell von
| | einem anderem Programm aufgerufen wurde
| | $$ '$'
| | $r Wagenrücklauf (cr)
status | vrns | enthält den Rückgabewert eines Kommandos
history | vnx | maximale Einträge der History-Liste
ignoreerr | vx | wenn gesetzt, dann wird ein Skipt im normalen
| | Fehlerfall nicht abgebrochen
noclobber | vx | bei Ausgabeumlenkung '>' in eine Datei, darf
| | diese noch nicht existieren, bei '>>' muß
| | diese existeren (s.o.)
noxArg | xs | keine Parameterübergabe an ein Programm über
| | xArg-Verfahren
noARGV | x | keine Parameterübergabe an ein Programm über
| | ARGV-Verfahren
chainproc | nxs | Prozentangabe zum Auslagern von no|Desktop
chainabs | nxs | Kilobyteangabe zum Auslagern von no|Desktop
| | Überschreitet die Größe eines Programms +
| | 'chainproc'-Prozent des Programms +
| | chainabs-Kilobyte den größtmöglichen
| | Speicherbereich, so wird unter Normal-TOS
| | no|Desktop ausgelagert
fastsave | dx | wenn gesetzt, dann wird beim Desktop-Speichern
| | eine optimierte, aber nicht mehr lesbare Datei
| | erzeugt
fastxsave | dxs | wenn gesetzt, dann wird beim Auslagern von
| | no|Desktop eine optimierte, aber nicht mehr
| | lesbare Datei erzeugt
useKobold | dx | das Hilfsprogramm 'KOBOLD' wird benutzt
| | (bei cp, mx, rm)
koboldPRG | dx | Name und Pfadangabe von 'KOBOLD'
| |
version | rns | enthält die aktuelle Versionsnummer des no|Desktop
| | als String (z.B. "3.00")
multitask | vr | das no|Desktop-System läuft unter einem
| | preemptiven Multitasking-Betriebssystem
CPU | rns | Name des internen Prozessors (z.B. MC68000)
TIME | rns | aktuelles Datum und Uhrzeit im Format:
| | 'Djjmmtthhmmss'
screenw | rns | Breite des Bildschirms in Pixeln
screenh | rns | Höhe des Bildschirms in Pixeln
ncolors | rns | Anzahl der Farbebenen (Planes) des Bildschirms
noWcon | dx | wenn gesetzt, dann werden keine WCON-Fenster
| | benutzt (s.o.) (nicht setzbar unter
| | Multitasking-Betriebssystemen)
wshpos | x | Koordinaten des WSH-Fensters
wcon1pos | x | Koordinaten des WCON1-Fensters
wcon2pos | x | Koordinaten des WCON2-Fensters
wcon3pos | x | Koordinaten des WCON3-Fensters
wauxicrnl | x | Umwandlung von 'cr' in 'crln' bei serieller Eingabe
wauxocrnl | x | Umwandlung von 'cr' in 'crln' bei serieller Ausgabe
wauxwin | x | WCON-Fensternummer des Terminalfensters
wtalkwin | x | WCON-Fensternummer des Talkfensters
wconscroll | dx | Anzahl der Zeilen, die in WCON-Fenstern in einem
| | Stück gescrollt werden sollen
| | (0 = halbe Fensterhöhe)
| |
deskcolor | ndxs | Farbe des Desktophintergrundes (0-15)
deskpatt | ndxs | Muster des Desktophintergrundes (0- 7)
wincolor | ndxs | Hintergrundfarbe von Fenstern (0-15)
winpatt | ndxs | Hintergrundmuster von Fenstern (0- 7)
blitter | dx | wenn gesetzt, ist ein vorhandener Blitter
| | angeschaltet (der initiale 'set-Zustand'
| | wird bei Programmstart anhand des aktuellen
| | Zustands des Blitters ermittelt)
cpucache | dx | wenn gesetzt, ist ein vorhandener CPU-Cache
| | angeschaltet (ab Prozessoren des Typs MC68030
| | aufwärts) (der initiale 'set-Zustand'
| | wird bei Programmstart anhand des aktuellen
| | Zustands des Caches ermittelt)
topdelay | ndxs | Zeitwert zum automatischen Fensterwechsel,
| | wenn die Maus auf ein anderes Fenster geführt
| | wird (0 = AUS)
kbdelay | ndxs | Wert der Verzögerung bis die Tastaturwieder-
| | holung einsetzt. Möglich sind Werte von
| | 0 (AUS) bis 99
kbrepeat | ndxs | Geschwindigkeit der Tastaturwiederholung.
| | Möglich sind Werte von 0 (AUS) bis 99
linenums | dxs | wenn gesetzt, dann werden in Textfenstern
| | Zeilennummern angezeigt
tabsize | ndxs | Länge eines Tabulator-Zeichens (0 bis 20)
fontsize | ndxs | Grö₧e des Systemfonts in Textfenstern
| | (momentan: 4, 6, 9, 12, 13 oder 26)
maxfiles | ndxs | maximale Anzahl von Dateien, die in einem
| | LS-Fenster dargestellt werden können
| | (minimal 224)
wlsmaxcl | ndxs | Anzahl der Spalten in einem LS-Fenster
| | (0 = automatische Berechnung anhand der
| | Fenstergrö₧e)
wlslook | ndxs | Art der Darstellung in einem LS-Fenster
| | mögliche Werte:
| | "B" Icons
| | "N" normaler Text
| | "K" kleiner Text
wlssort | ndxs | Art der Sortierung in einem LS-Fenster
| | mögliche Werte:
| | "A" nach Art
| | "N" nach Namen
| | "D" nach Datum
| | "G" nach Grö₧e
| | "U" unsortiert, d.h. Reihenfolge
| | im Dateisystem
wlstxtshow | ndxs | Art der anzuzeigenden Informationen bei
| | Textdarstellung in einem LS-Fenster. Diese
| | Variable kann einen String aus den folgenden
| | Buchstaben enthalten:
| | "G" mit Grö₧e
| | "A" mit Attributen
| | "D" mit Datum
| | "T" mit Uhrzeit
| | Wenn der Inhalt von wlstxtshow "GADT" ist,
| | dann werden also Texte mit allen möglichen
| | Dateiinformationen angezeigt.
wlsincols | dx | wenn gesetzt, dann wird ein LS-Fenster in
| | Spalten aufgebaut
wlswithhid | dxs | wenn gesetzt, dann werden auch 'versteckte'
| | Dateien in einem LS-Fenster angezeigt
wlswithsys | dxs | wenn gesetzt, dann werden auch 'System'-
| | Dateien in einem LS-Fenster angezeigt
wlsfastdraw| dx | wenn gesetzt, dann wird eine optimierte
| | Ausgabefunktion verwendet, um Icons oder
| | gro₧en Text in LS-Fenstern darzustellen
| | (benötigt aber mehr Speicher pro Fenster!!!)
cpdialog | ndxs | Ausgabemodus für das cp-Kommando
| | mögliche Werte:
| | "n" keine Ausgaben
| | "c" mit Startdialog
| | "v" Ausgaben zeigen, aber kein Dialog
| | mit Benutzer
| | "i" mit Einzelbestätigung jeder Datei
mvdialog | ndxs | Ausgabemodus für das mv-Kommando (Werte siehe
| | cpdialog)
rmdialog | ndxs | Ausgabemodus für das rm-Kommando (Werte siehe
| | cpdialog)
touchdialog| ndxs | Ausgabemodus für das touch-Kommando (Werte
| | siehe cpdialog)
cpsmallmem | x | wenn gesetzt, dann verwenden die Kommandos
| | cp und mv nur einen kleinen Speicherbereich
| | (unter Multitasking-Betriebssystemen ohne
| | Bedeutung)
warnifro | dxs | wenn gesetzt, dann erscheint bei den Kommandos
| | mv und rm eine Warnung falls eine Datei das
| | 'nur lesbar Flag' gesetzt hat
warnifcnfl | dxs | wenn gesetzt, dann erscheint bei den Kommandos
| | cp und mv auf jeden Fall eine Warnung falls
| | ein Namenskonflikt entsteht (Datei bzw.
| | Ordner existiert schon im Ziel)
cpsetdate | dx | wenn gesetzt, dann erhält eine Datei-Kopie das
| | aktuelle Datum
cpclearsrc | dx | wenn gesetzt, dann wird das Archiv-Flag der
| | Quell-Datei beim Kopieren einer Datei gelöscht
cpcleardst | dx | wenn gesetzt, dann wird das Archiv-Flag der
| | Ziel-Datei beim Kopieren einer Datei gelöscht
cmrwinfcnt | ndxs | Anzahl der Dateien, ab der der Kopierdialog
| | im Fenster läuft
cmrwinbcnt | ndxs | Kilobytes, ab der der Kopierdialog im Fenster
| | läuft
| |
multiuser | vr | das no|Desktop-System läuft im Multiuserbetrieb
UNAME | vrns | Name des Users
UID | rns | Benutzernummer im Multiuserbetrieb
GID | rns | Gruppennummer im Multiuserbetrieb
--------------------------------------------------------------------------------
A2 besondere CLI-Anweisungen
------------------------------
- 'return'-Kommando
Definition return [<Value>]
Verwendung in Skripten
Beschreibung bricht die Bearbeitung eines Scripts' ab.
der optionale Parameter <value> steht nach Abbruch des
Scripts' in der Variablen 'status'
- 'goto'-Kommando
Definition goto <Labelname>
Verwendung in Skripten
Beschreibung Steht innerhalb eines Skriptes die unbedingte Sprung-
anweisung zu einem Labelnamen, so sucht der CLI das gesamte
Skript nach dem Vorkommen von <Labelname> ab und führt
die Skriptbeabeitung nach dem Label fort. Wird kein
Labelname gefunden so wird das Skript in jedem Fall
abgebrochen.
Der Labelname darf maximal 12 Buchstaben oder Zahlen
umfassen, muß mit einem Buchsstaben beginnen und durch
einen ':' beendet werden. Es wird Groß- und Kleinschreibung
beachtet! Der Labelname muß allein in einer Zeile und
außerhalb aller Schleifenkonstrukte und bedingten
Anweisungen stehen.
Beispiel testit:
.
.
.
if (-e TEST.C) goto testit
- 'if'-Kommando
Definition if (<Bedingung>) <Kommando>
oder
if (<Bedingung>) then
<Kommando>
.
[else
<Kommando>
.]
[elif (Bedingung) then
<Kommando>
.]
endif
Verwendung in Skripten, Objektdefinitionsdatei, (einzeilig in der shell)
Beschreibung Durch das 'if'-Kommando wird eine Anweisung nur dann
ausgeführt, wenn die in Klammern stehende Bedingung
erfüllt ist.
Das Kommando liegt in zwei Varianten vor:
1. einer einzeiligen, bei der das bedingte Kommando
unmittelbar hinter die Bedingung geschrieben werden
muß, und
2. einem mehrzeiligen Konstrukt, welches immer durch
'endif' beendet werden muß.
Ist die Bedingung erfüllt, werden alle Kommandos der
nächsten Zeilen bis zu einem 'endif', 'else' oder 'elif'
ausgeführt. Ist die Bedingung nicht erfüllt, werden die
Kommandos, die nach einem optionalen 'else' stehen,
ausgeführt. Das Kommando 'elif' steht für 'else if' und
prüft im 'else'-Fall erneut eine Bedingung; dieses
Kommando verhindert das Schachteln von 'if'-Konstrukten.
Die Kommandos 'if ... then', 'else', 'elif ... then' und
'endif' müssen allein in einer Zeile stehen.
Beispiel if (! -e "\TEMP") then
mkdir "C:\TEMP"
cp test.c \temp
elif (! -e "\TEMP\TEST.C") then
cp test.c \temp
else
echo test.c wurde schon kopiert
endif
- 'foreach'-Kommando
Definition foreach <Variablenname> <Liste>
Kommando
.
end
Verwendung in Skripten, Objektdefinitionsdatei
Beschreibung Das 'foreach'-Kommando weist einer Variablen nacheinander
jedes Wort in einer definierten 'Liste' zu. Die Kommandos
bis zum Kommando 'end' werden solange ausgeführt, bis die
'Liste' leer ist. Das Kommando 'end' muß allein in einer
Zeile stehen.
Die Liste enthält Wörter, die durch Leerzeichen voneinander
getrennt sind. Die Liste kann durch Klammern eingerahmt
werden. Die Wörter können 'wildcards' enthalten, diese
werden zu Beginn des Kommandos expandiert.
Mit dem Kommando 'continue' wird zum Beginn der bedingten
Kommandos gesprungen und mit dem nächsten Listeneintrag
weitergemacht. Das Kommando 'break' bricht die Bearbeitung
der Schleife ab und fährt mit dem Kommando unterhalb von
'end' fort.
Beispiel foreach i (*.c *.h *.prj *.cfg)
lharc a test.lzh $i
echo "$i wurde gerade archiviert..."
end
- 'while'-Kommando
Definition while (<Bedingung>)
Kommando
.
wend
Verwendung in Skripten, Objektdefinitionsdatei
Beschreibung Solange die Bedingung erfüllt ist, werden alle Kommandos
zwischen 'while' und 'wend' ausgeführt. Die Kommandos
müssen allein in einer Zeile stehen. Mit 'break' wird die
Schleife abgebrochen, mit 'continue' erneut zur 'while'-
Bedingung gesprungen.
Beispiel set i = 1
while ($i < 10)
echo $i". Durchlauf"
set i @ $i + 1
wend
