From 04e68443040c7abad84d66477e98f93bed701760 Mon Sep 17 00:00:00 2001 From: Lars-Dominik Braun Date: Mon, 4 Feb 2019 13:09:03 +0100 Subject: Initial import --- doc/system-manual/1.8.7/doc/systemhandbuch.2 | 1351 ++++++++++++++++++++++++++ 1 file changed, 1351 insertions(+) create mode 100644 doc/system-manual/1.8.7/doc/systemhandbuch.2 (limited to 'doc/system-manual/1.8.7/doc/systemhandbuch.2') diff --git a/doc/system-manual/1.8.7/doc/systemhandbuch.2 b/doc/system-manual/1.8.7/doc/systemhandbuch.2 new file mode 100644 index 0000000..c4772f0 --- /dev/null +++ b/doc/system-manual/1.8.7/doc/systemhandbuch.2 @@ -0,0 +1,1351 @@ +#start(2.5,1.5)# +#pageblock# +#block# +#page (35)# +#headeven# + +%#center#EUMEL-Systemhandbuch + + +#end# +#headodd# + +#center#3. ELAN-Programme#right#% + + +#end# + + +#ib(9)#3. #ib#ELAN-Programme#ie##ie(9)# + + + + +#ib(9)#3.1. #ib#Wertebereich#ie#e und #ib#Speicherbedarf#ie##ie(9)# + + +#ib#INT-Objekte#ie# + + +Jedes #ib#Datenobjekt#ie# vom Typ INT belegt im Speicher 2 Bytes. Mögliche INT-Werte sind +die ganzen Zahlen von -32768 bis +32767 einschließlich. + + + + +#ib#REAL-Objekte#ie# + + +Jedes Datenobjekt vom Typ REAL belegt im Speicher 8 Bytes. + +REALs haben eine 13-stellige #ib#Mantisse#ie#, die im Rechner dezimal geführt wird. (Das +heißt, bei Konversionen zwischen interner und TEXT-Darstellung treten keine Run­ +dungsfehler auf.) Der Wertebereich wird durch folgende Eckwerte abgelegt: + + 9.999999999999e+126 größter REAL-Wert + 0.000000000001 kleinster positiver REAL-Wert mit x + 1.0 > 1.0 + 9.999999999999e-126 kleinster positiver REAL-Wert > 0.0 + -9.999999999999e-126 größter negativer REAL-Wert + -9.999999999999e+126 kleinster REAL-Wert + + + + + +#ib#BOOL-Objekte#ie# + + +Jedes Datenobjekt vom Typ BOOL belegt im Speicher 2 Bytes. + + + + + +#ib#TEXT-Objekte#ie# + + +Jedes Datenobjekt vom Typ TEXT besteht aus einem festen Teil von 16 Bytes und +möglicherweise aus einem flexiblen Teil auf dem #on("i")##on("b")##ib#Heap#ie##off("i")##off("b")#. Im festen Teil werden #ib#Texte bis +zur Länge von 13 Zeichen#ie# untergebracht. Wenn eine TEXT-Variable einen Wert mit +mehr als 13 Zeichen Länge annimmt, werden alle Zeichen auf dem Heap unterge­ +bracht. Genauer ergibt sich folgendes Bild: + + kurzer Text (LENGTH <= 13): + + Heap-Link 2 Bytes + Textlänge 1 Byte + Text 13 Bytes + + langer Text (LENGTH > 13): + + Heap-Link 2 Bytes + 255 1 Byte + Länge 2 Bytes + ungenutzt 11 Bytes + +Wenn eine Variable einmal Platz auf dem Heap bekommen hat, behält sie diesen +vorbeugend auch dann, wenn sie wieder einen kurzen Text als Wert erhält. So muß +wahrscheinlich kein neuer Platz auf dem Heap zugewiesen werden, wenn sie wieder +länger wird. Das gilt allerdings nur bis zur nächsten #ib#Garbage Collection#ie# auf den +TEXT-Heap, denn dabei werden alle Heap-Container minimal gemacht bzw. gelöscht, +wenn sie nicht mehr benötigt werden. Der Platz auf dem Heap wird in Vielfachen von +16 Bytes vergeben. In Fremddatenräumen wird in jedem #ib#Container#ie# neben dem eigent­ +lichen Text auch die Containerlänge untergebracht. + +Beispiele: TEXT-Länge Speicherbedarf (Byte) + + 0 16 + 13 16 + 14 32 + 15 48 + 30 48 + 31 64 + 46 64 + 47 80 + 62 80 + + +Die Heapgröße eines Fremddatenraums berechnet sich als: + + 1024 * 1024 - 520 = 1048056 - stat Bytes + +'stat' ist dabei die statistische Größe der Datenstruktur, die dem Datenraum aufgeprägt +wurde. Bei einem BOUND ROW 1000 TEXT ergibt sich also eine Heapgröße von + + 1048056 - (1000 * 16) = 1032056 Bytes. + + + + + + +#ib#ROW- und STRUCT-Objekte#ie# + + +Bei der Berechnung des Speicherbedarfs von #ib#STRUCT#ie#s und #ib#ROW#ie#s muß man beden­ +ken, daß längere Datenobjekte ausgerichtet werden. Und zwar werden alle Objekte, die +mindestens die Länge eines REAL-Objektes haben, auf durch 8 teilbare Speichera­ +dressen ausgerichtet. Man bedenke, daß bei ROWs alle Elemente entsprechend ihres +Elementtyps ausgerichtet sind. + +Beispiele: Länge (Byte) + + ROW 2 BOOL 4 + ROW 4 INT 8 + ROW 5 INT 16 + ROW 2 STRUCT (INT, BOOL) 4 + ROW 100 STRUCT (INT,INT) 400 + ROW 100 STRUCT (INT,REAL) 1600 + ROW 100 STRUCT (INT,INT,INT,INT,REAL) 1600 + ROW 100 STRUCT (REAL, REAL) 1600 + ROW 100 STRUCT (INT,TEXT) 2400 + ROW 100 STRUCT (INT,INT,INT,INT,TEXT) 2400 + ROW 100 STRUCT (INT,TEXT,INT,TEXT) 4800 + ROW 100 STRUCT (INT,INT,TEXT,TEXT) 4000 + ROW 100 ROW 3 INT 600 + ROW 100 ROW 4 INT 800 + ROW 100 ROW 5 INT 1600 +aber: + ROW 500 INT 1000 + +#on("i")#Anmerkung: Bei der #ib#Speichervergabe#ie# der einfachen Variablen und Konstanten eines + Programms spielen Verluste aufgrund von Ausrichtungen in der Regel + keine Rolle. Der ELAN-Compiler optimiert dabei soweit möglich.#off("i")# +#page# +#headeven# + +%#center#EUMEL-Systemhandbuch + + +#end# +#headodd# + +#center#4. Standardpakete für Systemprogrammierer#right#% + + +#end# + + +#ib(9)#4. #ib#Standardpakete für + Systemprogrammierer#ie(9)##ie# + + +#ib(9)#4.1. #ib#Fehlerbehandlung#ie##ie(9)# + + +Übersicht + + +#on("italics")# + Fehler treten auf, wenn ein Programm eine gewünschte Leistung + nicht erbringen kann. Solche Situationen müssen von System- + Programmen kontrolliert behandelt werden. Die folgenden Aus­ + führungen sind somit nur für diejenigen interessant, die "Sy­ + stem"-Programme schreiben wollen.#off("italics")# + +#ib#Fehler#ie# treten in Operationen auf, wenn diese eine geforderte Leistung nicht erbringen +können (z.B. das Drucken einer nicht vorhandenen Datei). Da folgende Anweisungen +aber davon ausgehen, daß die gewünschten Leistungen erbracht wurden, ist es nicht +sinnvoll, die Operation weiter auszuführen. Wir sprechen vom #ib#Abbruch einer Operation#ie#, +wenn nach einem Fehler keine Anweisungen mehr ausgeführt werden, sondern die +Operation verlassen wird. Im EUMEL-System kann durch folgende drei Maßnahmen +ein Abbruch verursacht werden: + +- Aufruf der Prozedur '#ib#errorstop#ie#': + Die Operation wird mit einer Fehlermeldung abgebrochen, die man dem Aufruf von + 'errorstop' als Parameter beifügt werden kann. + +- Aufruf der Prozedur '#ib#stop#ie#': + Die Operation wird abgebrochen. Wirkt wie 'errorstop' mit der Meldung "stop". + +- Umschalten in den Supervisor: + Durch Betätigen der Taste SV und Eingabe des Kommandos '#ib#halt#ie#'. Die laufende + Operation wird abgebrochen. Wirkt wie ein 'errorstop', der von "außen" in das + Programm induziert wird. + +Da alle drei Maßnahmen zum Abbruch führen können und somit eine anormale (vor­ +zeitige) Beendigung eines Programms bewirken, werden sie im folgenden zusammen­ +fassend als #ib#Fehler#ie# bezeichnet. + +Für solche Fehler bietet das EUMEL-System die Möglichkeit, den Abbruch zu unter­ +drücken. Dies kann notwendig werden, wenn + +a) bestimmte Fehlerfälle vom aufrufenden Programm selbst behandelt werden sollen. + Beispiel: + + Der EUMEL-Editor wird aufgerufen, um eine Datei zu bearbeiten. Er versucht als + erstes, die Datei zu assoziieren. Existiert die Datei nicht, wird die Prozedur + (z.B. 'old'), mit der die Datei angemeldet werden soll, normalerweise mit der Feh­ + lermeldung ' "datei" gibt es nicht' abgebrochen. Diesen Fehlerzustand fängt der + Editor jedoch ab und versucht, eine neue Datei einzurichten (Anmerkung: In Wirk­ + lichkeit fragt der Editor natürlich vor der Assoziierung mit 'exists' ab, ob die Datei + existiert). + +b) eine Operation die Kontrolle auf jeden Fall behalten soll. + + Dies ist z.B. beim Monitor notwendig. Gleich welche Fehler vom Monitor gerufene + Programme produzieren, der Monitor muß in der Lage sein, die weitere Bearbei­ + tung zu ermöglichen. + +c) eine Operation nicht unterbrechbar sein darf. + + Beispielsweise dürfen Programm(teil)e, die Daten transportieren, nicht unterbro­ + chen werden, da sonst ein Verlust dieser Daten eintreten könnte. + + + +#ib(9)##ib#Fehlerbehandlung#ie# und #ib#Fängerebenen#ie##ie(9)# + + +Der Aufruf einer der Prozeduren + + #ib#errorstop#ie# + #ib#stop#ie# + #ib#halt#ie# + +(wobei letztere vom Supervisor gegeben werden muß) werden zusammenfassend als +#ib#Fehler#ie# bezeichnet. Bei einem Fehler wird ein #ib#Fehlerzustand#ie# gesetzt. Im Fehlerzustand +merkt sich das EUMEL-System, daß ein Fehler vorliegt. Die Prozeduren + + #ib#enable stop#ie# + #ib#disable stop#ie# + +bestimmen, ob Operationen im Fehlerzustand weiter bearbeitet oder abgebrochen +werden. Beispiel: + + + INT VAR x; + get (x); + ... + disable stop; + x := x * x; + ... + + +Hier wird mit 'disable stop' verhindert, daß ein Abbruch beispielsweise durch 'INT- +Ueberlauf' auftreten kann. Die Anweisungen nach 'x * x' werden also weiter bearbei­ +tet. + +Welchen Wert hat aber nun die Variable 'x', nachdem der Fehler auftrat? Offensicht­ +lich war die den Fehler auslösende Operation '*' nicht in der Lage, den richtigen Wert +zu errechnen. #ib#Abgebrochene Operationen#ie# liefern in der Regel keinen Wert. Dadurch ist +der Wert von 'x' in unserem Beispiel nach einem Fehler bei '*' undefiniert. Es ist nun +ersichtlich, daß mit der Anwendung der 'disable stop'-Prozedur äußerst vorsichtig zu +verfahren ist, weil u.U. Werte verloren gehen können bzw. mit unerwarteten Werten +weitergerechnet wird. + +Damit Programmierer erfahren können, ob ein Fehler aufgetreten ist, gibt es die Infor­ +mations-Prozedur + + #ib#is error#ie# + +über den Fehlerzustand. Die Prozedur liefert den Wert TRUE, wenn ein Fehler vorliegt, +andernfalls FALSE. Die Prozedur + + #ib#clear error#ie# + +"löscht" den Fehlerzustand, d.h. anschließende Abfragen mit 'is error' liefern FALSE. +(Die "richtige" Reaktion auf den Fehler muß ein Programmierer natürlich selbst be­ +stimmen). + +Beispiel: + + + INT VAR x; + get (x); + ... + disable stop; + x := x * x; + IF is error + THEN put ("'x'-Wert zu groß"); + x := 0; + clear error + FI; + ... + + +Leider würden jetzt aber auch alle folgenden Anweisungen bei eventuellen Fehlern +nicht abgebrochen, also auch in Situationen, in denen ein Abbruch erwünscht ist, um +#ib#Programmierfehler#ie# zu erkennen. Deshalb können durch + + #ib#enable stop#ie# + +Abbrüche wieder zugelassen werden. Wenn wir jetzt also schreiben: + + + INT VAR x; + get (x); + ... + disable stop; + x := x * x; + IF is error + THEN put ("'x'-wert zu gross"); + x := 0; + clear error + FI; + enable stop; + ... + + +dann würden - wie gewünscht - eventuelle Fehler in den Anweisungen nach 'enable +stop' zu einem Abbruch führen. + +Nicht mit '#ib#clear error#ie#' gelöschte Fehler führen bei '#ib#enable stop#ie#' ebenfalls zu einem +Abbruch. In dem Programmteil + + + ... + disable stop; + x := x * x; + enable stop; + ... + + +würde der eventuell auftretender Fehler 'INT Ueberlauf' nicht abgefangen, sondern nur +verzögert wirksam, weil er nicht mit 'clear error' gelöscht wurde. + +Für die Behandlung von Fehlern durch Benutzer gibt es Prozeduren, die eine adäquate +Reaktion auf den Fehler erlauben. Mit + + #ib#error message#ie# + +können Sie auf die erste Fehlermeldung (eines 'error stop') nach dem letzen 'clear +error' zugreifen (d.h. Folgefehler verändern nicht die Originalmeldung). Die Prozedur + + #ib#error code#ie# + +liefert den #ib#Fehlercode#ie#, der bei der Prozedur 'errorstop' zusätzlich zum #ib#Fehlertext#ie# +angegeben werden kann. + + #ib#error line#ie# + +liefert die Zeilennummer des zuletzt aufgetretenen Fehlers. Mit + + #ib#put error#ie# + +kann eine noch anstehende Fehlermeldung ausgegeben werden. Beispiel: + + + INT VAR x; + get (x); + ... + disable stop; + x := x * x; + IF is error + THEN IF error message = "INT-Ueberlauf" + THEN put ("'x'-wert zu gross"); + ELSE put error + FI; + clear error + FI; + enable stop; + ... + + +Tritt ein Fehler auf, so wird die den Fehler auslösende Operation entweder abgebro­ +chen oder "normal" weiter bearbeitet, je nachdem, ob 'enable stop' oder 'disable stop' +gesetzt ist. Auf jeden Fall wird der #ib#Fehlerzustand#ie# an die aufrufende Operation weiter­ +gemeldet, die wiederum abgebrochen oder weiterbearbeitet werden kann usw. Die +#ib#Weitermeldung#ie# eines Fehlers kann auch über mehrere Stufen erfolgen, solange bis der +Fehler gelöscht wird. Andererseits gilt 'enable/ disable stop' nicht nur für die aktuelle +Operation, sondern auch für gerufene Operationen ("Vererbung"). Die gerufenen Ope­ +rationen können allerdings 'enable/disable stop' neu festlegen. Beispiel: + + + PROC a: PROC b: PROC c: + ... ... ROW 10 INT VAR x; + disable stop; enable stop; ... + b; ... INT VAR i :: 4711; + IF is error c; x [i] := ...; + THEN ... ... ... + clear error END PROC b END PROC c + FI; + enable stop + END PROC a; + + +In der Prozedur 'a' wird die Prozedur 'b' aufgerufen. Diese ruft wiederum eine Prozedur +'c' auf. Für die Prozedur 'c' gilt nun der Zustand 'enable stop' der Prozedur 'b' (#ib#Verer­ +bung von 'enable stop'#ie#). Tritt jetzt in 'c' der Subskriptions-Fehler auf, wird 'c' abgebro­ +chen. Die Wirkung der fehlerauslösenden Operation ist nicht definiert. + +Da aber auch die Prozedur 'b' im 'enable stop' Zustand ist, wird auch die Prozedur 'b' +abgebrochen. Der Fehler bleibt jedoch erhalten, wird also weitergemeldet. Dies wirkt +sich so aus, daß die Anweisung 'c' nicht ausgeführt wird. Da die Prozedur 'a' 'disable +stop' gesetzt hat, werden die auf den Aufruf von 'b' folgenden Anweisungen durchlau­ +fen und somit durch 'clear error' der Fehler gelöscht. In diesem Beispiel "fängt" die +Prozedur 'a' Fehler auf, die in den Prozeduren 'b' und 'c' entstehen können. + +Ein solcher #ib#Fänger#ie# wird durch zwei Prozeduren konstruiert. Der eigentliche Fänger +(hier: Prozedur 'a') ruft eine ausführende Prozedur (hier: 'b') im 'disable stop'-Zustand +auf. Die gerufene Prozedur setzt sofort 'enable stop' und führt dann die eigentlichen +Aktionen aus. So wird die gerufene Prozedur abgebrochen (kann also im Fehlerfall +nicht zuviel Schaden anrichten). Der Abbruch führt bis zur Fängerprozedur ('a') hinter +den Aufruf der gerufenen Prozedur ('b'). Nach Löschung eventuell auftretender Fehler +ist somit sichergestellt, daß der Fänger immer weiterarbeiten kann. + + + +#ib(9)#Wichtiger Hinweis#ie(9)# + + + + 1. #on("italics")##on("bold")#Da im 'disable stop'-Zustand kein Fehler zum Abbruch führt, kann + eine Operation in diesem Zustand auch nicht durch 'halt' abge­ + brochen werden. Einerseits ist das für manche Systemteile wün­ + schenswert, andererseits können Operationen, die auf Grund von + Programmierfehlern nicht terminieren (Endlosschleifen), nicht + unter Kontrolle gebracht werden. Also Vorsicht! (Letztes Mittel: + Task löschen)#off("italics")##off("bold")# + + 2. #on("i")##on("b")#Es ist nicht (!) garantiert, daß im Fehlerzustand aufgerufene + Prozeduren ihre normale Wirkung haben. Garantiert ist dies je­ + doch für alle Prozeduren und Operatoren, die in diesem Kapi­ + tel aufgeführt werden.#off("i")##off("b")# + +#on("italics")##on("bold")#Merke: Fehler sind im EUMEL-System Aufrufe der Prozeduren 'errorstop', + 'stop' oder das Betätigen der SV Taste und dem Supervisor- + Kommando 'halt'. Ein Fehler gilt solange, bis er mit Hilfe der + Prozedur 'clear error' gelöscht wurde. Die Prozeduren 'enable/ + disable stop' steuern die Abarbeitung der Operationen im Fehler­ + fall. Gilt für eine Operation 'enable stop', wird die Operation + abgebrochen, d.h. die restlichen Anweisungen der Operation + nach der Fehler auslösenden Anweisung werden nicht durchlau­ + fen. Ist 'disable stop' gesetzt, werden die restlichen Operationen + weiterhin abgearbeitet. 'enable/disable stop' gilt für alle - auch + indirekt - aufgerufenen Operationen ("Vererbung"), es sei denn, in + den gerufenen Operationen wird ein erneutes 'enable/disable + stop' gesetzt. Über die Aufrufkette werden ggf. auch die Fehler + zurück gemeldet.#off("italics")##off("bold")# + + + #on("italics")##on("bold")#Eine Fänger-Ebene ist eine Prozedur, die 'disable stop' setzt und + dann andere Operationen aufruft. Nach jedem dieser Aufrufe + kann eine Fehlerbehandlung mit 'clear error' durchgeführt wer­ + den. Damit ist gewährleistet, daß Fehler immer von der Fänger- + Ebene "aufgefangen" und entsprechend behandelt werden.#off("italics")##off("bold")# + + + +#ib(9)##ib#Prozeduren zur Fehlerbehandlung#ie##ie(9)# + + +#ib#clear error#ie# + PROC clear error + Zweck: Löscht den Fehlerzustand. 'is error' liefert anschließend wieder FALSE. + 'error message', 'error code' und 'error line' werden nicht gelöscht. + +#ib#disable stop#ie# + PROC disable stop + Zweck: Unterbindet den Abbruch in aufgerufenen Operationen. 'disable stop' + gilt für die Prozedur, in der sie aufgerufen wird und in allen folgenden + gerufenen Prozeduren, es sei denn, sie wird durch 'enable stop' außer + Kraft gesetzt. Wird die Operation verlassen, in der 'disable stop' aufge­ + rufen wurde, wird der "alte" Zustand wiederhergestellt, der vor dem + Aufruf der Operation galt. 'disable stop' kann weiterhin in einer aufge­ + rufenen Operation durch den Aufruf von 'enable stop' in dieser und den + folgenden Operationen außer Kraft gesetzt werden. + +#ib#enable stop#ie# + PROC enable stop + Zweck: Setzt die Wirkung eines Aufrufs von 'disable stop' zurück. Fehler ('error­ + stop', 'stop' oder 'halt') in der aktuellen Operation oder den folgenden + aufgerufenen Operationen führen zum Abbruch. Bisher nicht gelöschte + Fehler (siehe 'clear error') führen sofort zum Abbruch. + +#ib#error code#ie##--goalpage ("fehlercodes")# + INT PROC error code + Zweck: Liefert den durch 'errorstop' gesetzten #ib#Fehlercode#ie#. Beispiel: + + PROC test: + enable stop; + error stop (110, "Dies ist mein Abbruch!"); + END PROC test; + + ... + disable stop; + test; + put (error code); (* liefert 110 *) + clear error; + enable stop + + +#ib#error line#ie# + INT PROC error line + Zweck: Liefert die Zeilennummmer des Fehlers (Voraussetzung : Die Überset­ + zung erfolgt im 'checkon-Modus). + +#ib#error message#ie# + TEXT PROC error message + Zweck: Liefert die Fehlermeldung als Text. Anhand dieser Meldung kann ent­ + schieden werden, welcher Fehler vorliegt. + Hinweis: Eine Fehlermeldung "" (also: 'error stop ("")') führt zum Fehlerabbruch + mit der Bedeutung "Fehlermeldung wurde bereits ausgegeben". Dem­ + entsprechend erfolgt bei der Fehlermeldung 'niltext' keine Reaktion bei + 'put error'. + +#ib#errorstop#ie# + PROC error stop (TEXT CONST message) + Zweck: Bricht ab und setzt die Zeilennummer (wenn man sich im 'checkon'- + Modus befindet), in der der Fehler aufgetreten ist, sowie den Text 'mes­ + sage'. Der Abbruch kann mit 'disable stop' unterbunden werden. 'error­ + stop' hat keine Wirkung, wenn ein noch nicht gelöschter Fehler vorliegt. + Zu einer Fehlermeldung "" siehe auch die Prozedur 'error message'. Als + 'error-code' wird 0 gesetzt. + + + PROC error stop (INT CONST code, TEXT CONST message) + Zweck: Analog obiger 'errorstop'-Prozedur, aber mit Angabe des Fehlercodes, + der durch die Prozedur 'error code' in einer Fängerebene erfragt wer­ + den kann. + +#ib#is error#ie# + BOOL PROC is error + Zweck: Informationsprozedur auf das Vorhandensein eines Fehlers. + +#ib#put error#ie# + PROC put error + Zweck: Gibt die durch 'errorstop' gesetzte Fehlermeldung aus, falls ein Fehler + noch nicht gelöscht ist (siehe auch: 'error message'). + + + + +#ib##ib(9)#Fehlercode#ie#s#ie(9)# + + +Einige Fehlercodes sind bereits belegt: + + 0 kein Fehlercode spezifiziert (Standardwert) + 1 'halt' vom Terminal + 2 Stack-Ueberlauf + 3 Heap-Ueberlauf + 4 INT-Ueberlauf + 5 DIV durch 0 + 6 REAL-Ueberlauf + 7 TEXT-Ueberlauf + 8 zu viele DATASPACEs + 9 Ueberlauf bei Subskription + 10 Unterlauf bei Subskription + 11 falscher DATASPACE-Zugriff + 12 INT nicht initialisiert + 13 REAL nicht initialisiert + 14 TEXT nicht initialisiert + 15 nicht implementiert + 16 Block unlesbar + 17 Codefehler + 100 Syntax-Fehler beim Übersetzen + + + + + +#ib(9)#4.2. #ib#THESAURUS#ie##ie(9)# + + + +Ein #ib#Thesaurus#ie# ist ein #ib#Namensverzeichnis#ie#, das bis zu 200 Namen beinhalten kann. +Dabei muß jeder Namen mindestens ein Zeichen und darf höchstens 100 Zeichen lang +sein. Steuerzeichen (code < 32) sind in Namen nicht erlaubt. + +Ein Thesaurus ordnet jedem eingetragenen Namen einen Index zwischen 1 und 200 +(einschließlich) zu. Diese Indizes bieten dem Anwender die Möglichkeit, Thesauri zur +Verwaltung benannter Objekte zu verwenden. (Der Zugriff erfolgt dann über den Index +eines Namens in einem Thesaurus). So werden Thesauri u.a. von der Dateiverwaltung +benutzt. Sie bilden die Grundlage der ALL- und SOME-Operatoren. + + + + +#ib(9)#Grundoperationen#ie(9)# + + +#ib#CONTAINS#ie# + BOOL OP CONTAINS (THESAURUS CONST t, TEXT CONST name) + Zweck: Liefert genau dann TRUE, wenn 't' den Namen 'name' enthält. Falls + 'name=""' oder 'LENGTH name > 100', wird FALSE geliefert. + +#ib#delete#ie# + PROC delete (THESAURUS VAR t, TEXT CONST name, INT VAR index) + Zweck: Falls der Name 'name' im Thesaurus 't' enthalten ist, wird er dort ge­ + löscht. In 'index' wird dann sein alter Index geliefert, unter dem er im + Thesaurus eingetragen war. Ist der Name nicht im Thesaurus enthalten, + wird 0 als Index geliefert. + + PROC delete (THESAURUS VAR t, INT CONST index) + Zweck: Der Eintrag mit dem angegebenen Index wird aus dem Thesaurus 't' + gelöscht. + +#ib#empty thesaurus#ie# + THESAURUS PROC empty thesaurus + Zweck: Für Initialisierungszwecke wird ein leerer Thesaurus geliefert. + +#ib#get#ie# + PROC get (THESAURUS CONST t, TEXT VAR name, INT VAR index) + Zweck: Liefert den "nächsten" Eintrag aus dem Thesaurus 't'. "Nächster" heißt + hier, der kleinste vorhandene mit einem Index größer als 'index'. Dabei + wird in 'name' der Name und in 'index' der Index des Eintrags geliefert. + D.h. 'index' wird automatisch weitergeschaltet. Den ersten Eintrag erhält + man entsprechend durch Aufruf mit 'index=0'. Nach dem letzten Ein­ + trag wird 'name=""' und 'index=0' geliefert. Beispiel: + + + TEXT VAR name; + INT VAR index := 0 ; + get (thesaurus, name, index) ; + WHILE index > 0 REP + putline (name) ; + get (thesaurus, name, index) + PER + + +#ib#highest entry#ie# + INT PROC highest entry (THESAURUS CONST t) + Zweck: Liefert den höchsten belegten Index des Thesaurus 't'. + Achtung: Das ist nicht die Anzahl der vorhandenen Namen, da durch + Löschungen Lücken entstanden sein können. + +#ib#insert#ie# + PROC insert (THESAURUS VAR t, TEXT CONST name, INT VAR index) + Zweck: Der Name 'name' wird als zusätzlicher Eintrag in den Thesaurus 't' + eingetragen und der dafür vergebene Index geliefert. Falls der Thesau­ + rus schon voll ist und der Name nicht mehr eingetragen werden kann, + wird 0 als Index geliefert. + Achtung: Mehrfacheintragungen sind möglich. Wenn man diese verhin­ + dern will, muß man entsprechend vermittels + + + IF NOT t CONTAINS name + THEN insert (t, name, index) + FI + + + eintragen. + Fehlerfall: + * Name unzulaessig + + PROC insert (THESAURUS VAR t, TEXT CONST name) + Zweck: s.o. Allerdings wird der Index des Namens nicht geliefert. Ein Thesau­ + rusüberlauf wird entsprechend als 'errorstop' gemeldet. + Fehlerfälle: + * Name unzulaessig + * THESAURUS-Ueberlauf + +#ib#link#ie# + INT PROC link (THESAURUS CONST t, TEXT CONST name) + Zweck: Liefert den Index des Namens 'name' im Thesaurus 't'. Falls der Name + nicht enthalten ist, wird 0 geliefert. Ist der Name mehrfach im Thesau­ + rus enthalten, ist nicht definiert, welcher der möglichen Indizes geliefert + wird. + +#ib#name#ie# + TEXT PROC name (THESAURUS CONST t, INT CONST index) + Zweck: Liefert den Namen des Eintrags mit dem Index 'index' aus dem The­ + saurus 't'. Falls kein solcher Eintrag im Thesaurus enthalten ist, wird + Niltext geliefert. + +#ib#rename#ie# + PROC rename (THESAURUS VAR t, TEXT CONST old, new) + Zweck: Ändert im Thesaurus 't' einen Eintrag mit dem alten Namen 'old' in 'new' + um. Falls 'old' nicht im Thesaurus enthalten ist, wird keine Leistung + erbracht. Falls 'old' mehrfach in 't' enthalten ist, ist nicht definiert, wel­ + cher der möglichen Einträge geändert wird. + Fehlerfall: + * Name unzulaessig + + PROC rename (THESAURUS VAR t, INT CONST index, TEXT CONST new) + Zweck: Ändert im Thesaurus 't' den Namen des durch 'index' identifizierten + Eintrags in 'new'. + Fehlerfall: + * Name unzulaessig + +#ib#THESAURUS#ie# + TYPE THESAURUS + Zweck: Bezeichnet Thesaurus-Datenobjekte + +:= + OP := (THESAURUS VAR dest, THESAURUS CONST source) + Zweck: Zuweisung + + + + + + +#ib(9)#Verknüpfungsoperationen#ie(9)# + +Das Paket '#ib#nameset#ie#' bietet die Möglichkeit, Operationen nicht nur auf einzelnen Datei­ +en, sondern auf (geordneten) Mengen ablaufen zu lassen: + +#ib#ALL#ie# + THESAURUS OP ALL (TASK CONST task) + Zweck: Liefert einen Thesaurus, der alle Dateinamen der angegebenen Task + enthält. + + THESAURUS OP ALL (TEXT CONST file name) + Zweck: Liefert einen Thesaurus, der die in der angegebenen Datei vorhande­ + nen Namen (jede Zeile ein Name) enthält. + +#ib#all#ie# + THESAURUS PROC all + Zweck: Liefert einen Thesaurus, der alle Dateinamen der eigenen Task enthält. + Entspricht 'ALL myself'. + +#ib#LIKE#ie# + THESAURUS OP LIKE (THESAURUS CONST thesaurus, TEXT CONST muster) + Zweck: Alle im Thesaurus enthaltenen Dateien, die dem 'muster' entsprechen + sind im Ergebnisthesaurus enthalten. + (Die Syntax von 'muster' findet man bei der Beschreibung des Pattern- + Matching) + +#ib#SOME#ie# + THESAURUS OP SOME (THESAURUS CONST thesaurus) + Zweck: Bietet den angegebenen Thesaurus im EUMEL-Editor zum Ändern an. + Es können nicht erwünschte Namen gestrichen werden. + + THESAURUS OP SOME (TASK CONST task) + Zweck: Aufruf von: SOME ALL task. + + THESAURUS OP SOME (TEXT CONST file name) + Zweck: Aufruf von: SOME ALL filename. + +#ib#FILLBY#ie# + OP FILLBY (THESAURUS VAR thesaurus, FILE VAR file) + Zweck: Schreibt 'file' in den Thesaurus. Dabei werden Zeilen, die schon im + Thesaurus sind, nicht mehr in den Thesaurus geschrieben. Jede Zeile + kommt im Thesaurus also nur einmal vor. + + OP FILLBY (FILE VAR file, THESAURUS CONST thesaurus) + Zweck: Schreibt den Thesaurus in die Datei 'file'. + + OP FILLBY (TEXT CONST filename, + THESAURUS CONST thesaurus) + Zweck: Richtet eine Datei mit dem Namen 'filename' ein und schreibt den The­ + saurus in die Datei. + ++ + THESAURUS OP + (THESAURUS CONST left, right) + Zweck: Liefert die Vereinigungsmenge von 'left' und 'right'. + Achtung: Die Vereinigungsmenge enthält keine Namen mehrfach. + + THESAURUS OP + (THESAURUS CONST left, TEXT CONST right) + Zweck: Fügt dem Thesaurus 'right' zu, wenn 'right' noch nicht im Thesaurus + enthalten ist. + +- + THESAURUS OP - (THESAURUS CONST left, right) + Zweck: Liefert die Differenzmenge. Achtung: Die Differenzmenge enthält keine + Namen mehrfach. + + THESAURUS OP - (THESAURUS CONST left, TEXT CONST right) + Zweck: Nimmt den Namen 'right' aus dem Thesaurus. + +/ + THESAURUS OP / (THESAURUS CONST left, right) + Zweck: Liefert die Schnittmenge + Achtung: Die Schnittmenge enthält keine Namen mehrfach. + +#ib#do#ie# + PROC do (PROC (TEXT CONST) operate, THESAURUS CONST thesaurus) + Zweck: Ruft 'operate' nacheinander mit allen im Thesaurus enthaltenen Namen + auf. + + PROC do (PROC (TEXT CONST, TASK CONST) operate, + THESAURUS CONST thesaurus, TASK CONST task) + Zweck: s.o. + +#ib#erase#ie# + PROC erase (THESAURUS CONST thesaurus) + Zweck: Löscht alle aufgeführten Dateien in der Vater-Task. + + PROC erase (THESAURUS CONST thesaurus, TASK CONST manager) + Zweck: Löscht alle aufgeführten Dateien in der Task 'manager'. + +#ib#fetch#ie# + PROC fetch (THESAURUS CONST thesaurus) + Zweck: Holt alle aufgeführten Dateien vom Vater. + + PROC fetch (THESAURUS CONST thesaurus, TASK CONST manager) + Zweck: Holt alle aufgeführten Dateien vom 'manager'. + +#ib#fetch all#ie# + PROC fetch all (TASK CONST manager) + Zweck: Holt alle Dateien vom 'manager'. Diese Prozedur entspricht dem Aufruf + der Prozedur 'fetch (ALL manager, manager)'. + + PROC fetch all + Zweck: Aufruf der Prozedur 'fetch all (father)'. + +#ib#forget#ie# + PROC forget (THESAURUS CONST thesaurus) + Zweck: Löscht alle aufgeführten Dateien in der Benutzer-Task. + +#ib#insert#ie# + PROC insert (THESAURUS CONST thesaurus) + Zweck: Insertiert alle aufgeführten Dateien in der Benutzer-Task. + +#ib#remainder#ie# + PROC remainder + Zweck: Liefert nach einem 'errorstop' die noch nicht bearbeiteten Dateien. + Beispiel: + 'save all (archive)' + kann dazu führen, daß nicht alle Dateien auf das Archiv geschrie­ + ben werden können. Fehlermeldung: + '"....." kann nicht geschrieben werden (Archiv voll)' + Nachdem man eine neue Floppy ins Archivlaufwerk gelegt hat, + kann man mit + 'save (remainder, archive)' + den Rest der Dateien auf der Floppy sichern. + +#ib#save#ie# + PROC save (THESAURUS CONST thesaurus) + Zweck: Schickt alle aufgeführten Dateien zur Vater-Task. + + PROC save (THESAURUS CONST thesaurus, TASK CONST manager) + Zweck: s.o. + +#ib#save all#ie# + PROC save all (TASK CONST manager) + Zweck: Schickt alle eigenen Dateien zum 'manager'. Diese Prozedur entspricht + dem Aufruf der Prozedur 'save (ALL myself, manager)'. + + PROC save all + Zweck: Aufruf der Prozedur 'save all (father)'. + + +Beispiele: + + save (ALL myself) + forget (ALL myself) + forget (all) + fetch (SOME father) + fetch (ALL father - ALL myself) + insert (ALL "gen datei") + save (ALL myself - ALL archive, archive) + + + + +#ib(9)#4.3. #ib#Kommandos und Dialog#ie(9)##ie# + + + +#ib##ib(9)#Kommandodialog#ie##ie(9)# + + +Das Paket "#ib#command dialogue#ie#" dient zur zentralen Steuerung und einfachen Durch­ +führung von #ib#Kommando-Dialog#ie#en wie + + "datei" loeschen (j/n)? + +Er wird von allen Systemteilen verwandt, die einen Kommandodialog mit dem Benut­ +zer aufnehmen. Anwenderprozeduren mit ähnlichen Problemen sollten genauso damit +arbeiten. + +Der Kommandodialog kann zentral aus- und eingeschaltet werden. + + + +#ib#command dialogue#ie# + BOOL PROC command dialogue + Zweck: Liefert den aktuellen Zustand des Kommandodialogs: + TRUE - Dialog soll geführt werden! + FALSE - Dialog soll nicht geführt werden! + + PROC command dialogue (BOOL CONST status) + Zweck: Schaltet den Kommandodialog ein ('status' = TRUE) oder aus ('status' + = FALSE). Der alte Zustand wird überschrieben. Soll später wieder in + den alten Zustand zurückgeschaltet werden, muß er vorher erfragt und + gesichert werden. + +#ib#yes#ie# + BOOL PROC yes (TEXT CONST question) + Zweck: a) Kommandodialog soll geführt werden (command dialogue = TRUE) + Der übergebene Fragetext wird durch " (j/n)?" ergänzt auf dem Ter­ + minal ausgegeben. Als Antwort wird eine der Tasten , , + , , , akzeptiert; jede andere Eingabe führt zu + einem akustischen Signal und der Fragewiederholung. Das Resultat + der Prozedur ist + TRUE bei bejahender Antwort (j,J,y,Y) + FALSE bei verneinender Antwort (n,N) + b) Kommandodialog soll nicht geführt werden (command dialogue = + FALSE) + Keine Aktion, das Resultat ist TRUE. + +#ib#no#ie# + BOOL PROC no (TEXT CONST question) + Zweck: a) Kommandodialog soll geführt werden (command dialogue = TRUE) + Frage und Antwort wie bei 'yes'. Das Resultat ist + TRUE bei verneinender Antwort (n,N) + FALSE bei bejahender Antwort (j,J,y,Y) + b) Kommandodialog soll nicht geführt werden (command dialogue = + FALSE) + Keine Aktion, das Resultat ist FALSE. + +#ib#say#ie# + PROC say (TEXT CONST message) + Zweck: IF command dialogue THEN out (text) FI + +#ib#last param#ie# + TEXT PROC last param + Zweck: Liefert den zuletzt gesetzten Parameter-Text (siehe folgende Proze­ + dur). Falls 'command dialogue' = TRUE und die 'param position' > 0 + ist, wird der Parametertext als Standardparameter an der angegebenen + x-Position eine Zeile höher in der Form ("...") ausgegeben. Diese Proze­ + dur wird von den parameterlosen Kommandos bzw. Prozeduren wie + 'edit', 'run' usw. verwandt, um mit dem Standardparameter weiterzuar­ + beiten. + + PROC last param (TEXT CONST new) + Zweck: Setzt 'last param' auf 'new'. (Das Setzen muß explizit durchgeführt + werden und geschieht nicht implizit durch den 'command handler'. 'Last + param' wird beispielsweise von den einparametrigen Prozeduren 'edit' + und 'run' gesetzt. + +#ib#param position#ie# + PROC param position (INT CONST x) + Zweck: Setzt die Echoposition für 'last param'. Bei x=0 wird ein Echo unter­ + drückt. + +#ib#std#ie# + TEXT PROC std + Zweck: Liefert wie 'last param' den zuletzt gesetzten Parameter. Im Gegensatz + dazu wird der Parameter aber nicht ausgegeben. + + + + + +#ib##ib(9)#Kommandoverarbeitung#ie##ie(9)# + + +Das Paket '#ib#command handler#ie#' stellt Prozeduren zur #ib#Kommandoanalyse#ie# und zum +Führen des kompletten Kommandodialogs zur Verfügung. + + +#ib#get command#ie# + PROC get command (TEXT CONST dialogue text, TEXT VAR command line) + Zweck: Falls eine Fehlermeldung aussteht, ('is error' liefert TRUE), wird sie über + 'put error' ausgegeben und der Fehlerzustand zurückgesetzt. Der 'dialo­ + gue text' wird als Dialogaufforderung ausgegeben und der Benutzer + kann eine Kommandozeile eingeben. Die letzte Kommandozeile wird + ihm dabei automatisch (zum Ändern) angeboten, wenn vorher eine + Fehlermeldung anstand. Der Benutzer kann dies ebenfalls erreichen, + wenn er zu Beginn gibt. Die Kommandozeile wird dem Auf­ + rufer in der Variablen 'command line' geliefert. + + PROC get command (TEXT CONST dialogue text) + Zweck: s.o. Allerdings wird eine interne Kommandozeile des Pakets 'command + handler' als 'command line' verwandt. Dadurch wird es möglich, alle + Spuren einer Kommandoeingabe durch 'cover tracks' zu beseitigen. + +#ib#analyze command#ie# + PROC analyze command (TEXT CONST command list, command line, + INT CONST permitted type, + INT VAR command index, number of params, + TEXT VAR param 1, param 2) + Zweck: Die übergebene Kommandozeile ('command line') wird anhand der + übergebenen 'command list' analysiert. Sie ist ein TEXT, der aus einer + Folge von Kommandospezifikationen besteht. Jede hat die Form + K:I.P + + K Kommandotext, Prozedurname nach ELAN-Syntax + I Hauptindex, Form eines INT-Denoters + P Parameterspezifikation, eine Folge der Ziffern 0, 1 und 2. + + Beispiele: + - 'edit:15.012' + Das Kommando 'edit' wird in drei verschieden parametrisierten + Formen spezifiziert: + edit mit 0 Parameter erhält Index 15 + edit mit 1 Parameter erhält Index 16 + edit mit 2 Parametern erhält Index 17 + + - 'fetch:18.1' + Das Kommando 'fetch' wird in einer Form spezifiert: + fetch mit 1 Parameter erhält Index 18 + + Die Analyse erfolgt gemäß ELAN-Syntaxregeln. Dabei sind als Para­ + meter Denoter vom Typ TEXT und vom übergebenen ' permitted type' + zugelassen. Diese Typen werden wie beim Scanner (s. Benutzerhand­ + buch Programmierung Kap. 5.6) angegeben: + + 1 tag + 2 bold + 3 number + 4 text + 5 operator + 6 delimiter + + Falls das Kommando in der Kommandoliste gefunden wird (und die + Syntax in Ordnung ist), wird der entsprechende 'command index' zu­ + rückgemeldet. Die Parameter werden (falls vorhanden) in 'param 1' und + 'param 2' abgelegt. Undefinierte oder nicht vorhandene Parameter + werden als Niltext geliefert. Wenn ein Kommando vorhanden ist, die + Anzahl der Parameter aber nicht stimmt, wird der negative Hauptindex + geliefert. Ist es vollkommen unbekannt oder ist die Eingabe zu komplex + (mehrere Kommandos, Ausdrücke oder komplexere ELAN-Statements), + wird 0 geliefert. Der Anwender kann in solchen Fällen die Analyse mit + einer anderen Kommandoliste fortsetzen, das Kommando dem ELAN- + Compiler übergeben oder eine Fehlermeldung auslösen (s. 'command + error'). + + PROC analyze command (TEXT CONST command list, + INT CONST permitted type, + INT VAR command index, number of params, + TEXT VAR param 1, param 2) + Zweck: s.o. Allerdings wird die interne Kommandozeile des Pakets 'command + handler' als 'command line' verwandt. + +#ib#command error#ie# + PROC command error + Zweck: Falls bei der Kommandoanalyse ein Fehler gefunden wurde, führt er + nicht zum 'errorstop', sondern wird nur hinterlegt. (Soll das Kommando + dem Compiler übergeben werden, liegt ja evt. überhaupt kein Fehler + vor.) Diese hinterlegte Meldung kann mit 'command error' als 'errorstop' + gegeben werden. Mögliche Meldungen: + "ungueltiger name" + ") fehlt" + "( fehlt" + "Parameter ist kein TEXT ("fehlt)" + "Kommando zu schwierig" + +#ib#cover tracks#ie# + PROC cover tracks + Zweck: Die Spuren der letzten Kommandoanalyse werden gelöscht. Das dient + u.a. dazu, daß später eingerichtete Sohntasks keine Relikte des Kom­ + mandos mehr auf dem Textheap vorfinden und evtl. mittels nicht initiali­ + sierter TEXT VARs herausfinden können. Vollständig können die Spuren + aber nur dann gelöscht werden, wenn für die Kommandoanalyse die + 'get command'- und 'analyze command'-Prozeduren benutzt wurden, + die auf der internen Kommandozeile des Pakets 'command handler' + arbeiten. + +#ib#do command#ie# + PROC do command + Zweck: Die interne Kommandozeile des Pakets 'command handler' wird dem + ELAN-Compiler zur Ausführung übergeben. + + + + + +#ib(9)#Beispiele zur Kommandoverarbeitung#ie(9)# + + +#ib##ub#Kleiner Monitor#ue##ie# + + +LET command list = "otto:1.12emil:3.012hugo:6.0" ; + +LET number = 3 , + text = 4 ; + +INT VAR command index, params ; +TEXT VAR param 1, param 2 ; + +PROC monitor : + + disable stop ; + command dialogue (TRUE) ; + REP get command ("gib kleines kommando:") ; + analyze command (command list, text, + command index, params, + param 1, param 2) ; + execute command + PER + +ENDPROC monitor ; + +PROC execute command : + + enable stop ; + SELECT command index OF + CASE 1 : otto (param 1) + CASE 2 : otto (param 1, param 2) + CASE 3 : emil + CASE 4 : emil (param 1) + CASE 5 : emil (param 1, param 2) + CASE 6 : hugo + OTHERWISE do command line + END SELECT + +ENDPROC execute command ; + + + +#ib(9)##ub#Steuerkommando-Analyse#ue##ie(9)# + + +PROC command (TEXT CONST command text) : + + disable stop ; + command dialoge (FALSE) ; + analyze command (command list, command text, number, + command index, params, param 1, param 2) ; + execute command ; + IF is error + THEN put error ; + clear error + FI + +ENDPROC command ; + +PROC execute command : + + enable stop ; + SELECT command index OF + CASE .... + OTHERWISE IF command index = 0 + THEN errorstop ("unbekanntes Kommando") ELSE command error + FI + END SELECT + +ENDPROC execute command ; + + + + + +#ib(9)#4.4. Verschiedenes#ie(9)# + + +#ib(9)##ib#SESSION#ie(9)##ie# + + +Mit Hilfe von 'session' kann man feststellen, ob das System neu gestartet wurde. Dabei +spielt es keine Rolle, ob es korrekt ('shutup') abgeschaltet wurde, oder ob es sich um +einen "RERUN" handelt. + +#ib#session#ie# + INT PROC session + Zweck: Liefert eine "Sitzungsnummer". Diese wird automatisch bei jedem + Systemstart erhöht. + +Beispiel: + + + REP + INT VAR old session := session ; + WHILE session = old session REP pause (100) PER ; + putline ("Neuer Systemstart") + PER. + + + + +#ib(9)##ib#INITFLAG#ie##ie(9)# + + +Im Multi-User-System ist es oft notwendig, Pakete beim Einrichten einer neuen Task in +dieser neu zu initialisieren. Das muß z.B. bei der Dateiverwaltung gemacht werden, da +die neue Task ja nicht die Dateien des Vaters erbt. Mit Hilfe von INITFLAG-Objekten +kann man zu diesem Zweck feststellen, ob ein Paket #on("b")##on("i")#in dieser Task#off("b")##off("i")# schon initialisiert +wurde. + + +#ib#INITFLAG#ie# + TYPE INITFLAG + Zweck: Erlaubt die Deklaration entsprechender Flaggen. + +:= + OP := (INITFLAG VAR flag, BOOL CONST flagtrue) + Zweck: Erlaubt die Initialisierung von INITFLAGs + +#ib#initialized#ie# + BOOL PROC initialized (INITFLAG VAR flag) + Zweck: Wenn die Flagge in der Task A auf TRUE oder FALSE gesetzt wurde, + dann liefert sie beim ersten Aufruf den entsprechenden Wert, danach + immer TRUE (in der Task A!). + Beim Einrichten von Söhnen wird die Flagge in den Sohntasks automa­ + tisch auf FALSE gesetzt. So wird erreicht, daß diese Prozedur in den neu + eingerichteten Söhnen und Enkeltasks genau beim ersten Aufruf FALSE + liefert. + + +Beispiel: + + PACKET stack DEFINES push, pop: + + INITFLAG VAR in this task := FALSE ; + INT VAR stack pointer ; + ROW 1000 INT VAR stack ; + + PROC push (INT CONST value) : + + initialize stack if necessary ; + .... + + ENDPROC push ; + + PROC pop (INT VAR value) : + + initialize stack if necessary ; + .... + + ENDPROC pop ;. + + initialize stack if necessary : + IF NOT initialized (in this task) + THEN stack pointer := 1 + FI . + + ENDPACKET stack + + + + + +#ib(9)##ib#Bit-Handling#ie##ie(9)# + + +Die #ib#Bit-Operationen#ie# arbeiten auf INT-Objekten. Sie können z.B. für die Systempro­ +grammierung benutzt werden, wenn es um Bitmasken u.ä. geht. + +Ein INT besteht aus 16 Bits. Dabei hat das niederwertigste die Nummer 0, das höch­ +stwertige die Nummer 15. + + +#ib#AND#ie# + INT OP AND (INT CONST left, right) + Zweck: Bitweise UND-Verknüpfung von 'left' mit 'right'. + +#ib#OR#ie# + INT OP OR (INT CONST left, right) + Zweck: Bitweise ODER-Verknüpfung von 'left' mit 'right'. + +#ib#XOR#ie# + INT OP XOR (INT CONST left, right) + Zweck: Bitweise EXCLUSIV-ODER-Verknüpfung von 'left' mit 'right'. + +#ib#bit#ie# + BOOL PROC bit (INT CONST bits, bit no) + Zweck: Liefert TRUE genau dann, wenn das Bit mit der Nummer 'bit no' in dem + INT 'bits' gesetzt ist. + +#ib#set bit#ie# + PROC set bit (INT VAR bits, INT CONST bit no) + Zweck: Das Bit mit der Nummer 'bit no' wird in 'bits' auf 1 gesetzt. + +#ib#reset bit#ie# + PROC reset bit (INT VAR bits, INT CONST bit no) + Zweck: Das Bit mit der Nummer 'bit no' wird in 'bits' auf 0 gesetzt. + +#ib#rotate#ie# + PROC rotate (INT VAR bits, INT CONST number of bits) + Zweck: Bits können mit dieser Prozedur zyklisch geschiftet werden. + Bsp.: rotate (1,1) ---> 2 + rotate (1,2) ---> 4 + rotate (1,-3) ---> 16384 + rotate (16384,3) ---> 1 + +#ib#lowest set#ie# + INT PROC lowest set (INT CONST bits) + Zweck: Liefert die Nummer des niederwertigsten 1-Bits in 'bits'. Ist kein Bit auf 1 + gesetzt, wird -1 geliefert. + +#ib#lowest reset#ie# + INT PROC lowest reset (INT CONST bits) + Zweck: Liefert die Nummer des niederwertigsten 0-Bits in 'bits'. Ist kein Bit auf 0 + gesetzt, wird -1 geliefert. + + + + + +#ib(9)#4.5. #ib#Blockorientierte Ein-/Ausgabe#ie##ie(9)# + + + +Die blockorientierte Ein-/Ausgabe dient dazu, Datenraumseiten (#ib#Blöcke#ie#) oder Teile +davon über die #ib#Kanäle#ie# zu transferieren. Sie wird vom System u.a. beim Archivzugriff +und bei der Konfigurierung der Kanäle eingesetzt. + +Die Wirkung der blockorientierten Ein-/Ausgabeoperationen kann dabei kanal- und +rechnerspezifisch unterschiedlich sein. +Auf dem Archivkanal (31) und allen anderen Block-IO-Kanälen werden bei +'code 1 = 0' die normalen Blocklese- bzw. -schreiboperationen durchgeführt. 'code 2' +gibt dabei die Blocknummer an. Andere (positive) Werte von 'code 1' sind zur Zeit +nicht offiziell definiert. Negative Werte können vom SHard für Spezialaufgaben verge­ +ben werden. + + + +#ib#blockin#ie# + PROC blockin (DATASPACE VAR ds, INT CONST page nr, code1, code2, + INT VAR return code) + Zweck: Die Seite 'page nr' des Datenraums 'ds' wird "eingelesen". Die Opera­ + tion kann durch 'code1' und 'code2' näher gesteuert werden. + + PROC blockin (ROW 256 INT VAR block, INT CONST code1, code2, + INT VAR return code) + Zweck: Wie oben, nur wird der Block direkt als Datenstruktur übergeben. + +#ib#blockout#ie# + PROC blockout (DATASPACE CONST ds, INT CONST page nr, + code1, code2, INT VAR return code) + Zweck: Die Seite 'page nr' des Datenraums 'ds' wird "ausgegeben". Die Opera­ + tion kann durch 'code1' und 'code2' näher gesteuert werden. + + PROC blockout (ROW 256 INT CONST block, INT CONST code1, code2, + INT VAR return code) + Zweck: Wie oben, nur wird der Block als Datenstruktur übergeben. + +#ib#control#ie# + PROC control (INT CONST code1, code2, code3, INT VAR return code) + Zweck: Diese Prozedur dient zur Kanalsteuerung. + +#ib#ds pages#ie# + INT PROC ds pages (DATASPACE CONST ds) + Zweck: Liefert die Anzahl der belegten Seiten eines Datenraums. (Jede Seite ist + 512 Byte groß.) + +#ib#next ds page#ie# + INT PROC next ds page (DATASPACE CONST ds, INT CONST page nr) + Zweck: Liefert die Nummer der nächsten (von 'page nr' an gerechneten) Seite + des Datenraums. Die erste belegte Seite erhält man durch + + next ds page (ds, -1) + + #on ("b")#Achtung: Die Seitennummern müssen nicht lückenlos sein.#off ("b")# + -- cgit v1.2.3