path: root/doc/user-manual/1.7.3-pd/doc/pd.Handbuch.Teil7

                     EUMEL-Benutzerhandbuch 
 
          TEIL 7: Dateien, Datei-Verwaltung und Datenräume         
 
1. Übersicht 
 
Dateien dienen zur Aufnahme von Informationen, die auch über die Bearbei- 
tungszeit eines Programms erhalten bleiben (können). Dateien werden als 
Objekte in einer Task gehalten. Sie bleiben solange erhalten, bis sie expli- 
zit gelöscht ('forget'-Kommando) oder die Task beendet wird ('end'-Kommando). 
 
Dateien kann man an andere Tasks schicken ('save'-Kommando) oder von anderen 
Tasks holen ('fetch'-Kommando). Mit diesen (hier vorgestellten) Kommandos 
ist der Transport von Dateien jedoch nur in direkter Linie des Task-Baums 
möglich, also an einen "Vater" oder einen "Sohn". Damit ist automatisch eine 
Datei-Hierarchie im EUMEL-System realisiert. 
 
Alle Datei-Arten des EUMEL-Systems basieren auf Datenräumen. Ein Datenraum 
ist ein Speicherplatz, der 1 MByte Daten speichern kann und vom EUMEL-System 
verwaltet wird. Datenräume können gelöscht, kopiert usw. werden. Mit Hilfe 
Mit Hilfe von Datenräumen werden alle Datei-Arten des EUMEL-Systems reali- 
siert, indem einem Datenraum eine Struktur (Datentyp) aufgeprägt wird. Da- 
durch wird es Benutzern des EUMEL-Systems ermöglicht, auf einfache Weise 
neben den bereits vorhandenen Datei-Arten (FILEs für die Speicherung von 
Texten, PICFILEs für die Speicherung von Bildinformationen, u.a.m.) 
spezielle Dateien zu konstruieren. 
 
Die wichtigste Datei-Art, mit der ein Benutzer in Berührung kommt, ist die 
sequentielle Datei, genannt FILE. Ein FILE kann nur TEXTe aufnehmen und hat 
z.Zt. ein Fassungsvermögen von 4000 Zeilen (Sätze). Insgesamt darf ein FILE 
1 MByte aufnehmen. Eine Datei-Zeile (Satz) kann bis zu 32 000 Zeichen auf- 
nehmen. 
 
FILEs können in einer von drei Betriebsrichtungen bearbeitet werden: 
- "input":   nur Lesen. 
- "output":  nur Schreiben. 
- "modify":  Lesen/Schreiben und zusätzlich beliebiges Positionieren, Ein- 
             fügen und Löschen von Sätzen. 
 
'input'-Dateien sind also Eingabedateien, 'output'- sind Ausgabedateien und 
'modify'-Dateien kann man verändern. Insbesondere die 'modify'-Dateien eig- 
nen sich, um andere Datei-Arten leicht zu realisieren (z.B. indexsequentiel- 
le Dateien). 
 
Eine Datei kann auf einen bestimmten Zeilenbereich eingeschränkt werden. Ein 
solches Segment kann selbst wie eine Datei von einem Programm behandelt 
werden. 
 
 
 
2. Datei-Kommandos 
 
Dateien werden in der Regel in einer Benutzer-Task gehalten. Die Kommandos 
für die Behandlung von Dateien in einer Benutzer-Task werden hier vorge- 
stellt. Dann wird erklärt, wie Dateien zu einer übergeordneten Task ge- 
schickt oder geholt werden können. 
 
 
 
Datei-Kommandos für Benutzer-Tasks 
 
Im Monitor-Dialog kann man Dateien kopieren, löschen und einen anderen Namen 
geben. 
 
Mit dem Kommando 
 
     edit ("dateiname") 
 
wird eine Text-Datei im Monitor-Dialog (implizit) eingerichtet, wenn es sich 
um einen noch nicht vorhandenen 'dateiname' handelt (vergl. auch die Editor- 
Beschreibung). 
 
Welche Dateien in der Benutzer-Task vorhanden sind, kann mit dem Kommando 
 
     list 
 
erfragt werden. 'list' zeigt auf dem Bildschirm die Dateinamen der Benutzer- 
Task. Vor jedem Namen steht ein Datum, welches anzeigt, an welchem Tag die 
Datei zuletzt von einem Programm bearbeitet wurde. Ein 'a' hinter dem Datum 
kennzeichnet Dateien, die nach einer Archivierung nicht bearbeitet wurden. 
 
Ein Duplizieren einer Datei kann mit 
 
     copy ("alte datei", "neue datei") 
 
erreicht werden, wobei eine Kopie von 'alter datei' angelegt wird, die den 
Namen 'neue datei' erhält. Man beachte, daß es sich um eine logische (und 
vorerst um keine physikalische) Kopie handelt. Erst bei Schreibzugriffen 
werden Seiten " entshared" ("copy-on-write"). Ein Umbenennen einer Datei 
kann mit   
 
     rename ("alter datei name", "neuer datei name") 
 
erfolgen. Mit 
 
     forget ("dateiname") 
 
kann eine Datei gelöscht werden. 
 
Wurde in einer Datei editiert, kann durch Löschen oder Einfügen von Zeilen 
der interne Verwaltungsaufwand hoch werden, so daß Positionierungen nicht 
mehr effizient vor sich gehen. Mit dem Kommando 
 
     reorganize ("dateiname") 
 
wird die Datei so organisiert, als wenn sie neu erstellt wäre (gilt nur für 
Text-Dateien). Sie braucht dann in der Regel auch etwas weniger Speicher- 
platz.  
 
 
Merke: Das Kommando 'rename' gibt einer Datei einen anderen Namen, 'copy' 
dupliziert eine Datei. Mit 'list' kann man sich anzeigen lassen, welche 
Dateien in der Task vorhanden sind. 
 
 
 
Datei-Kommandos für Vater-Tasks 
 
Man kann Dateien von einer Vater-Task holen oder an eine Vater-Task schicken, 
um sie dort längerfristig zu speichern. Auch wenn die Benutzer-Task gelöscht 
wird, bleiben alle Dateien, die bei einer Vater-Task gespeichert (also 
"gerettet") sind, erhalten. Andere Sohn-Tasks können sich Dateien bei einer 
Vater-Task abholen. 
 
Auf Dateien einer Benutzer-Task können andere Nutzer aus anderen Tasks in 
der Regel nicht zugreifen. Manchmal ist es jedoch notwendig, daß mehrere 
Nutzer Dateien gemeinsam benutzen oder eine Datei eine Task "überleben" soll. 
In solchen Fällen muß man Dateien bei einem Vater aufbewahren. 
 
Mit der Prozedur 
 
     global manager 
 
kann die Benutzer-Task zu einem Datei-Manager gemacht werden. Erst nach 
Aufruf dieser Prozedur können Söhne dieser Task eingerichtet werden. 
 
Von einer Benutzer-Task kann eine Datei mit 
 
     save ("Buch 1") 
 
der direkten Vater-Task übergeben werden, wobei 'buch 1' in der Benutzer- 
Task erhalten bleibt. 'save' wirkt also wie ein Transport einer Kopie der 
angegebenen Datei in die Vater-Task. Achtung: ist eine Datei 'Buch 1' in der 
Vater-Task bereits vorhanden, wird diese ohne Warnung überschrieben. 
 
Analog zu der 'forget'-Prozedur für Dateien einer Benutzer-Task können 
Dateien einer unmittelbaren Vater-Task mit 
 
     erase ("datei name") 
 
gelöscht werden. Soll eine Datei von einer Vater-Task in eine Benutzer-Task 
geholt werden, so benutzt man die Prozedur 
 
     fetch ("datei") 
 
Nach Aufruf dieser Prozedur wird eine Kopie der angegebenen Datei in der 
Benutzer-Task angelegt. Ist bereits eine Datei 'datei' in der Benutzer-Task 
vorhanden, so erfolgt eine Fehlermeldung. 
 
Mit 'save', 'fetch' und 'erase' ist es möglich, daß zwei oder mehr Benutzer 
eine Datei alternierend bearbeiten. In diesem Fall müssen sich die Benutzer 
als Söhne einer gemeinsamen Vater-Task einrichten und die Datei mit 'fetch' 
jeweils in die Benutzer-Task holen. Um zu verhindern, daß ein anderer Be- 
nutzer zur gleichen Zeit mit der Datei arbeitet, wird sie jeweils mit 'erase' 
bei der Vater-Task gelöscht. Nach Beendigung der Arbeiten muß die Datei dann 
wieder mit 'save' in die Vater-Task transportiert werden. Dann steht sie 
wieder anderen Benutzern zur Verarbeitung zur Verfügung. Beispiel: 
 
     fetch  ("datei"); erase ("datei");    (* Datei vom Vater holen und dort 
                                              loeschen *) 
     edit   ("datei");                     (* Datei bearbeiten *) 
     save   ("datei");                     (* Datei zur Vater-Task bringen *) 
     forget ("datei")                      (* Datei in Benutzer-Task 
                                              loeschen *) 
 
Mit den Prozeduren 
 
     save all 
     fetch all 
 
kann man alle Dateien einer Benutzer-Task in die direkte Vater-Task schicken 
oder von dort holen. 
 
Merke:
       * * * * * * * * * * 
       *                 * 
       *         <-+     *  Vater-Task 
       *     |     |     * 
       * * * | * * | * * * 
             |     | 
           fetch  save 
             |     | 
       * * * | * * | * * * 
       *     |     |     * 
       *     ->edit|     *  Benutzer-Task 
       *                 * 
       * * * * * * * * * * 
 
 
 
Ansprechen von anderen Tasks 
 
Sollen Dateien in andere als die direkte Vater-Task transportiert oder von 
anderen Tasks geholt werden, muß man den internen Task-Bezeichner angeben. 
 
Es gibt einige Prozeduren, mit denen man den internen Task-Bezeichner einer 
Task bekommt. Solch eine Prozedur ist 
 
     father 
 
Prozeduren, mit denen man Dateien transportieren kann, liegen auch in einer 
Version vor, bei denen man den internen Task-Bezeichner angeben kann. 
Beispiel: 
 
     save  ("datei", father)        (* wie: save  ("datei") *) 
     erase ("datei", father)        (* wie: erase ("datei") *) 
     fetch ("datei", father)        (* wie: fetch ("datei") *) 
 
Weitere Prozeduren, die einen internen Task-Bezeichner liefern, sind: 
 
     myself 
     printer 
     public 
     archive 
 
Anmerkung: Zur Prozedur 'archive' siehe auch das nächste Kapitel; zu 'print' 
siehe auch SPOOLER. Dadurch kann man Dateien auch zu anderen als der 
Vater-Task transportieren, holen oder löschen. Beispiele: 
 
     erase ("datei", public)     (* Loescht 'datei' in Task 'PUBLIC' *) 
     fetch ("datei", public)     (* Holt 'datei' aus der Task "PUBLIC" *) 
     save  ("datei", public)     (* Kopiert 'datei' in die Task 'PUBLIC' *) 
     save  ("datei", printer)    (* Uebergibt 'datei' dem Spooler und 
                                    druckt die Datei *) 
     list  (father)              (* Listet Dateien der Vater-Task *) 
 
Bei komplizierten "Verwandschafts-Verhältnisse" von Tasks ist es einfacher, 
eine Task mit Hilfe des Task-Namens anzusprechen. Das erfolgt mit Hilfe der 
Prozedur 'task'. Beispiel: 
 
     save ("datei", task ("hugo")) 
 
'task' liefert den internen Task-Bezeichner von 'hugo'. Die Umkehr-Prozedur 
zu 'task' ist 'name': 
 
     put (name (myself)) 
 
schreibt den Namen der Task, in der man sich gerade befindet, auf den Bild- 
schirm. 
 
Durch die Prozedur 'father', die einen internen Task-Bezeichner als 
Parameter erwartet, kann man an die Vater-Task einer Task gelangen. 
Beispiel: 
 
     save ("datei", father (father)) 
 
Hier wird die Datei 'datei' an die Vater-Task der Vater-Task geschickt (also 
zur "Großvater-Task"). 
 
Mit dem Operator         / 
 
kann man aus einem Tasknamen den internen Tasknamen erhalten. '/' kann über- 
all dort eingesetzt werden, wo ein interner Taskname verlangt wird. Beispiel: 
 
     task status (/"meine task") 
 
 
Merke: Mit den internen Task-Bezeichner kann man mit anderen Tasks als der 
Vater-Task kommunizieren. 
 
 
 
Kommandos für mehrere Dateien 
 
Durch die vom EUMEL-System bereitgestellten Task-Variablen und Datei-Ver- 
zeichnisse (Thesaurus, Plural: Thesauren) ist es möglich, mehrere Dateien 
mit einem Kommando zu behandeln. 
 
Sollen alle Dateien einer Task zu einer anderen transportiert werden (mit 
'save') oder alle Dateien geholt werden, kann man 'save all' und 'fetch all' 
auch mit einem internen Task-Bezeichner versehen. Beispiele: 
 
     save all  (public) 
     fetch all (public) 
 
Damit werden alle Dateien der Benutzer-Task zu der Task 'PUBLIC' geschickt 
oder von dort geholt. 
 
Die internen Tasknamen wie z.B. 'myself', 'father', 'public' usw. werden 
auch bei dem Einsatz eines Thesaurus benutzt. Was ist ein "Thesaurus"? 
 
Das EUMEL-System hält sich die Dateinamen einer Task des Taskbaums in einer 
internen Liste. Die Namens-Liste wird Thesaurus (laut Duden: ein 
"systematisch geordnetes Verzeichnis") genannt. 
 
Der Operator  ALL  liefert den Thesaurus einer Task. Beispiel: 
 
     ALL father 
     ALL myself 
 
liefert jeweils den Thesaurus der Vater- oder der eigenen Task. Solche 
Thesauren kann man als Parameter der meisten der oben erwähnten Kommandos 
verwenden: 
 
     save   (ALL myself)    (* kopiert alle Dateien in die Vater-Task; 
                               arbeitet wie 'save all' *) 
     forget (ALL myself)    (* loescht alle Dateien der Benutzer-Task *) 
     fetch  (ALL father)    (* holt alle Dateien der Vater-Task; 
                               arbeitet wie 'fetch all' *) 
 
Der Operator  SOME  dagegen bietet einen Thesaurus vorher zum Editieren an, 
um Dateinamen zu streichen (HOP RUBOUT). Beispiele: 
 
     fetch  (SOME father)   (* holt die nicht gestrichenen Dateien *) 
     save   (SOME myself)   (* kopiert die nicht gestrichenen Dateien *) 
     forget (SOME myself)   (* loescht die nicht gestrichenen Dateien *) 
 
Es ist auch möglich, aus den Thesauren mehrerer Tasks einen neuen Thesaurus 
zu bilden: 
 
     -           (* Differenzmenge    *) 
     /           (* Schnittmenge      *) 
     +           (* Vereinigungsmenge *) 
 
Beispiel: 
 
     fetch (ALL father - ALL myself) 
 
holt alle Dateien der Vater-Task, die nicht bereits in der Benutzer-Task 
sind. 
 
 
Merke: Mit den Operatoren 'ALL' und 'SOME' kann man mehrere Dateien mit 
einem Kommando behandeln. 
 
 
 
Datei-Schutz durch Paßworte und Verschlüsselung 
 
Dateien können vor unbefugtem Zugriff mit Hilfe von Paßworten und/oder der 
Verschlüsselung der Informationen geschützt werden. 
 
 
 
Paßworte 
 
Paßworte für Dateien dienen zur Verhinderung von unbefugtem Zugriff auf 
Dateien, die bei einer Vater-Task gespeichert werden. (Die Dateien der 
Benutzer-Task können durch ein Task-Paßwort geschützt werden). Dabei sollte 
man bedenken, daß Paßworte bekannt werden können. 
 
Der Paßwort-Schutz ist im EUMEL-System etwas sicherer als in anderen 
Betriebssystemen, weil Paßworte nur selten angegeben werden müssen und 
daher nicht so leicht bekannt werden können (z.B. durch "über die Schulter 
schauen"). Die Kommandozeile wird zudem bei der Angabe eines Paßworts nach 
dem Betätigen der RETURN-Taste gelöscht. 
 
Paßworte werden nur im Verkehr mit Vater-Tasks eingesetzt. Lokale Benutzer- 
Dateien brauchen nicht gesondert gesichert zu werden, da man ein Paßwort 
auf die Benutzer-Task legen kann oder die zu sichernden Dateien aus dem 
System nehmen kann. Ein Paßwort kann mit der Prozedur 
 
     enter password ("schreibpasswort / lesepasswort") 
 
angegeben oder ein bereits eingestelltes Paßwort kann mit dieser Prozedur 
überschrieben werden. Voreingestellt ist kein Paßwort. Nachdem ein Benutzer 
die 'enter password'-Prozedur angegeben hat, wird jeder Datei-Verkehr mit 
einer Vater-Task mit Hilfe dieses Paßworts überprüft. Unzulässige Zugriffe 
durch Benutzer anderer Tasks auf Dateien einer Vater-Task werden abgewiesen. 
 
Ein Paßwort hat eine eigene Syntax. Es besteht aus zwei Teilen, die leer 
sein können und die durch ein "/"-Zeichen voneinander getrennt sind. Der 
erste Teil ist das Schreib-Paßwort, der zweite das Lese-Paßwort. Wird kein 
Lese-Paßwort angegeben, gilt das Schreib-Paßwort auch für das Lesen. Ist 
also kein "/"-Zeichen im Paßwort-String vorhanden, so wird das Schreib- 
Paßwort sozusagen gedoppelt. Beispiele: 
 
    enter password ("")             (* kein Paßwort *) 
    enter password ("hugo")         (* 'hugo' gilt fuer das Schreiben und 
                                       Lesen *) 
    enter password ("egon/meier")   (* 'egon' fuers Schreiben, 'meier' fuers 
                                       Lesen *) 
 
Zusätzlich kann das "-"-Zeichen in dem Teil des Paßworts angegeben werden, 
für den ein Zugriff nicht erlaubt sein soll. Beispiel: 
 
   enter password ("-/nurlesen")    (* Schreibzugriff nicht erlaubt, 
                                       Lese-Passwort ist 'nurlesen' *) 
 
Das Lese-Paßwort gilt für die Prozedur 
 
     fetch 
 
während das Schreib-Paßwort für die Prozeduren 
 
     save 
     erase 
 
gilt. Sofern die betreffende Datei durch ein Paßwort geschützt ist, ist 
folgendes zu beachten: 
 
a) fetch: 
   Will ein Benutzer mit der Prozedur 'fetch' eine Datei in seine Benutzer- 
   Task holen, so wird sein aktuell eingestelltes Paßwort (nur Lese-Teil) 
   und das Paßwort der Datei überprüft. Stimmen diese nicht überein, so wird 
   der 'fetch'-Zugriff auf eine Datei der Vater-Task abgewiesen. 
 
b) save: 
   Bei einem Transport in eine Vater-Task mit Hilfe der Prozedur 'save' sind 
   zwei Fälle zu unterscheiden: 
 
      - Datei ist in der Vater-Task noch nicht vorhanden: Diese Datei wird 
        in der Vater-Task mit dem aktuellen Paßwort des Benutzers einge- 
        tragen. 
 
      - Datei ist in der Vater-Task bereits vorhanden und soll durch die 
        neue Datei ersetzt werden: Es wird überprüft, ob das aktuelle 
        Schreib-Paßwort des Benutzers mit dem der gleichnamigen Datei in der 
        Vater-Task übereinstimmt. Ist dies nicht der Fall, wird die Datei 
        nicht in der Vater-Task eingetragen. 
 
c) erase: 
   Soll eine Datei der Vater-Task gelöscht werden, wird überprüft, ob das 
   aktuelle Schreib-Paßwort mit dem der zu löschenden Datei in der Vater- 
   Task übereinstimmt. Ist dies nicht der Fall, wird die Lösch-Operation 
   abgewiesen. 
 
 
Merke: Dateien können bei der Sicherung in einer Vater-Task vor unbefugtem 
Zugriff durch Paßworte geschützt werden. 
 
 
 
Dateien verschlüsseln 
 
Zusätzlich zu einem Paßwort kann man eine Datei vor unbefugtem Zugriff 
schützen, indem sie verschlüsselt wird. 
 
Mit den Prozeduren 
 
     crypt 
     decrypt 
 
kann eine Datei ver- oder entschlüsselt werden (Datenschutz für einzelne 
Dateien). Dabei ist es möglich, eine Datei mehrfach zu verschlüsseln (man 
muß die Verschlüsselung dann allerdings auch mehrfach rückgängig machen). 
Beispiel: 
 
     crypt ("datei", "schluessel") 
 
verschlüsselt 'datei' mit 'schluessel'. Die Entschlüsselung erfolgt, indem 
man die Prozedur 'decrypt' auf 'datei' anwendet und den gleichen Schlüssel 
zur Entschlüsselung benutzt. Beispiel: 
 
     decrypt ("datei", "schluessel") 
 
Den Text des Schlüssels (hier: 'schluessel') sollte man sich also unbedingt 
merken, sonst kann die Datei nicht mehr entschluesselt werden. 
 
Merke: Dateien werden durch 'crypt' und 'decrypt' ver- und entschlüsselt. 
 
 
 
3. Das Archiv 
 
Dateien werden im EUMEL-System auf Systemträgern gespeichert. Mit dem Archiv 
können Dateien vom System auf externe Speichermedien (normalerweise 
Disketten) gebracht und von diesen ins System geholt werden. 
 
Das EUMEL-Archiv hat folgende Aufgaben: 
 
a) Das Archiv wird als Sicherheitsbereich benutzt, indem man von wichtigen 
   Dateien Kopien anlegt und diese außerhalb des EUMEL-Systems speichert. 
 
b) Man kann das Archiv-System aber auch benutzen, um Dateien, die nur selten 
   oder in größeren Zeitabständen benötigt werden, zu kopieren ("archi- 
   vieren") und im EUMEL-System zu löschen. Falls diese Dateien wieder 
   gebraucht werden, können sie wieder in das EUMEL-System geholt werden. 
   Damit wird erreicht, daß im EUMEL-System nur die wirklich notwendigen 
   Dateien stehen. 
 
c) Sollen Dateien von einer EUMEL-Installation auf eine andere übertragen 
   werden, so kann man ebenfalls Archive verwenden. 
 
d) Bei Versionswechsel des EUMEL-Systems sind Archive die einzige Möglich- 
   keit, Dateien in die neue Systemversion einzuspielen. Dabei wird garan- 
   tiert, daß zumindest Archive der letzten Version gelesen werden können. 
 
Merke: Durch das Archiv können Dateien außerhalb des Systems gesichert 
werden. 
 
 
 
Das Archiv reservieren 
 
Soll archiviert werden, muß man das dem Archiv-System mitteilen, damit nicht 
ein anderer Benutzer zur gleichen Zeit auf das Archiv zugreift. Dieser 
Vorgang wird "reservieren" genannt. 
 
Archiv-Disketten haben aus Sicherheitsgründen einen Namen. Dieser Name muß 
bei der Anmeldung einer Archivierung angegeben werden. Die Anmeldung einer 
Archivierung und gleichzeitige Reservierung erfolgt mit  
 
     archive ("name") 
 
Der Archiv-Name wird bei folgenden Archiv-Operationen zur Überprüfung mit 
dem eingelegten Archiv verwandt. 
 
Wichtig: Eine Diskette sollte erst nach dem 'archive'-Kommando in das 
Laufwerk geschoben werden, d.h. erst dann, wenn das Archiv-System reserviert 
ist. Sonst kann es geschehen, daß ein anderer Benutzer auf dieser Diskette 
archiviert. 
 
Archivierungen erfolgen durch die schon beschriebenen Transportkommandos 
'save' und 'fetch'. Dabei wird als Zieltask 'archive' angegeben. Beispiel: 
 
     save  ("mein buch", archive) 
     fetch ("kapitel 1", archive) 
     save all  (archive) 
     fetch all (archive) 
 
Das Archiv bleibt für den Nutzer solange reserviert, wie er Archivierungs- 
operationen vollzieht. Dann sollte er das Archiv wieder für andere Benutzer 
mit der Prozedur 
 
   release (archive) 
 
freigeben. 
 
Leitet ein Nutzer innerhalb von fünf Minuten nach der letzten Archiv- 
Operation keine neue ein und meldet sich ein anderer Nutzer mit 'archive' 
bei dem Archiv-System an, so wird dem ersten Nutzer die Archiv-Berechtigung 
entzogen, um Blockaden zu verhindern. Wenn der erste Nutzer eine erneute 
Archiv-Operation versucht, erhält er eine Fehlermeldung. Dadurch kann ein 
Nutzer das Archiv längere Zeit (ohne 'release') benutzen, ohne den Betrieb 
zu stören, da andere Nutzer bei Bedarf jederzeit eingeschoben werden. 
 
Wichtig: Muß die Archiv-Floppy gewechselt werden (weil etwa von einer 
Diskette eine Datei gelesen wurde und diese auf eine andere geschrieben 
werden soll), muß erneut das 'archive'-Kommando gegeben werden. Dies ist 
notwendig, um das Verzeichnis aller auf der Diskette befindlichen Dateien 
der neuen Diskette zu lesen. 
 
Merke: Mit 'archive' wird die Archiv-Verwaltung für einen Nutzer reserviert, mit 'release' wieder freigegeben. Mit 'archive' wird 
gleichzeitig ein Archiv-Name eingestellt, der bei Archiv-Operationen mit dem 
auf der Diskette gespeicherten Archiv-Namen verglichen wird. 
 
 
 
Archiv löschen und einen Namen geben 
 
Bevor ein Archiv-Diskette benutzt werden kann, muß sie den mit 'archive' 
eingestellten Namen bekommen. 
 
Bei der Erstbenutzung eines Archivs muß dieses mit einem Namen versehen 
werden. Als Archiv-Name wird der mit 'archive' eingestellte Name verwandt. 
Dies erfolgt mit der Prozedur 
 
     clear (archive) 
 
Gleichzeitig werden alle Dateien, die sich eventuell vorher auf dem Archiv- 
Träger befanden, gelöscht. Somit wird 'clear' auch für das Löschen von 
Archiven verwendet. 
 
 
Merke: Mit 'clear' wird die Archiv-Diskette gelöscht und gleichzeitig der 
mit 'archive' eingestellte Name gegeben. 
 
 
 
Einfache Archiv-Operationen 
 
In diesem Abschnitt werden einfache Archiv-Operationen beschrieben. 
 
Mit den Prozeduren 
 
     save  ("datei", archive) 
     fetch ("datei", archive) 
     erase ("datei", archive) 
 
kann jeweils eine Datei auf die Archiv-Diskette ('save') und von dem Archiv 
in das EUMEL-System kopiert ('fetch') oder auf dem Archiv gelöscht ('erase') 
werden. Dabei bedeutet 'datei' die zu kopierende Datei und 'archive' der 
interne Task-Name für die Archiv-Verwaltung. Bei den ersten zwei Kommandos 
ist zu beachten, daß die Datei, die auf das Archiv geschrieben (bei 'save') 
oder die in die Benutzer-Task geholt werden soll (bei 'fetch'), immer 
kopiert wird. Dateien bleiben also im "Ursprung" immer erhalten. 
 
Ist eine Datei gleichen Namens bereits auf der Archiv-Diskette (bei 'save') 
oder in der Benutzer-Task (bei 'fetch') vorhanden, wird von der Archiv-Ver- 
waltung angefragt, ob diese Datei überschrieben werden darf. Es kann somit 
nicht zu einem unbeabsichtigten Löschen von Dateien kommen. 
 
Mit dem Kommando 
 
     list (archive) 
 
erhält man (wie bei dem "normalen" 'list'-Kommando) ein Namens-Verzeichnis 
aller Dateien, die sich auf der eingelegten Archiv-Diskette befinden. 
 
 
Merke: Nachdem ein Archiv mit 'archive' reserviert wurde, kann mit 'save' 
eine Datei auf das Archiv geschrieben und mit 'fetch' eine Datei von dem 
Archiv in die Benutzer-Task kopiert werden. 
 
 
 
Archiv-Operationen für mehrere Dateien 
 
Hier wird beschrieben, wie man mehrere Dateien auf einmal auf ein Archiv 
schreibt oder von einem Archiv liest. 
 
Mit den Kommandos 
 
     save  all (archive) 
     fetch all (archive) 
 
werden alle Dateien der Benutzer-Task auf das Archiv geschrieben bzw. von 
dort geholt. 
 
Zusätzlich ist es möglich, die Operatoren 'ALL' und 'SOME' auf ein Archiv 
anzuwenden. Wie bereits geschildert, liefern diese Operatoren einen 
Thesaurus der angegebenen Task: 'ALL' liefert alle Dateinamen, während man 
bei 'SOME' eine Auswahl treffen kann. Damit ist es möglich, alle oder einige 
Dateien der Benutzer-Task auf eine Archiv-Diskette zu kopieren oder von der 
Archiv-Diskette in die Benutzer-Task zu holen: 
 
     fetch (SOME archive, archive)   (* zeigt die Namen der Dateien der 
                                        Archiv-Diskette. Die nicht ge- 
                                        strichenen Dateien werden in die 
                                        Benutzer-Task geholt *) 
     save  (SOME myself, archive)    (* zeigt die Namen der Dateien der 
                                        Benutzer-Task. Die nicht ge- 
                                        strichenen Dateien werden auf die 
                                        Archiv-Diskette kopiert *) 
     save  (ALL archive, archive)    (* sichert alle Dateien der Benutzer- 
                                        Task, die sich schon auf dem Archiv 
                                        befinden (alte Version). Das 
                                        Kommando ist für Sicherungs- 
                                        Disketten gedacht, bei dem man immer 
                                        die gleichen Dateien auf dem Archiv 
                                        haben will  *) 
 
Durch die Thesaurus-Operatoren '-' (Differenzmenge), '/' (Schnittmenge) und 
'+' (Vereinigungsmenge) kann man kompliziertere Wirkungen erzielen. 
Beispiele: 
 
 save (ALL myself - ALL archive, archive)  (* Schreibt alle Dateien der 
                                              Benutzer-Task auf das Archiv, 
                                              die nicht bereits auf dem 
                                              Archiv stehen *) 
 save (ALL myself - ALL father - ALL archive, archive) 
                                           (* Schreibt alle Dateien der 
                                              Benutzer-Task auf das Archiv, 
                                              mit Ausnahme der Dateien, die 
                                              längerfristig in der Vater- 
                                              Task gespeichert sind und die 
                                              nicht bereits auf dem Archiv 
                                              stehen *) 
 fetch (ALL archive - ALL myself)          (* Holt alle Dateien vom Archiv, 
                                              die sich nicht bereits in der 
                                              Benutzer-Task befinden *) 
 
Werden mehrere Dateien mittels eines Thesaurus bearbeitet, kann man nach 
einer Unterbrechung der Bearbeitung (d.h. Fehlermeldung) die Operation wieder 
aufsetzen. Dazu liefert das Kommando 
 
     remainder 
 
den "Rest"-Thesaurus. Er enthält alle nicht bearbeiteten Dateinamen. 
Beispiel: 
 
     save (SOME myself, archive)  (* Unterbrechung, z.B. durch einen vom 
                                     Programm erzeugten 'errorstop' oder SV 
                                     und 'halt' *) 
     save (remainder, archive)    (* bearbeitet die restlichen Dateien *) 
 
 
Merke: Mit 'save all' bzw. 'fetch all' kann man alle Dateien einer Benutzer- 
Task archivieren bzw. alle Dateien eines Archivs in die Benutzer-Task holen. 
Mit den Operatoren SOME und ALL sind weitere Operationen möglich. 
 
 
 
Fehlermeldungen des Archivs 
 
Bei Archiv-Operationen kann es zu Fehlersituationen kommen. 
 
Versucht man eine Datei vom Archiv zu lesen, kann es vorkommen, daß das 
Archiv-System 
 
     Lese-Fehler (Archiv) 
 
meldet und den Lese-Vorgang abbricht. Dies kann auftreten, wenn die Floppy 
beschädigt oder aus anderen Gründen nicht lesbar ist (z.B. nicht justierte 
Disketten-Geräte). In einem solchen Fall vermerkt das Archiv-System intern, 
daß die Datei nicht korrekt gelesen werden kann. Das sieht man z.B. beim 
'list (archive)'. Dort ist der betreffende Datei-Name mit dem Zusatz 'mit 
Lese-Fehler' gekennzeichnet. Um diese Datei trotzdem zu lesen, muß man sie 
im Datei-Namen mit dem Zusatz 'mit Lese-Fehler' versehen. Beispiel: 
 
     fetch ("dateiname mit Lese-Fehler") 
 
Die Datei wird in diesem Fall trotz Lese-Fehler (Informationsverlust!) vom 
Archiv gelesen. 
 
Um solche Fälle möglichst zu vermeiden, sieht das EUMEL-System die 
Möglichkeit vor, Archive bzw. Archiv-Dateien nach beschreiben zu prüfen. Das 
erfolgt mit dem Kommando 
 
     check ("dateiname", archive)    (* oder *) 
     check (ALL archive, archive)    (* fuer alle Archiv-Dateien *) 
 
Durch dieses Kommando werden eventuelle Lese-Fehler gemeldet. 
 
Weitere Fehlermeldungen des Archivs: 
 
* Lesen unmöglich (Archiv)       Archiv-Floppy nicht eingelegt oder die Tür 
                                 des Laufwerks ist nicht geschlossen. 
 
* Schreiben unmöglich (Archiv)   Floppy ist schreibgeschützt. 
 
* Archiv nicht angemeldet        Archiv wurde nicht angemeldet 
                                 ('archive ("name")' geben). 
 
* Lese-Fehler (Archiv)           Siehe obige Beschreibung. 
 
* Schreibfehler (Archiv)         Die Floppy kann nicht (mehr) beschrieben 
                                 werden. Andere Floppy verwenden. 
 
* Speicherengpass                Im System ist nicht mehr genügend Platz, um 
                                 eine Datei vom Archiv zu laden. 
                                 Ggf. Dateien löschen. 
 
* RERUN beim Archiv-Zugriff      Das System wurde bei einer Archiv-Operation 
                                 durch Ausschalten bzw. Reset unterbrochen. 
 
* ... gibt es nicht              Die Datei ... gibt es nicht auf dem Archiv. 
 
* Archiv heißt ...               Die eingelegte Floppy hat einen anderen als 
                                 den eingestellten Archiv-Namen. 
 
* Archiv wird von Task ... benutzt   Das Archiv wurde von einem anderen 
                                     Benutzer reserviert. 
 
* ... kann nicht geschrieben werden (Archive voll)    Das Archiv ist voll. 
                                                      Neue Archiv-Floppy 
                                                      benutzen. 
 
* Archiv inkonsistent            Die eingelegte Floppy hat nicht die Struk- 
                                 tur einer Archiv-Floppy ('clear (archive)' 
                                 vergessen). 
 
* save/erase wegen Lese-Fehler verboten    Bei Archiven mit Lese-Fehler sind 
                                           Schreiboperationen verboten, weil 
                                           ein Erfolg nicht garantiert 
                                           werden kann. 
 
 
 
4. FILEs in Programmen 
 
Die bisher geschilderten Kommandos gelten für alle Datei-Arten. In diesem 
Kapitel wird der Standard Datei-Typ FILE beschrieben. Eine Datei von Daten- 
typ FILE ist eine sequentielle Datei, die das Lesen und Schreiben von Daten 
in strikter Aufeinanderfolge von Sätzen erlaubt (Betriebsrichtungen 'input' 
und 'output'). Die Betriebsrichtung 'modify' erlaubt das gleichzeitige Lesen 
und Schreiben sowie beliebiges Positionieren. 
 
 
 
Deklaration, Assoziierung und Betriebsrichtungen 
 
Für ELAN-Programme gibt es standardmäßig den Datentyp FILE. FILEs müssen 
deklariert werden. Die Kopplung einer FILE VAR im Programm mit einer Datei 
erfolgt durch eine Assoziierungsprozedur. Bei der Assoziierung muß man an- 
geben, wie die Datei bearbeitet werden soll. 
 
Dateien müssen in einem ELAN-Programm - wie alle anderen Objekte auch - 
deklariert werden. Beispiel: 
 
     FILE VAR f :: ... 
 
Mit der Deklaration wird dem ELAN-Compiler der Name der Datei-Variablen 
bekannt gemacht. Dabei ist zu beachten, daß im EUMEL-System alle FILEs mit 
VAR deklariert werden müssen, denn jede Lese/Schreib-Operation verändert 
einen FILE. FILE CONST Objekte sind also nicht erlaubt. Ähnlich wie bei 
anderen Datenobjekten werden FILEs initialisiert. In der Regel erfolgt dies 
mit einer Assoziierungsprozedur. Beispiele: 
 
     FILE VAR meine datei :: sequential file (output, "daten")        
     ... 
     (* oder: *) 
     TEXT VAR datei name; 
     put ("Dateiname bitte:"); get (datei name); 
     FILE VAR f :: sequential file (input, datei name); 
 
Die Assoziierungsprozedur 'sequential file' hat die Aufgabe, eine in einem 
Programm deklarierte FILE VAR mit einer bereits vorhandenen oder noch einzu- 
richtenden Datei (abhängig von der Betriebsrichtung, siehe unten) des 
EUMEL-Systems zu koppeln. Den Dateinamen gibt man als zweiten Parameter 
an. Dadurch können ELAN-Programme geschrieben werden, die Dateien 
bearbeiten, deren Namen man beim Erstellen des Programms noch nicht kennt. 
 
Der erste Parameter gibt die sog. Betriebsrichtung an. Sie bestimmt, in 
welcher Weise die assoziierte Datei bearbeitet wird. Es gibt folgende drei 
Betriebsarten: 
 
a) input: 
   Die Datei kann vom Programm nur gelesen werden. Durch 'input' wird bei 
   der Assoziierung automatisch auf den ersten Satz der Datei positioniert. 
   Ist die zu lesende Datei nicht vorhanden, wird ein Fehler gemeldet. 
 
b) output: 
   Die Datei kann vom Programm nur beschrieben werden. Durch 'output' wird 
   bei der Assoziierung automatisch hinter den letzten Satz der Datei 
   positioniert (bei einer leeren Datei also auf den ersten Satz). Ist die 
   Datei vor der Assoziierung nicht vorhanden, wird sie automatisch einge- 
   richtet. 
 
c) modify: 
   Die Datei kann vom Programm in beliebiger Weise gelesen und beschrieben 
   werden. Im Gegensatz zu den Betriebsrichtungen 'input' und 'output', bei 
   denen ausschließlich ein rein sequentielles Lesen oder Schreiben erlaubt 
   ist, kann bei 'modify' beliebig positioniert, gelöscht, eingefügt und neu 
   geschrieben werden. Hier ist nicht definiert, auf welchen Satz der Datei 
   man nach erfolgter Assoziierung steht. Die Datei wird automatisch einge- 
   richtet, wenn sie vor der Assoziierung nicht vorhanden war. 
 
Anmerkung: 
In jeder Betriebsrichtung sind nur bestimmte Operationen zugelassen. Z.B. 
sind bei 'input' keine Schreib-Prozeduren erlaubt. Vergl. dazu die nächsten 
Abschnitte. 
 
Neben der Betriebsrichtung 'input', 'output' oder 'modify' muß bei 
'sequential file' als zweiter Parameter der Name der zu bearbeitenden Datei 
angegeben werden. Beispiel: 
 
     TEXT VAR datei name, zeile; 
     put ("Bitte Name der zu bearbeitenden Datei eingeben:"); 
     get (datei name); 
     FILE VAR f :: sequential file (input, dateiname); 
     ... 
     getline (f, zeile); 
     ... 
 
Hier wird der Name der zu bearbeitenden Datei zuerst eingelesen. Diese Datei 
wird mit 'f' in der Betriebsrichtung 'input' assoziiert, d.h. würde man z.B. 
die Prozedur 
 
     putline (f, irgendein text) 
 
an einer Stelle im Programm verwenden, wird ein Fehler gemeldet. Die Be- 
triebsrichtung hilft also, Fehler bei der Programmierung zu vermeiden. 
 
Mit den Prozeduren 
 
     modify (f) 
     input  (f) 
     output (f) 
 
kann die Betriebsrichtung von Dateien geändert werden. 
 
Dateien brauchen im EUMEL-System vor Programmende nicht geschlossen zu 
werden, da sie vom System immer konsistent gehalten werden. 
 
Merke: Die Betriebsrichtung gibt an, wie man eine Datei bearbeiten will. 
'input' steht für Lesen, 'output' für Schreiben und 'modify' für Verändern. 
Jede Datei muß vor einer Benutzung mit 'sequential file' assoziiert werden. 
Die Assoziierungsprozedur stellt die Kopplung zwischen dem Programm und dem 
EUMEL-Betriebssystem her. 
 
 
 
Operationen der Betriebsrichtung 'output' 
 
In der Betriebsrichtung 'output' sind nur Schreib-Operationen gestattet. 
'output' ist also für das Bearbeiten von Ausgabedateien vorgesehen. 
 
Mit den Prozeduren 
 
     put 
 
können INT-, REAL- und TEXT-Werte in eine Datei geschrieben werden. Die 
Prozedur 
 
     line 
 
sorgt dafür, daß eine neue Zeile in der Datei begonnen wird. Beispiel: 
 
     FILE VAR f :: sequential file (output, "daten"); 
     put (f, "Daten:"); 
     line (f); 
     schreibe daten. 
 
     schreibe daten: 
     INT VAR intwert; 
     REAL VAR textwert; 
     put ("bitte Daten eingeben (INT, REAL):"); 
     REP 
       get (intwert); 
       put (f, intwert); 
       get (realwert); 
       put (f, realwert); 
       line (f); 
     UNTIL yes ("fertig") END REP. 
 
Durch die Assoziierungsprozedur mit der Betriebsrichtung 'output' wird 
hinter den letzten Satz der Datei positioniert, bei einer leeren Datei also 
auf den ersten Satz. In dem ersten Satz in unserem Beispiel wird also 
'Daten:' geschrieben. Durch die Prozedur 'line' geht man auf den nächsten 
Satz. Dann werden jeweils ein INT- und ein REAL-Wert in eine Datei-Zeile 
geschrieben, bis die Frage 'fertig' mit 'j' beantwortet wird. 
 
Die 'put'-Prozeduren schreiben die Werte jeweils in die aktuelle Datei-Zeile. 
Zwischen den Werten wird von den 'put'-Prozeduren jeweils ein Leerzeichen 
eingefügt. Im Gegensatz zu den 'put'-Prozeduren schreibt die Prozedur 'write' 
einen TEXT ohne ein anschließendes Leerzeichen in die aktuelle Datei-Zeile. 
Beispiel: 
 
     ... 
     write (f, "meine Daten:"); 
     write (f, " "); 
     write (f, text (17 + 4)); 
     (* das Gleiche wie: put (f, "meine Daten:"); put (f, 17 + 4)   *) 
 
Auf eine neue Datei-Zeile kann auf zwei verschiedene Arten positioniert 
werden: 
 
a) Prozedur 'line': 
   Diese darf auch mit einem Parameter angegeben werden, der die Anzahl 
   Zeilen angibt. Beispiel: 
 
        line (f);    (* positioniert auf die naechste Zeile  *) 
        line (f, 1)  (* das Gleiche                          *) 
        line (f, 4)  (* Vier Zeilen weiter; dazwischen sind 3 Leerzeilen *) 
 
b) Überschreiten der Zeilengrenze: 
   Eine Datei-Zeile kann (voreingestellt) 77 Zeichen aufnehmen. Wird bei 
   einer Schreib-Operation diese Grenze überschritten, wird der auszugebende 
   Wert auf die nächste Zeile plaziert. Mit der Prozedur 'max line length' 
   kann die eingestellte Datei-Zeilenlänge gelesen oder verändert werden. 
   Beispiel: 
 
        FILE VAR f :: sequential file (output, "meine daten"); 
        put (max line length (f));    (* ergibt 77 *) 
        max line length (f, 132); 
        put (max line length (f))     (* ergibt 132 *) 
 
   Ist die Länge des auszugebenden Textes größer als die verbleibende 
   Zeilenbreite, wird der Text auf der nächsten Zeile ausgegeben. 
 
Die 'putline'-Prozedur bietet die Möglichkeit, eine ganze Datei-Zeile auf 
einmal auszugeben. Eine Positionierung auf die nächste Datei-Zeile ('line') 
braucht dabei nicht vorgenommen werden. Beispiel: 
 
     TEXT VAR zeile :: ""; 
     ... 
     zeile := ...; 
     putline (f, zeile); 
     ... 
 
Merke: In der Betriebsrichtung 'output' kann in eine Datei geschrieben 
werden. Dazu stehen die Prozeduren 'put', 'write' und 'putline' zur Verfü- 
gung. Die Prozedur 'line' positioniert auf die nächste Zeile der Ausgabe- 
datei. Mit 'max line length' kann die Länge einer Datei-Zeile verändert oder 
erfragt werden. 
 
 
 
Operationen der Betriebsrichtung 'input' 
 
In der Betriebsrichtung 'input' sind nur Lese-Operationen gestattet. 'input' 
ist also für das Bearbeiten von Eingabedateien vorgesehen. 
 
Analog der Betriebsrichtung 'output' sind bei 'input' 'get'-Prozeduren vor- 
handen, die INT-, REAL- oder TEXT-Werte aus einer Datei lesen. Beispiel: 
 
     FILE VAR f :: sequential file (input, "Betriebszeiten"); 
     REAL VAR zeiten; 
     zeiten einlesen und berechnen. 
 
     zeiten einlesen und berechnen: 
        REP 
          get (f, zeiten); 
          IF zeiten = 0.0 
            THEN LEAVE zeiten einlesen und berechnen 
          FI; (* siehe auch 'eof'-Prozedur *) 
          berechne 
        END REP. 
 
     berechne: 
        ... 
 
Die 'get'-Prozeduren positionieren automatisch auf die nächste Zeile, sofern 
keine Werte mehr in der aktuellen Zeile vorhanden sind. Mit der Prozedur 
'line' kann explizit auf die nächste Zeile positioniert werden. Damit können 
die restlichen Daten einer Zeile überschlagen werden. Für die 'get'-Proze- 
duren gilt, daß jeder zu lesende Wert entweder beim nächsten Leerzeichen 
oder beim Zeilenende aufhört. Beispiel: 
 
     FILE VAR f :: sequential file (input, "text"); 
     TEXT VAR wort; 
     lese worte. 
 
     lese worte: 
        REP 
          get (f, wort); (* Lesen eines Worts ohne Leerzeichen *) 
          put (wort);    (* Schreiben eines Worts mit Leerzeichen *) 
          IF wort = "Ende" 
            THEN LEAVE lese worte 
          FI 
        END REP. 
 
 
Trennzeichen ("separator") zwischen den Worten sind also Leerzeichen, welche 
nicht eingelesen werden. Manchmal sollen jedoch Daten eingelesen werden, die 
durch andere Zeichen als dem Leerzeichen voneinander getrennt sind. Eine 
Möglichkeit, solche Daten zu behandeln, bietet die 'getline'-Prozedur. Sie 
liest (analog 'putline') eine ganze Zeile und positioniert auf die nächste 
Zeile. Dann kann man mit Hilfe von TEXT-Prozeduren solche Zeilen 'per Hand' 
auseinandernehmen. Als Beispiel zeigen wir ein Programm, welches den zweiten 
Wert einer Zeile lesen soll. Die Werte werden durch Kommata voneinander 
getrennt: 
 
     FILE VAR eingabe datei :: sequential file (input, "daten"); 
     TEXT VAR zeile, wert; 
     lese jeweils zweiten wert; 
     verarbeite wert. 
 
     lese jeweils zweiten wert: 
        REP 
          getline (f, zeile); 
          IF zeile = "Ende" 
            THEN LEAVE lese jeweils zweiten wert 
          FI; 
          extrahiere zweiten wert 
        END REP. 
 
     extrahiere zweiten wert: 
        wert := subtext (zeile, anfang, ende). 
 
     anfang: 
        pos (zeile, ",") + 1. 
 
     ende: 
        pos (zeile, ",", anfang) + 1. 
 
     verarbeite wert: 
        ... 
 
Diese (etwas umständliche) Methode ist immer dann angebracht, wenn Zeilen 
unterschiedlich untersucht werden müssen. Eine einfachere Möglichkeit, die 
in vielen Fällen angewandt werden kann, bietet eine andere Form der 'get'- 
Prozedur, bei der man das oder die Trennzeichen angeben kann. Beispiel: 
 
     ... 
     extrahiere zweiten wert: 
        get (f, wert, ",");       (* ersten Wert der Zeile ueberlesen *) 
        get (f, wert, ",").       (* hier der richtige zweite Wert    *) 
 
Hier wird also das Trennzeichen mit angegeben (dritter Parameter). Eine 
andere Methode müssen wir anwenden, wenn Daten nicht durch ein Trennzeichen 
unterschieden werden, sondern nur durch ihre Länge definiert sind. Beispiel: 
 
     ... 
     lese fuenfstellige werte: 
        REP 
          get (f, wort, 5); 
          verarbeite wert 
          ... 
        END REP. 
 
Bei dieser 'get'-Prozedur wird die Länge des einzulesenden Textes als 
dritter Parameter angegeben. Man beachte, daß die letzten zwei 'get'-Proze- 
duren nur TEXTe einlesen. Entsprechende Typwandlungen hat der Programmierer 
vorzunehmen. 
 
Merke: Die Betriebsrichtung 'input' erlaubt nur Lesen aus einer Eingabedatei. 
Für diesen Zweck gibt es die Prozeduren 'get', 'getline' und 'line'. 
 
 
 
Operationen der Betriebsrichtung 'modify' 
 
Die Betriebsrichtung 'modify' erlaubt das Lesen und Schreiben von Informa- 
tionen auf Dateien. Zusätzlich ist beliebiges Positionieren auf Dateien 
erlaubt. 'modify' ist also für Dateien gedacht, die man gleichzeitig als 
Ausgabe- und Eingabedateien behandeln will. 
 
Die Betriebsrichtung 'modify' erlaubt ein Ändern einer Datei ("updating"), 
wobei die sequentielle Natur der Datei erhalten bleibt. 
 
Eine Datei der Betriebsrichtung 'modify' muß ebenso mit 'sequential file' 
assoziiert werden, wie bei den zwei anderen Betriebsrichtungen. Während bei 
'input' auf den ersten bzw. bei 'output' auf den letzten Satz der Datei 
positioniert wird, ist bei 'modify' nicht definiert, auf welchem Satz der 
Datei nach erfolgter Assoziierung positioniert wird. Man muß also die erste 
Positionierung explizit vornehmen. Für die Zwecke der Positionierung gibt es 
die Prozeduren 
 
     to line          (* auf eine bestimmte Zeile            *) 
     col              (* auf eine Spalte innerhalb der Zeile *) 
     down             (* eine Zeile vorwaerts                *) 
     up               (* eine Zeile zurueck                  *) 
 
Neben diesen Positionierungsprozeduren gibt es die Informationsprozeduren: 
 
     lines             (* Anzahl Zeilen in der Datei *) 
     line no           (* aktuelle Zeilennummer      *) 
     eof               (* Dateiende?                 *) 
 
Beispiele: 
 
     down (f);        (* wie: to line (f, line no (f) + 1)   *) 
                      (*                    Nicht über eof   *) 
     up   (f);        (* wie: to line (f, line no (f) - 1)   *) 
                      (*                Nicht über Zeile 1   *) 
 
Mit der Prozedur 
 
     read record 
 
kann der Satz, auf den aktuell positioniert wurde, gelesen werden. Mit 
 
     write record 
 
kann sein Inhalt geschrieben werden (also auch "überschreiben"). Mit den 
Prozeduren 
 
     insert record 
     delete record 
 
kann eine Zeile vor der aktuellen eingefügt (Position ist dann die einge- 
fügte Zeile) oder der aktuelle Satz gelöscht werden (Position ist dann der 
nächste Satz). Beispiele: 
 
     FILE VAR f :: sequential file (modify, "meine daten") 
     TEXT VAR zeile, neue zeile; 
     to line (f, 1); 
     read record (f, zeile);  (* erste Zeile lesen         *) 
     ... 
     insert record (f);       (* neue erste Zeile          *) 
     write record  (f, neue zeile); 
     down (f);                (* auf die 2. Zeile, die vorher die 1. war *) 
     delete record (f);       (* diese loeschen, so dass die 
                                 Zeilenzahl wieder stimmt  *) 
 
Das nächste Beispiel zeigt, wie hinter den letzten Satz einer Datei eine 
Zeile eingefügt werden kann (hier wird ausgenutzt, daß man in der Betriebs- 
richtung 'modify' hinter den letzten Satz der Datei positioniert werden 
kann):   
 
    FILE VAR f :: sequential file (modify, "test"); 
    to line (f, lines (f));   (* auf die letzte Zeile      *) 
    down (f); 
    insert record (f); 
    write record (f, "neue letzte Zeile"); 
    ... 
 
Mit 'down' bzw. 'up' kann man auch um einige Zeilen auf einmal vorwärts oder 
rückwärts positionieren. Beispiele: 
 
     down (f, 17)             (* 17 Zeilen vorwaerts   *) 
     up   (f, 13)             (* 13 zeilen rueckwaerts *) 
 
Merke: In der Betriebsrichtung 'modify' können Dateien gelesen und/oder ge- 
schrieben werden ('read record' oder 'write record'). Positionierungen kön- 
nen mit 'down', 'up' oder 'to line' vorgenommen werden. 
 
 
 
Manipulationen von FILEs 
 
FILEs können im EUMEL-System auch als Einheiten behandelt werden. Dazu 
stehen die bereits erläuterten Prozeduren zur Verfügung, die wir hier der 
Vollständigkeit halber nochmals aufführen. 
 
Mit der Prozedur 
 
     exists 
 
kann erfragt werden, ob eine Datei bereits existiert. Beispiel: 
 
     TEXT VAR name; 
     REP 
       erfrage name; 
     UNTIL exists (name) END REP; 
     ... 
 
     erfrage name: 
       put ("Dateiname bitte:"); 
       get (name); 
       line. 
 
Weitere Prozeduren: 
 
    forget                          (* Datei löschen *) 
    rename                          (* umbenennen    *) 
    copy                            (* kopieren      *) 
 
Für Programmierer ist eine Version der 'forget'-Prozedur interessant, die 
eine Datei ohne Kontroll-Anfrage löscht. Beispiel: 
 
     forget ("meine scratch datei", quiet) 
 
Merke: Mit 'exists' kann erfragt werden, ob ein FILE bereits existiert. 
 
 
 
Texte Suchen 
 
Mit den Prozeduren 'down' und 'up' kann man (ebenso wie im Editor) auch nach 
Texten suchen. 
 
Die Prozeduren 'down' bzw. 'up' suchen einen Text in der Datei. Beispiele: 
 
     down (f, "dieser text") 
     up (f, "noch'n text") 
 
Diese Prozeduren suchen direkt auf der Dateistruktur. Wird der gesuchte Text 
gefunden, steht man direkt auf dem gesuchten Text. Wird der Text nicht 
gefunden, steht man auf dem ersten (bei 'up') oder hinter dem letzten (bei 
'down') Zeichen der Datei. Die Position innerhalb der Zeile nach einer Suche 
kann mit 
 
     col (f) 
 
abgefragt werden. Um die Suche auf einen Bereich zu beschränken, kann man 
'down' bzw. 'up' mit einem weiterem Parameter versehen, der die max. Anzahl 
von Zeilen angibt. Beispiel: 
 
     FILE VAR f :: ... 
     ... 
     INT VAR akt zeilennr :: line no (f); 
     down (f, "pattern", 100); 
     (* sucht in den naechsten 100 Zeilen nach 'pattern' *) 
     IF line no (f) <> akt zeilen nr + 100 
       THEN gefunden 
       ELSE nicht gefunden 
     FI; 
     ... 
 
Achtung: 'down' bzw. 'up' beginnen die Suche immer mit dem nächsten Zeichen 
in Suchrichtung, so daß man mehrmals hintereinander suchen kann, ohne in 
eine Endlosschleife zu geraten (Erinnerung: wird ein Text gefunden, ist die 
Position innerhalb der Zeile das erste Zeichen des gesuchten Begriffs). 
 
Mit den Prozeduren (gleiche Parameterversorgung wie 'down' und 'up') 
 
     downety 
     uppety 
 
beginnt man mit der Suche immer auf der aktuellen Position. Darum sollte man 
diese Prozeduren mit Vorsicht verwenden. Mit der Prozedur 
 
     pattern found 
 
kann man anfragen, ob die letzte Suchoperation erfolgreich war oder nicht. 
Beispiel: 
 
     FILE VAR f :: ... 
     ... 
     INT VAR akt zeilennr :: line no (f); 
     down (f, "pattern", 100); 
     (* sucht in den naechsten 100 Zeilen nach 'pattern' *) 
     IF pattern found THEN gefunden 
       ELSE nicht gefunden 
     FI; 
     ... 
 
Mit der Prozedur 
 
     at 
 
kann man anfragen, ob man auf einem gewünschten Wort steht. Beispiel: 
 
     IF at (f, "pattern") 
       THEN .. 
     FI 
 
Die Prozedur 
 
     word 
 
liefert das aktuelle Wort der aktuellen Position einer Zeile. Beispiele: 
 
     TEXT VAR dieses wort :: word (f); 
     (* Zeichenkette von der aktuellen Position bis zum nächsten Blank oder 
     Zeilenende *) 
     dieses wort := word (f, "<"); 
     (* Zeichenkette (Wort) von der aktuellen Position bis zum Zeichen '<' 
     oder Zeilenende *) 
     dieses wort := word (f, 13); 
     (* Zeichenkette (Wort) mit der Laenge 13 *) 
 
Merke: Die Prozeduren 'down' und 'up' suchen einen Text innerhalb einer 
Datei. Mit 'at' kann man anfragen, ob man auf dem gesuchten Begriff steht. 
'word' liefert das aktuelle Wort. 
 
 
 
FILE-Ausschnitte 
 
Hier wird erklärt, wie man mehrere Zeilen aus einer Datei auf einmal löschen 
und/oder verschieben und wie man nur einen Ausschnitt einer Datei zugänglich 
machen kann. 
 
Den einfachsten Zugang zu Datei-Abschnitten erhält ein Programmierer durch 
einige Anwendungsprozeduren, die u.a. auch im Editor verwandt werden. Dort 
gibt es die Möglichkeit, einen markierten Bereich "vorsichtig" zu löschen 
und u.U. an anderer Stelle wieder einzufügen (ESC RUBOUT und ESC RUBIN). 
Solche Prozeduren stehen auch einem Programmierer zur Verfügung. Beispiel: 
 
     FILE VAR f :: .... 
     .... 
     remove (f, 100);       (* entfernt 100 Zeilen von der aktuellen 
                               Position rueckwaerts (!) aus der Datei 'f' *) 
     to line (27);          (* zum Beispiel *) 
     re insert (f)          (* fuegt die "vorsichtig" geloeschten Zeilen vor 
                               (!) die Zeile 27 ein *) 
 
Die Prozedur 
 
     remove 
 
löscht also eine angebbare Anzahl von Zeilen in der Datei (rückwärts von der 
aktuellen Zeilennummer ab) und schreibt diesen Datei-Abschnitt in einen 
internen Puffer. Man beachte, daß sich dabei natürlich die Zeilennummer der 
Datei ändert. Die entfernten Zeilen können aus dem internen Puffer an einer 
anderen Stelle durch 
 
     reinsert 
 
genau einmal wieder eingefügt werden. Sollen jedoch die mit 'remove' ent- 
fernten Zeilen wirklich gelöscht und nicht mehr an anderer Stelle eingesetzt 
werden, dann kann man die Prozedur 
 
     clear removed 
 
verwenden. Beispiel: 
 
     ... 
     remove (f, 50);        (* loescht vorsichtig *) 
     clear removed (f);     (* und endgueltig     *) 
     ... 
 
Durch solche Löschungen oder Einfügungen entstehen Datei-Segmente. 
Innerhalb eines Segments kann direkt positioniert werden. Werden jedoch 
Löschungen oder Einfügungen vorgenommen (Sätze werden ein- oder ausgekettet), 
muß erst zu einem entsprechenden Segment positioniert und dann innerhalb des 
Segments auf den entsprechenden Satz positioniert werden. Das kann - je nach 
Anzahl der Segmente - zeitaufwendig sein. Deshalb existiert die Prozedur 
 
     segments 
 
mit der man feststellen kann, wieviel Datei-Segmente in der Datei existieren. 
(Sind es "zu viele", kann man die Datei "reorganisieren"). 
 
Diese und die folgenden Prozeduren nutzen eine vom EUMEL-System bereitge- 
stellte Möglichkeit, Ausschnitte aus Dateien wie eigenständige Dateien zu 
behandeln. Beispiel: 
 
    FILE VAR f :: ... 
    ... 
    FRANGE VAR alter bereich; 
    set range (f, 200, 1, alter bereich); 
        (* Datei mit 200 Zeilen von der Spalte 1 der aktuellen Zeile *) 
    edit (f);                          (* Zeilen 1-200 editieren *) 
    set range (f, alter bereich);      (* Datei zuruecksetzen *) 
    ... 
 
Von dem Beispiel-Programm wird die Datei 'f' bearbeitet. Die FRANGE-Variable 
dient hier dazu, sich den ursprünglichen Bereich der Datei 'f' (der auch 
schon eingeschränkt sein kann), zu merken. Mit der Prozedur 'set range' wird 
die Datei 'f' auf 200 Zeilen eingeschränkt (von der aktuellen Zeile 200 
Zeilen rückwärts). Mit der Prozedur 'edit' kann nun der Benutzer unseres 
Programms die (eingeschränkte) Datei beliebig editieren. Ihm steht am Anfang 
Zeilen 1 bis 200 zur Verfügung; die "ausgeblendeten" Datei-Teile kann er 
nicht verändern. Mit dem zweiten Aufruf von 'set range' wird der einge- 
schränkte (und u.U. veränderte) Datei-Bereich aufgehoben, so daß hier wieder 
alle ursprünglichen Datei-Zeilen zur Verfügung stehen. 
 
Solche Beschränkungen können natürlich mehrmals geschachtelt vorgenommen 
werden. Um nach Ablauf solcher Programmteile sicher wieder die ursprüngliche 
Datei (mit allen ihren Zeilen) zur Verfügung zu haben, gibt es die Prozedur 
 
     reset range (f) 
 
Sie setzt die Datei 'f' auf den größtmöglichen Bereich zurück. 
 
Merke: Mit 'remove' und 'reinsert' können Zeilen gelöscht und/oder ver- 
schoben werden. Mit dem Datentyp FRANGE und den Prozeduren 'set range' 
können Dateien eingeschränkt werden. 
 
 
 
5. Datenräume 
 
Die bis jetzt behandelten Dateien können nur TEXTe aufnehmen (bei einigen 
Schreib-/Lese-Operationen werden Daten in Texte umgewandelt, z.B. bei 'get' 
und 'put'). Damit ist gewährleistet, daß alle Programme im EUMEL-System 
(Editor, Drucker, Compiler, Benutzer-Programme usw.) auf gleiche Art und 
Weise auf Dateien zugreifen können, unabhängig davon, welche Daten wirklich 
gespeichert sind. Der folgende Abschnitt zeigt, wie man mit Dateien umgeht, 
die nicht vom Standardtyp FILE sind. 
 
 
 
Konzept des Datenraums 
 
Standarddateien (FILEs) können nur Texte aufnehmen, da sie ja hauptsächlich 
für die Kommunikation mit dem Menschen (vorwiegend mit Hilfe des Editors bzw. 
Ein-/Ausgabe) gedacht sind. Will man Zahlen in einen FILE ausgeben, so 
müssen diese zuvor in Texte umgewandelt werden. Hierfür stehen Standard- 
prozeduren zur Verfügung (z.B. 'put (f, 17)'). 
 
Will man aber Dateien zur Kommunikation zwischen Programmen verwenden, die 
große Zahlenmengen austauschen, verursachen die Umwandlungen von Zahlen 
in TEXTe und umgekehrt unnötigen Rechenaufwand. Daher wurden in EUMEL� die 
Datenräume eingef�hrt, die es gestatten, beliebige Strukturen (Typen) in 
Dateien zu speichern. Solche Datenräume kann man weder mit dem Editor noch 
mit dem Standarddruckprogramm (print) bearbeiten, da diese ja den Typ des in 
der Datei gespeicherten Objektes nicht kennen. 
 
Einen Datenraum kann man sich als eine Sammlung von Daten vorstellen (u.U. 
leer), die ausschließlich von einem Programm her behandelt wird. Man kann 
einem Datenraum durch ein Programm einen Datentyp "aufprägen". Meist handelt 
es sich um Reihungen, weil die Benutzung von Datenräumen erst bei größeren 
Datenmengen lohnt. Nach einem solchen "Aufpräge"-Vorgang kann der Datenraum 
wie ein "normaler" Datentyp behandelt werden, mit dem Unterschied, daß die 
Daten in einem Datenraum (d.h. Datei) gespeichert werden. Somit können nach- 
folgende Programme auf die im Datenraum gespeicherten Daten zugreifen, so- 
fern sie den gleichen Datentyp auf den Datenraum aufprägen. 
 
Merke: Ein Datenraum ist eine Sammlung von Daten. Er kann ausschließlich 
durch ein Programm (und z.B. nicht durch den Editor) behandelt werden. 
Programme können Datenräumen Datentypen aufprägen und sie dann mit den ver- 
fügbaren Operationen dieses Datentyps manipulieren. 
 
 
Ein Beispiel 
 
Diesen etwas komplizierten Vorgang wollen wir an Hand eines Beispiels 
Schritt für Schritt erklären. 
 
Angenommen, Programmierer Meier hat ein Gehaltsprogramm zu erstellen. Er 
überlegt sich, das Programm in (mindestens) zwei Moduln (PACKETs) zu er- 
stellen: 
 
a) Berechnung der Gehaltssumme aus den Arbeitszeiten (also Bruttogehalt) und 
   dann 
b) Endgültige Berechnung der Gehälter durch Abzug von Steuern usw. 
 
Das Programm aus a) erstellt also eine Gehaltsliste für alle Beschäftigten 
des Betriebs. Die Gehaltsliste soll ebenfalls von Modul b) genutzt werden. 
 
Meier entschließt sich, die Gehaltsliste in einem Datenraum zu speichern. 
Das hat neben der effizienteren Bearbeitung noch den Vorteil, daß man die 
Gehaltsliste - ohne Programmierkenntnisse zu besitzen - nicht mit dem Editor 
bearbeiten kann (Datenschutz). 
 
Dem ELAN-Compiler muß Meier also mitteilen, daß die Reihung für die 
Gehaltsliste (oder irgendein anderer Datentyp) nicht im Speicherbereich des 
Programms, sondern in einem Datenraum gespeichert werden soll. Dies erfolgt 
mit dem Schlüsselwort BOUND, welches dem Datentyp bei der Deklaration 
vorangestellt wird. Beispiel: 
 
     BOUND ROW 1000 REAL VAR gehaltsliste 
 
Dieses BOUND-Objekt muß Meier noch mit einer Datei verbinden, man spricht 
von "ankoppeln". Die Ankopplung erfolgt durch den Operator ':='. Dies kann 
man gleich bei der Initialisierung vornehmen. Beispiel: 
 
     BOUND ROW 1000 REAL VAR gehaltsliste := new ("hugo") 
 
Die Prozedur 'new' kreiert dabei einen leeren Datenraum (hier mit dem Namen 
'hugo'), der mit Hilfe der Zuweisung (hier: Initialisierung) an die Variable 
'gehaltsliste' gekoppelt wird. 
 
Nun kann Meier mit der 'gehaltsliste' arbeiten wie mit allen anderen Feldern 
auch, mit dem Unterschied, daß die Daten, die er in 'gehaltsliste' speichert, 
eigentlich im Datenraum 'hugo' gespeichert sind. Beispiele: 
 
     gehaltsliste [5] := 10 000.0;           (* Traumgehalt *) 
     gehaltsliste [index] INCR 200.0;        (* usw.        *) 
 
Meier kann auch Prozeduren schreiben, die auf der Gehaltsliste arbeiten. 
Beispiel: 
 
     PROC sort (ROW 1000 REAL VAR liste): 
     ... 
     END PROC sort; 
     ... 
     sort (gehaltsliste); 
     ... 
 
Man beachte, daß der formale Parameter der Prozedur 'sort' nicht mit BOUND 
spezifiziert werden darf (BOUND wird nur bei der Deklaration des Objekts 
angegeben). Das ist übrigens ein weiterer wichtiger Vorteil von BOUND-Objek- 
ten: man kann alle Prozeduren des EUMEL-Systems auch für BOUND-Objekte 
verwenden, nur die Datentypen müssen natürlich übereinstimmen. 
 
Nach der Bearbeitung des Moduls a) ist Meier nun sicher, daß seine Brutto- 
daten in dem Datenraum 'hugo' stehen. Meier braucht (genauso wie bei FILEs) 
den Datenraum nicht zu schließen. Im zweiten Modul muß Meier nun erneut ein 
BOUND-Objekt deklarieren. 
Deshalb deklariert Meier nun 
 
     BOUND ROW 1000 REAL VAR nettoliste :: old ("hugo"); 
 
Hier muß Meier nun die Prozedur 'old' verwenden, weil der Datenraum bereits 
aus dem ersten Modul existiert. Nun kann Meier weiter programmieren, bis er 
letztendlich den Datenraum löscht: 
 
     forget ("hugo") 
 
Merke: Ein Datenobjekt eines beliebigen Datentyps kann mit einem vorange- 
stellten BOUND deklariert werden und an einen Datenraum gekoppelt werden. 
Der Datentyp ist dann auf den Datenraum aufgeprägt und man kann mit ihm 
arbeiten wie mit allen anderen Objekten dieses Datentyps. 
 
 
 
Datenräume als Datentyp 
 
Datenräume können auch als eigener Datentyp (DATASPACE) in einem Programm 
behandelt werden. Somit können Datenräume (als Ganzes) ohne Kenntnis eines 
eventuell (vorher oder später) aufgeprägten Typs verwandt werden. 
 
Als Operationen auf DATASPACE-Objekten sind nur Transporte, Löschen und 
Initialisieren zugelassen. 
 
     DATASPACE VAR ds :: old ("daten"); 
 
Der Zuweisungsoperator bewirkt eine Kopie des Datenraums vom rechten auf 
den linken Operanden. Des weiteren gibt es eine DATASPACE Konstante 'nil- 
space', die eine leere Datenraum repräsentiert. Mit diesem Wert initialisiert 
der Datei-Manager Dateien, die neu kreiert werden. 
 
Eine neuer Datenraum kann durch 
 
     new ("name") 
 
eingerichtet werden. 'new' liefert gleichzeitig einen Datenraum und wird 
deshalb für Initialisierungen verwandt. Beispiel: 
 
     DATASPACE VAR datenraum :: new ("name1");   (* Kopie ! *) 
 
Ein bereits vorhandener Datenraum in der Benutzer-Task kann mit 
 
     old ("datei") 
 
erneut benutzt werden. 'old' liefert (wie 'new') einen DATASPACE, so daß 
'old' ebenfalls zur Initialisierung benutzt werden kann. Die Prozedur 
 
     nilspace 
 
liefert einen leeren Datenraum. 
 
Für Datenräume gelten zusätzlich einige der Prozeduren wie für FILEs, u.a.: 
 
     forget 
     fetch 
     save 
     rename 
 
Ausgenommen davon sind Prozeduren, die einen TEXT-File voraussetzen, wie 
z.B. 'crypt' und 'decrypt', 'put', 'putline' usw. 
 
Abschließend soll hier noch auf häufig gemachte Fehler hingewiesen werden: 
 
Wenn man an ein DATASPACE-Objekt zuweist (z.B.: DATASPACE VAR ds := 
new ("mein datenraum")) so erhält man, wie oben erwähnt, eine Kopie des 
Datenraums in 'ds'. Koppelt man jetzt 'ds' an ein BOUND-Objekt an und führt 
Änderungen durch, so wirken diese nur auf die Kopie und nicht auf die Quelle 
(d.h. im Beispiel, daß die Datenraum 'hugo' nicht verändert wird, hier also 
leer bleibt). Für Änderungen in den vom Datei-Manager verwalteten Dateien 
ist also stets direkt anzukoppeln, wie es im Beispiel gezeigt wurde. 
 
Wenn man ein DATASPACE-Objekt benutzt, ohne den Datei-Manager zu verwenden, 
so muß man selbst dafür sorgen, daß dieses Objekt nach seiner Benutzung 
wieder gelöscht wird. Das Löschen geschieht durch die Prozedur 'forget'. 
Ferner ist zu beachten, daß vor der Ankopplung an ein BOUND-Objekt das 
DATASPACE-Objekt initialisiert wird (im Normalfall mit 'nilspace'). Beispiel: 
 
     DATASPACE VAR ds :=  nilspace; 
     BOUND ROW 1000 REAL VAR real feld := ds; 
     .... 
     real feld [index] := wert; 
     .... 
     forget (ds) (* Datei löschen, damit der Platz wieder verwendet wird *) 
 
Ein automatisches Löschen von DATASPACE-Objekten erfolgt auch nicht bei 
Programmende (sonst könnten sie ihre Funktion als Datei nicht erfüllen). 
Erst beim Löschen einer Task werden alle ihr gehörenden DATASPACE-Objekte 
freigegeben. Verboten ist weiterhin folgendes: 
 
     BOUND X ...; 
 
wobei 'X' mit BOUND deklariert wurde oder ein DATASPACE ist. 
 
Merke: Datenräume können durch 'new' erschaffen werden. Mit 'old' kann ein 
bereits vorhandener Datenraum angesprochen werden. Im Übrigen gelten auch 
einige der für FILEs vorhandenen Operationen. 
 
 
 
Datei-Typen definieren 
 
Durch die Datenräume und die Datentyp-Definition von ELAN ist es für 
Programmierer relativ einfach, neue Datei-Datentypen zu definieren. 
 
In der Regel reicht der Datentyp FILE für "normale" Anwendungen aus, jedoch 
kann es manchmal sinnvoll und notwendig sein, neue Datei-Typen für spezielle 
Aufgaben zu definieren. 
 
In diesem Abschnitt zeigen wir an dem Beispiel DIRFILE (welcher zwar im 
ELAN-Standard definiert, aber nicht im EUMEL-System realisiert ist), wie ein 
neuer Datei-Datentyp definiert wird: 
 
     PACKET dirfiles DEFINES DIRFILE, :=, dirfile, getline, ...: 
 
     LET maxsize = 1000; 
 
     TYPE DIRFILE = BOUND ROW maxsize TEXT; 
     (* DIRFILE besteht aus TEXTen; Zugriff erfolgt ueber einen 
        Schluessel, der den Index auf die Reihung darstellt *) 
 
     OP := (DIRFILE VAR dest, DATASPACE CONST space): 
       CONCR (dest) := space 
     END OP :=; 
 
     DATASPACE PROC dirfile (TEXT CONST name): 
       IF exists (name) 
         THEN old (name) 
         ELSE new (name) 
       FI 
     END PROC dirfile; 
 
     PROC getline (DIRFILE CONST df, INT CONST index, TEXT VAR record): 
       IF index <= 0 
         THEN errorstop ("access before first record") 
       ELIF index > maxsize 
         THEN errorstop ("access after last record") 
         ELSE record := df [index] 
       FI 
     END PROC getline; 
 
     PROC putline (DIRFILE CONST df, INT CONST index, TEXT VAR record): 
       ... 
     END PROC putline; 
 
     ... 
     END PACKET dirfiles; 
 
Die Prozedur 'dirfile' ist die Assoziierungsprozedur für DIRFILEs (analog 
'sequential file' bei FILEs). 'dirfile' liefert entweder einen bereits vor- 
handenen Datenraum oder richtet einen neuen ein. Um eine Initialisierung mit 
der 'dirfile'-Prozedur vornehmen zu können, braucht man auch einen Zu- 
weisungsoperator, der den Datenraum an den DIRFILE-Datentyp koppelt. 
 
Zugriffe auf einen DIRFILE sind nun relativ einfach zu schreiben. Im obigen 
Beispiel wird nur die Prozedur 'getline' gezeigt. 
 
Nun ist es möglich, Programme zu schreiben, die den DIRFILE-Datentyp 
benutzen. Beispiel: 
 
     DIRFILE VAR laeufer :: 
           dirfile ("Nacht von Borgholzhausen"); 
     INT VAR nummer; 
     TEXT VAR name; 
 
     REP 
       put ("Startnummer bitte:"); 
       get (nummer); 
       line; 
       put ("Name des Laeufers:"); 
       get (name); 
       putline (laeufer, nummer, name); 
       line 
     UNTIL no ("weiter") END REP; 
     ... 
 
Merke: Neue Datei-Typen für spezielle Anwendungen kann man leicht selbst 
programmieren. 
 
 
 
6. Beschreibung der Prozeduren 
 
In diesem Abschnitt werden alle Operationen, die für Dateien zur Verfügung 
stehen, aufgeführt. Dabei werden die Operationen für FILEs und Datenräume 
mit (F) gekennzeichnet. 
 
+ 
   THESAURUS OP + (THESAURUS CONST left, right) 
   Zweck: Vereinigungsmenge von 'left' und 'right'. 
 
   THESAURUS OP + (THESAURUS VAR left, TEXT CONST name) 
   Zweck: Nimmt den TEXT 'name' in den Thesaurus 'left' auf. Beispiel: 
 
             save (SOME father + "hugo", archive) 
 
- 
   THESAURUS OP - (THESAURUS CONST left, right) 
   Zweck: Differenzmenge von 'left' und 'right'. 
 
   THESAURUS OP - (THESAURUS VAR left, TEXT CONST name) 
   Zweck: Liefert einen Thesaurus aus left, aber ohne den Eintrag 'name'. 
          Beispiel: 
 
             save (ALL myself - "hugo", archive) 
 
/ 
   THESAURUS OP / (THESAURUS CONST left, right) 
   Zweck: Schnittmenge von 'left' und 'right'. 
 
   TASK OP / (TEXT CONST task name) 
   Zweck: Liefert aus einem Tasknamen den internen Tasknamen. '/' kann über- 
          all dort eingesetzt werden, wo ein interner Taskname verlangt wird. 
 
ALL 
   THESAURUS OP ALL (TASK CONST task) 
   Zweck: Liefert einen Thesaurus, der alle Dateinamen der angegebenen Task 
          enthält (auch der Benutzer-Task: 'myself'). 
 
   THESAURUS OP ALL (TEXT CONST file name) 
   Zweck: Liefert einen Thesaurus, der die in 'file name' vorhandenen Datei- 
          namen (jede Zeile ein Name) enthält. 
 
at (F) 
   BOOL PROC at (FILE VAR f, TEXT CONST word) 
   Zweck: Abfrage, ob man auf 'word' in der Datei 'f' positioniert ist. 
          Beispiel: 
 
            ... 
            down (f, "muster") 
            IF at (f, "muster") 
              THEN gefunden 
              ELSE nicht gefunden 
            FI; 
            ... 
 
archive 
   PROC archive (TEXT CONST archive name) 
   Zweck: Anmeldung von Archiv-Operationen. 'archive name' wird zur Über- 
          prüfung für alle folgenden Archiv-Operationen verwandt, um die 
          unberechtigte Benutzung eines Archivs zu verhindern. Die Anmeldung 
          wird abgelehnt, wenn ein anderer Nutzer das Archiv belegt hat. 
 
   TASK PROC archive 
   Zweck: Liefert den internen Task-Bezeichner für die Verwendung in 
          Datei-Kommandos. Beispiel: 
 
              save ("datei", archive) 
 
brother 
   TASK PROC brother (TASK CONST task) 
   Zweck: Liefert den internen Task-Bezeichner der angegebenen "Bruder"- 
          Task. 
 
check 
   PROC check (TEXT CONST dateiname, TASK CONST task) 
   Zweck: Überprüft, ob die Datei 'dateiname' auf dem Archiv lesbar ist. 
          Beispiel: 
 
             check ("meine datei", archive) 
 
   PROC check (THESAURUS CONST t, TASK CONST task) 
   Zweck: Überprüft, ob die in dem Thesaurus 't' enthaltenen Dateien auf dem 
          Archiv lesbar sind. Beispiel: 
 
             check (ALL archive, archive) 
 
clear 
   PROC clear (TASK CONST task) 
   Zweck: Löscht alle Dateien der Task 'task'. Ist z.Z. nur für die Task 
          'ARCHIVE' implementiert. 
 
clear removed (F) 
   PROC clear removed (FILE VAR f) 
   Zweck: Löscht die mit 'remove' "vorsichtig" gelöschten Zeilen aus der 
          Datei 'f' endgültig. 
 
close (F) 
   PROC close (FILE VAR file) 
   Zweck: Schließen der Datei 'file'. Im EUMEL-System ist der Aufruf von 
          'close' nicht notwendig. 'close' wurde nur aufgenommen, um die 
          Kompatibilität zu Standard zu wahren. 
 
col (F) 
   PROC col (FILE VAR f, INT CONST position) 
   Zweck: Positionierung auf die Spalte 'position' innerhalb der aktuellen 
          Zeile. 
 
   INT PROC col (FILE CONST f) 
   Zweck: Liefert die aktuelle Position innerhalb der aktuellen Zeile. 
 
copy (F) 
   PROC copy (TEXT CONST source, destination) 
   Zweck: Kopiert die Datei 'source' in eine neue Datei mit dem Namen 
          'destination' in der Benutzer-Task. 
   Fehlerfälle: 
        * destination file already exists 
          Eine Datei mit dem Namen 'destination' existiert bereits. 
        * source file does not exist 
          Die Ursprungsdatei mit dem Namen 'source' ist nicht vorhanden. 
        * directory overflow 
          Die Anzahl der zulässigen Dateien der Benutzer-Task ist über- 
          schritten. 
 
   PROC copy (DATASPACE CONST ds, TEXT CONST destination) 
   Zweck: Eintragen eines unbenannten DATASPACE in die Datei-Verwaltung. 
   Fehlerfälle: 
        * destination file already exists 
          Eine Datei mit dem Namen 'destination' existiert bereits. 
        * directory overflow 
          Die Anzahl der zulässigen Dateien der Benutzer-Task ist über- 
          schritten. 
 
create 
   PROC create (TEXT CONST name) 
   Zweck: Erschafft einen neuen Datenraum in der Benutzer-Task. 
   Fehlerfälle: 
        * file already exists 
          Eine Datei mit dem Namen 'name' existiert bereits in der Benutzer- 
          Task. 
        * directory overflow 
          Die Anzahl der zulässigen Dateien der Benutzer-Task ist über- 
          schritten. 
 
crypt (F) 
   PROC crypt (TEXT CONST name, parole) 
   Zweck: Verschlüsseln des Inhaltes der Datei 'name' mit Hilfe des Textes 
          'parole' für Zwecke des Datenschutzes. Die Verschlüsselung ist 
          umso besser (bzw. umso schwieriger zu "knacken"), je länger der 
          Text 'parole' ist. Die Datei kann mit der Prozedur 'decrypt' 
          wieder entschlüsselt werden. 
 
          Eine Datei kann mehrfach verschlüsselt werden. Dabei gilt bei 
          einer Entschlüsselung das Klammerungsprinzip. Es muß also genau so 
          oft entschlüsselt werden, wie anfangs verschlüsselt wurde. Dabei 
          ist auf die richtige Angabe der 'parole'n zu achten. Beispiel: 
 
               crypt ("hugo", "verschluesselung1"); 
               crypt ("hugo", "verschluesselung2"); 
               ... 
               decrypt ("hugo", "verschluesselung2"); 
               decrypt ("hugo", "verschluesselung1") 
 
          Achtung: 'crypt' und 'decrypt' sind nicht standardmäßig insertiert. 
 
decrypt (F) 
   PROC decrypt (TEXT CONST name, parole) 
   Zweck: Entschlüsselt die Datei 'name' mit Hilfe der angegebenen 'parole'. 
          Dabei ist darauf zu achten, daß die gleiche 'parole' anzugeben 
          ist, die verwendet wurde, um die Datei zu verschlüsseln (sonst 
          wirkt 'decrypt' wie ein erneuter Aufruf von 'crypt').Beim mehr- 
          fachen Ver- und Entschlüsseln ist das Klammerungsprinzip zu be- 
          achten (dazu vergl. 'crypt'). 
 
delete record (F) 
   PROC delete record (FILE VAR file) 
   Zweck: Der aktuelle Satz der Datei 'file' wird gelöscht. Der folgende 
          Satz wird der aktuelle Satz. Die Datei 'file' muß mit der Verar- 
          beitungsart 'modify' assoziiert worden sein. 
 
do 
   PROC do (PROC (TEXT CONST) operate, THESAURUS CONST thesaurus) 
   Zweck: Ruft 'operate' mit allen im 'thesaurus' enthaltenen Dateinamen 
          nacheinander auf. Man beachte, daß bei Prozedur-Parametern der 
          Name der Prozedur hinter dessen Parametern geschrieben wird. 
          Beispiel: 
 
            do (PROC (TEXT CONST) reorganize, ALL myself) 
 
   PROC do (PROC (TEXT CONST, TASK CONST) operate, 
            THESAURUS CONST thesaurus, TASK CONST task) 
   Zweck: S.o.. Dabei ist zu beachten, daß 'task' als zweiter Parameter in 
          der Prozedur 'operate' eingesetzt wird. Beispiel: 
 
           do (PROC (TEXT CONST, TASK CONST) save, 
               SOME myself, father) 
           (* enspricht: *) 
           save (SOME myself, father) 
 
down (F) 
   PROC down (FILE VAR f) 
   Zweck: Positionieren um eine Zeile vorwärts in der Datei 'f'. 
 
   PROC down (FILE VAR f, INT CONST number) 
   Zweck: Positionieren um 'number' Zeilen vorwärts in der Datei 'f'. 
 
   PROC down (FILE VAR f, TEXT CONST pattern) 
   Zweck: Suche nach 'pattern' in der Datei 'f'. Wird 'pattern' gefunden, 
          ist die Position das erste Zeichen von 'pattern'. Andernfalls 
          steht man hinter dem letzten Zeichen der Datei. Achtung: 'down' 
          sucht vom nächsten Zeichen rechts ab, so daß wiederholtes Suchen 
          keine Endlosschleife ergibt. 
 
   PROC down (FILE VAR f, TEXT CONST pattern, INT CONST number) 
   Zweck: Wie obiges 'down', aber maximal nur 'number'-Zeilen weit. 
 
downety (F) 
   PROC downety (FILE VAR f, TEXT CONST pattern) 
   Zweck: Suche nach 'pattern' in der Datei 'f'. Wird 'pattern' gefunden, 
          ist die Position das erste Zeichen von 'pattern'. Andernfalls 
          steht man auf dem letzten Zeichen der Datei. Achtung: 'downety' 
          sucht (im Gegensatz zu 'down') vom aktuellen Zeichen. 
 
   PROC downety (FILE VAR f, TEXT CONST pattern, INT CONST number) 
   Zweck: Wie obiges 'downety', aber maximal nur 'number'-Zeilen weit. 
 
enter password 
   PROC enter password (TEXT CONST password) 
   Zweck: Einstellen eines Paßwortes in der Benutzer-Task für den Datei- 
          Verkehr mit einer Vater-Task. Der Parameter 'password' kann dabei 
          aus zwei Teilen bestehen, die durch ein "/"-Zeichen getrennt 
          werden müssen. Der erste Teil bedeutet das schreib-Passwort,  
          während der TEXT nach dem "/"-Zeichen das Lese-Paßwort beinhaltet. 
          Enthält der Parameter 'password' kein "/"-Zeichen, gilt der ange- 
          gebene TEXT sowohl für das Schreib- wie auch für das Lese-Paßwort. 
          Im Schreib- bzw. Lese-Teil des Paßworts kann man das "-"-Zeichen 
          angeben, um eine Datei vor überschreibendem oder lesendem Zugriff 
          zu schützen. 
 
          Die Paßwort-Überprüfung findet statt bei 
 
               - fetch  (Überprüfung der Lese-Berechtigung) 
               - save   (Überprüfung der Schreib-Berechtigung) 
               - erase  (Überprüfung der Schreib-Berechtigung) 
 
eof (F) 
   BOOL PROC eof (FILE CONST file) 
   Zweck: Informationsprozedur auf das Ende eines FILEs. Liefert den Wert 
          TRUE, sofern hinter den letzten Satz eines FILEs positioniert 
          wurde.   
 
erase 
   PROC erase (TEXT CONST name) 
   Zweck: Löscht eine Datei mit dem Namen 'name' in der unmittelbaren 
          Vater-Task. 
   Fehlerfälle: 
        * ... gibt es nicht 
          Eine Datei mit dem Namen 'name' existiert in der unmittelbaren 
          Vater-Task nicht. 
        * wrong password 
          Es wurde mit der Prozedur 'enter password' nicht das richtige 
          Paßwort angegeben. 
 
   PROC erase (TEXT CONST name, TASK CONST task) 
   Zweck: Löscht eine Datei mit dem Namen 'name' in der Task 'task'. Bei- 
          spiel: 
 
            erase ("meine datei", father) 
 
   PROC erase (THESAURUS CONST thesaurus) 
   Zweck: Löscht die im 'thesaurus' angegebenen Dateien in der Vater-Task. 
          Beispiel (löscht alle Dateien in der Vater-Task, die in der Benut- 
          zer-Task vorhanden sind): 
 
             erase (ALL myself) 
 
   PROC erase (THESAURUS CONST thesaurus, TASK CONST manager) 
   Zweck: S.o.. 
 
exists (F) 
   BOOL PROC exists (TEXT CONST name) 
   Zweck: Informationsprozedur zur Abfrage der Existenz einer Datei in der 
          Benutzer-Task. Beispiel: 
 
             IF exists ("dateiname") 
               THEN FILE VAR f :: sequential file ...; 
               ELSE errorstop ("Datei existiert nicht") 
             FI 
 
father 
   TASK PROC father 
   Zweck: Liefert den internen Task-Bezeichner der Vater-Task der Benutzer- 
          Task. Beispiel: 
 
             save ("datei", father) 
 
   TASK PROC father (TASK CONST task) 
   Zweck: Liefert den internen Task-Bezeichner von 'task'. Beispiel: 
 
          save ("datei", father (father))    (* Kopiert 'datei' zum "Opa" *) 
 
fetch 
   PROC fetch (TEXT CONST name) 
   Zweck: Einbringen einer Datei in die Benutzer-Task von dem "direkten" 
          Vater im Taskbaum. 
   Fehlerfälle: 
        * ... gibt es nicht 
          Die Datei existiert bei dem Vater nicht. 
        * directory overflow 
          Die Anzahl der zulässigen Dateien der Benutzer-Task ist über- 
          schritten. 
        * wrong password 
          Es wurde mit der Prozedur 'enter password' nicht das richtige 
          Paßwort angegeben. 
 
   PROC fetch (TEXT CONST name, TASK CONST task) 
   Zweck: Kopieren einer Datei in die Benutzer-Task von 'task'. Beispiel: 
 
            fetch ("datei", public) 
 
   PROC fetch (THESAURUS CONST thesaurus) 
   Zweck: Holt alle im 'thesaurus' enthaltenen Dateien von der Vater-Task. 
 
   PROC fetch (THESAURUS CONST thesaurus, TASK CONST manager) 
   Zweck: Holt alle im 'thesaurus' enthaltenen Dateien von der 'manager'- 
          Task. 
 
forget (F) 
   PROC forget (TEXT CONST name) 
   Zweck: Löschen einer Datei mit dem Namen 'name' in der Benutzer-Task. 
   Fehlerfälle: 
        * ... gibt es nicht 
          Die Datei mit dem Namen 'name' existiert nicht in der Benutzer- 
          Task. 
 
   PROC forget (DATASPACE VAR ds) 
   Zweck: Löschen des Datenraums 'ds'. 
 
   PROC forget (THESAURUS CONST thesaurus) 
   Zweck: Löscht die im 'thesaurus' enthaltenen Dateinamen in der Benutzer- 
          Task. Beispiel: 
 
            forget (SOME myself) 
 
   PROC forget (TEXT CONST file name, QUIET CONST q) 
   Zweck: Löschen der Datei 'file name' ohne Anfrage. Als zweiter Parameter 
          muß 'quiet' übergeben werden. Beispiel: 
 
            forget ("hugo", quiet) 
 
get (F) 
   PROC get (FILE VAR f, INT VAR number) 
   Zweck: Lesen eines INT-Wertes 'number' von der Datei 'f'. 
 
   PROC get (FILE VAR f, REAL VAR number) 
   Zweck: Lesen eines REAL-Wertes 'number' von der Datei 'f'. 
 
   PROC get (FILE VAR f, TEXT VAR text) 
   Zweck: Lesen eines TEXT-Wertes 'text' von der Datei 'f'. 
 
   PROC get (FILE VAR f, TEXT VAR text, TEXT CONST delimiter) 
   Zweck: Lesen eines TEXT-Wertes 'text' von der Datei 'f', bis das Zeichen 
          'delimiter' angetroffen wird. Ein eventueller Zeilenwechsel in der 
          Datei  wird dabei nicht übergangen. 
 
   PROC get (FILE VAR f, TEXT VAR text, INT CONST maxlength) 
   Zweck: Lesen eines TEXT-Wertes 'text' von der Datei 'f' mit 'maxlength' 
          Zeichen. Ein eventueller Zeilenwechsel in der Datei wird dabei 
          nicht übergangen. 
 
getline (F) 
   PROC get line (FILE VAR file, TEXT VAR record) 
   Zweck: Lesen einer Zeile 'record' von einer sequentiellen Datei 'file'. 
          Die Datei muß mit 'input' assoziiert sein (vergl. 'sequential 
          file'). 
  Fehlerfälle: 
        * file not open 
          Die Datei 'file' ist gegenwärtig nicht assoziiert. 
        * input after end of file 
          Es wurde versucht, über die letzte Zeile einer Datei zu lesen. 
        * input access to output file 
          Es wurde versucht, von einem mit 'output' assoziierten FILE zu 
          lesen.   
 
global manager 
   PROC global manager 
   Zweck: Durch den Aufruf der Prozedur wird die Benutzer-Task zu einem 
          Datei-Manager. Danach können Söhne dieser Task eingerichtet 
          werden. 
 
input (F) 
   PROC input (FILE VAR f) 
   Zweck: Ändern der Verarbeitungsart von 'modify' oder 'output' in 'input'. 
          Dabei wird auf den ersten Satz der Datei positioniert. 
 
   TRANSPUTDIRECTION CONST input 
   Zweck: Assoziierung in Zusammenhang mit der Prozedur 'sequential file' 
          einer sequentiellen Datei mit der 'TRANSPUTDIRECTION' 'input' (nur 
          lesen). 
 
insert record (F) 
   PROC insert record (FILE VAR file) 
   Zweck: Es wird ein leerer Satz in die Datei 'file' vor die aktuelle 
          Position eingefügt. Dieser Satz kann anschließend mit 'write 
          record' beschrieben werden (d.h. der neue Satz ist jetzt der 
          aktuelle Satz). Die Datei 'file' muß mit der Verarbeitungsart 
          'modify' assoziiert worden sein. 
 
line no (F) 
   INT PROC line no (FILE CONST file) 
   Zweck: Liefert die aktuelle Zeilennummer. 
 
line (F) 
   PROC line (FILE VAR file) 
   Zweck: Positionierung auf die nähhste Zeile der Datei 'file'. Die Datei 
          'file' darf mit 'output' oder 'input' assoziiert sein. Wird ver- 
          sucht, über das Ende eines mit 'input' assoziierten FILEs zu 
          positionieren, wird keine Aktion vorgenommen. 
 
   PROC line (FILE VAR file, INT CONST lines) 
   Zweck: Positionierung auf 'lines' nächste Zeilen der Datei 'file'. Die 
          Datei 'file' darf mit 'output' oder 'input' assoziiert sein. Wird 
          versucht, über das Ende eines mit 'input' assoziierten FILEs zu 
          positionieren, wird keine Aktion vorgenommen. Ist 'lines' <= 0, 
          wird keine Aktion durchgeführt. 
 
lines (F) 
   PROC lines (FILE VAR f) 
   Zweck: Liefert die Anzahl der Zeilen der Datei 'f'. 
 
list 
   PROC list 
   Zweck: Listet alle Dateien der Benutzer-Task mit Namen und Datum des 
          letzten Zugriffs auf dem Terminal auf. 
 
   PROC list (FILE VAR f) 
   Zweck: Schreibt alle Dateien der Benutzer-Task mit Namen und Datum der 
          letzten Änderung in die Datei 'f'. 
 
   PROC list (TASK CONST task) 
   Zweck: Listet alle Dateien der angegebenen 'task' mit Namen und Datum der 
          letzten Änderung auf dem Terminal auf. Beispiel: 
 
            list (father) 
 
max line length (F) 
   INT PROC max line length (FILE CONST file) 
   Zweck: Informationsprozedur über die Anzahl von Zeichen in einer Zeile 
          der Datei 'file'. Standardmäßig sind die Anzahl der Zeichen einer 
          Zeile wie beim Editor 77 Zeichen. 
 
   PROC max line length (FILE VAR file, INT CONST number) 
   Zweck: Setzen der Anzahl von Zeichen einer Zeile in dem FILE 'file'. 
 
modify (F) 
   TRANSPUTDIRECTION CONST modify 
   Zweck: Diese Betriebsrichtung erlaubt das Vorwärts- und Rückwärts-Posi- 
          tionieren und das beliebige Einfügen und Löschen von Sätzen. 
          'modify' wird für die Assoziierungsprozedur 'sequential file' 
          benötigt.   
 
   PROC modify (FILE VAR f) 
   Zweck: Ändern der Betriebsrichtung von 'input' oder 'output' in die Be- 
          triebsrichtung 'modify'. 
 
myself 
   TASK PROC myself 
   Zweck: Liefert den internen Task-Bezeichner der Benutzer-Task. Beispiel: 
 
            save (ALL myself, father) 
 
name 
   TEXT PROC name (TASK CONST task) 
   Zweck: Liefert den TEXT-Namen von 'task'. Beispiel: 
 
             put (name (myself)) 
 
new (F) 
   DATASPACE PROC new (TEXT CONST name) 
   Zweck: Richtet eine neue Datei in der Benutzer-Task ein. 
   Fehlerfälle: 
        * file already exists 
          Die Datei mit dem Namen 'name' existiert bereits in der Benutzer- 
          Task. 
        * directory overflow 
          Die Anzahl der zulässigen Dateien in der Benutzer-Task ist über- 
          schritten. 
 
nilspace (F) 
   DATASPACE CONST nilspace 
   Zweck: Liefert einen leeren Datenraum. 
 
old (F) 
   DATASPACE PROC old (TEXT CONST name) 
   Zweck: Eine bereits vorhandene Datei der Benutzer-Task wird erneut zur 
          Bearbeitung angemeldet. 
   Fehlerfälle: 
        * ... gibt es nicht 
          Die Datei mit dem Namen 'name' ist nicht in der Benutzer-Task 
          vorhanden. 
 
output (F) 
   PROC output (FILE VAR file) 
   Zweck: Ändern der Verarbeitungsart von 'input' oder 'modify' in 'output'. 
          Dabei wird hinter den letzten Satz der Datei positioniert. 
 
   TRANSPUTDIRECTION CONST output 
   Zweck: In Verbindung mit der Prozedur 'sequential file' kann eine Datei 
          assoziiert werden mit der Betriebsrichtung 'output' (nur 
          schreiben). 
 
pattern found 
   BOOL PROC pattern found 
   Zweck: Liefert TRUE, sofern die letzte Suchoperation (siehe 'down' und 
          'up') erfolgreich war, sonst FALSE. 
 
printer 
   TASK PROC printer 
   Zweck: Liefert den internen TASK-Bezeichner der SPOOLer-Task für den 
          Drucker. Beispiel: 
 
            save ("datei", printer) 
 
public 
   TASK PROC public 
   Zweck: Liefert den internen Task-Bezeichner von "PUBLIC". Beispiel: 
 
             fetch ("datei", public) 
 
put (F) 
   PROC put (FILE VAR f, INT CONST number) 
   Zweck: Ausgabe eines INT-Wertes 'number' in die Datei 'f'. Dabei wird ein 
          Leerzeichen an die Ausgabe angefügt. 
 
   PROC put (FILE VAR f, REAL CONST number) 
   Zweck: Ausgabe eines REAL-Wertes 'number' in die Datei 'f'. Dabei wird 
          ein Leerzeichen an die Ausgabe angefügt. 
 
   PROC put (FILE VAR f, TEXT CONST text) 
   Zweck: Ausgabe eines TEXT-Wertes 'text' in die Datei 'f'. Dabei wird ein 
          Leerzeichen an die Ausgabe angefügt. 
 
putline (F) 
   PROC putline (FILE VAR file, TEXT CONST record) 
   Zweck: Ausgabe eines TEXTes 'record' in die Datei 'file'. 'file' muß mit 
          'output' assoziiert sein. 
   Fehlerfälle: 
        * file not open 
          Die Datei 'file' ist gegenwärtig nicht assoziiert. 
        * output access to input file 
          Es wurde versucht, auf einen mit 'input' assoziierten FILE zu 
          schreiben. 
 
read record (F) 
   PROC read record (FILE CONST file, TEXT VAR record) 
   Zweck: Liest den aktuellen Satz der Datei 'file' in den TEXT 'record'. 
          Die Position wird dabei nicht verändert. Die Datei 'file' muß mit 
          der Verarbeitungsart 'modify' assoziiert worden sein. 
 
reinsert (F) 
   PROC reinsert (FILE VAR f) 
   Zweck: Einfügen von "vorsichtig gelöschten" Zeilen (vergl. 'remove') an 
          der aktuellen Position. 
 
release 
   PROC release (TASK CONST task) 
   Zweck: Aufgabe der Reservierung des Archivs. Ein implizites 'release' 
          wird automatisch fünf Minuten nach der letzten Archiv-Operation 
          gegeben, sofern ein 'archive' eines anderen Nutzers vorliegt. 
          Beispiel: 
 
             release (archive) 
 
rename (F) 
   PROC rename (TEXT CONST oldname, newname) 
   Zweck: Umbenennen einer Datei von 'oldname' in 'newname'. 
 
remainder 
   THESAURUS PROC remainder 
   Zweck: Liefert nach der Unterbrechung einer Thesaurus-Operation den 
          "Rest"-Thesaurus. 
 
reorganize (F) 
   PROC reorganize (TEXT CONST filename) 
   Zweck: Reorganisiert eine Datei. Die durch eventuelles Einfügen und 
          Löschen entstandene Lücken werden eliminiert und die Anordung der 
          Sätze der Datei wird linearisiert. 
 
reset (F) 
   PROC reset (FILE VAR file) 
   Zweck: Positionieren in einem FILE auf den Anfang (bei mit 'input' asso- 
          ziierten FILEs) oder auf das Ende (bei mit 'output' assoziierten 
          FILEs).   
 
reset range (F) 
   PROC reset range (FILE VAR file) 
   Zweck: Setzt alle Einschränkungen auf 'file' zurück. Siehe auch 'set 
          range'. 
 
remove (F) 
   PROC remove (FILE VAR f, INT CONST anzahl) 
   Zweck: Löscht eine 'anzahl' von Zeilen "vorsichtig" aus der Datei 'f', 
          die mit 'reinsert' an anderer Stelle wieder eingesetzt werden 
          können. 
 
save 
   PROC save (TEXT CONST datei) 
   Zweck: Datei 'datei' wird an die unmittelbare Vater-Task übertragen. 
   Fehlerfälle: 
        * ... gibt es nicht 
          Eine Datei mit dem Namen 'datei' existiert nicht in der Benutzer- 
          Task. 
        * directory overflow 
          Die Anzahl der zulässigen Dateien in 'task' ist überschritten. 
        * wrong password 
          Es wurde mit der Prozedur 'enter password' nicht das richtige 
          Paßwort angegeben. 
 
   PROC save (TEXT CONST name, TASK CONST task) 
   Zweck: Datei mit dem Namen 'name' in Task 'task' kopieren. Beispiel: 
 
            save ("meine datei", father) 
 
   Fehlerfälle: 
        * ... gibt es nicht 
          Eine Datei mit dem Namen 'name' existiert nicht in der Benutzer- 
          Task. 
        * directory overflow 
          Die Anzahl der zulässigen Dateien in der angegebenen task ist 
          überschritten. 
        * wrong password 
          Es wurde mit der Prozedur 'enter password' nicht das richtige 
          Paßwort angegeben. 
 
   PROC save (THESAURUS CONST thesaurus) 
   Zweck: Kopiert die Dateien, die in 'thesaurus' enthalten sind, in die 
          Vater-Task. Beispiel: 
 
            save (SOME myself) 
 
   PROC save (THESAURUS CONST thesaurus, TASK CONST manager) 
   Zweck: Kopiert die Dateien, die in 'thesaurus' enthalten sind, in Task 
          'manager'. 
 
segments (F) 
   INT PROC segments (FILE CONST f) 
   Zweck: Liefert die Anzahl der Datei-Segmente von 'f'. Nach 'reorganize' 
          besteht 'f' aus einem Segment. Einfügungen oder Löschungen 
          erhöhen die Segmentanzahl. 
 
sequential file (F) 
   FILE PROC sequential file (TRANSPUTDIRECTION CONST mode, DATASPACE VAR ds) 
   Zweck: Assoziierung einer sequentiellen Datei mit dem Dataspace 'ds' und 
          der Betriebsrichtung 'TRANSPUTDIRECTION' (vergl. 'modify', 'input' 
          bzw. 'output'). Diese Prozedur dient zur Assoziierung eines tempo- 
          rären Datenraums in der Benutzer-Task, der nach der Beendigung 
          des Programmlaufs nicht mehr zugriffsfähig ist (weil der Name des 
          Datenraums nicht mehr ansprechbar ist). Somit muß der Datenraum 
          explizit vom Programm gelöscht werden. 
 
   FILE PROC sequential file (TRANSPUTDIRECTION CONST mode, TEXT CONST name) 
   Zweck: Assoziierung einer sequentiellen Datei mit dem Namen 'name' und 
          der Betriebsrichtung 'TRANSPUTDIRECTION' (vergl. 'input' bzw. 
          'output'). Existiert der FILE bereits, dann wird mit 'input' auf 
          den Anfang des FILEs, bei 'output' hinter den letzten Satz der 
          Datei positioniert. Existiert dagegen der FILE noch nicht und ist 
          die TRANSPUTDIRECTION 'output', wird ein neuer FILE eingerichtet. 
   Fehlerfall: 
        * input file not existing 
          Es wurde versucht, einen nicht vorhandenen FILE mit 'input' zu 
          assoziieren. 
 
set range (F) 
   PROC set range (FILE VAR f, INT CONST anz, INT CONST column, FRANGE VAR b) 
   Zweck: Schränkt die Datei 'f' auf 'anz' Zeilen beginnend bei der Position 
          'column' der aktuellen Zeile. Der "alte" Datei-Bereich wird in 'b' 
          gespeichert. 
 
   PROC set range (FILE VAR f, FRANGE VAR b) 
   Zweck: Setzt die Datei 'f' auf die in 'b' gespeicherten Bereich zurück. 
 
son 
   TASK PROC son (TASK CONST task) 
   Zweck: Liefert den internen Task-Bezeichner der Sohn-Task. Beispiel: 
 
             put (name (son (myself))) 
 
SOME 
   THESAURUS OP SOME (THESAURUS CONST thesaurus) 
   Zweck: Bietet den angegebenen 'thesaurus' zum Editieren an. Dabei können 
          nicht erwünschte Namen gestrichen werden. 
 
   THESAURUS OP SOME (TASK CONST task) 
   Zweck: Bietet einen THESAURUS von 'task' zum Editieren an. 
 
   THESAURUS OP SOME (TEXT CONST file name) 
   Zweck: Bietet einen 'thesaurus', der aus 'file name' gebildet wird, zum 
          editieren an. 
 
to line (F) 
   PROC to line (FILE VAR f, INT CONST number) 
   Zweck: Positionierung auf die Zeile 'number'. Nur erlaubt in der 
          Betriebsrichtung 'modify'. 
 
task 
   TASK PROC task (TEXT CONST task name) 
   Zweck: Liefert den internen Task-Bezeichner von 'task name'. Beispiel: 
 
             save ("datei", task ("PUBLIC")) 
 
             (* das gleiche wie:   *) 
 
             save ("datei", public) 
 
type (F) 
   INT PROC type (DATASPACE CONST ds) 
   Zweck: Liefert den frei wählbaren (INT-) Schlüssel des Datenraums 'ds'. 
          Wurde der Datenraum noch nie angekoppelt, so liefert die Prozedur 
          'type' einen Wert < 0, erfolgte eine Ankopplung und hat ein 
          Programmierer für den Datenraum 'ds' noch keinen anderen Schlüssel 
          festgelegt, so liefert 'type' den Wert '0'. 
 
   PROC type (DATASPACE CONST ds, INT CONST type) 
   Zweck: Setzt den frei wählbaren Schlüssel 'type' für den Datenraum 'ds' 
          (vergl. obige Prozedur 'type'). 
 
up (F) 
   PROC up (FILE VAR f) 
   Zweck: Positionieren um eine Zeile rückwärts in der Datei 'f'. 
 
   PROC up (FILE VAR f, INT CONST number) 
   Zweck: Positionieren um 'number' Zeilen rückwärts in der Datei 'f'. 
 
   PROC up (FILE VAR f, TEXT CONST pattern) 
   Zweck: Suche nach 'pattern' rückwärts in der Datei 'f'. Wird 'pattern' 
          gefunden, ist die Position das erste Zeichen von 'pattern'. 
          Andernfalls steht man auf dem ersten Zeichen der Datei. Achtung: 
          'down' sucht vom nächsten Zeichen links ab, so daß wiederholtes 
          Suchen keine Endlosschleife ergibt. 
 
   PROC up (FILE VAR f, TEXT CONST pattern, INT CONST number) 
   Zweck: Wie obiges 'up', aber maximal nur 'number'-Zeilen weit. 
 
uppety (F) 
   PROC uppety (FILE VAR f, TEXT CONST pattern) 
   Zweck: Suche nach 'pattern' rückwärts in der Datei 'f'. Wird 'pattern' 
          gefunden, ist die Position das erste Zeichen von 'pattern'. 
          Andernfalls steht man auf dem ersten Zeichen der Datei. Achtung: 
          'uppety' sucht (im Gegensatz zu 'up') vom aktuellen Zeichen. 
 
   PROC uppety (FILE VAR f, TEXT CONST pattern, INT CONST number) 
   Zweck: Wie obiges 'uppety', aber maximal nur 'number'-Zeilen weit. 
 
word (F) 
    TEXT PROC word (FILE CONST f) 
    Zweck: Liefert das aktuelle Wort (bis zum nächsten Leerzeichen oder 
           Zeilenende). 
 
    TEXT PROC word (FILE CONST f, TEXT CONST sep) 
    Zweck: Liefert einen Text von der aktuellen Position bis zum nächsten 
           'sep-Zeichen oder Zeilenende. 
 
    TEXT CONST word (FILE CONST f, INT CONST len) 
    Zweck: Liefert einen Text von der aktuellen Position mit der Länge 'len' 
           bzw. bis zum Zeilenende. 
 
write (F) 
   PROC write (FILE VAR f, TEXT CONST text) 
   Zweck: Schreibt 'text' in die Datei 'f' (analog 'put (f, text)'), aber 
          ohne Trennblank. 
 
write record (F) 
   PROC write record (FILE VAR file, TEXT CONST record) 
   Zweck: Schreibt einen Satz in die Datei 'file' an die aktuelle Position. 
          Dieser Satz muß bereits vorhanden sein, d.h. mit 'write record' 
          kann keine leere Datei beschrieben werden, sondern es wird der 
          Satz an der aktuellen Position überschrieben. Die Position in der 
          Datei wird nicht verändert. Die Datei 'file' muß mit der Verar- 
          beitungsart 'modify' assoziiert worden sein.