home *** CD-ROM | disk | FTP | other *** search
/ SPACE 2 / SPACE - Library 2 - Volume 1.iso / program / 575 / okami13b / tricks.doc < prev   
Encoding:
Text File  |  1991-12-15  |  29.7 KB  |  936 lines

  1.           ===============================================
  2.  
  3. @(#)        OKAMI SHELL VERSION 1.3 - TIPS UND TRICKS
  4.  
  5.           ===============================================
  6.                  Stand: 29.6.91
  7.  
  8.  
  9.         BITTE ERST DIE DATEIEN README UND OKAMI.DOC LESEN!
  10.  
  11. ----------------------------------------------------------------------------
  12. INHALT
  13.  
  14.     Profile
  15.     Aufruf von Programmen
  16.     Benutzung der Shell von Diskette aus
  17.     Beispiel-Shellscripts
  18.         oksave.sh
  19.         e.sh
  20.         showpic.sh
  21.         startprg.sh
  22.     Shell-Funktionen
  23.     Die gemexec-Funktion
  24.     Die screensave-Funktion
  25.     Speichern und Restaurieren der Shell-Einstellungen
  26.     MS-DOS-Gefühle
  27.     C-Shell-Gefühle
  28.     Gulam-Shell und Master
  29.     Die Versionsnummer der Shell
  30.     Diverses
  31.         Trikolor-Bildschirm
  32.         Aufruf vom Desktop
  33.         Zweideutige Kommandonamen
  34.         Compiler-Aufruf
  35.         Ändern von Dateinamen-Extendern
  36.         Programmierung des UPN-Rechners
  37.  
  38. ----------------------------------------------------------------------------
  39. PROFILE
  40.  
  41. Ich benutze das folgende Profile zum Konfigurieren der Shell im Festplatten-
  42. betrieb.
  43.  
  44.  
  45.     # Okami-Shell - System-Profile
  46.  
  47.     TERM=Atari Mega ST4
  48.     # Cursor etwas schneller blinkend
  49.     cursor +bv 12
  50.     # Aktuelles Directory im Prompt anzeigen
  51.     PS1=['$CWD'] ^^^$'  '
  52.     # Pipes auf die Ramdisk
  53.     PIPDIR=i:\
  54.     # Nach Ende der Shell CWD sichern...
  55.     set +s
  56.     # ...und den Cursor abschalten
  57.     trap cursor -v
  58.     # Directories trennen wie in Unix mit Slash
  59.     set +b
  60.     # anmelden als Applikation, stört ja nicht
  61.     gon
  62.     # Word Wrap On
  63.     echo ^033v
  64.  
  65.     # Bidschirm löschen durch viele Leerzeilen, Cursor steht dann unten
  66.     echo "^n^n^n^n^n^n^n^n^n^n^n^n^n^n^n^n^n^n^n^n^n^n^n^n^n^n^n^n^n^n^n^n"
  67.  
  68.     # Einschaltmeldung
  69.     echo 
  70.     echo $TERM
  71.     # Versionsnummer der Shell, des TOS und von MiNT (falls vorhanden)
  72.     ver -otM
  73.     echo
  74.     # Ausgabe des Datums des letzten Logins
  75.     cat lastlog 2>NULL:
  76.     echo
  77.     # Ausgabe des freien Speichers
  78.     echo Free RAM: `mem` Bytes
  79.     echo
  80.     # Ausgabe in invertierter Schrift
  81.     echo ^033pType help for command survey.^033q
  82.     echo
  83.     # Datum speichern
  84.     echo Last Login: `date` >lastlog
  85.     # Letztes CWD zurückholen
  86.     cd `cat wdir`
  87.  
  88.  
  89. Laufwerk I ist eine Ramdisk (Luftschloß 1MB), die die Aufgabe hat,
  90. die Pipe-Operationen zu beschleunigen. Dadurch, daß die Pipe auf die Ramdisk
  91. gelegt wird (PIPDIR=i:\), erfolgen alle Pipe-Operationen ohne Platten-
  92. zugriff.
  93. Durch die Einstellung "set +s" wird die Shell veranlaßt, vor dem Programm-
  94. ende das aktuelle Verzeichnis in die Datei $HOME\wdir zu schreiben. Das
  95. Profile benutzt diese Datei, um das aktuelle Verzeichnis wieder auf den
  96. alten Wert einzustellen. So ist man nach dem Start der Shell immer in
  97. dem Verzeichnis, in dem man war, als man die Shell zuletzt verlassen hatte.
  98. Durch die Einstellung "set +x" werden in einer Eingabe alle Slashes (/) in
  99. Backslashes (\) umgeformt, wodurch man die Möglichkeit hat, Dateinamen wie
  100. in Unix einzugeben, also shell/bin/sh.ttp anstatt shell\bin\sh.ttp.
  101. Natürlich erzeugt dann das Kommando
  102.         echo 6/3=2
  103. die Ausgabe
  104.         6\3=2
  105. da alle Slashes umgeformt werden, aber das stört normalerweise nicht.
  106. (den UPN-Rechner stört es übrigens auch nicht, da er den Backslash als
  107. Divisionszeichen versteht. Aus "upn 6 3 /" wird also "upn 6 3 \".)
  108. Außerdem kann man sich in Notfällen mit einfachen Anführungszeichen retten,
  109.     echo '6/3=2'
  110. ergibt also immer
  111.     6/3=2
  112. .
  113.  
  114. ----------------------------------------------------------------------------
  115. AUFRUF VON PROGRAMMEN
  116.  
  117. (Der folgende Abschnitt ist im wesentlichen für Festplattenbenutzer von
  118. Interesse.)
  119.  
  120. Viele Programme gehen davon aus, das sich gewisse Dateien wie z.B. RSCs im
  121. aktuellen Verzeichnis befinden. Um ein solches Kommando zu starten, muß
  122. man also mit cd in das jeweilige Verzeichnis wechseln, was unter Umständen
  123. einige Tipparbeit macht, vor allem bei einer Festplatte. Mit der Okami-
  124. Shell ist es möglich, Programme von überall, also von jedem beliebigen
  125. aktuellen Verzeichnis aus zu starten.
  126. Es sei z.B. GEMTEST.PRG ein Programm, das im Verzeichnis D:\PROG\GEMTEST
  127. steht und eine RSC-Datei aus dem aktuellen Verzeichnis nachladen muß.
  128. Zum Start des Programms müßte man also eingeben
  129.  
  130.     cd d:\prog\gemtest
  131.     gemtest
  132.  
  133. Man kann allerdings auch so vorgehen:
  134. Man erzeugt sich eine Datei namens GEMTEST.SH im Verzeichnis $HOME\bin,
  135. die ungefähr so aussieht:
  136.  
  137.     A=`set -`
  138.     set +x
  139.     d:/prg/gemtest/gemtest.prg
  140.     set $A
  141.     unset A
  142.  
  143. Zuerst wird der augenblickliche Zustand der Shellflags in der Variablen
  144. A gespeichert, danach wird das Flag x aktiviert. Wenn dieses Flag akti-
  145. viert ist, führt die Shell vor dem Start eines Binärprogramms ein cd in
  146. das Directory aus, in dem sich das Programm befindet. Nach dem Ende des
  147. Programm wird das ursprüngliche Directory wieder restauriert.
  148. Danach wird das Programm gestartet.
  149. Nach Programmende werden die Shell-Flags werden auf den gespeicherten Wert
  150. zurückgesetzt. Danach wird die lokal verwendete Shellvariable A freigegeben.
  151. Wenn das Flag -x immer gesetzt ist, kann man denselben Effekt erreichen
  152. durch:
  153.     hash gemtest d:/prg/gemtest/gemtest.prg
  154.  
  155. Normalerweise ist das Flag x immer aktiviert. Programme, die sich in einem
  156. der in der Shellvariablen PATH gespeicherten Directories befinden, werden
  157. also immer korrekt gestartet, indem man nur ihren Namen eingibt.
  158.  
  159. ----------------------------------------------------------------------------
  160. BENUTZUNG DER SHELL VON DISKETTE AUS
  161.  
  162. Wenn möglich, sollte man die Shell auf einem schnellen Massespeicher wie
  163. Festplatte oder Ramdisk installieren. Wer die Shell hauptsächlich mit
  164. Disketten benutzt, ärgert sich vermutlich darüber, daß es ziemlich lange
  165. dauert, bis ein falsch eingetipptes Kommando als solches erkannt wird,
  166. da die Shell in allen möglichen Ordnern auf der Diskette nach einer
  167. passenden Datei sucht. Mit den folgenden Einstellungen im Profile kann
  168. die Anzahl dieser Suchoperationen minimiert werden:
  169.  
  170.     PATH=.,$HOME\bin
  171.     CDPATH=.
  172.  
  173. Wenn man den Programm-Suchpfad auf das aktuelle Directory abkürzt (mit der
  174. Einstellung "PATH=."), werden noch weniger Suchoperationen durchgeführt,
  175. man kann dann allerdings die mitgelieferten externen Kommandos, die sich
  176. in dem Directory $HOME/bin befinden sollten, nicht mehr von überallher
  177. durch den einfachen Kommandonamen aufrufen, sondern muß den ganzen Pfad
  178. angeben (z.B. nicht einfach "format", sondern "$HOME\bin\format.ttp").
  179.  
  180.  
  181. ----------------------------------------------------------------------------
  182. BEISPIEL-SHELLSCRIPTS
  183.  
  184. 1) oksave.sh
  185.  
  186. Ich benutze das folgende Shellscript namens oksave.sh zum Sichern der
  187. Quelldateien der Shell auf Diskette.
  188.  
  189.  
  190.     DEST=$1
  191.     if [ -v DEST ]
  192.       echo Verwendung: oksave Directory
  193.       exit
  194.     fi
  195.     if [ -d $DEST ]
  196.     else
  197.       echo Ein Directory namens $DEST existiert nicht, anlegen? (j/n)
  198.       read B
  199.       if [ -v B ]
  200.         B=n
  201.       fi
  202.       if [ $B = j ]
  203.         mkdir $DEST
  204.         B=
  205.       else
  206.         B=
  207.         exit
  208.       fi
  209.     fi
  210.     echo ^nSichern der Okami-Files auf $DEST ^n
  211.     A=$CWD
  212.     cd e:\okami
  213.     backup -r $DEST <files.lst
  214.     B=`date`
  215.     C=`drvname $DEST`
  216.     echo $B: Okami-Sources gesichert auf $DEST >>oklog
  217.     echo $B: Okami-Sources gesichert auf $DEST >>$C/oklog 
  218.     echo Sichern beendet.
  219.     cd $A
  220.     unset DEST A B C
  221.  
  222.  
  223. Das aktuelle Directory wird in einer Shellvariablen gespeichert und dann
  224. auf e:\okami (wo sich die Quellen befinden) umgestellt. Dort befindet
  225. sich ebenfalls eine Datei namens files.lst, in der die Namen aller zu
  226. sichernden Dateien stehen. Diese Datei wird als Eingabe für das Backup-
  227. Kommando benutzt, das alle Dateien auf Diskette sichert, und zwar in
  228. den Ordner, der beim Aufruf des Scripts als Parameter angegeben wird
  229. ($1). Danach werden Datum und Uhrzeit des Sicherns in eine Datei namens
  230. oklog sowohl im Wurzelverzeichnis der Diskette als auch in e:\okami
  231. geschrieben. Diese Datei wächst, d.h. die Angaben werden an die Datei
  232. angehängt, so daß sie die Daten aller Sicherungen enthält. Danach wird
  233. das aktuelle Laufwerk wiederhergestellt und die verwendeten Shellvariablen
  234. freigegeben.
  235. Hier ein Auszug aus der Datei files.lst:
  236.  
  237.  
  238.     # Okami-Shell-Dateien zum Sichern auf Diskette
  239.     # Quellen
  240.     sh.c
  241.     cmds.c
  242.     cmds2.c
  243.     utl.c
  244.     utl2.c
  245.     okami.h
  246.     okext.h
  247.     # ausführbare Dateien
  248.     sh.ttp
  249.     msh.prg
  250.     gem.prg
  251.  
  252.  
  253. 2) e.sh
  254.  
  255. Das Shellscript e.sh dient zum Aufruf des Editors. Das Editorprogramm be-
  256. findet sich in der Datei $HOME\bin\editor.prg. Durch die Verwendung dieses
  257. Shellscripts ist es möglich, irgendwo im Dateisystem den Editor für irgend-
  258. eine Datei aufzurufen.
  259.  
  260.  
  261.     FILE=$*
  262.     if [ -v FILE ]
  263.     then
  264.       FILE=$EFILE
  265.     fi
  266.     FILE=`fullname $FILE`
  267.     $HOME\bin\editor.prg $FILE
  268.     EFILE=$FILE
  269.     unset FILE
  270.  
  271.  
  272. Der Name der zu editerenden Datei wird dem Script als Parameter übergeben.
  273. Die Zeile "FILE=`fullname $FILE`" erzeugt in der Variablen FILE
  274. den absoluten Dateinamen, der dem Editorprogramm als Parameter übergeben
  275. wird.
  276.  
  277. Wenn dieses Script ohne Parameter aufgerufen wird, so wird der in der Shell-
  278. variablen EFILE gespeicherte Dateiname benutzt. In dieser Variablen wird
  279. nach jedem Editoraufruf der jeweilige Dateiname gespeichert, so daß man,
  280. wenn man dieselbe Datei mehrmals hintereinander editieren möchte, den Datei-
  281. namen nur einmal angeben muß:
  282.         e datei.txt                     editieren von datei.txt
  283.         e datei2.txt                    editieren von datei2.txt
  284.         e                               ebenfalls datei2.txt
  285.  
  286. Ggfs. muß man dieses Script noch erweitern, um dem Editor mehrere Parameter
  287. zu übergeben (für den Micro-Emacs z.B. den Namen der Konfigurationsdatei o.ä.).
  288.  
  289.  
  290.  
  291. 3) showpic.sh
  292.  
  293. Dieses Script zeigt, wie man die Shell programmieren kann. Es dient dazu,
  294. Bilddateien, die im Bitmap-Screenformat abgespeichert wurden (Dateilänge
  295. >32000 Bytes), zu laden und anzuzeigen. Es gehört zum Lieferumfang der
  296. Shell, die Bedienungsanleitung befindet sich in commands.doc.
  297.  
  298.  
  299.  
  300. 4) startprg.sh
  301.  
  302. Die Idee zu diesem Shellscript stammt von Thomas Behrens aus Eschweiler und
  303. lautet, ein Programm in einer Fileselectbox auszuwählen und dann zu starten.
  304. Dazu genügt eigentlich die folgende Zeile:
  305.     fsel | xargs {}
  306. oder noch einfacher
  307.     `fsel`
  308. , wenn man aber den Abbruch-Button der Box abtesten und dem Programm eine
  309. Parameterzeile übergeben will, sollte man folgendes Script benutzen:
  310.  
  311.     FILE=`fsel *.* "" KEY "Welches Programm ausführen?"`
  312.     if [ $KEY = 1 ]
  313.     then
  314.       echo "Bitte Kommandozeile eingeben:"
  315.       read CMD
  316.       $FILE $CMD
  317.     fi
  318.     unset FILE KEY CMD
  319.  
  320. Beide Lösungen funktionieren übrigens sowohl mit Binärprogrammen als auch
  321. mit Shellscripts.
  322.  
  323. ---------------------------------------------------------------------------
  324. SHELL-FUNKTIONEN
  325.  
  326. Natürlich sollte man alle häufig gebrauchten Shellscripts resident halten,
  327. und zwar als Shellfunktionen. Es ist möglich, ein Shellscript so zu schreiben,
  328. daß es sich beim ersten Aufruf selber als Funktion installiert; bei allen
  329. weiteren Aufrufen wird dann die Funktion benutzt.
  330.  
  331. Sei z.B. folgendes Shellscript in der Datei hallo.sh, also unter dem Namen
  332. hallo aufzurufen:
  333.  
  334.  
  335.     echo Hallo Anwender!
  336.     echo Der freie Speicherplatz beträgt `mem` Bytes.
  337.     echo Auf Platte C: sind `df -f c:` Bytes frei.
  338.  
  339.  
  340. Setzt man nun die Zeilen
  341.         hallo()
  342.         {
  343. an den Beginn und die Zeilen
  344.         }
  345.         hallo
  346. an das Ende dieses Scripts, also so:
  347.  
  348.  
  349.     hallo()
  350.     {
  351.       echo Hallo Anwender!
  352.       echo Der freie Speicherplatz beträgt `mem` Bytes.
  353.       echo Auf Platte C: sind `df -f c:` Bytes frei.
  354.     }
  355.     hallo
  356.  
  357.  
  358. so wird beim Start des Scripts die Shellfunktion hallo installiert, und bei
  359. jedem weiteren Aufruf von hallo wird nicht das Script, sondern die Funktion
  360. aufgerufen. Mit dem Kommando
  361.  
  362.     unset hallo
  363.  
  364. kann man die Funktion wieder aus dem Speicher entfernen.
  365.  
  366.  
  367. Die Shellfunktionen machen übrigens eine alias-Funktion völlig überflüssig,
  368. da sie auch benutzt werden können, um interne Kommandos umzudefinieren: Wer
  369. anstelle von ls lieber ls -C hat, gibt einfach ein
  370.  
  371.         ls()
  372.         {
  373.           !ls -C $*
  374.         }
  375.  
  376. Wer irgendwann das normale ls benutzen will, kann das tun, indem er es als
  377. !ls aufruft.
  378.  
  379. Ebenso helfen Shellfunktionen, Tippfehler zu vermeiden; wer ständig dor
  380. oder dior statt dir tippt, versuche
  381.  
  382.         dior()
  383.         {
  384.           dir $*
  385.         }
  386.  
  387. (Wer sich wundert, daß die Okami-Shell trotzdem ein alias-Kommando hat:
  388. das dient nur dazu, das Anlegen dieser Mini-Funktionen einfacher zu ge-
  389. stalten und um Shellscripts anderer Shells ausführen zu können. Man kann
  390. also ebenso schreiben:
  391.     alias ls !ls -C
  392. und
  393.     alias dior dir
  394. .)
  395.  
  396. Mein Unix-Tippfehler-Script enthält mehrere Dutzend Schreibweisen der
  397. häufig benutzten Kommandos wie dir, grep und der Make-Aufrufe xmake,
  398. qmake und remake.
  399.  
  400. Besondere Funktionen haben die vordefinierten (aber vom Anwender vollständig
  401. umdefinierbaren) Shellfunktionen gemexec und screensave, die im folgenden
  402. Abschnitt beschrieben werden.
  403.  
  404. ---------------------------------------------------------------------------
  405. DIE GEMEXEC-FUNKTION
  406.  
  407. Mit der kann man wirklich einiges machen, denn sie gibt dem Anwender die
  408. Möglichkeit, das Verhalten der Shell beim Start von GEM-Programmen frei zu
  409. programmieren. Dabei stehen ihm alle die nicht zu unterschätzenden Funktionen
  410. der Shell zur Verfügung.
  411.  
  412. Die folgende gemexec-Funktion kann benutzt werden, um nach dem Ende eines GEM-
  413. Programms den Bildschirm wieder so herzustellen, wie er vor dem Aufruf war.
  414. Dazu werden die internen Kommandos getscr und putscr sowie die VT52-Sequenzen
  415. zum Speichern und Wiederherstellen der Cursorposition benutzt. Dabei werden
  416. allerdings 32000 Bytes zum Speichern des Bildschirminhaltes belegt. Aus
  417. diesem Grund speichert die Funktion den Bildschirm nur dann, wenn die
  418. Shellvariable SAVESCR gesetzt ist. Man kann das Speichern also mit
  419.         SAVESCR=1
  420. ein- und mit
  421.         SAVESCR=
  422. wieder ausschalten.
  423.  
  424.     gemexec()
  425.     {
  426.       _=$0
  427.       if [ +v SAVESCR ]
  428.       then
  429.         # Cursorposition speichern
  430.         echo ^033j^c
  431.         # Bildschirm speichern
  432.         getscr
  433.       fi
  434.       # Bildschirm grau
  435.       scr -g
  436.       # Cursor unsichtbar
  437.       cursor -v
  438.       # das Gem-Programm ausführen
  439.       exec -g $_
  440.       if [ +v SAVESCR ]
  441.       then
  442.         # Bildschirm wiederherstellen
  443.         putscr
  444.         # Speicher freigeben
  445.         putscr -f
  446.         # Cursorposition wiederherstellen
  447.         echo ^033k^c
  448.         # Cursor wieder sichtbar
  449.         cursor +v
  450.       else
  451.         cls
  452.       fi
  453.       unset _
  454.     }
  455.  
  456.  
  457. Das folgende Beispiel zeigt, wie man das "Applikation anmelden" des Desktop
  458. auf diese Weise simulieren kann. Es macht alle Dateien mit Extender .gfa und
  459. .c ausführbar. Beim Ausführen einer .gfa-Datei wird der GFA-Basic-Interpreter,
  460. beim Ausführen einer .c-Datei der C-Compiler aufgerufen. Alle anderen Programme
  461. werden wie üblich ausgeführt. Wichtig dabei ist, daß die Extender .gfa und .c
  462. sowohl in XEXT als auch in GEXT aufgeführt werden.
  463.  
  464.     XEXT=$XEXT,.gfa,.c
  465.     GEXT=$GEXT,.gfa,.c
  466.     gemexec()
  467.     {
  468.       _=$0 $*
  469.  
  470.       # Extender ermitteln, Flag setzen
  471.       F=0
  472.       E=`extname $_`
  473.  
  474.       # GFA-Basic? 
  475.       if [ $E = .gfa ]
  476.       then
  477.         F=1
  478.         exec -g d:/gfabasic/gfabasic.prg $_
  479.       fi
  480.       # C-Source?
  481.       if [ $E = .c ]
  482.       then
  483.         F=1
  484.         exec -g d:/compiler/cc.ttp $_
  485.       fi
  486.       # Weder-noch, also normal ausführen
  487.       if [ $F = 0 ]
  488.       then
  489.         # wie das Default-gemexec
  490.         cls
  491.         cursor -v
  492.         exec -g $_
  493.         cls
  494.       fi
  495.  
  496.       # Variablen freigeben
  497.       unset E F _
  498.     }
  499.  
  500. Die Benutzung des Flags $f entscheidet darüber, ob das Programm am Ende doch
  501. noch mit exec -g aufgerufen wird.
  502.  
  503. ---------------------------------------------------------------------------
  504. DIE SCREENSAVE-FUNKTION
  505.  
  506. Wenn in der Eingabe Control-P gedrückt wird, ruft die Shell die Shellfunktion
  507. screensave auf. In der Voreinstellung wird dadurch die normale Drucker-Hard-
  508. copy ausgelöst (was sinnvoll ist, wenn die Tastenkombination Alt-Help von
  509. einem residenten Programm okkupiert ist), aber durch Ändern der screensave-
  510. Funktion kann der Anwender jede beliebige Operation durch Ctrl-P auslösen
  511. lassen. Die folgenden drei screensave-Funktionen dienen dazu, die Hardcopy
  512. ähnlich dem Snapshot-Programm in eine Datei umzuleiten.
  513.  
  514. Die erste Version fragt den Anwender mit einer Fileselect-Box nach dem Datei-
  515. namen. Diese Funktion geht davon aus, daß gon aktiviert ist.
  516. Alle Versionen stellen während des Speicherns den Cursor auf nichtblinkend
  517. und schalten ihn, wenn die Shell wieder zur Eingabe bereit ist, wieder auf
  518. blinkend zurück. Wer das nicht will, läßt die cursor-Aufrufe weg.
  519.  
  520.     screensave()
  521.     {
  522.       # Cursor nicht blinkend
  523.       cursor -b
  524.       # Bildschirm sichern
  525.       getscr
  526.       # nach einem Dateinamen fragen
  527.       fsel *.pic "" KEY "Dateiname für Hardcopy?" | read FILE
  528.       # Abbruch geklickt?
  529.       if [ $KEY = 1 ]
  530.       then
  531.         # nein, in die Datei speichern
  532.         putscr -s $FILE
  533.       fi
  534.       # Speicher und Variablen freigeben
  535.       putscr -f
  536.       unset KEY FILE
  537.       # Cursor wieder blinkend
  538.       cursor +b
  539.     }
  540.  
  541. Die zweite Version verhält sich eher wie das Snapshot-Kommando. Sie baut selber
  542. einen Dateinamen zusammen. Der Dateiname ist "screen.", der Extender eine
  543. laufende Nummer. Der Zähler befindet sich in der Shellvariablen _SCRCOUNT,
  544. aufwärtsgezählt wird mit Hilfe des UPN-Rechners.
  545.  
  546.     screensave()
  547.     {
  548.       cursor -b
  549.       getscr
  550.       if [ -v _SCRCOUNT ]
  551.       then
  552.         # Wenn es die Zählvariable noch nicht gibt, bei 0 anfangen
  553.         _SCRCOUNT=0
  554.       else
  555.         # ansonsten 1 addieren.
  556.         upn %ld $_SCRCOUNT ++ | read _SCRCOUNT
  557.         # Das Ergebnis lassen wir nicht auf dem Stack rumliegen...
  558.         upn pop
  559.       fi
  560.       # wie oben.
  561.       putscr -s screen.$_SCRCOUNT
  562.       putscr -f
  563.       cursor +b
  564.       unset FILE
  565.     }
  566.  
  567. Die dritte Version fragt den Anwender, ob er die Hardcopy in eine Datei oder
  568. auf den Drucker haben möchte. Es benutzt dazu eine Alert-Box, funktioniert
  569. also nur, wenn gon aktiv ist.
  570.  
  571.     screensave()
  572.     {
  573.       # Zuerst den Bildschirmspeicher sichern
  574.       cursor -b
  575.       getscr
  576.       # Dann den Anwender fragen
  577.       alert ques 1 "Bildschirm speichern nach..." "Drucker^|Datei" A
  578.       read A
  579.       if [ $A = 1 ]
  580.       then
  581.         # Druckerausgabe, dazu den Bildschirm wieder so herrichten,
  582.         # wie er vor dem echo war
  583.         putscr
  584.         hardcopy
  585.       else
  586.         # Datei
  587.         ................. (wie eins der beiden obigen Beispiele)
  588.       fi
  589.       # Speicher freigeben
  590.       putscr -f
  591.       unset A
  592.       cursor +b
  593.     }
  594.  
  595. Man kann das natürlich beliebig weit treiben und ein komplettes Menüprogramm
  596. schreiben, daß mit Ctrl-P aufgerufen wird.
  597.  
  598. ---------------------------------------------------------------------------
  599. SPEICHERN UND RESTAURIEREN DER SHELL-EINSTELLUNGEN
  600.  
  601. Die Okami-Shell bietet die Möglichkeit, einen großen Teil ihrer Einstellungen
  602. bei Programmende abzuspeichern und beim nächsten Programmstart wiederherzu-
  603. stellen. Die folgenden Kommandos sollte man in sein Profile schreiben, um
  604. die einzelnen Funktionen zu übernehmen.
  605.  
  606. 1. Das aktuelle Directory:
  607.     set +s
  608.  
  609. 2. Die history-Liste:
  610.     trap +history ^>$HOME/hist.sav
  611.     history -l <$HOME/hist.sav
  612.  
  613. 3. Die Shellvariablen:
  614.     trap +vars -x ^>$HOME/vars.sav
  615.     trap +export ^>>$HOME/vars.sav
  616.     trap +readonly ^>>$HOME/vars.sav
  617.     . $HOME/vars.sav
  618.  
  619. 4. Die Shellfunktionen:
  620.     trap +fcts -l ^>$HOME/fcts.sav
  621.     . fcts.sav
  622.  
  623. 5. Die set-Einstellungen:
  624.     trap +set - ^>$HOME/set.sav
  625.     xargs set <$HOME/set.sav
  626.  
  627. 6. Die Blinkrate des Cursors:
  628.     trap +cursor ^>$HOME/cursor.sav
  629.     xargs cursor <$HOME/cursor.sav
  630.  
  631. 7. Die Tastatureinstellung:
  632.     trap +keyb - ^>$HOME/keyb.sav
  633.     xargs keyb <$HOME/keyb.sav
  634.  
  635. 8. Die umdefinierten Funktionstasten:
  636.     trap +keydef list ^>$HOME/keydef.sav
  637.     . $HOME/keydef.sav
  638.  
  639. 9. Das Clipboard-Directory:
  640.     trap +echo 'clipb $CLIPDIR' ^>$HOME/clipb.sav
  641.     . $HOME/clipb.sav
  642.    Vorher sollte allerdins "gon" im Profile stehen.
  643.  
  644. 10. Die Laufwerksbezeichnungen:
  645.     trap +drive ^>$HOME/drive.sav
  646.     xargs drive <$HOME/drive.sav
  647.  
  648. 11. Die Hashtabelle:
  649.     trap +hash * ^>$HOME/hash.sav
  650.     . $HOME/hash.sav
  651.     
  652. ---------------------------------------------------------------------------
  653. MS-DOS-GEFÜHLE
  654.  
  655. Die Unverbesserlichen, die sich statt wie in Unix lieber wie in MS-DOS
  656. fühlen wollen und das aktuelle Laufwerk nicht mit
  657.         cd a:
  658. , sondern einfach mit
  659.         a:
  660. einstellen wollen, können sich mit entsprechenden Shellfunktionen helfen.
  661. Setzt man sich folgende Zeilen für jedes angemeldete Laufwert ins Profile:
  662.  
  663.         a:()
  664.         {
  665.           cd a:
  666.         }
  667.         A:()
  668.         {
  669.           cd a:\
  670.         }
  671.  
  672. dann kann man durch Eingabe von a: das aktuelle Laufwerk a: einstellen und
  673. durch Eingabe von A: in Mupfel-Manier ins Rootdirectory von a: wechseln.
  674. Eine Liste der angemeldeten Laufwerke erhält man bekanntlich mit
  675.         df -m
  676. . Natürlich kann man sich diese Funktionen auch in eine eigene Datei, z.B.
  677. msdos.sh, schreiben und diese dann im Profile mit
  678.         . mshdos.sh
  679. aufrufen. Unixfans erstellen außerdem eine Datei namens killmsdos.sh, in
  680. der sie mit den Zeilen
  681.         a:()
  682.         {}
  683.         A:()
  684.         {}
  685. usw. (für jedes vorhandene Laufwerk) die MS-DOS-Funktionen wieder löschen.
  686.  
  687. ---------------------------------------------------------------------------
  688. C-SHELL-GEFÜHLE
  689.  
  690. Wer sich lieber wie in der C-Shell (/bin/csh) fühlt als wie in der Bourne-
  691. Shell, kann sich auch mit Shellfunktionen helfen.
  692. In der C-Shell werden Variablen mit dem set-Kommando gesetzt:
  693.  
  694.     set()
  695.     {
  696.       VAR=$1
  697.       VAL=$2 $3 $4 $5 $6 $7 $8 $9
  698.       $VAR=$VAL
  699.     }
  700.  
  701. Environmentvariablen setzt man man mit setenv.
  702.  
  703.     setenv()
  704.     {
  705.       VAR=$1
  706.       VAL=$2 $3 $4 $5 $6 $7 $8 $9
  707.       $VAR=$VAL
  708.       export $VAL
  709.     }
  710.  
  711. ---------------------------------------------------------------------------
  712. GULAM-SHELL UND MASTER
  713.  
  714. In manchen Punkten ist die Gulam-Shell unschlagbar, z.B. was den eingebau-
  715. ten Editor und die Regular-Expression-Fähigkeiten (egrep) angeht (im Ernst:
  716. auch unter Unix habe ich egrep noch nie benutzt), in anderen Beziehungen
  717. hat Okami die Nase vorn (z.B. bei den Möglichkeiten von chmod und Pipes.) Man
  718. kann die Gulam-Shell von der Okami-Shell aus aufrufen, dabei werden alle
  719. exportierten Shellvariablen übergeben und können unter Gulam mit setenv
  720. angesehen werden (anders als Okami unterscheidet Gulam zwischen Environment-
  721. und Shell-Variablen).
  722.  
  723. Fast dasselbe gilt für dir kommerzielle Master-Shell, von der mir leider nur
  724. das Referenznahdbuch zur Verfügung stand. Obwohl Master eine Reihe von Fähig-
  725. keiten hat, vor denen Okami sich respektvoll verbeugen muß, z.B. Unix-Filenamen
  726. und Regular Expressions bis auf TOS-Ebene, Links und Locks usw., ist Master
  727. doch in nicht allen Punkten voraus. Die Shellfunktionen von Okami sind dem
  728. alias-System sicherlich in ihrer Flexibilität weit überlegen (programmieren 
  729. Sie mal while und if in ein alias), und Okami hat eine ganze Reihe von in-
  730. ternen Kommandos, die die Programmierung vereinfachen, z.B. basename, test,
  731. getscr/putscr usw., die Master vermissen läßt. Ein gewaltiges Plus für Okami
  732. ist natürlich der Preis: wer direkt bei mir bestellt, zahlt nicht mehr als
  733. zweimal 1,70 für Porto. Außerdem dürfte es schwierig sein, an die Quellen von
  734. Master zu gelangen.
  735.  
  736. ----------------------------------------------------------------------------
  737. DIE VERSIONSNUMMER DER SHELL
  738.  
  739.     "Was heißt Manta GTE?    - GETUNED EY!!!!!!"
  740.                     (unbekannter Manta-Witz-Erfinder)
  741.  
  742. Damit keine ähnlichen Mutmaßungen über die Bedeutung der Versionsnummer der
  743. Okami-Shell aufkommen, hier die genaue Beschreibung, was selbige uns zu
  744. sagen hat.
  745.  
  746. Die Versionsnummer, die in der Shell-Variablen $VERSION gespeichert ist und
  747. von dem ver-Kommando ausgegeben wird, gibt ziemlich genaue Auskunft über die
  748. vorliegende Version der Shell und ist folgendermaßen aufgebaut:
  749.  
  750.     z.B. "1.3b+ X"
  751.  
  752. 1 : die Hauptnummer (eine Zahl, gefolgt von einem Punkt)
  753.     diese Nummer ändert sich nur unter besonderen Umständen, z.B. Por-
  754.     tierungen auf andere Rechner oder größeren Umstellungen der Programm-
  755.     struktur, Bedienung usw. Versionen mit unterschiedlicher Hauptnummer
  756.     sind nicht unbedingt kompatibel zueinander.
  757.  
  758. 3 : die Versionsnummer (eine Zahl)
  759.     kennzeichnet die laufende Nummer der Shell und ändert sich mit den
  760.     vollständigen (d.h. garantiert vollständig getesteten und dokumen-
  761.     tierten) Versionen, die von Zeit zu Zeit veröffentlicht werden, wenn
  762.     mir mal eine Weile nichts neues einfällt (also nicht allzu häufig).
  763.     Diese Versionen werden über Pd-Versandstellen vertrieben.
  764.     
  765. Alle anderen Angaben treten optional auf:
  766.  
  767. b : die Zwischen-Release-Nummer (ein Kleinbuchstabe)
  768.     kennzeichnet Releases, die zwischen den o.a. Versionen herauskommen.
  769.     Wer seine Shell direkt bei mir bestellt, bekommt mit großer Wahr-
  770.     scheinlichkeit eine solche Zwischenversion. Sie sind im großen und
  771.     ganzenfehlerfrei und dokumentiert, obwohl das hier nicht so sicher
  772.     ist wie    bei den Hauptversionen (die keine Zwischen-Release-Nummern
  773.     haben).
  774.  
  775. + : die Test-Kennung
  776.     mit dem Pluszeichen werden die Arbeitsversionen gekennzeichnet, die
  777.     normalerweise nicht veröffentlicht werden. Diese Versionen enthalten
  778.     möglicherweise noch Fehler.
  779.  
  780. X : die Erweiterungsspezifikation (ein oder mehrere Großbuchstaben)
  781.     die Großbuchstaben kennzeichnen erweiterte, verkürzte oder konfektio-
  782.     nierte Versionen. Folgende Erweiterungsspezifikationen können auftre-
  783.     ten:
  784.         F    die Version enthält eine höhere Anzahl von Shell-
  785.             funktionen.
  786.         V    die Version enthält eine höhere Anzahl von Shell-
  787.             variablen.
  788.         L    die Version enthält eine höhere Anzahl von ver-
  789.             schachtelbaren while-Ebenen.
  790.         X    die Version enthält sonstige Erweiterungen der
  791.             Kapazität.
  792.         R    die Version ist restriktiv, d.h. sie enthält wesent-
  793.             lich weniger interne Kommandos als die regulären
  794.             Versionen.
  795.         P    bei Programmstart wird das Profile immer geladen,
  796.             außer es wird der Parameter "-" übergeben (die
  797.             regulären Versionen verhalten sich umgekehrt).
  798.         K    die Version ist auf die Wünsche eines bestimmten
  799.             Anwenders konfektioniert.
  800.  
  801. Die zeitliche Reihenfolge der Versionen lautet also:
  802.  
  803.     1.3        Hauptrelease
  804.     1.3+        Arbeitsversion
  805.     1.3a        Zwischenrelease
  806.     1.3a+        Arbeitsversion
  807.     1.3b        Zwischenrelease
  808.     1.3b+        Arbeitsversion
  809.     ....
  810.     1.4        Hauptrelease
  811.     1.4+        Arbeitsversion
  812.     usw.
  813.  
  814. Eine genauere Analyse der Shell (Anzahl der möglichen Variablen, Shellfunk-
  815. tionen und geschachtelten whiles, maximale Zeilenanzahl des sort-Kommandos,
  816. Länge des History-Puffers, Größe des UPN-Stacks usw.) kann mit dem Kommando
  817. "ver -l" erzeugt werden.
  818.  
  819. ----------------------------------------------------------------------------
  820. DIVERSES
  821.  
  822. Trikolor-Bildschirm:
  823.  
  824. Durch Verwendung des Kommandos
  825.  
  826. scr -b ; cursor +bv 1
  827.  
  828. auf einem Monochrom-Bildschirm blinkt der Cursor so schnell, daß er wie eine
  829. dritte Farbe auf dem Bildschirm wirkt. Dieser Effekt ist jedoch nur bei
  830. dunklem Hintergrund (scr -b) deutlich sichtbar.
  831.  
  832.  
  833. ~~~~~~~~~~~~~~~~~~~
  834. Aufruf vom Desktop:
  835.  
  836. Wenn man sh.ttp vom Desktop aufruft und eine Kommandozeile eingibt, die
  837. von der Shell ausgeführt werden soll, so erscheint nach der Ausführung
  838. dieser Kommandos wieder das Desktop, ohne daß der Anwender Zeit hat,
  839. eventuelle Ausgaben zu lesen.
  840. Um das zu verhindern, kann das read-Kommdando benutzt werden. Um z.B.
  841. für alle angemeldeten Laufwerke die Platzstatistik (mit dem Kommando
  842. df) zu erhalten, klickt man auf sh.ttp und gibt folgende Kommando-
  843. zeile ein:
  844.  
  845.     df ; read
  846.  
  847. oder
  848.  
  849.     df ; echo Taste: ; read
  850.  
  851. (Die Leerzeichen um die Strichpunkte sind nicht unbedingt notwendig).
  852. Nach der Ausführung von df wartet die Shell auf eine Eingabe (die durch
  853. Druck auf RETURN beendet sein muß). Im zweiten Beispiel wird außerdem
  854. noch der Text "Taste:" ausgegeben.
  855.  
  856.  
  857. ~~~~~~~~~~~~~~~~~~~~~~~~~~
  858. Zweideutige Kommandonamen:
  859.  
  860. Wenn ein Programm denselben Namen wie ein internes Shellkommando hat, dann
  861. kann dieses Programm nicht einfach mit Namen aufgerufen werden. Hat man
  862. z.B. ein Script namens test.sh, dann wird durch Eingabe von "test" nicht
  863. das Script, sondern das interne Kommando "test" aufgerufen. Um das zu ver-
  864. hindern, gibt man den Kommandonamen in Großbuchstaben ein, also "TEST" oder
  865. "Test", dann wird das externe Kommando aufgerufen. Das liegt daran, daß
  866. Groß-Kleinschreibung bei internen Kommandos von Bedeutung ist, bei Datei-
  867. namen und damit bei externen Kommandos aber nicht.
  868.  
  869.  
  870. ~~~~~~~~~~~~~~~~
  871. Compiler-Aufruf:
  872.  
  873. Folgende Zeilen habe ich im Aufrufshellscript für den Compiler:
  874.  
  875.     D=`date`
  876.     echo $D
  877.     echo "#define _CMP_DAT" ^"$D^" >$INC/cmpdat.h
  878.  
  879.  
  880. Dies erzeugt bei jedem Compileraufruf eine Headerdatei namens cmpdat.h
  881. (die Environmentvariable INC speichert den Pfad der Headerdateien), in der
  882. ein Makro namens _CMP_DAT definiert wird, das das aktuelle Datum beinhaltet,
  883. z.B.
  884.  
  885.         #define _CMP_DAT "03.07.1991 19:54:42"
  886.  
  887. Diese Datei in die C-Quellen eingebunden, und man hat in jedem Programm
  888. das individuelle Datum der Erstellung. Das Ergebnis kann man sich in der
  889. Okami-Shell mit "ver -c" ansehen.
  890.  
  891.  
  892. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  893. Ändern von Dateinamen-Extendern:
  894.  
  895. Die Kommandos basename, dirname und extname kann man benutzen, um den Extender
  896. einer Datei zu ändern, z.B. um zu einer C-Quelldatei den Namen der zugehörigen
  897. Objektdatei zu ermitteln.
  898.  
  899. Man kann dieses Kommando zusammen mit dirname benutzen, um z.B. zu dem Namen
  900. einer C-Quelldatei den Namen der zugehörigen Objektdatei zu ermitteln.
  901.  
  902.     echo Bitte einen C-Quelldateinamen eingeben:
  903.     read FILE
  904.     EXT=`extname $FILE`
  905.     if [ $EXT != .c ]
  906.     then
  907.       echo Das ist keine C-Quelldatei!
  908.     else
  909.       DIR=`dirname $FILE`
  910.       FILE=`basename $FILE .c`
  911.       echo Die Objektdatei ist $DIR/$FILE.o
  912.     fi
  913.     unset FILE DIR
  914.  
  915. Ergibt:
  916.     Bitte einen C-Quelldateinamen eingeben:
  917.     e:/okami/cmds4.c
  918.     Die Objektdatei ist e:/okami/cmds4.o
  919.  
  920. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  921. Programmierung des UPN-Rechners:
  922.  
  923. Der UPN-Rechner ist nicht wirklich programmierbar, aber es ist möglich,
  924. häufig benutzte Sequenzen von Kommandos in Shellvariablen abzulegen und
  925. diese dann mit dem UPN-Rechner zu benutzen. Die folgende Zeile speichert in
  926. der Variablen BKOEFF ein Programm zum Berechnen des Binominalkoeffizienten.
  927.     BKOEFF="2 sto 1 sto 1 rcl fact 2 rcl fact 1 rcl 2 rcl - fact * /"
  928. Um z.B. 5 über 3 zu berechnen, gibt man ein:
  929.     upn 5 3 $BKOEFF
  930. Um die Summe aller Zahlen von 1 bis x zu berechnen, kann man folgendes Pro-
  931. gramm benutzen:
  932.     SUM="dup sqr + 2 /"
  933. Dann berechnet "upn 5 $SUM" die Summe der Zahlen von 1 bis 5.
  934.  
  935. Dies funktioniert auch mit dem calc-Shellscript.
  936.