Initial import

12 files changed, 11312 insertions, 0 deletions

diff --git a/doc/programmer-manual/1.8.7/doc/programmierhandbuch.1 b/doc/programmer-manual/1.8.7/doc/programmierhandbuch.1
new file mode 100644
index 0000000..24f2b03
--- /dev/null
+++ b/doc/programmer-manual/1.8.7/doc/programmierhandbuch.1
@@ -0,0 +1,650 @@
+#headandbottom("1","EUMEL-Benutzerhandbuch","TEIL 1 : Einleitung","1")# 
+#pagenr("%",1)##setcount(1)##block##pageblock# 
+#headeven# 
+#center#EUMEL-Benutzerhandbuch 
+#center#____________________________________________________________ 
+ 
+#end# 
+#headodd# 
+#center#TEIL 1 : Einleitung 
+#center#____________________________________________________________ 
+ 
+#end# 
+#bottomeven# 
+#center#____________________________________________________________ 
+1 - % #right#GMD 
+#end# 
+#bottomodd# 
+#center#____________________________________________________________ 
+GMD #rigth#1 - % 
+#end# 
+ 
+TEIL 1 : Einleitung 
+ 
+ 
+1.1  Allgemeines über EUMEL 
+ 
+Dieses Buch bietet eine Übersicht über die Standardprozeduren des Betriebssystem
+EUMEL. Es bietet damit sowohl Hilfestellung für die Benutzung der standardmäßig
+vorhandenen Kommandos als auch für die Programmierung, also die Erweiterung
+dieses Kommandovorrats. Es ist jedoch kein Lehrbuch der Programmierung! 
+ 
+In den ersten drei Kapiteln dieses Programmierhandbuches werden einige Grund­
+begriffe des Systems, die grundlegende Programmiersprache (ELAN) und der
+EUMEL-Editor erläutert. 
+ 
+Das vierte Kapitel bietet eine Übersicht über diejenigen Prozeduren und Operatoren,
+die eher der 'Job-Control-Language' zugerechnet werden können, also häufig im
+Kommandodialog benutzt werden. 
+ 
+Im fünften Teil sind diejenigen Operationen beschrieben, die meistenteils für die
+Programmierung benutzt werden. (Compiler, Operationen auf den elementaren Daten­
+typen, Dateien, Ein- und Ausgabe usw.). 
+ 
+Diese Trennung ist jedoch recht willkürlich, es ist ja gerade eine der wichtigen Eigen­
+schaften dieses Betriebssystems, daß es keine Trennung zwischen der Kommando­
+sprache des Betriebssystems und Programmmiersprache für das System gibt. Jedes
+Systemkommando ist Aufruf einer ELAN Prozedur, jede neue Prozedur stellt eine
+Erweiterung des Kommandovorrats des Systems dar. 
+ 
+Aus Gründen der Übersichtlichkeit der Zusammenstellung ist dieses Buch nicht frei
+von Vorwärtsverweisen! 
+ 
+#page# 
+ 
+1.2  Struktur des Betriebssystems EUMEL  
+ 
+Grundlegend für das Verständnis des Betriebssystems EUMEL ist der Begriff der
+#on("b")#Task#off("b")#. Eine Task kann als theoretisch unendliche Wiederholung eines Systempro­
+gramms der Form: 
+ 
+         'nimm Kommando entgegen' 
+         'verarbeite Kommando' 
+ 
+aufgefaßt werden. Einige Tasks existieren bereits als Grundstock des Systems,
+weitere werden von Benutzern des Systems erschaffen und dienen als persönliche
+Arbeitsumgebung für den 'Eigentümer'. Eine Task kann als benutzereigener, unab­
+hängiger Computer im Computer betrachtet werden, denn sie kann Kommandos
+entgegennehmen und ausführen und Daten verwalten und aufbewahren. 
+ 
+Eine Task kann neu erzeugt werden, an einen Bildschirm gekoppelt werden und
+beendet werden. 
+ 
+Das Tasksystem ist in einer baumartigen Struktur angeordnet. Außer der Wurzel 'UR'
+hat jede Task einen Vorgänger ('Vater-Task') und möglicherweise Nachfolger
+('Sohn-Tasks'). 
+ 
+#on("u")##ib#Task-Organisation#ie##off("u")# 
+ 
+ 
+       SUPERVISOR 
+             - 
+           SYSUR 
+               ARCHIVE 
+               configurator 
+               OPERATOR 
+               shutup 
+ 
+       UR 
+           PUBLIC 
+               Benutzertask1 
+               Benutzertask2 
+                   Benutzertask3 
+                 ..... 
+ 
+ 
+ 
+Jeder Benutzer arbeitet innerhalb eines EUMEL-Systems, indem er eine Task an
+sein Terminal koppelt und dort Programme aufruft. 
+ 
+Dateien sind grundsätzlich Eigentum einer Task. Es ist grundlegend für das Verständ­
+nis des Betriebssystems EUMEL, die Beziehung zwischen Tasks und Dateien zu
+erkennen. 
+ 
+Eine Task ist ein Prozeß, der gegebenenfalls Dateien besitzt. Dateien können nur in
+einer Task existieren. Um eine Datei einer anderen Task zur Verfügung zu stellen,
+wird eine Kopie der Datei an die andere Task geschickt, die sendende Task ist da­
+nach Eigentümer des 'Originals', die empfangende Task Eigentümer der 'Kopie'. 
+ 
+Soll eine Hierarchie von Dateien aufgebaut werden, so ist sie über eine Hierarchie
+von Tasks zu realisieren, da in einer Task alle Dateien gleichberechtigt sind. 
+ 
+Bis zu dieser Stelle war stets von Dateien die Rede. Dateien sind jedoch ein Spezial­
+fall der grundlegenderen Struktur des Datenraumes. 
+ 
+Ein #ib#Datenraum#ie# ist ein allgemeiner Datenbehälter. Ein Datenraum kann beliebige
+Daten aufnehmen und erlaubt direkten Zugriff auf diese Daten. Die Struktur der Daten
+im Datenraum unterscheidet sich nicht von der Struktur der Programmdaten. Der
+'innere Datentyp' eines Datenraums wird vom Programmierer festgelegt. 
+ 
+Vorgeprägt vom System gibt es Textdateien, jeder andere Datentyp muß vom Pro­
+grammierer geprägt werden, um so Dateien erzeugen zu können, die Objekte eben
+dieses neuen Typs enthalten. 
+#page# 
+ 
+ 
+1.3  Eigenschaften des Betriebssystems 
+ 
+Der erste Entwurf des Mikroprozessor-Betriebssystems EUMEL (#on("b")#E#off("b")#xtendable multi
+#on("b")#U#off("b")#ser #on("b")#M#off("b")#icroprozessor #on("b")#EL#off("b")#AN system) entstand 1979 mit dem Anspruch, auf Mikrocom­
+putern den Anwendern Hilfsmittel und Unterstützungen zu bieten, wie sie sonst nur
+auf Großrechnern zur Verfügung gestellt werden. 
+ 
+Aspekte, die EUMEL von anderen Betriebssystemen für Mikrocomputer unterscheiden,
+sind: 
+ 
+- Hardwareunabhängigkeit 
+- Multitaskingkonzept 
+- Multiuserbetrieb 
+- Erweiterbarkeit 
+- virtuelle Speicherverwaltung 
+- Datensicherheit 
+ 
+ 
+ 
+#on("u")##on("b")#Das EUMEL-Schichtenmodell#off("b")##off("u")# 
+ 
+Die Hardwareunabhängigkeit des Betriebssystems EUMEL begründet sich in seinem
+Aufbau aus Schichten (sogenannten virtuellen Maschinen), die einen klar definierten
+Leistungsumfang haben. 
+ 
+#center#beliebige Anwendungen 
+#center#Textverarbeitung, Datenbanken etc. 
+ 
+#center#Systemdienste: Monitor, Dateiverwaltung, Editor 
+#center#Task-System 
+#center#Standardpakete (BOOL, INT, REAL, TEXT) 
+#center#ELAN-Compiler 
+ 
+#center#EUMEL0 
+#center#(virtueller Prozessor mit eigenem Befehlssatz) 
+ 
+#center#SHard (Gerätetreiber) 
+ 
+#center#Hardware 
+ 
+ 
+Jede Schicht erwartet und erhält von ihren Nachbarn wohldefinierte Eingaben und gibt
+wohldefinierte Ausgaben weiter. Änderungen in einer Schicht müssen also in den
+angrenzenden Schichten beachtet werden, aber nicht in allen Teilen des Systems. 
+ 
+Um EUMEL auf Rechner mit einem neuen Prozessortyp zu portieren, wird zunächst
+eine auf die Eigenheiten des Prozessors abgestimmte EUMEL0-Maschine entworfen
+und eine Hardwareanpassung (#ib#SHard#ie# : Software/Hardware-Interface) für einen
+Rechner mit diesem Prozessor hergestellt. Alle höheren Schichten des Systems
+bleiben unberührt. Weitere mit diesem Prozessortyp ausgestattete Rechner können mit
+EUMEL betrieben werden, indem ein SHard für dieses Rechnermodell geschrieben
+wird. 
+ 
+Aus Benutzersicht ist wichtig, daß dadurch jegliche Software, die auf irgendeinem
+Rechner unter EUMEL verfügbar ist, auf jedem anderen Rechner, für den eine
+EUMEL Portierung existiert, lauffähig ist und gleiches Verhalten zeigt. Eine Vernet­
+zung beliebiger Rechner, auf die EUMEL portiert ist, ist problemlos möglich. 
+ 
+Desweiteren ist für den Benutzer des Systems von Bedeutung, daß er von der hard­
+warenahen Schicht entfernt ist. Weder die Programmiersprache noch irgendwelche
+speziellen Systemfunktionen gewähren direkten Zugriff auf den Speicher oder Regi­
+sterinhalte. Diese Tatsache hat weitreichende Folgen in Hinsicht auf Datenschutz und
+Systemsicherheit. 
+ 
+ 
+ 
+ 
+Multi-Tasking-/Multi-User-Betrieb 
+Wie einleitend dargestellt, besteht ein EUMEL-System aus diversen Tasks. Durch
+eine Aufteilung der Prozessorzeit in Zeitscheiben ist eine (quasi) parallele Bedienung
+mehrerer Tasks möglich. 
+ 
+Die multi-user-Fähigkeit des Betriebssystems wird durch den Anschluß mehrerer
+Bildschirmarbeitsplätze (Terminals) an V.24 Schnittstellen des Rechners erreicht.
+Dabei wird jeder Schnittstelle eine sogenannte Kanalnummer zugeordnet. Jeder
+Benutzer kann seine Task dann an einen Kanal (=Terminal) koppeln und an diesem
+Terminal gleichzeitig mit anderen Benutzern arbeiten. 
+ 
+ 
+ 
+ 
+Prozeßkommunikation und Netzwerkfähigkeit 
+Grundlage der Kommunikation ist die 'Manager-Eigenschaft' von Tasks. Eine Task
+ist 'Manager', wenn sie Aufträge anderer Tasks annehmen und ausführen kann.
+Insbesondere kann ein Manager veranlaßt werden, eine an ihn geschickte Datei anzu­
+nehmen, bzw. eine ihm gehörende Datei an die fordernde Task zu schicken. 
+ 
+Derartige Kommunikationslinien verlaufen normalerweise in der Baumstruktur des
+Systems: z.B. ist die Task 'PUBLIC' (vergl. Seite 2) grundsätzlich Manager-Task.
+Eine unterhalb von PUBLIC liegende Task kann eine Datei an PUBLIC senden, bzw.
+von PUBLIC holen. 
+ 
+Es ist auch möglich, eine Task für den Zugriff beliebiger anderer Tasks zu öffnen und
+somit beliebige Kommunikationspfade aufzubauen. Prinzipiell ist damit auch schon der
+Aufbau eines Netzwerkes beschrieben, denn sendende und empfangende Tasks
+können sich auf verschiedenen Rechnern befinden. 
+ 
+Durch selbst erstellte Programme kann der Eigentümer einer 'Manager-Task' die
+Reaktion dieser Task auf einen Auftrag von außen bestimmen. Beispielsweise kann
+ein Manager derart programmiert werden, daß er nur Dateien empfängt und ausdruckt,
+aber niemals Dateien verschickt (Spool-Task). 
+ 
+ 
+ 
+Erweiterbarkeit 
+Die Programmiersprache ELAN ist im EUMEL-System gleichzeitig Programmier-
+und System-Kommandosprache (JCL), denn jedes Kommando ist Aufruf einer
+ELAN-Prozedur und jede vom Benutzer geschriebene ELAN-Prozedur erweitert
+den Kommandovorrat des Systems. 
+ 
+Da alle EUMEL-Werkzeuge (einschließlich Editor) selbst ELAN-Programme sind,
+kann das System vom Benutzer selbst durch Hinzufügen eigener ELAN-Programme
+oder Programmpakete beliebig erweitert werden. Dabei können die bereits implemen­
+tierten Systemteile (z.B. die Fenstertechnik des Editors) genutzt werden. 
+ 
+Ein Benutzer muß, um alle Möglichkeiten vom EUMEL zu nutzen, nur eine Sprache
+lernen und nicht - wie bei anderen Betriebssystemen - zwei unterschiedliche, eine
+Kommando- und eine Programmiersprache. 
+ 
+ELAN selbst ist eine PASCAL-ähnliche Programmiersprache, die mit Hilfe der
+schrittweisen Verfeinerung (Refinement-Konzept) die Top-Down-Programmierung
+unterstützt. Das Paketkonzept, das der Modularisierung dient, und die freie Wahl von
+Bezeichnernamen sind Voraussetzung für übersichtliche und effiziente Programmie­
+rung. 
+ 
+ 
+ 
+ 
+Virtuelle Speicherverwaltung 
+Im EUMEL-System wird der Hauptspeicherplatz nach dem #on("b")#Demand-Paging-Prinzip#off("b")#
+verwaltet. Daten und Programme werden dazu in Seiten von 512 Byte aufgeteilt. Nur
+diejenigen Seiten, die wirklich benötigt werden, werden vom Hintergrundspeicher
+(Platte) in den Hauptspeicher geholt. Damit ist für den Benutzer bezüglich seiner
+Programm- bzw. Dateigrößen nicht mehr der Hauptspeicher, sondern die Hinter­
+grundkapazität von Bedeutung. Die Durchsatzgeschwindigkeit (Performance) ist
+abhängig von der Größe des RAM-Speichers und der Zugriffsgeschwindigkeit des
+Hintergrundmediums. Das Demand-Paging-Verfahren ist Grundlage für den
+Multi-User-Betrieb, wobei der Hauptspeicherplatz möglichst effizient zu nutzen und
+kein Benutzer zu benachteiligen ist. 
+ 
+Beim Duplizieren eines Datenraumes wird im EUMEL-System lediglich eine logische,
+keine physische Kopie erzeugt. Zwei Seiten (zweier Datenräume) heißen dann gekop­
+pelt (geshared), wenn beide Seiten physisch demselben Block zugeordnet sind. Erst
+bei einem Schreibzugriff werden die Seiten entkoppelt (entshared) und tatsächlich
+physisch kopiert. Daher der Name "#on("b")#copy-on-write#off("b")#". 
+ 
+Dieses Prinzip wird natürlich auch systemintern angewandt. Beispielsweise erbt eine
+Sohn-Task den Kommandovorrat der Vater-Task, indem der Standard-Datenraum,
+der die vorübersetzten ELAN-Prozeduren enthält, in der beschriebenen Weise kopiert
+wird. Prozeduren, die später hinzugefügt werden, werden natürlich nicht vererbt, da
+die Standard-Datenräume dann entkoppelt werden. 
+ 
+ 
+ 
+ 
+Datensicherheit 
+Störungen (inklusive Stromausfall) werden systemseitig durch eine automatische
+#on("b")#Fixpoint-Rerun-Logik#off("b")# aufgefangen, indem zum Zeitpunkt eines Fixpunkts der Inhalt
+des RAM Speichers, der seit dem letzten #ib#Fixpunkt#ie# verändert wurde auf den
+permanenten Speicher (Festplatte) geschrieben wird. Somit kann nach einer Störung
+immer auf den Systemzustand des letzten Fixpunktes aufgesetzt werden und die
+Datenverluste halten sich in erträglichen Grenzen. 
+ 
+Der Zeitraum zwischen zwei Fixpunkten beträgt standardmäßig 15 Minuten, kann aber
+vom Benutzer anders eingestellt werden. 
+ 
+Auch bei dieser Sicherung wird das Copy-on-write-Prinzip angewendet, so daß
+Platz- und Zeitaufwand gering sind und den normalen Ablauf nicht stören. 
+ 
+#page# 
+
+1.4  Wichtige Begriffe 
+ 
+-  #on("b")##ib#archive#ie##off("b")#.  Spezielle Task zur Verwaltung des Diskettenlaufwerks. Da für die
+   längerfristige Datenhaltung und zur zusätzlichen Datensicherung Dateien auf
+   Disketten geschrieben werden, besitzt das EUMEL-System für diese Aufgabe
+   eine besondere Task, die die Bedienung vereinfacht und exklusiven Zugriff auf das
+   Laufwerk garantiert. 
+ 
+-  #on("b")##ib#configurator#ie##off("b")#.  Besondere Task im Systemzweig des EUMEL-Systems. In
+   dieser Task ist die #ib#Konfiguration#ie# von Kanälen möglich, d.h. Kanal und
+   angeschlossenenes Gerät werden aufeinander abgestimmt. 
+ 
+-  #on("b")##ib#editor#ie##off("b")#.  Programm zur Dateibearbeitung am Bildschirm. Das Programm wird
+   durch das ( Monitor- ) Kommando 'edit' und die Eingabe des Namens der ge­
+   wünschten Datei als Parameter gestartet. 
+ 
+   Da ein Bildschirm normalerweise auf 80 Zeichen Zeilenbreite und 24 Zeilen be­
+   schränkt ist, kann der Editor als Fenster betrachtet werden, das über die mögli­
+   cherweise weitaus größere Datei bewegt wird und durch das der betrachtete Aus­
+   schnitt der Datei bearbeitet werden kann. 
+ 
+-  #on("b")##ib#manager task#ie##off("b")#.  Task, die Aufträge von anderen Tasks entgegennehmen und
+   ausführen #on("u")#kann#off("u")#. Beispielsweise ist die Verwaltung von Dateien, die mehreren
+   Benutzern (= anderen Tasks) zugänglich sein sollen, eine typische Aufgabe für
+   einen Manager. 
+ 
+-  #on("b")##ib#Monitor#ie##off("b")#. Der Empfänger von Kommandos innerhalb einer Task ist der Monitor. Der
+   Monitor ist sichtbar durch eine Zeile, in der 'gib kommando' steht. In diese Zeile
+   werden #ib#Kommando#ie#s und erforderliche Parameter eingegeben. 
+ 
+-  #on("b")##ib#Supervisor#ie##off("b")#.  Spezielle Task zur Überwachung eines EUMEL-Systems. Ein
+   Benutzer kann durch die Supervisor-Kommandos Leistungen von dieser Task
+   fordern: neue Task einrichten, Task wiederaufnehmen und diverse Informationen. 
+ 
+-  #on("b")##ib#Task#ie##off("b")#.  Beliebig langlebiger Prozeß im EUMEL-System, der die Arbeits­
+   umgebung für Benutzer bildet. Jede Task besitzt einen #ib#Standard-Datenraum#ie#, der
+   Code und Compilertabellen der Task enthält und kann weitere Datenräume
+   (Dateien) besitzen. 
+ 
+#page# 
+
+1.5  Die Notation in diesem Buch 
+ 
+Beachten Sie bitte folgende Regeln der Aufschreibung: 
+ 
+-  Funktionstasten werden ebenso wie besondere Tastenkombinationen explizit als
+   Tasten dargestellt: 
+ 
+      <SV>     <ESC>     <e>     
+ 
+       
+-  Alles, was Sie am Bildschirm Ihres Rechners schreiben oder lesen sollen, ist in
+   Textbereiche, die einen Bildschirm darstellen, eingefaßt. 
+ 
+  Beispiel: 
+ 
+____________________________________________________________________________ 
+    gib kommando: 
+    edit ("mein programm") 
+ 
+____________________________________________________________________________ 
+ 
+ 
+-  Innerhalb des Handbuchs sind in der Aufschreibung die Konventionen der Pro­
+   grammiersprache ELAN berücksichtigt. Dabei sind folgende Besonderheiten zu
+   beachten: 
+ 
+   1) Kommandos werden grundsätzlich klein geschrieben. 
+ 
+   2) Dateinamen u.ä. sind Textdenoter und werden somit in Klammern und Anfüh­
+      rungsstriche gesetzt. In diesem Buch steht an den Stellen, wo ein Dateiname
+      auftaucht #on("i")# 'dateiname' #off("i")#; den Namen, den Sie tatsächlich verwenden, können
+      Sie frei wählen. 
+ 
+   3) Falls besondere Begriffe oder Beispiele innerhalb eines normalen Textes
+      auftreten, werden sie in einfache Anführungsstriche gesetzt. 
+ 
+ 
+#page# 
+
+1.6  Die Funktionstasten des EUMEL-Systems 
+ 
+Die Lage der EUMEL-Funktionstasten entnehmen Sie bitte der speziellen Installa­
+tionsanleitung zu dem von Ihnen benutzten Gerät. #l pos (0.0)##l pos(4.0)# 
+ 
+ 
+<v> <^> <>> <<>    Positionierungstasten 
+#table# 
+ 
+<SHIFT>           Umschalttaste 
+ 
+<CR>              Eingabe-/ Absatztaste 
+ 
+<ESC>             Kommandotaste 
+ 
+<SV>              Supervisortaste 
+ 
+<HOP>             Verstärkertaste 
+ 
+<RUBOUT>          Löschtaste 
+ 
+<RUBIN>           Einfügetaste 
+ 
+<TAB>             Tabulatortaste 
+ 
+<MARK>            Markiertaste 
+ 
+<STOP>            Stoptaste 
+ 
+<WEITER>          Weitertaste 
+#tableend##clear pos# 
+ 
+Weitere Informationen hierzu finden Sie in der Installationsanleitung zu dem von Ihnen
+benutzten Rechner oder Terminal. 
+#page# 
+ 
+1.7  Eine Beispielsitzung 
+ 
+Im Folgenden wird eine Beispielsitzung skizziert, in der ein ELAN-Programm erstellt
+und getestet wird. 
+ 
+  <SV>       SUPERVISOR aufrufen 
+ 
+ 
+ 
+____________________________________________________________________________ 
+ 
+                                           Terminal 2  
+ 
+ 
+                      EUMEL Version 1.8/M 
+ 
+ 
+        gib supervisor kommando: 
+        begin("meine erste Task") 
+ 
+ 
+ 
+   ESC ? --> help 
+   ESC b --> begin("")            ESC h --> halt 
+   ESC c --> continue("")         ESC s --> storage info 
+   ESC q --> break                ESC t --> task info 
+ 
+____________________________________________________________________________ 
+ 
+ 
+ 
+ 
+Durch das Kommando 'begin ("meine erste Task")', welches durch <CR> abgeschlos­
+sen werden muß, wird eine Task mit dem Namen 'meine erste Task' im Benutzer­
+zweig, also unterhalb von 'PUBLIC' angelegt. Würde diese Task bereits existieren, so
+könnten Sie sie mit 'continue ("meine erste Task")' an das Terminal holen. 
+ 
+____________________________________________________________________________ 
+ 
+    gib kommando : 
+    edit ("mein erstes Programm") 
+ 
+____________________________________________________________________________ 
+ 
+ 
+In der Task eröffnen Sie eine Datei mit dem Kommando 'edit ("dateiname")'. 
+ 
+ 
+____________________________________________________________________________ 
+ 
+    gib kommando : 
+    edit ("mein erstes Programm") 
+  "mein erstes Programm" neu einrichten (j/n) ? j 
+ 
+____________________________________________________________________________ 
+ 
+ 
+Falls diese Datei neu ist, erfolgt eine Kontrollfrage (zur Kontrolle der gewünschten
+Schreibweise des Dateinamens), die Sie durch <j> bejahen. 
+ 
+ 
+____________________________________________________________________________ 
+  ............ mein erstes Programm ............... Zeile 1  #markon#    
+_
+____________________________________________________________________________ 
+ 
+ 
+ 
+ 
+ 
+ 
+In die noch leere Datei tippen Sie nun den Programmtext ein. 
+ 
+ 
+____________________________________________________________________________ 
+  ............ mein erstes Programm ............... Zeile 1 
+ _INT PROC ggt (INT CONST a, b): 
+   INT VAR b kopie :: abs (b), a kopie :: abs (a); 
+    WHILE b kopie <> 0 REPEAT 
+      INT VAR rest := a kopie MOD b kopie; 
+      a kopie := b kopie; 
+      b kopie := rest 
+    END REPEAT; 
+   a kopie 
+ END PROC gt; 
+ 
+ REP 
+   lies 2 zahlen ein; 
+   gib groessten gemeinsamen teiler aus 
+ UNTIL no ("weitertesten") PER. 
+ 
+ lies 2 zahlen ein: 
+   line; put ("2 Zahlen eingeben:"); 
+   INT VAR a, b; 
+   get (a); get (b). 
+ 
+ gib groessten gemeinsamen teiler aus: 
+   put ("der größte gemeinsame Teiler von"); 
+   put (a); put ("und"); put (b); put ("ist"); put (ggt (a,b)); 
+   line. 
+ 
+____________________________________________________________________________ 
+ 
+ 
+In dem Programmbeispiel wird ein Prozedur 'ggt' definiert, die den größten gemein­
+samen Teiler zweier Zahlen bestimmt. Die Prozedur soll für verschiedene Beispiele
+getestet werden; dies geschieht in dem Hauptprogramm, das solange Zahlen einliest
+und den größten gemeinsamen Teiler ausgibt, bis der Benutzer auf die Frage 'weiter­
+testen (j/n) ?' mit <n> antwortet. 
+ 
+Haben Sie das Programm eingegeben, so können Sie die Bearbeitung dieser Pro­
+grammdatei durch Drücken der Tasten <ESC> <q> (nacheinander!) beenden. 
+ 
+ 
+____________________________________________________________________________ 
+ 
+   gib kommando : 
+   run ("mein erstes Programm") 
+ 
+____________________________________________________________________________ 
+ 
+ 
+Um Ihr Programm zu übersetzen und auszuführen, geben Sie das Kommando
+'run ("dateiname")'. 
+ 
+Der Verlauf der Übersetzung, die zwei Läufe über das Programm erfordert, ist am
+Zähler, der an der linken Seite des Bildschirms ausgegeben wird, zu erkennen. 
+ 
+Werden beim Übersetzen des Programms Fehler entdeckt, so werden diese im 'note­
+book' parallel zur Programmdatei gezeigt. In dem Beispielprogramm wurde ein
+Schreibfehler in Zeile 9 gemacht. 
+ 
+ 
+____________________________________________________________________________ 
+  ............ mein erstes Programm ............... Zeile 1 
+ _INT PROC ggt (INT CONST a, b): 
+   INT VAR b kopie :: abs (b), a kopie :: abs (a); 
+   WHILE b kopie <> 0 REPEAT 
+      INT VAR rest := a kopie MOD b kopie; 
+      a kopie := b kopie; 
+      b kopie := rest 
+   END REPEAT; 
+   a kopie 
+ END PROC gt; 
+ 
+ REP 
+  .................. notebook ..................... Zeile 1  #markon#    
+   Zeile 9    FEHLER bei >> gt << 
+              ist nicht der PROC Name 
+ 
+ 
+____________________________________________________________________________ 
+ 
+ 
+ 
+Diesen Fehler müssen Sie nun verbessern. 
+ 
+____________________________________________________________________________ 
+  ............ mein erstes Programm ............... Zeile 9 
+ INT PROC ggt (INT CONST a, b): 
+   INT VAR b kopie :: abs (b), a kopie :: abs (a); 
+   WHILE b kopie <> 0 REPEAT 
+      INT VAR rest := a kopie MOD b kopie; 
+      a kopie := b kopie; 
+      b kopie := rest 
+   END REPEAT; 
+   a kopie 
+ END PROC ggt;_ 
+ 
+ REP 
+  .................. notebook ..................... Zeile 1 
+   Zeile 9    FEHLER bei >> gt << 
+              ist nicht der PROC Name 
+ 
+____________________________________________________________________________ 
+ 
+ 
+ 
+ 
+Haben Sie das Programm korrigiert, so können Sie die Datei durch Drücken der
+Tasten <ESC> <q> (nacheinander!) wieder verlassen. 
+ 
+ 
+____________________________________________________________________________ 
+ 
+    gib kommando : 
+    run ("mein erstes Programm") 
+ 
+____________________________________________________________________________ 
+ 
+ 
+Nach Eingabe von <R> wird das Programm erneut übersetzt. 
+ 
+ 
+____________________________________________________________________________ 
+ 
+ Keine Fehler gefunden,  136 B Code, 82 B Paketdaten generiert 
+ 
+ 
+       *******  ENDE DER UEBERSETZUNG  ******* 
+ 
+ 
+ 2 Zahlen eingeben: _ 
+ 
+____________________________________________________________________________ 
+ 
+ 
+Das Programm war jetzt fehlerfrei. Nach der Übersetzung wurde die Ausführung
+gestartet. Nun können Beispiele getestet werden. 
+ 
+____________________________________________________________________________ 
+ 
+ 2 Zahlen eingeben: 125 250 
+ der größte gemeinsame Teiler von 125 und 225 ist 25 
+ weitertesten (j/n) ? 
+ 
+____________________________________________________________________________ 
+ 
+ 
+Beantwortet man die Frage mit <n>, so wird die Ausführung des Programms beendet. 
+ 
+ 
+____________________________________________________________________________ 
+ 
+   gib kommando : 
+ 
+____________________________________________________________________________ 
+ 
+ 
+Um die Arbeit in der Task zu beenden, geben Sie auch an dieser Stelle <ESC> <q>
+(nacheinander!) ein. 
+ 
+Nach Verlassen der Task ist wiederum die EUMEL-Tapete auf dem Bildschirm. Jede
+weitere Aktion wird wiederum von hier aus durch <SV> begonnen. Insbesondere vor
+dem #ib#Ausschalten des Geräts#ie# muß nach <SV> eine Task des priviliegierten System­
+zweigs (oft: '#ib#shutup#ie#') mit <ESC> <c> an das Terminal gekoppelt werden, in der das
+Kommando 'shutup' gegeben wird. 
+
diff --git a/doc/programmer-manual/1.8.7/doc/programmierhandbuch.2a b/doc/programmer-manual/1.8.7/doc/programmierhandbuch.2a
new file mode 100644
index 0000000..a204091
--- /dev/null
+++ b/doc/programmer-manual/1.8.7/doc/programmierhandbuch.2a
@@ -0,0 +1,1845 @@
+#headandbottom("1","EUMEL-Benutzerhandbuch","TEIL 2 : ELAN","2")# 
+#pagenr("%",1)##setcount(1)##block##pageblock# 
+#headeven# 
+#center#EUMEL-Benutzerhandbuch 
+#center#____________________________________________________________ 
+ 
+#end# 
+#headodd# 
+#center#TEIL 2 : ELAN 
+#center#____________________________________________________________ 
+ 
+#end# 
+#bottomeven# 
+#center#____________________________________________________________ 
+2 - % #right#GMD 
+#end# 
+#bottomodd# 
+#center#____________________________________________________________ 
+GMD #right# 2 - % 
+#end# 
+ 
+TEIL 2:  ELAN 
+ 
+2.1  Besondere Eigenschaften von ELAN 
+ 
+Kerneigenschaften von ELAN sind das #ib#Paketkonzept#ie# und die Methode des
+#ib#Refinements#ie#. 
+ 
+#on("b")#Paketkonzept:#off("b")# 
+ELAN bietet die Möglichkeit, neue Datentypen sowie Prozeduren und Operatoren auf
+diesen Datentypen zu definieren. Eine solche Definition von Algorithmen und Daten­
+typen kann zu einer logischen Einheit, einem Paket, zusammengefaßt werden. Pakete
+können in einer Task vorübersetzt werden und erweitern damit automatisch den
+Sprachumfang. 
+ 
+#on("b")#Methode des Refinements:#off("b")# 
+Die Methode des Refinements erlaubt das schrittweise Herleiten von Problemlösungen
+von der jeweils geeigneten Terminologie herunter zu den von ELAN standardmäßig
+angebotenen Sprachelementen. Durch diese Vorgehensweise wird in äußerst starkem
+Maße ein strukturierter Programmentwurf gemäß dem Top-Down-Prinzip gefördert. 
+ 
+Die Programmiersprache ELAN wird im EUMEL-System zu folgenden Zwecken
+eingesetzt: 
+ 
+-  Systemimplementationssprache 
+-  Kommandosprache 
+-  Anwenderprogrammiersprache 
+#page# 
+ 
+2.2  Lexikalische Elemente 
+ 
+Unter lexikalischen Elementen einer Programmiersprache versteht man die Elemente,
+in denen ein Programm notiert wird. 
+ 
+In ELAN sind dies: 
+ 
+-  Schlüsselwörter 
+-  Bezeichner 
+-  Sonderzeichen 
+-  Kommentare 
+ 
+ 
+ 
+ 
+2.2.1  Schlüsselwörter 
+ 
+Einige Wörter haben in ELAN eine feste Bedeutung und können somit nicht frei
+gewählt werden. Solche Wörter werden im EUMEL-System in Großbuchstaben
+geschrieben, Leerzeichen dürfen nicht enthalten sein. 
+ 
+Beispiele: 
+ 
+ 
+VAR 
+INT 
+WHILE 
+ 
+ 
+Wie später beschrieben wird, gibt es in ELAN auch die Möglichkeit, neue Schlüssel­
+wörter einzuführen. 
+ 
+ 
+#page# 
+ 
+2.2.2  Bezeichner 
+ 
+Bezeichner oder Namen werden benutzt, um Objekte in einem Programmtext zu
+benennen und zu identifizieren (z.B: Variablennamen, Prozedurnamen). 
+ 
+Namen werden in ELAN folgendermaßen formuliert: 
+ 
+Das erste Zeichen eines Namens muß immer ein Kleinbuchstabe sein. Danach dürfen
+bis zu 254 Kleinbuchstaben, aber auch Ziffern folgen. Zur besseren Lesbarkeit können
+Leerzeichen in einem Namen erscheinen, die aber nicht zum Namen zählen. Sonder­
+zeichen sind in Namen nicht erlaubt. 
+ 
+Beispiele für #on("b")#korrekte#off("b")# Bezeichner: 
+ 
+ 
+das ist ein langer name 
+x koordinate 
+nr 1 
+ 
+ 
+ 
+Beispiele für #on("b")#falsche#off("b")# Bezeichner: 
+ 
+ 
+x*1 
+1 exemplar 
+Nr 1 
+#page# 
+ 
+2.2.3  Sonderzeichen 
+ 
+Sonderzeichen sind Zeichen, die weder Klein- oder Großbuchstaben, noch Ziffern
+sind. Sie werden in ELAN als Trennzeichen oder als Operatoren benutzt. 
+ 
+In ELAN gibt es folgende Trennungszeichen: 
+ 
+-  das Semikolon (';') trennt Anweisungen 
+-  der Doppelpunkt (':') trennt Definiertes und Definition 
+-  der Punkt ('.') wird als Endezeichen für bestimmte Programmabschnitte, als Dezi­
+   malpunkt und als Selektor-Zeichen für Datenstrukturen benutzt 
+-  das Komma (',') trennt Parameter 
+-  Klammernpaare ('(', ')') werden zum Einklammern von Parameterlisten oder Teil­
+   ausdrücken benutzt 
+-  mit Anführungszeichen ('"') werden Text-Denoter umrahmt 
+-  eckige Klammernpaare ('[', ']') werden zur Subskription benutzt. 
+ 
+ 
+Als Operatornamen sind folgende Sonderzeichen erlaubt: 
+ 
+-  ein Sonderzeichen, sofern es nicht als Trennzeichen benutzt wird: 
+   !  $  %  &  '  *  +  -  /  <  =  >  ?  §  ^  '  ~ 
+-  eine Kombination von zwei Sonderzeichen. Diese Kombination muß jedoch bereits
+   in ELAN existieren: 
+   :=   <=   >=   <>   ** 
+ 
+#page# 
+ 
+2.2.4  Kommentare 
+ 
+Kommentare dienen ausschließlich der Dokumentation eines Programms. Sie werden
+vom Compiler überlesen und haben somit keinen Einfluß auf die Ausführung eines
+Programms. Sie dürfen an beliebigen Stellen eines Programmtextes geschrieben
+werden, jedoch nicht innerhalb von Schlüsselwörtern und Namen. Ein Kommentar darf
+über mehrere Zeilen gehen. In ELAN sind Kommentare nur in wenigen Fällen notwen­
+dig, da Programme durch andere Mittel gut lesbar geschrieben werden können. 
+ 
+Ein Kommentar in ELAN wird durch Kommentarklammern eingeschlossen. Es gibt
+folgende Formen von Kommentarklammern: 
+ 
+(*     Kommentar    *) 
+{      Kommentar     } 
+\#(     Kommentar    )# 
+ 
+Die letzte Version '\#(  Kommentar  )\#' wird im EUMEL-System nicht
+unterstützt; statt dessen gibt es noch folgende Möglichkeit: 
+ 
+\#     Kommentar    \# 
+ 
+Da bei der Kommentarkennzeichnung mit \# für Kommentaranfang und -ende das
+gleiche Zeichen benutzt wird, ist eine Schachtelung hier nicht möglich. 
+#page# 
+ 
+2.3  Datenobjekte 
+ 
+Eine Klasse von Objekten mit gleichen Eigenschaften wird in Programmiersprachen
+Datentyp genannt. Dabei hat ein Datentyp immer einen Namen, der die Klasse von
+Objekten sinnvoll kennzeichnet. Als ein Datenobjekt wird ein Exemplar eines Daten­
+typs (also ein spezielles Objekt einer Klasse) bezeichnet. 
+ 
+Datentypen sind in ELAN ein zentrales Konzept. Jedes der in einem ELAN-
+Programm verwandten Datenobjekte hat einen Datentyp; somit kann man Datentypen
+auch als Eigenschaften von Datenobjekten ansehen. Für jeden Datentyp sind nur
+spezielle Operationen sinnvoll. Man kann nun Compilern die Aufgabe überlassen zu
+überprüfen, ob stets die richtige Operation auf einen Datentyp angewandt wird. 
+ 
+ 
+ 
+2.3.1   Elementare Datentypen 
+ 
+Einige Datentypen spielen bei der Programmierung eine besondere Rolle, weil sie
+häufig benötigt werden. 
+ 
+In ELAN sind das die Datentypen für 
+ 
+-  ganze Zahlen (INT) 
+-  reelle Zahlen (REAL) 
+-  Zeichen und Zeichenfolgen (TEXT) 
+-  Wahrheitswerte (BOOL). 
+ 
+Diese Datentypen sind von der Sprache ELAN vorgegeben und werden elementare
+Datentypen genannt. Für effiziente Rechnungen mit elementaren Datentypen gibt es
+in den meisten Rechnern spezielle Schaltungen, so daß die Hervorhebung und be­
+sondere Rolle, die sie in Programmiersprachen spielen, gerechtfertigt ist. Zudem hat
+man Werte-Darstellungen (Denoter) innerhalb von Programmen für die elementaren
+Datentypen vorgesehen. 
+ 
+ 
+ 
+2.3.1.1  Denoter für elementare Datentypen 
+ 
+Die Darstellung eines Werts in einem Rechner zur Laufzeit eines Programms wird
+Repräsentation genannt. Wenn es eindeutig ist, daß es sich nur um die Repräsenta­
+tion im Rechner handelt, spricht man kurz von Werten. Um mit Objekten elementarer
+Datentypen arbeiten zu können, muß es in einem Programm die Möglichkeit geben,
+Werte eines Datentyps zu bezeichnen (denotieren). Die Werte-Darstellungen, die in
+ELAN Denoter genannt werden, sind für jeden Datentyp unterschiedlich. Wie bereits
+erwähnt, haben alle Datenobjekte in ELAN (also auch Denoter) nur einen - vom
+Compiler feststellbaren - Datentyp. Aus der Form eines Denoters ist also der Daten­
+typ erkennbar: 
+ 
+ 
+ 
+INT-Denoter: 
+Sie bestehen aus einer Aneinanderreihung von Ziffern. 
+ 
+Beispiele: 
+ 
+ 
+17 
+007 
+32767 
+0 
+ 
+ 
+Führende Nullen spielen bei der Bildung des Wertes keine Rolle (sie werden vom
+ELAN-Compiler überlesen). Negative INT-Denoter gibt es nicht. Negative Werte
+werden durch eine Aufeinanderfolge des monadischen Operators '-' (siehe 2.4.1.1)
+und eines INT- Denoters realisiert. 
+ 
+ 
+REAL-Denoter: 
+Hier gibt es zwei Formen: 
+Die erste besteht aus zwei INT-Denotern, die durch einen Dezimalpunkt getrennt
+werden. 
+ 
+Beispiele: 
+ 
+ 
+0.314159 
+17.28 
+ 
+ 
+Der Dezimalpunkt wird wie ein Komma in der deutschen Schreibweise benutzt. Nega­
+tive REAL-Denoter gibt es wiederum nicht. 
+ 
+Die zweite Form wird als "wissenschaftliche Notation" bezeichnet. Sie findet dann
+Verwendung, wenn sehr große Zahlen oder Zahlen, die nahe bei Null liegen, darge­
+stellt werden müssen. 
+ 
+Beispiele: 
+ 
+ 
+3.0 e5 
+3.0e-5 
+ 
+ 
+Der INT-Denoter hinter dem Buchstaben #on("b")#e#off("b")# gibt an, wie viele Stellen der Dezimal­
+punkt nach rechts (positive Werte) bzw. nach links (negative Werte) zu verschieben
+ist. Dieser Wert wird Exponent und der Teil vor dem Buchstaben #on("b")#e#off("b")# Mantisse genannt. 
+ 
+ 
+TEXT-Denoter: 
+Sie werden in Anführungszeichen eingeschlossen. 
+ 
+Beispiele: 
+ 
+ 
+"Das ist ein TEXT-Denoter" 
+"Jetzt ein TEXT-Denoter ohne ein Zeichen: ein leerer Text" 
+"" 
+ 
+ 
+Zu beachten ist, daß das Leerzeichen ebenfalls ein Zeichen ist. Soll ein Anführungs­
+zeichen in einem TEXT erscheinen (also gerade das Zeichen, welches einen Denoter
+beendet), so muß es doppelt geschrieben werden. 
+ 
+Beispiele: 
+ 
+ 
+"Ein TEXT mit dem ""-Zeichen" 
+"Ein TEXT-Denoter nur mit dem ""-Zeichen:" 
+"""" 
+ 
+ 
+Manchmal sollen Zeichen in einem TEXT-Denoter enthalten sein, die auf dem
+Eingabegerät nicht zur Verfügung stehen. In diesem Fall kann der Code-Wert des
+Zeichens angegeben werden. 
+ 
+Beispiel: 
+ 
+ 
+"da"251"" 
+ 
+ 
+ist gleichbedeutend mit "daß". Der Code-Wert eines Zeichens ergibt sich aus der
+EUMEL-Code-Tabelle (siehe 5.2.4.1), in der jedem Zeichen eine ganze Zahl zuge­
+ordnet ist. 
+ 
+ 
+BOOL-Denoter: 
+Es gibt nur zwei BOOL-Denoter: 
+TRUE für "wahr" und FALSE für "falsch". 
+ 
+ 
+ 
+2.3.1.2  LET-Konstrukt für Denoter 
+ 
+Neben der Funktion der Abkürzung von Datentypen (siehe 2.6.3) kann das LET-
+Konstrukt auch für die Namensgebung für Denoter verwandt werden. 
+ 
+Die LET-Vereinbarung sieht folgendermaßen aus: 
+ 
+ 
+#on("i")##on("b")#LET#off("i")##off("b")# Name #on("i")##on("b")#=#off("i")##off("b")# Denoter 
+ 
+ 
+Mehrere Namensgebungen können durch Komma getrennt werden. 
+ 
+ 
+____________________________________________________________________________ 
+ .......................... Beispiele: ......................... 
+ LET anzahl = 27; 
+ LET pi     = 3.14159, 
+     blank  = " "; 
+____________________________________________________________________________ 
+ 
+ 
+Der Einsatz von LET-Namen für Denoter hat zwei Vorteile: 
+ 
+-  feste Werte im Programm sind leicht zu ändern, da nur an einer Stelle des Pro­
+   gramms der Denoter geändert werden muß 
+   (z.B.: In Vereinbarungen von Reihungen (siehe 2.6.1) können LET-Denoter, im
+          Gegensatz zu Konstanten, als Obergrenze angegeben werden. Dieser
+          Wert kann dann auch an anderen Stellen des Programms, z.B. in Schlei­
+          fen (siehe 2.4.2.5), benutzt werden. Bei Änderung der Reihungsgröße
+          braucht dann nur an einer Stelle des Programms der Wert geändert zu
+          werden.) 
+-  der Name gibt zusätzliche Information über die Bedeutung des Denoters. 
+ 
+ 
+ 
+2.3.2   Zugriffsrecht 
+ 
+Von manchen Datenobjekten weiß man, daß sie nur einmal einen Wert erhalten
+sollen. Sie sollen also nicht verändert werden. Oder man weiß, daß in einem Pro­
+grammbereich ein Datenobjekt nicht verändert werden soll. Um ein unbeabsichtigtes
+Verändern zu verhindern, wird in ELAN dem Datenobjekt ein zusätzlicher Schutz
+mitgegeben: das Zugriffsrecht oder Accessrecht. 
+ 
+In der Deklaration eines Datenobjekts können folgende Accessattribute angegeben
+werden: 
+ 
+-  #on("i")##on("b")#VAR  #off("i")##off("b")#  für lesenden und schreibenden (verändernden) Zugriff 
+ 
+-  #on("i")##on("b")#CONST#off("i")##off("b")#  für nur lesenden Zugriff. 
+ 
+ 
+ 
+2.3.3  Deklaration 
+ 
+Damit man Datenobjekte in einem Programm ansprechen kann, gibt man einem
+Datenobjekt einen Namen (wie z.B. einen Personennamen, unter der sich eine wirk­
+liche Person "verbirgt"). Will man ein Datenobjekt in einem Programm verwenden, so
+muß man dem Compiler mitteilen, welchen Datentyp und welches Accessrecht das
+Objekt haben soll. Das dient u.a. dazu, nicht vereinbarte Namen (z.B. verschriebene)
+vom Compiler entdecken zu lassen. Weiterhin ist aus dem bei der Deklaration ange­
+gebenen Datentyp zu entnehmen, wieviel Speicherplatz für das Objekt zur Laufzeit zu
+reservieren ist. 
+ 
+Eine Deklaration oder Vereinbarung besteht aus der Angabe von 
+ 
+-  Datentyp 
+-  Zugriffsrecht ( #on("i")##on("b")#VAR#off("i")##off("b")# oder #on("i")##on("b")#CONST#off("i")##off("b")#) 
+-  Name des Datenobjekts. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ INT VAR mein datenobjekt; 
+ 
+____________________________________________________________________________  
+ 
+ 
+Verschiedene Datenobjekte mit gleichem Datentyp und Accessrecht dürfen in einer
+Deklaration angegeben werden; sie werden durch Kommata getrennt. Mehrere Dekla­
+rationen werden - genauso wie Anweisungen - durch das Trennzeichen Semikolon
+voneinander getrennt. 
+ 
+____________________________________________________________________________ 
+ .......................... Beispiele: ......................... 
+ INT VAR mein wert, dein wert, unser wert; 
+ BOOL VAR listen ende; 
+ TEXT VAR zeile, wort; 
+ 
+____________________________________________________________________________ 
+ 
+ 
+2.3.4  Initialisierung 
+ 
+Um mit den vereinbarten Datenobjekten arbeiten zu können, muß man ihnen einen
+Wert geben. Hat ein Datenobjekt noch keinen Wert erhalten, so sagt man, sein Wert
+sei undefiniert. Das versehentliche Arbeiten mit undefinierten Werten ist eine beliebte
+Fehlerquelle. Deshalb wird von Programmierern streng darauf geachtet, diese Fehler­
+kuelle zu vermeiden. Eine Wertgebung an ein Datenobjekt kann (muß aber nicht)
+bereits bei der Deklaration erfolgen. In ELAN wird dies Initialisierung genannt. Für mit
+CONST vereinbarte Datenobjekte ist die Initialisierung die einzige Möglichkeit, ihnen
+einen Wert zu geben. Die Initialisierung von Konstanten ist zwingend vorgeschrieben
+und wird vom Compiler überprüft. 
+ 
+Die Initialisierung besteht aus der Angabe von 
+ 
+-  Datentyp 
+-  Zugriffsrecht ( #on("i")##on("b")#VAR#off("i")##off("b")# oder #on("i")##on("b")#CONST#off("i")##off("b")#) 
+-  Name des Datenobjekts 
+-  Operator #on("i")##on("b")#::#off("i")##off("b")# oder #on("i")##on("b")#:=#off("i")##off("b")# 
+-  Wert, den das Datenobjekt erhalten soll (Denoter, Ausdruck). 
+ 
+____________________________________________________________________________ 
+ .......................... Beispiele: ......................... 
+ INT CONST gewuenschtes gehalt :: 12 000; 
+ TEXT VAR zeile :: ""; 
+ REAL CONST pi :: 3.14159, zwei pi := 2.0 * pi; 
+ BOOL VAR bereits sortiert :: TRUE; 
+____________________________________________________________________________ 
+#page# 
+ 
+2.4  Programmeinheiten 
+ 
+Neben Deklarationen (Vereinbarungen) sind Programmeinheiten die Grundbestandteile
+von ELAN. 
+ 
+ 
+Programmeinheiten können sein: 
+ 
+#on("b")#-  elementare Programmeinheiten #off("b")# 
+   -  Ausdruck 
+   -  Zuweisung 
+   -  Refinementanwendung 
+   -  Prozeduraufruf 
+ 
+#on("b")#-  zusammengesetzte Programmeinheiten #off("b")# 
+   -  Folge 
+   -  Abfrage 
+   -  Auswahl 
+   -  Wiederholung 
+ 
+#on("b")#-  abstrahierende Programmeinheiten #off("b")# 
+   -  Refinementbvereinbarung 
+   -  Prozedurvereinbarung 
+   -  Operatorvereinbarung 
+   -  Paketvereinbarung. 
+#page# 
+ 
+2.4.1  Elementare Programmeinheiten 
+ 
+ 
+2.4.1.1  Ausdruck 
+ 
+Ausdrücke sind eine Zusammenstellung von Datenobjekten (Denoter, VAR- oder
+CONST-Objekte) und Operatoren. Jeder korrekte Ausdruck liefert einen Wert. Der
+Typ des Ausdrucks wird bestimmt durch den Typ des Wertes, den der Ausdruck
+liefert. 
+ 
+ 
+Operatoren 
+ 
+Operatoren werden in ELAN durch ein oder zwei Sonderzeichen oder durch Groß­
+buchstaben als Schlüsselwort dargestellt (siehe 2.4.3.3). 
+ 
+Als Operanden (also die Datenobjekte, auf die ein Operator "wirken" soll) dürfen
+VAR- und CONST-Datenobjekte, Denoter oder Ausdrücke verwendet werden. Typ
+der Operanden und des Resultats eines Operators werden in der Operatorvereinba­
+rung festgelegt (siehe 2.4.3.3). 
+ 
+Man unterscheidet zwei Arten von Operatoren: 
+ 
+#on("b")#-  monadische Operatoren #off("b")# 
+   Monadischen Operatoren haben nur einen Operanden, der rechts vom Operator­
+   zeichen geschrieben werden muß. 
+ 
+   Beispiel: 
+ 
+ 
+   - a 
+   NOT x 
+ 
+ 
+   Der '-' - Operator liefert den Wert von a mit umgekehrten Vorzeichen. a muß
+   dabei vom Datentyp INT oder REAL sein. 
+   Der Operator 'NOT' realisiert die logische Negation. y muß vom Datentyp BOOL
+   sein. 
+ 
+ 
+#on("b")#-  dyadische Operatoren #off("b")# 
+   Dyadische Operatoren haben zwei Operanden. Das Operatorzeichen steht zwi­
+   schen den beiden Operanden. 
+ 
+   Beispiele: 
+ 
+ 
+   a + b 
+   a - b 
+   a * b 
+   a DIV b 
+   a ** b 
+   x < y 
+   x <> y 
+   x AND y 
+   x OR y 
+ 
+ 
+   In den ersten fünf Beispielen werden jeweils die Werte von zwei INT-Objekten a
+   und b addiert (Operatorzeichen: '+'), subtrahiert ('-'), multipliziert ('*'), dividiert
+   (ganzzahlige Division ohne Rest: 'DIV') und potenziert ('**'). 
+   Im sechsten und siebten Beispiel werden zwei BOOL-Werte x und y verglichen
+   und im achten und neunten Beispiel die logische Operation 'und' (Operator 'AND')
+   bzw. 'oder' (Operator 'OR') durchgeführt. 
+ 
+ 
+Priorität von Operatoren 
+ 
+Es ist erlaubt, einen Ausdruck wiederum als Operanden zu verwenden. Praktisch
+bedeutet dies, daß mehrere Operatoren und Datenobjekte zusammen in einem Aus­
+druck geschrieben werden dürfen. 
+ 
+Beispiele: 
+ 
+ 
+a + 3 - b * c 
+- a * b 
+ 
+ 
+Die Reihenfolge der Auswertung kann man durch Angabe von Klammern steuern. 
+ 
+Beispiel: 
+ 
+ 
+(a + b) * (a + b) 
+ 
+ 
+Es wird jeweils erst 'a + b' ausgewertet und dann erst die Multiplikation durchge­
+führt. In ELAN ist es erlaubt, beliebig viel Klammernpaare zu verwenden (Regel: die
+innerste Klammer wird zuerst ausgeführt). Es ist sogar zulässig, Klammern zu ver­
+wenden, wo keine notwendig sind, denn überflüssige Klammernpaare werden überle­
+sen. Man muß jedoch beachten, daß Ausdrücke, und damit auch z.B. #on("b")#(a)#off("b")#, immer
+Accessrecht CONST haben. 
+ 
+Beispiel: 
+ 
+ 
+((a - b)) * 3 * ((c + d) * (c - d)) 
+ 
+ 
+Somit können beliebig komplizierte Ausdrücke formuliert werden. 
+ 
+Um solche Ausdrücke einfacher zu behandeln und sie so ähnlich schreiben zu kön­
+nen, wie man es in der Mathematik gewohnt ist, wird in Programmiersprachen die
+Reihenfolge der Auswertung von Operatoren festgelegt. In ELAN wurden neun Ebe­
+nen, Prioritäten genannt, festgelegt: 
+ 
+ 
+#on("bold")#Priorität               Operatoren 
+#off("bold")# 
+ 
+   9                     alle monadischen Operatoren 
+   8                     ** 
+   7                     *, /, DIV, MOD 
+   6                     +, - 
+   5                     =, <>, <, <=, >, >= 
+   4                     AND 
+   3                     OR 
+   2                     alle übrigen, nicht in dieser Tabelle aufgeführten 
+                         dyadischen Operatoren 
+   1                     := 
+ 
+(Die erwähnten Operatoren in der Tabelle werden in der Beschreibung der Standard­
+prozeduren und -Operatoren besprochen). 
+ 
+Operatoren mit der höchsten Priorität werden zuerst ausgeführt, dann die mit der
+nächst niedrigeren Priorität usw.. Operatoren mit gleicher Priorität werden von links
+nach rechts ausgeführt. Dadurch ergibt sich die gewohnte Abarbeitungsfolge wie beim
+Rechnen. 
+ 
+Beispiel: 
+ 
+ 
+-2 + 3 * 2 ** 3 
+ 
+a) -2 
+b) 2 ** 3 
+c) 3 * (2 ** 3) 
+d) ((-2)) + (3 * (2 ** 3)) 
+ 
+ 
+Wie bereits erwähnt, ist es immer erlaubt, Klammern zu setzen. Ist man sich also
+über die genaue Abarbeitungsfolge nicht im Klaren, so kann man Klammern verwen­
+den. 
+ 
+ 
+ 
+2.4.1.2  Zuweisung 
+ 
+Ein spezieller Operator ist die Zuweisung. 
+ 
+Form: 
+ 
+ 
+Variable #on("i")##on("b")#:=#off("i")##off("b")# Wert 
+ 
+ 
+Dieser Operator hat immer die geringste Priorität, wird also immer als letzter einer
+Anweisung ausgeführt. Die Zuweisung wird verwendet, um einer Variablen einen
+neuen Wert zu geben. Der Operator ':=' liefert kein Resultat (man sagt auch, er
+liefert keinen Wert) und verlangt als linken Operanden ein VAR-Datenobjekt, an den
+der Wert des rechten Operanden zugewiesen werden soll). Der Wert des linken Oper­
+anden wird also verändert. Der rechte Operand wird nur gelesen. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ a := b; 
+ 
+____________________________________________________________________________  
+ 
+ 
+Hier wird der Wert von 'b' der Variablen 'a' zugewiesen. Der vorher vorhandene Wert
+von 'a' geht dabei verloren. Man sagt auch, der Wert wird überschrieben. 
+ 
+Als rechter Operand des ':='-Operators darf auch ein Ausdruck stehen. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ a := b + c; 
+ 
+____________________________________________________________________________  
+ 
+ 
+Hier wird das Resultat von 'b + c' an die Variable 'a' zugewiesen. Man beachte
+dabei die Prioritäten der Operatoren '+' (Priorität 6) und ':=' (Priorität 1): die Addition
+wird vor der Zuweisung ausgeführt. Die Auswertung von Zuweisungen mit Ausdrücken
+muß immer so verlaufen, da die Zuweisung stets die niedrigste Priorität aller Operato­
+ren hat. 
+ 
+Oft kommt es vor, daß ein Objekt auf der linken und rechten Seite des Zuweisungs­
+operators erscheint, z.B. wenn ein Wert erhöht werden soll. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ a := a + 1; 
+ 
+____________________________________________________________________________  
+ 
+ 
+Hier wird der "alte", aktuelle Wert von 'a' genommen, um '1' erhöht und dem Objekt
+'a' zugewiesen. Man beachte, daß hier in einer Anweisung ein Datenobjekt unter­
+schiedliche Werte zu unterschiedlichen Zeitpunkten haben kann. 
+ 
+ 
+ 
+2.4.1.3  Refinementanwendung 
+ 
+In ELAN ist es möglich, Namen für Ausdrücke oder eine bzw. mehrere Anweisungen
+zu vergeben. Das Sprachelement, das diese Namensgebung ermöglicht, heißt Refi­
+nement. Die Ausführung eines solchen Namens heißt Refinementanwendung, die
+Namensgebung heißt Refinementvereinbarung (siehe 2.4.3.1). Die Ausdrücke oder
+Anweisungen bilden den Refinementrumpf. Ein Refinement kann man in einem Pro­
+gramm unter dem Refinementnamen ansprechen. Man kann sich die Ausführung so
+vorstellen, als würden der Refinementrumpf immer dort eingesetzt, wo der Name des
+Refinements als Operation benutzt wird. 
+ 
+ 
+ 
+2.4.1.4  Prozeduraufruf 
+ 
+Eine Prozedur ist eine Sammlung von Anweisungen und Daten, die zur Lösung einer
+bestimmten Aufgabe benötigt werden. Eine Prozedur wird in einer Prozedurvereinba­
+rung definiert (siehe 2.4.3.2). Eine solche Prozedur kann man in einem Programm
+unter einem Namen (eventuell unter Angabe von Parametern) ansprechen. Man
+spricht dann vom Aufruf einer Prozedur oder einer Prozeduranweisung. 
+ 
+Formen des Prozeduraufrufs: 
+ 
+-  #on("b")#Prozeduren ohne Parameter#off("b")# werden durch den Prozedurnamen angesprochen. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ pause; 
+ 
+____________________________________________________________________________  
+ 
+ 
+   (Die Prozedur 'pause' wartet bis ein Zeichen eingegeben wird) 
+ 
+ 
+-  #on("b")#Prozeduren mit Parameter#off("b")# werden durch 
+ 
+ 
+   Prozedurnamen #on("i")##on("b")#(#off("i")##off("b")# aktuelle Parameterliste #on("i")##on("b")#)#off("i")##off("b")# 
+ 
+ 
+   aufgerufen. Eine Parameterliste ist entweder ein Datenobjekt oder mehrere durch
+   Kommata getrennte Datenobjekte. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ pause (10); 
+ 
+____________________________________________________________________________ 
+ 
+ 
+   (Mit der Prozedur 'pause (INT CONST zeitgrenze)' kann für eine Zeitdauer von
+   'zeitgrenze' in Zehntel-Sekunden gewartet werden. Die Wartezeit wird durch
+   Erreichen der Zeitgrenze oder durch Eingabe eines Zeichens abgebrochen) 
+ 
+ 
+   Bei den aktuellen Parametern ist folgendes zu beachten: 
+ 
+   a) Wird ein VAR-Parameter in der Definition der Prozedur vorgeschrieben, darf
+      kein Ausdruck als aktueller Parameter "übergeben" werden, weil an einen
+      Ausdruck nichts zugewiesen werden kann. Ausdrücke haben - wie bereits
+      erwähnt - das Accessrecht CONST. 
+ 
+____________________________________________________________________________ 
+ ........................ Gegenbeispiel: ....................... 
+ TEXT VAR text1, text2; 
+ text1 := "Dieses Beispiel "; 
+ text2 := "Fehlermeldung"; 
+ insert char (text1 + text2, "liefert eine", 17); 
+ 
+____________________________________________________________________________ 
+ 
+ 
+      (Die Prozedur 'insert char (TEXT VAR string, TEXT CONST char, INT CONST
+      pos)' fügt das Zeichen 'char' in den Text 'string' an der Position 'pos' ein) 
+ 
+   b) Wird ein CONST-Parameter verlangt, dann darf in diesem Fall ein Ausdruck
+      als aktueller Parameter geschrieben werden. Aber auch ein VAR-Datenobjekt
+      darf angegeben werden. In diesem Fall wird eine Wandlung des Accessrechts
+      (CONSTing) vorgenommen: der aktuelle Parameter erhält sozusagen für die
+      Zeit der Abarbeitung der Prozedur das Accessrecht CONST. 
+ 
+ 
+   In ELAN sind auch Prozeduren als Parameter erlaubt. Die Prozedur als aktueller
+   Parameter wird in der Parameterliste folgendermaßen angegeben: 
+ 
+ 
+   Resultattyp #on("i")##on("b")#PROC#off("i")##off("b")# #on("i")##on("b")#(#off("i")##off("b")# virtuelle Parameterliste #on("i")##on("b")#)#off("i")##off("b")# Procname 
+ 
+ 
+   Die Angabe des Resultattyps entfällt, wenn es sich nicht um eine wertliefernde
+   Prozedur handelt. Die virtuelle Parameterliste inklusive der Klammern entfällt, falls
+   die Prozedur keine Parameter hat. Die virtuelle Parameterliste beschreibt die
+   Parameter der Parameterprozedur. Es werden Datentyp und Zugriffsrecht eines
+   jeden Parameters angegeben, jedoch ohne Namen. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ wertetabelle (REAL PROC (REAL CONST) sin, 
+               untergrenze, obergrenze, schrittweite); 
+  
+ 
+   (Die Prozedur 'sin' wird an die Prozedur 'wertetabelle' übergeben) 
+ 
+____________________________________________________________________________ 
+ 
+ 
+2.4.2 Zusammengesetzte Programmeinheiten 
+ 
+ 
+2.4.2.1  Folge 
+ 
+Mehrere in einer bestimmten Reihenfolge auszuführende Anweisungen werden als
+Folge bezeichnet. In ELAN kann man eine oder mehrere Anweisungen in eine Pro­
+grammzeile schreiben oder eine Anweisung über mehrere Zeilen. Das setzt jedoch
+voraus, daß die Anweisungen voneinander getrennt werden. Die Trennung von Anwei­
+sungen erfolgt in ELAN durch das Trennsymbol Semikolon. Es bedeutet soviel wie:
+"führe die nächste Anweisung aus". 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ put ("mein"); 
+ put (1); 
+ put (". Programm") 
+ 
+____________________________________________________________________________ 
+ 
+ 
+(Die Prozedur 'put' gibt den als Parameter angegebenen Wert auf dem Ausgabegerät
+aus) 
+ 
+ 
+ 
+2.4.2.2  Abfrage 
+ 
+Mit Abfragen steuert man die bedingte Ausführung von Anweisungen. Abhängig von
+einer Bedingung wird in zwei verschiedene Programmabschnitte verzweigt. 
+ 
+Der formale Aufbau einer Abfrage sieht folgendermaßen aus: 
+ 
+ 
+#on("i")##on("b")#IF#off("i")##off("b")# Bedingung 
+   #on("i")##on("b")#THEN#off("i")##off("b")# Abschnitt 
+   #on("i")##on("b")#ELSE#off("i")##off("b")# Abschnitt 
+#on("i")##on("b")#END IF#off("i")##off("b")# 
+ 
+ 
+Der ELSE-Teil darf dabei auch fehlen. Anstelle von #on("i")##on("b")#END IF#off("i")##off("b")# darf auch die Abkürzung #on("i")##on("b")#FI#off("i")##off("b")# (IF von hinten gelesen) benutzt werden.
+ 
+In folgenden Beispielen wird der Absolutbetrag von 'a' ausgegeben: 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ INT VAR a; 
+ get (a); 
+ IF a < 0 
+    THEN a := -a 
+ END IF; 
+ put (a) 
+  
+____________________________________________________________________________ 
+ 
+ 
+Die Umkehrung des Vorzeichens von a im THEN-Teil wird nur durchgeführt, wenn
+der BOOLesche Ausdruck ('a < 0') den Wert TRUE liefert. Liefert er den Wert
+FALSE, wird die Anweisung, die der bedingten Anweisung folgt (nach END IF), ausge­
+führt. Das obige Programm kann auch anders geschrieben werden: 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ INT VAR a; 
+ get (a); 
+ IF a < 0 
+    THEN put (-a) 
+    ELSE put (a) 
+ END IF 
+  
+____________________________________________________________________________ 
+ 
+ 
+Der THEN-Teil wird wiederum ausgeführt, wenn die BOOLesche Bedingung erfüllt
+ist. Liefert sie dagegen FALSE, wird der ELSE-Teil ausgeführt. 
+ 
+Die bedingte Anweisung ermöglicht es, abhängig von einer Bedingung eine oder
+mehrere Anweisungen ausführen zu lassen. Dabei können im THEN- bzw. ELSE-
+Teil wiederum bedingte Anweisungen enthalten sein. 
+ 
+ 
+Abfragekette 
+Bei Abfrageketten kann das ELIF-Konstrukt eingesetzt werden. (ELIF ist eine Zu­
+sammenziehung der Worte ELSE und IF). 
+ 
+Anstatt 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ IF bedingung1 
+    THEN aktion1 
+    ELSE IF bedingung2 
+            THEN aktion2 
+            ELSE aktion3 
+         END IF 
+    END IF; 
+ 
+____________________________________________________________________________ 
+ 
+ 
+kann man besser 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ IF bedingung1 
+    THEN aktion1 
+ ELIF bedingung2 
+    THEN aktion2 
+    ELSE aktion3 
+ END IF; 
+  
+____________________________________________________________________________ 
+ 
+ 
+schreiben. 
+ 
+ 
+ 
+2.4.2.3  Auswahl 
+ 
+Die Auswahl wird benutzt, wenn alternative Anwendungen in Abhängikeit von Werten
+eines Datenobjekts ausgeführt werden sollen. 
+ 
+Der formale Aufbau der Auswahl sieht folgendermaßen aus: 
+ 
+ 
+#on("i")##on("b")#SELECT#off("i")##off("b")# INT-Ausdruck #on("i")##on("b")#OF#off("i")##off("b")# 
+   #on("i")##on("b")#CASE#off("i")##off("b")# 1. Liste von INT-Denotern #on("i")##on("b")#:#off("i")##off("b")# Abschnitt 
+   #on("i")##on("b")#CASE#off("i")##off("b")# 2. Liste von INT-Denotern #on("i")##on("b")#:#off("i")##off("b")# Abschnitt 
+                   . 
+                   . 
+                   . 
+   #on("i")##on("b")#CASE#off("i")##off("b")# n. Liste von INT-Denotern #on("i")##on("b")#:#off("i")##off("b")# Abschnitt 
+   #on("i")##on("b")#OTHERWISE#off("i")##off("b")# Abschnitt 
+#on("i")##on("b")#END SELECT#off("i")##off("b")# 
+ 
+ 
+Eine Liste von INT-Denotern besteht aus einem oder mehreren durch Kommata ge­
+trennten INT-Denotern. Der OTHERWISE-Teil darf auch fehlen. Man sollte ihn
+jedoch verwenden, um Fehlerfälle abzufangen. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ SELECT monat OF 
+    CASE 2: IF schaltjahr 
+               THEN tage := 29 
+               ELSE tage := 28 
+            END IF 
+    CASE 4, 6, 9, 11: tage := 30 
+    CASE 1, 3, 5, 7, 8, 10 ,12: tage := 31 
+    OTHERWISE kein monat 
+ END SELECT; 
+  
+____________________________________________________________________________ 
+ 
+ 
+(In diesem Programmausschnitt werden die Tage eines Monats bestimmt) 
+ 
+ 
+ 
+2.4.2.4  Wertliefernde Abfrage und 
+         wertliefernde Auswahl
+          
+ 
+Soll eine Abfrage oder eine Auswahl einen Wert liefern, dann darf der ELSE- bzw.
+der OTHERWISE-Teil nicht fehlen und alle Zweige müssen einen Wert liefern. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ SELECT monat OF 
+    CASE 2: IF schaltjahr 
+               THEN 29 
+               ELSE 28 
+            END IF 
+    CASE 4, 6, 9, 11: 30 
+    CASE 1, 3, 5, 7, 8, 10 ,12: 31 
+    OTHERWISE kein monat; 0 
+ END SELECT; 
+  
+____________________________________________________________________________ 
+ 
+ 
+2.4.2.5  Wiederholung 
+ 
+Die Wiederholung dient zur mehrfachen Ausführung von Anweisungen, meist in Ab­
+hängigkeit von einer Bedingung. Darum wird die Wiederholungsanweisung oft auch
+Schleife genannt und die in ihr enthaltenen Anweisungen Schleifenrumpf. 
+ 
+Es gibt verschiedene Schleifentypen: 
+ 
+-  Endlosschleife 
+-  abweisende Schleife 
+-  nicht abweisende Schleife 
+-  Zählschleife. 
+ 
+ 
+Endlosschleife 
+Bei der Endlosschleife wird nicht spezifiziert, wann die Schleife beendet werden soll. 
+ 
+Form: 
+ 
+ 
+#on("i")##on("b")#REPEAT#off("i")##off("b")# 
+   Abschnitt 
+#on("i")##on("b")#END REPEAT#off("i")##off("b")# 
+ 
+ 
+Anstelle von #on("i")##on("b")#REPEAT#off("i")##off("b")# darf die Abkürzung #on("i")##on("b")#REP#off("i")##off("b")# und anstelle von #on("i")##on("b")#END REPEAT#off("i")##off("b")# 
+das Schlüsselwort #on("i")##on("b")#PER#off("i")##off("b")# (REP von hinten gelesen)
+benutzt werden. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ break; 
+ REPEAT 
+    fixpoint; 
+    pause (18000) 
+ END REPEAT 
+  
+____________________________________________________________________________ 
+ 
+ 
+Wird dieses Programm in einer Task im SYSUR-Zweig ausgeführt, so führt diese
+Task Fixpunkte im Abstand von 30 Minuten durch. 
+ 
+ 
+ 
+Abweisende Schleife 
+Bei der abweisenden Schleife wird die Abbruchbedingung an den Anfang der Schleife
+geschrieben. 
+ 
+Form: 
+ 
+ 
+#on("i")##on("b")#WHILE#off("i")##off("b")# Bedingung #on("i")##on("b")#REPEAT#off("i")##off("b")# 
+   Abschnitt 
+#on("i")##on("b")#END REPEAT#off("i")##off("b")# 
+ 
+ 
+Bei jedem erneuten Durchlauf der Schleife wird überprüft, ob der BOOLesche Aus­
+druck den Wert TRUE liefert. Ist das nicht der Fall, wird die Bearbeitung mit der
+Anweisung fortgesetzt, die auf das Schleifenende folgt. Die Schleife wird abweisende
+Schleife genannt, weil der Schleifenrumpf nicht ausgeführt wird, wenn die Bedingung
+vor Eintritt in die Schleife bereits FALSE liefert. 
+ 
+ 
+Nicht abweisende Schleife 
+Anders verhält es sich bei der nicht abweisenden Schleife. Bei der nicht abweisenden
+Schleife wird die Abbruchbedingung an das Ende der Schleife geschrieben. 
+ 
+Form: 
+ 
+ 
+#on("i")##on("b")#REPEAT#off("i")##off("b")# 
+   Abschnitt 
+#on("i")##on("b")#UNTIL#off("i")##off("b")# Bedingung #on("i")##on("b")#END REPEAT#off("i")##off("b")# 
+ 
+ 
+Hier wird der Schleifenrumpf auf jeden Fall einmal bearbeitet. Am Ende des Rumpfes
+wird die BOOLesche Bedingung abgefragt. Liefert sie den Wert FALSE, wird die
+Schleife erneut abgearbeitet. Liefert die Bedingung den Wert TRUE, wird die Schleife
+abgebrochen und mit der ersten Anweisung hinter der Schleife in der Bearbeitung
+fortgefahren. 
+ 
+Bei den beiden letztgenannten Arten der Wiederholungsanweisung ist es wichtig, daß
+Elemente der BOOLeschen Bedingung in der Schleife verändert werden, damit das
+Programm terminieren kann, d.h. die Schleife abgebrochen wird. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ TEXT VAR wort, satz :: ""; 
+ REPEAT 
+   get (wort); 
+   satz CAT wort; 
+   satz CAT " " 
+ UNTIL wort = "." PER; 
+  
+____________________________________________________________________________ 
+ 
+ 
+Dises Programm liest solange Wörter ein und verbindet diese zu einem Satz, bis ein
+Punkt eingegeben wurde. 
+ 
+ 
+ 
+Zählschleife 
+Zählschleifen werden eingesetzt, wenn die genaue Anzahl der Schleifendurchläufe
+bekannt ist. 
+ 
+Form: 
+ 
+ 
+#on("i")##on("b")#FOR#off("i")##off("b")# Laufvariable #on("i")##on("b")#FROM#off("i")##off("b")# Anfangswert #on("i")##on("b")#UPTO#off("i")##off("b")# Endwert #on("i")##on("b")#REPEAT#off("i")##off("b")# 
+   Abschnitt 
+#on("i")##on("b")#END REPEAT#off("i")##off("b")# 
+ 
+ 
+Bei Zählschleifen wird eine Laufvariable verwendet, die die INT-Werte von 'Anfangs­
+wert' bis 'Endwert' in Schritten von 1 durchläuft. 'Anfangswert' und 'Endwert' können
+beliebige INT-Ausdrücke sein. Diese Schleife zählt "aufwärts". Wird anstatt #on("i")##on("b")#UPTO#off("i")##off("b")#
+das Schlüsselwort #on("i")##on("b")#DOWNTO#off("i")##off("b")# verwendet, wird mit Schritten von 1 "abwärts" gezählt. 
+ 
+Form: 
+ 
+ 
+#on("i")##on("b")#FOR#off("i")##off("b")# Laufvariable #on("i")##on("b")#FROM#off("i")##off("b")# Endwert #on("i")##on("b")#DOWNTO#off("i")##off("b")# Anfangswert #on("i")##on("b")#REPEAT#off("i")##off("b")# 
+   Abschnitt 
+#on("i")##on("b")#END REPEAT#off("i")##off("b")# 
+ 
+ 
+Die Laufvariable darf in der Schleife nicht verändert werden. Nach dem normalen
+Schleifenende ist der Wert der Laufvariablen nicht definiert. 
+ 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ INT VAR summe :: 0, i; 
+ FOR i FROM 1 UPTO 100 REPEAT 
+    summe INCR i 
+ END REPEAT 
+  
+____________________________________________________________________________ 
+ 
+ 
+Dieses Programm berechnet die Summe der natürlichen Zahlen von 1 bis 100. 
+ 
+ 
+Die verschiedenen Schleifenarten können kombiniert werden: 
+ 
+ 
+#on("i")##on("b")#FOR#off("i")##off("b")# Laufvariable #on("i")##on("b")#FROM#off("i")##off("b")# Anfangswert #on("i")##on("b")#UPTO#off("i")##off("b")# Endwert 
+#on("i")##on("b")#WHILE#off("i")##off("b")# Bedingung #on("i")##on("b")#REPEAT#off("i")##off("b")# 
+   Abschnitt 
+#on("i")##on("b")#END REPEAT#off("i")##off("b")# 
+ 
+ 
+ 
+#on("i")##on("b")#FOR#off("i")##off("b")# Laufvariable #on("i")##on("b")#FROM#off("i")##off("b")# Anfangswert #on("i")##on("b")#UPTO#off("i")##off("b")# Endwert #on("i")##on("b")#REPEAT#off("i")##off("b")# 
+   Abschnitt 
+#on("i")##on("b")#UNTIL#off("i")##off("b")# Bedingung #on("i")##on("b")#END REPEAT#off("i")##off("b")# 
+ 
+ 
+ 
+ 
+ 
+#on("i")##on("b")#WHILE#off("i")##off("b")# Bedingung #on("i")##on("b")#REPEAT#off("i")##off("b")# 
+   Abschnitt 
+#on("i")##on("b")#UNTIL#off("i")##off("b")# Bedingung #on("i")##on("b")#END REPEAT#off("i")##off("b")# 
+ 
+#page# 
+ 
+2.4.3  Abstrahierende Programmeinheiten 
+ 
+ 
+2.4.3.1  Refinementvereinbarung 
+ 
+In ELAN ist es möglich, Namen für Ausdrücke oder eine bzw. mehrere Anweisungen
+zu vergeben. Das Sprachelement, das diese Namensgebung ermöglicht, heißt Refi­
+nement. Die Ausführung eines solchen Namens heißt Refinementanwendung (siehe
+2.4.1.3), die Namensgebung heißt Refinementvereinbarung. Die Ausdrücke oder
+Anweisungen bilden den Refinementrumpf. 
+ 
+Werden in einem Programm Refinements benutzt, dann wird der Programmteil bis
+zum ersten Refinement durch einen Punkt abgeschlossen. Die Refinementvereinba­
+rung sieht folgendermaßen aus: 
+ 
+ 
+Name #on("i")##on("b")#:#off("i")##off("b")# 
+   Abschnitt #on("i")##on("b")#.#off("i")##off("b")# 
+ 
+ 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ INT VAR a, b, x; 
+ einlesen von a und b; 
+ vertauschen von a und b; 
+ vertauschte werte ausgeben. 
+ 
+ einlesen von a und b: 
+    get (a); 
+    get (b). 
+ 
+ vertauschen von a und b: 
+    x := a; 
+    a := b; 
+    b := x. 
+ 
+ vertauschte werte ausgeben: 
+    put (a); 
+    put (b). 
+  
+____________________________________________________________________________ 
+ 
+ 
+Für den Namen 'einlesen von a und b' werden die Anweisungen 'get (a); get (b)' vom
+ELAN-Compiler eingesetzt. Man kann also die ersten vier Zeilen des Programms als
+eigentliches Programm ansehen, wobei die Namen durch die betreffenden Anwei­
+sungen ersetzt werden. Ein Refinement hat also keinen eigenen Datenbereich, d.h.
+Vereinbarungen, die in Refinements gemacht werden, gelten auch außerhalb des
+Refinements. 
+ 
+ 
+ 
+Vorteile der Refinementanwendung 
+Durch die sinnvolle Verwendung von Refinements wird ein Programm im Programm
+und nicht in einer separaten Beschreibung dokumentiert. Weiterhin kann ein Pro­
+gramm "von oben nach unten" ("top down") entwickelt werden: Das obige - zuge­
+geben einfache - Beispielprogramm wurde in drei Teile zerlegt und diese durch
+Namen beschrieben. Bei der Beschreibung von Aktionen durch Namen wird gesagt
+was gemacht werden soll. Es wird noch nicht beschrieben wie, denn auf dieser Stufe
+der Programmentwicklung braucht man sich um die Realisierung der Refinements
+(noch) keine Sorgen zu machen. Das erfolgt erst, wenn das Refinement programmiert
+werden muß. Dabei können wiederum Refinements verwendet werden usw., bis man
+auf eine Ebene "heruntergestiegen" ist, bei der eine (jetzt: Teil-) Problemlösung sehr
+einfach ist und man sie direkt hinschreiben kann. Man beschäftigt sich also an jedem
+Punkt der Problemlösung nur mit einem Teilaspekt des gesamten Problems. Zudem
+sieht man - wenn die Refinements einigermaßen vernünftig verwendet werden -
+dem Programm an, wie die Problemlösung entstanden ist. 
+ 
+Die Verwendung von Refinements hat also eine Anzahl von Vorteilen. 
+Refinements ermöglichen: 
+ 
+-  "top down" - Programmierung 
+-  Strukturierung von Programmen und damit effiziente Fehlersuche und gute Wart­
+   barkeit 
+-  Dokumentation im Programmtext. 
+ 
+ 
+Wertliefernde Refinements 
+Refinements können auch dort verwendet werden, wo ein Wert erwartet wird, z.B. in
+einem Ausdruck oder einer 'put'-Anweisung. In diesem Fall muß die letzte Anwei­
+sung des Refinements einen Wert liefert. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ INT VAR a :: 1, b :: 2, c :: 3; 
+ put (resultat). 
+ 
+ resultat: 
+    (a * b + c) ** 3. 
+  
+____________________________________________________________________________ 
+ 
+ 
+Man kann auch ein wertlieferndes Refinement mit mehreren Anweisungen schrei­
+ben. 
+ 
+Allgemeine Regel: 
+Die letzte Anweisung eines Refinements bestimmt, ob es einen Wert liefert - und
+wenn ja, von welchen Datentyp. 
+ 
+ 
+ 
+2.4.3.2  Prozedurvereinbarung 
+ 
+Eine Prozedur ist eine Sammlung von Anweisungen und Daten, die zur Lösung einer
+bestimmten Aufgabe benötigt werden. 
+ 
+Der formale Aufbau einer Prozedur sieht folgendermaßen aus: 
+ 
+ 
+#on("i")##on("b")#PROC#off("i")##off("b")# Prozedurname #on("i")##on("b")#:#off("i")##off("b")# 
+   Prozedurrumpf 
+#on("i")##on("b")#END PROC#off("i")##off("b")# Prozedurname 
+ 
+ 
+Der Prozedurrumpf kann Deklarationen, Anweisungen und Refinements enthalten. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+     PROC loesche bildschirm ab aktueller cursorposition: 
+        out (""4"") 
+     END PROC loesche bildschirm ab aktueller cursorposition 
+ 
+____________________________________________________________________________ 
+ 
+ 
+Verwendung von Prozeduren 
+Prozeduren werden verwendet, wenn 
+ 
+-  Anweisungen und Datenobjekte unter einem Namen zusammengefaßt werden
+   sollen ("Abstraktion") 
+-  gleiche Anweisungen von mehreren Stellen eines Programms verwandt werden
+   sollen (Codereduktion), u.U. mit verschieden Datenobjekten (Parameter) 
+-  Datenobjekte nur innerhalb eines Programmteils benötigt werden und diese nicht
+   von dem gesamten Programm angesprochen werden sollen. 
+ 
+In den folgenden Programmfragmenten werden zwei Werte vertauscht. In der ersten
+Lösung wird ein Refinement, in der zweiten eine Prozedur verwandt. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ IF a > b 
+   THEN vertausche a und b 
+ END IF; 
+ put (a); 
+ put (b); 
+ vertausche a und b. 
+ 
+ vertausche a und b: 
+    INT CONST x :: a; 
+    a := b; 
+    b := x. 
+ 
+____________________________________________________________________________ 
+ 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ PROC vertausche a und b: 
+    INT CONST x :: a; 
+    a := b; 
+    b := x 
+ END PROC vertausche a und b; 
+ 
+ IF a > b 
+   THEN vertausche a und b 
+ END IF; 
+ put (a); 
+ put (b); 
+ vertausche a und b; 
+ 
+____________________________________________________________________________ 
+ 
+ 
+Beim ersten Hinsehen leisten beide Programme das Gleiche. Es gibt jedoch drei
+wichtige Unterschiede: 
+ 
+1) Das Refinement 'vertausche a und b' wird zweimal (vom ELAN-Compiler) ein­
+   gesetzt, d.h. der Code ist zweimal vorhanden. Die Prozedur dagegen ist vom Code
+   nur einmal vorhanden, wird aber zweimal - durch das Aufführen des Prozedur­
+   namens - aufgerufen. 
+ 
+2) Die Variable 'x' ist in der ersten Programmversion während des gesamten Ablauf
+   des Programms vorhanden, d.h. ihr Speicherplatz ist während dieser Zeit belegt.
+   Solche Datenobjekte nennt man statische Datenobjekte oder auch (aus Gründen,
+   die erst etwas später offensichtlich werden) Paket-Objekte. Das Datenobjekt 'x'
+   der rechten Version dagegen ist nur während der Bearbeitung der Prozedur vor­
+   handen, sein Speicherplatz wird danach freigegeben. Solche Datenobjekte, die nur
+   kurzfristig Speicher belegen, werden dynamische Datenobjekte genannt. 
+ 
+   Prozeduren sind also ein Mittel, um die Speicherbelegung zu beeinflussen. 
+ 
+3) Da Refinements keinen eigenen Datenbereich haben, kann die Variable 'x' in der
+   ersten Programmversion - obwohl sie in einem Refinement deklariert wurde -
+   von jeder Stelle des Programms angesprochen werden. Solche Datenobjekte
+   werden globale Datenobjekte genannt. Das Datenobjekt 'x' der Prozedur dagegen
+   kann nur innerhalb der Prozedur angesprochen werden, es ist also ein lokales
+   Datenobjekt der Prozedur. Innerhalb der Prozedur dürfen globale Datenobjekte
+   (also Objekte, die außerhalb von Prozeduren deklariert wurden) auch angespro­
+   chen werden. 
+ 
+   Eine Prozedur in ELAN bildet im Gegensatz zu Refinements einen eigenen Gültig­
+   keitsbereich hinsichtlich Datenobjekten und Refinements, die innerhalb der Pro­
+   zedur deklariert werden. Prozeduren sind somit ein Mittel, um die in ihr dekla­
+   rierten Datenobjekte hinsichtlich der Ansprechbarkeit nach Außen "abzuschotten". 
+ 
+ 
+ 
+Prozeduren mit Parametern 
+Prozeduren mit Parametern erlauben es, gleiche Anweisungen mit unterschiedlichen
+Datenobjekten auszuführen. 
+ 
+Form: 
+ 
+ 
+#on("i")##on("b")#PROC#off("i")##off("b")# Prozedurname #on("i")##on("b")#(#off("i")##off("b")# formale Parameterliste #on("i")##on("b")#)#off("i")##off("b")# #on("i")##on("b")#:#off("i")##off("b")# 
+   Prozedurrumpf 
+#on("i")##on("b")#END PROC#off("i")##off("b")# Prozedurnamen 
+ 
+ 
+Die Parameterliste besteht aus einem oder mehreren durch Kommata getrennten Para­
+metern. Ein Parameter wird mit Datentyp, Accessrecht und Namen angegeben. 
+Ähnlich wie bei der Datendeklaration braucht man für aufeinanderfolgende Parameter
+mit gleichem Datentyp und gleichem Accessrecht die Attribute nur einmal anzugeben.
+Parameter mit Accessrecht #on("i")##on("b")#CONST#off("i")##off("b")# sind Eingabeparameter, Parameter mit Access­
+recht #on("i")##on("b")#VAR#off("i")##off("b")# realisieren Ein-/Ausgabeparameter. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ PROC vertausche (INT VAR a, b): 
+    INT VAR x :: a; 
+    a := b; 
+    b := x 
+ END PROC vertausche; 
+ 
+ INT VAR eins :: 1, 
+         zwei :: 2, 
+         drei :: 3; 
+ vertausche (eins, zwei); 
+ vertausche (zwei, drei); 
+ vertausche (eins, zwei); 
+ put (eins); put (zwei); put (drei) 
+  
+____________________________________________________________________________ 
+ 
+ 
+Die Datenobjekte 'a' und 'b' der Prozedur 'vertausche' werden formale Parameter
+genannt. Sie stehen als Platzhalter für die bei einem Prozeduraufruf einzusetzenden
+aktuellen Parameter (in obigen Beispiel die Datenobjekte 'eins', 'zwei' und 'drei'). 
+ 
+ 
+ 
+Prozeduren als Parameter 
+Es ist auch möglich, Prozeduren als Parameter zu definieren. 
+ 
+Eine Prozedur als Parameter wird folgendermaßen in der Parameterliste spezifiziert:  
+ 
+Resultattyp #on("i")##on("b")#PROC#off("i")##off("b")# #on("i")##on("b")#(#off("i")##off("b")# virtuelle Parameterliste #on("i")##on("b")#)#off("i")##off("b")# Prozedurname 
+ 
+ 
+Die Angabe des Resultattyps entfällt, wenn es sich nicht um eine wertliefernde Proze­
+dur handelt. Die virtuelle Parameterliste inklusive der Klammern entfällt, falls die
+Prozedur keine Parameter hat. Die virtuelle Parameterliste beschreibt die Parame­
+ter der Parameterprozedur. Es werden Datentyp und Zugriffsrecht eines jeden Para­
+meters angegeben, jedoch ohne Namen. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ PROC wertetabelle (REAL PROC (REAL CONST) funktion, 
+                    REAL CONST untergrenze, obergrenze, 
+                         schrittweite): 
+ 
+ REAL VAR wert; 
+ putline ("W E R T E T A B E L L E"); 
+ putline ("-----------------------"); 
+ wert := untergrenze; 
+ REPEAT 
+    put (text (wert, 10, 5)); 
+    put (text (funktion (wert), 10, 5)); 
+    line; 
+    wert INCR schrittweite 
+ UNTIL wert > obergrenze PER 
+ 
+ END PROC wertetabelle; 
+ 
+ (* Prozeduraufruf: *) 
+ wertetabelle (REAL PROC (REAL CONST) sin, 0.0, pi, 0.2) 
+ 
+____________________________________________________________________________ 
+ 
+ 
+Wertliefernde Prozeduren 
+Eine wertliefernde Prozedur sieht folgendermaßen aus: 
+ 
+ 
+Resultattyp #on("i")##on("b")#PROC#off("i")##off("b")# Prozedurname #on("i")##on("b")#(#off("i")##off("b")# formale Parameterliste #on("i")##on("b")#)#off("i")##off("b")# #on("i")##on("b")#:#off("i")##off("b")# 
+   wertliefernder Prozedurrumpf 
+#on("i")##on("b")#END PROC#off("i")##off("b")# Prozedurnamen 
+ 
+ 
+ 
+Die Parameterliste inklusive Klammerung kann fehlen. Der Prozedurrumpf muß einen
+Wert mit dem in Resultattyp angegeben Datentyp liefern. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ INT PROC max (INT CONST a, b): 
+    IF a > b 
+      THEN a 
+      ELSE b 
+    END IF 
+ END PROC max; 
+ 
+ put (max (3, 4)) 
+  
+____________________________________________________________________________ 
+ 
+ 
+(In diesem Beispiel wird das Maximum von 'a' und 'b' ermittelt und ausgegeben) 
+ 
+#page# 
+ 
+2.4.3.3  Operatorvereinbarung 
+ 
+Operatoren können in ELAN ähnlich wie Prozeduren definiert werden. Operatoren
+müssen einen und können maximal zwei Operatoren besitzen (monadische und dyadi­
+sche Operatoren). 
+ 
+Form: 
+ 
+ 
+Resultattyp #on("i")##on("b")#OP#off("i")##off("b")# Opname #on("i")##on("b")#(#off("i")##off("b")# ein oder zwei Parameter #on("i")##on("b")#)#off("i")##off("b")# #on("i")##on("b")#:#off("i")##off("b")# 
+   Operatorrumpf 
+#on("i")##on("b")#END OP#off("i")##off("b")# Opname 
+ 
+ 
+Der Resultattyp wird nur bei wertliefernden Operatoren angegeben. 
+ 
+Als Operatornamen sind erlaubt: 
+ 
+-  ein Sonderzeichen, sofern es nicht als Trennzeichen benutzt wird: 
+   !  $  %  &  '  *  +  -  /  <  =  >  ?  §  ^  '  ~ 
+-  eine Kombination von zwei Sonderzeichen. Diese Kombination muß jedoch bereits
+   in ELAN existieren: 
+   :=   <=   >=   <>   ** 
+-  ein Schlüsselwort (siehe 2.2.1). 
+ 
+ 
+ 
+Vereinbarung eines monadischen Operators 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ INT OP SIGN (REAL CONST argument): 
+    IF    argument < 0.0  THEN  -1 
+    ELIF  argument = 0.0  THEN  0 
+                          ELSE  1 
+    FI 
+ END OP SIGN 
+  
+____________________________________________________________________________ 
+ 
+ 
+(Der Operator 'SIGN' liefert abhängig vom Vorzeichen des übergebenen Wertes den
+INT-Wert -1, 0 oder 1) 
+ 
+ 
+ 
+Vereinbarung eines dyadischen Operators 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ TEXT OP * (INT CONST anzahl, TEXT CONST t): 
+    INT  VAR zaehler :: anzahl; 
+    TEXT VAR ergebnis :: ""; 
+    WHILE zaehler > 0 REP 
+       ergebnis := ergebnis + t; 
+       zaehler := zaehler - 1 
+    END REP; 
+    ergebnis 
+ END OP *; 
+  
+____________________________________________________________________________ 
+ 
+ 
+(Der Operator '*' verkettet 'anzahl'- mal den Text 't') 
+ 
+ 
+ 
+2.4.3.4  Paketvereinbarung 
+ 
+Pakete sind in ELAN eine Zusammenfassung von Datenobjekten, Prozeduren, Opera­
+toren und Datentypen. Diese bilden den Paketrumpf. Elemente eines Pakets (Prozedu­
+ren, Operatoren, Datentypen) können außerhalb des Pakets nur angesprochen werden,
+wenn sie in der Schnittstelle des Pakets, die auch "interface" genannt wird, aufge­
+führt werden. Mit anderen Worten: es können alle Elemente eines Pakets von außen
+nicht angesprochen werden, sofern sie nicht über die Schnittstelle "nach außen ge­
+reicht" werden. Pakete können separat übersetzt werden, so daß der "Zusammen­
+bau" eines umfangreichen Programms aus mehreren Paketen möglich ist. 
+ 
+Der formale Aufbau eines Pakets sieht folgendermaßen aus: 
+ 
+ 
+#on("i")##on("b")#PACKET#off("i")##off("b")# Paketname #on("i")##on("b")#DEFINES#off("i")##off("b")# Schnittstelle #on("i")##on("b")#:#off("i")##off("b")# 
+   Paketrumpf 
+#on("i")##on("b")#END PACKET#off("i")##off("b")# Paketname 
+ 
+ 
+In der Schnittstelle werden Prozeduren und Operatoren nur mit ihrem Namen, durch
+Kommata getrennt, angegeben. Weiterhin können Datentypen und mit CONST verein­
+barte Datenobjekte in der Schnittstelle aufgeführt werden, aber keine VAR-Datenob­
+jekte, weil diese sonst über Paket-Grenzen hinweg verändert werden könnten. 
+ 
+Im Gegensatz zu einer Prozedur kann ein PACKET nicht aufgerufen werden (nur die
+Elemente der Schnittstelle können benutzt werden). 
+ 
+Pakete werden zu folgenden Zwecken eingesetzt: 
+ 
+-  Spracherweiterung 
+-  Schutz vor fehlerhaftem Zugriff auf Datenobjekte 
+-  Realisierung von abstrakten Datentypen. 
+ 
+ 
+ 
+Spracherweiterung 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ PACKET fuer eine prozedur DEFINES swap: 
+ 
+ PROC swap (INT VAR a, b): 
+    INT CONST x :: a; 
+    b := a; 
+    a := x 
+ END PROC swap 
+ 
+ END PACKET fuer eine prozedur 
+  
+____________________________________________________________________________ 
+ 
+ 
+Dies ist ein Paket, das eine Tausch-Prozedur für INT-Datenobjekte bereitstellt. Das
+PACKET kann übersetzt und dem ELAN-Compiler bekannt gemacht werden
+(EUMEL: "insertieren"). Ist das geschehen, kann man 'swap' wie alle anderen Proze­
+duren (z.B. 'put', 'get') in einem Programm verwenden. Tatsächlich werden die mei­
+sten Prozeduren und Operatoren (aber auch einige Datentypen), die in ELAN zur
+Verfügung stehen, nicht durch den ELAN-Compiler realisiert, sondern durch solche
+PACKETs. Um solche Objekte einigermaßen zu standardisieren, wurde in der
+ELAN-Sprachbeschreibung festgelegt, welche Datentypen, Prozeduren und Operato­
+ren in jedem ELAN-System vorhanden sein müssen. Solche Pakete werden Stan­
+dard-Pakete genannt. Jeder Installation - aber auch jedem Benutzer - steht es
+jedoch frei, zu den Standard-Paketen zusätzliche Pakete dem Compiler bekannzu­
+geben, und damit den ELAN-Sprachumfang zu erweitern. 
+ 
+ 
+ 
+Schutz vor fehlerhaftem Zugriff auf Datenobjekte 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ PACKET stack handling DEFINES push, pop, init stack: 
+ 
+ LET max = 1000; 
+ ROW max INT VAR stack; (* siehe Kapitel Reihung, 2.6.1. *) 
+ INT VAR stack pointer; 
+ 
+ PROC init stack: 
+    stack pointer := 0 
+ END PROC init stack; 
+ 
+ PROC push (INT CONST dazu wert): 
+    stack pointer INCR 1; 
+    IF stack pointer > max 
+      THEN errorstop ("stack overflow") 
+      ELSE stack [stack pointer] := dazu wert 
+    END IF 
+ END PROC push; 
+ 
+ PROC pop (INT VAR von wert): 
+    IF stack pointer = 0 
+      THEN errorstop ("stack empty") 
+      ELSE von wert := stack [stack pointer]; 
+           stack pointer DECR 1 
+    END IF 
+ END PROC pop 
+ 
+ END PACKET stack handling; 
+ 
+____________________________________________________________________________ 
+ 
+ 
+Dieses Packet realisiert einen Stack. Den Stack kann man über die Prozeduren 'init
+stack', 'push' und 'pop' benutzen. 
+#page# 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ init stack; 
+ werte einlesen und pushen; 
+ werte poppen und ausgeben. 
+ 
+ werte einlesen und pushen: 
+    INT VAR anzahl :: 0, wert; 
+    REP 
+       get (wert); 
+       push (wert); 
+       anzahl INCR 1 
+    UNTIL ende kriterium END REP. 
+ 
+ werte poppen und ausgeben: 
+    INT VAR i; 
+    FOR i FROM 1 UPTO anzahl REP 
+       pop (wert); 
+       put (wert) 
+    END REP. 
+  
+____________________________________________________________________________ 
+ 
+ 
+Die Datenobjekte 'stack' und 'stack pointer' haben nur Gültigkeit innerhalb des
+PACKETs 'stack handling'. 
+ 
+Anweisungen wie z.B. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ put (stack [3]); 
+ stack [27] := 5 
+  
+____________________________________________________________________________ 
+ 
+ 
+ 
+außerhalb des PACKETs 'stack handling' sind also verboten und werden vom
+ELAN-Compiler entdeckt. 
+ 
+Ein PACKET bietet also auch einen gewissen Schutz vor fehlerhafter Verwendung von
+Programmen und Datenobjekten. Wichtig ist weiterhin, daß die Realisierung des
+Stacks ohne weiteres geändert werden kann, ohne daß Benutzerprogramme im 'main
+packet' geändert werden müssen, sofern die Schnittstelle nicht verändert wird. Bei­
+spielsweise kann man sich entschließen, den Stack nicht durch eine Reihung, son­
+dern durch eine Struktur zu realisieren. Davon bleibt ein Benutzerprogramm unbe­
+rührt. 
+ 
+ 
+ 
+Realisierung von abstrakten Datentypen 
+Der Vollständigkeit halber wird folgendes Beispiel hier gezeigt. Wie neue Datentypen
+definiert werden, wird in Kapitel 2.7.1. erklärt. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ PACKET widerstaende DEFINES WIDERSTAND, REIHE, PARALLEL, 
+                             :=, get, put: 
+ 
+ TYPE WIDERSTAND = INT; 
+ 
+ OP := (WIDERSTAND VAR l, WIDERSTAND CONST r): 
+    CONCR (l) := CONCR (r) 
+ END OP :=; 
+ 
+ PROC get (WIDERSTAND VAR w): 
+    INT VAR i; 
+    get (i); 
+    w := WIDERSTAND : (i) 
+ END PROC get; 
+ 
+ PROC put (WIDERSTAND CONST w): 
+    put (CONCR (w)) 
+ END PROC put; 
+ 
+ WIDERSTAND OP REIHE (WIDERSTAND CONST l, r): 
+    WIDERSTAND : ( CONCR (l) + CONCR (r)) 
+ END OP REIHE; 
+ 
+ WIDERSTAND OP PARALLEL (WIDERSTAND CONST l, r): 
+   WIDERSTAND : 
+     ((CONCR (l) * CONCR (r)) DIV (CONCR (l) + CONCR (r))) 
+ END OP PARALLEL 
+ 
+ END PACKET widerstaende 
+ 
+____________________________________________________________________________ 
+ 
+ 
+Dieses Programm realisiert den Datentyp WIDERSTAND und mit den Operationen
+eine Fachsprache. 
+ 
+ 
+ 
+2.4.4  Terminatoren für Refinements, 
+       Prozeduren und Operatoren
+        
+ 
+Das LEAVE-Konstrukt wird verwendet, um eine benannte Anweisung (Refinement,
+Prozedur oder Operator) vorzeitig zu verlassen. Es ist auch möglich, geschachtelte
+Refinements zu verlassen. 
+ 
+Form: 
+ 
+#on("i")##on("b")#LEAVE#off("i")##off("b")# Name 
+ 
+ 
+Durch eine (optionale) WITH-Angabe kann auch eine wertliefernde benannte Anwei­
+sung verlassen werden. 
+ 
+Form: 
+ 
+#on("i")##on("b")#LEAVE#off("i")##off("b")# Name #on("i")##on("b")#WITH#off("i")##off("b")# Ausdruck 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ INT OP ** (INT CONST basis, exp): 
+     IF exp = 0 
+        THEN LEAVE ** WITH 1 
+     ELIF exp < 0 
+        THEN LEAVE ** WITH 0 
+     FI; 
+ 
+     INT VAR  zaehler, ergebnis; 
+     ergebnis := basis; 
+     FOR zaehler FROM 2 UPTO exp REP 
+        ergebnis := ergebnis * basis 
+     PER; 
+     ergebnis 
+ END OP ** 
+  
+____________________________________________________________________________ 
+ 
+ 
+(Diese Operation realisiert die Exponentiation für INT-Werte) 
+ 
+ 
+ 
+2.4.5  Generizität von Prozeduren 
+       und Operatoren
+        
+ 
+In ELAN ist es möglich, unterschiedlichen Prozeduren bzw. Operatoren gleiche
+Namen zu geben. Solche Prozeduren (Operatoren) werden generische Prozeduren
+(Operatoren) genannt. Die Identifizierung erfolgt durch Anzahl, Reihenfolge und Daten­
+typ der Parameter (Operanden). 
+ 
+Deshalb werden Prozeduren und Operatoren unter Angabe des Prozedur- bzw. des
+Operatorkopfes dokumentiert. 
+ 
+Beispiele: 
+ 
+ 
+INT  OP MOD (INT CONST  l, r) 
+REAL OP MOD (REAL CONST l, r) 
+ 
+ 
+Der MOD-Operator liefert den Rest einer Division. Er ist sowohl für INT- wie auch
+für REAL-Datenobjekte definiert. 
+ 
+ 
+ 
+PROC put (INT CONST wert) 
+PROC put (REAL CONST wert) 
+PROC put (TEXT CONST wert) 
+ 
+ 
+Die put-Prozedur ist für INT-, REAL- und TEXT-Datenobjekte definiert. 
+ 
+ 
+
+Priorität von generischen Operatoren
+Bei der Neudefinition von Operatoren kann man bereits benutzte Sonderzeichen oder
+Schlüsselwörter benutzen. In diesem Fall bekommt der neudefinierte Operator die
+gleiche Priorität wie der bereits vorhandene Operator. 
+ 
+ 
+ 
+2.4.6     Rekursive Prozeduren 
+           und Operatoren
+           
+ 
+Alle Prozeduren und Operatoren dürfen in ELAN rekursiv sein. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ INT PROC fakultaet (INT CONST n): 
+    IF n > 0 
+      THEN fakultaet (n-1) * n 
+      ELSE 1 
+    END IF 
+ END PROC fakultaet 
+  
+____________________________________________________________________________ 
+ 
+ 
+Die Fakultätsfunktion ist kein gutes Beispiel für eine Rekursion, denn das Programm
+kann leicht in eine iterative Version umgewandelt werden: 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ INT PROC fakultaet (INT CONST n): 
+    INT VAR prod :: 1, i; 
+    FOR i FROM 2 UPTO n REP 
+      prod := prod * i 
+    END REP; 
+    prod 
+ END PROC fakultaet 
+ 
+____________________________________________________________________________ 
+ 
+ 
+Die Umwandlung von einem rekursiven Programm in ein iteratives ist übrigens immer
+möglich, jedoch oft nicht so einfach, wie in dem Beispiel der Ackermann-Funktion: 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ INT PROC acker (INT CONST m, n): 
+    IF m = 0 
+      THEN n + 1 
+    ELIF n = 0 
+      THEN acker (m-1, 0) 
+      ELSE acker (m - 1, acker (m, n - 1)) 
+    ENDIF 
+ END PROC acker 
+ 
+____________________________________________________________________________ 
+ 
+ 
+Das eigentliche Einsatzgebiet von rekursiven Algorithmen liegt aber bei den 'back­
+track'-Verfahren. Diese werden eingesetzt, wenn eine exakte algorithmische Lösung
+nicht bekannt ist oder nicht gefunden werden kann und man verschiedene Versuche
+machen muß, um zu einem Ziel (oder Lösung) zu gelangen. 
+
diff --git a/doc/programmer-manual/1.8.7/doc/programmierhandbuch.2b b/doc/programmer-manual/1.8.7/doc/programmierhandbuch.2b
new file mode 100644
index 0000000..c2103ba
--- /dev/null
+++ b/doc/programmer-manual/1.8.7/doc/programmierhandbuch.2b
@@ -0,0 +1,1395 @@
+#headandbottom("52","EUMEL-Benutzerhandbuch","TEIL 2 : ELAN","2")# 
+#pagenr ("%", 52)##setcount(1)##block##pageblock# 
+#headeven# 
+#center#EUMEL-Benutzerhandbuch 
+#center#____________________________________________________________ 
+ 
+#end# 
+#headodd# 
+#center#TEIL 2 : ELAN 
+#center#____________________________________________________________ 
+ 
+#end# 
+#bottomeven# 
+#center#____________________________________________________________ 
+2 - % #right#GMD 
+#end# 
+#bottomodd# 
+#center#____________________________________________________________ 
+GMD #right#2 - % 
+#end# 
+ 
+ 
+2.5  Programmstruktur 
+ 
+Ein ELAN-Programm kann aus mehreren Moduln (Bausteinen) aufgebaut sein, die in
+ELAN PACKETs genannt werden. Das letzte PACKET wird "main packet" genannt,
+weil in diesem das eigentliche Benutzerprogramm (Hauptprogramm) enthalten ist. 
+Dies soll eine Empfehlung sein, in welcher Reihenfolge die Elemente eines PACKETs
+geschrieben werden sollen: 
+ 
+Ein "main packet" kann aus folgenden Elementen bestehen: 
+ 
+a) Deklarationen und Anweisungen. Diese müssen nicht in einer bestimmten Reihen­
+   folge im Programm erscheinen, sondern es ist möglich, erst in dem Augenblick zu
+   deklarieren, wenn z.B. eine neue Variable benötigt wird. Es ist jedoch gute Pro­
+   grammierpraxis, die meisten Deklarationen an den Anfang eines Programms oder
+   Programmteils (Refinement, Prozedur) zu plazieren. 
+ 
+   <Deklarationen> ; 
+   <Anweisungen> 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ INT VAR erste zahl, zweite zahl; 
+ 
+ page; 
+ put ("erste Zahl = "); get (erste zahl); 
+ put ("zweite Zahl ="); get (zweite zahl) 
+ 
+____________________________________________________________________________ 
+ 
+ 
+b) Deklarationen, Refinements und Anweisungen. In diesem Fall ist es notwendig, die 
+   Refinements hintereinander zu plazieren. Refinement-Aufrufe und/oder
+   Anweisungen sollten textuell vorher erscheinen. 
+ 
+   <Deklarationen> ; 
+   <Refinement-Aufrufe und/oder Anweisungen> . 
+   <Refinements> 
+ 
+   Innerhalb der Refinements sind Anweisungen und/oder Deklarationen möglich. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ INT VAR erste zahl, zweite zahl; 
+ 
+ loesche bildschirm; 
+ lies zwei zahlen ein. 
+ 
+ loesche bildschirm: 
+   page. 
+ 
+ lies zwei zahlen ein: 
+   put ("erste Zahl = "); get (erste zahl); 
+   put ("zweite Zahl ="); get (zweite zahl). 
+ 
+____________________________________________________________________________ 
+ 
+ 
+c) Deklarationen, Prozeduren und Anweisungen. Werden Prozeduren vereinbart,
+   sollte man sie nach den Deklarationen plazieren. Danach sollten die Anweisungen
+   folgen: 
+ 
+   <Deklarationen> ; 
+   <Prozeduren> ; 
+   <Anweisungen> 
+ 
+   Mehrere Prozeduren werden durch ";" voneinander getrennt. In diesem Fall sind
+   die Datenobjekte aus den Deklarationen außerhalb von Prozeduren statisch, d.h.
+   während der gesamten Laufzeit des Programm vorhanden. Solche Datenobjekte
+   werden auch PACKET-Daten genannt. Im Gegensatz dazu sind die Datenobjekte
+   aus Deklarationen in Prozeduren dynamische Datenobjekte, die nur während der
+   Bearbeitungszeit der Prozedur existieren. Innerhalb einer Prozedur dürfen wieder­
+   um Refinements verwendet werden. Ein Prozedur-Rumpf hat also den formalen
+   Aufbau wie unter a) oder b) geschildert. 
+ 
+   Die Refinements und Datenobjekte, die innerhalb einer Prozedur deklariert wurden,
+   sind lokal zu dieser Prozedur, d.h. können von außerhalb nicht angesprochen
+   werden. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ INT VAR erste zahl, zweite zahl; 
+ 
+ PROC vertausche (INT VAR a, b): 
+   INT VAR x; 
+ 
+   x := a; 
+   a := b; 
+   b := x 
+ END PROC vertausche; 
+ 
+ put ("erste Zahl = "); get (erste zahl); 
+ put ("zweite Zahl ="); get (zweite zahl); 
+ IF erste zahl > zweite zahl 
+    THEN vertausche (erste zahl, zweite zahl) 
+ FI 
+ 
+____________________________________________________________________________ 
+ 
+ 
+d) Deklarationen, Prozeduren, Anweisungen und PACKET-Refinements. Zusätzlich
+   zu der Möglichkeit c) ist es erlaubt, neben den Anweisungen außerhalb einer
+   Prozedur auch Refinements zu verwenden: 
+ 
+   <Deklarationen> ; 
+   <Prozeduren> ; 
+   <Anweisungen> . 
+   <Refinements> 
+ 
+   Diese Refinements können nun in Anweisungen außerhalb der Prozeduren benutzt
+   werden oder auch durch die Prozeduren (im letzteren Fall spricht man analog zu
+   globalen PACKET-Daten auch von PACKET-Refinements oder globalen Refine­
+   ments). In PACKET-Refinements dürfen natürlich keine Datenobjekte verwandt
+   werden, die lokal zu einer Prozedur sind. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ INT VAR erste zahl, zweite zahl; 
+ 
+ PROC vertausche (INT VAR a, b): 
+   INT VAR x; 
+ 
+   x := a; 
+   a := b; 
+   b := x 
+ END PROC vertausche; 
+ 
+ loesche bildschirm; 
+ lies zwei zahlen ein; 
+ ordne die zahlen. 
+ 
+ loesche bildschirm: 
+   page. 
+ 
+ lies zwei zahlen ein: 
+   put ("erste Zahl = "); get (erste zahl); 
+   put ("zweite Zahl ="); get (zweite zahl). 
+ 
+ ordne die zahlen: 
+   IF erste zahl > zweite zahl 
+      THEN vertausche (erste zahl, zweite zahl) 
+   FI 
+ 
+____________________________________________________________________________ 
+#page# 
+ 
+2.6  Zusammengesetzte Datentypen 
+ 
+In ELAN gibt es die Möglichkeit, gleichartige oder ungleichartige Datenobjekte zu
+einem Objekt zusammenzufassen. 
+ 
+ 
+2.6.1  Reihung 
+ 
+Die Zusammenfassung gleichartiger Datenobjekte, wird in ELAN eine Reihung (ROW)
+genannt. Die einzelnen Objekte einer Reihung werden Elemente genannt. 
+ 
+Eine Reihung wird folgendermaßen deklariert: 
+  
+-  Schlüsselwort #on("i")##on("b")#ROW#off("i")##off("b")# 
+-  Anzahl der zusammengefaßten Elemente 
+   (INT-Denoter oder durch LET definierter Name) 
+-  Datentyp der Elemente 
+-  Zugriffsrecht ( #on("i")##on("b")#VAR#off("i")##off("b")# oder #on("i")##on("b")#CONST#off("i")##off("b")# ) 
+-  Name der Reihung. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ ROW 10 INT VAR feld 
+ 
+____________________________________________________________________________ 
+ 
+ 
+Im obigen Beispiel wird eine Reihung von 10 INT-Elementen deklariert. ROW 10 INT
+ist ein (neuer, von den elementaren unterschiedlicher) Datentyp, für den keine Opera­
+tionen definiert sind, außer der Zuweisung. Das Accessrecht (VAR im obigen Bei­
+spiel) und der Name ('feld') gilt - wie bei den elementaren Datentypen - für diesen
+neuen Datentyp, also für alle 10 Elemente. 
+ 
+Warum gibt es keine Operationen außer der Zuweisung? Das wird sehr schnell
+einsichtig, wenn man bedenkt, daß es ja sehr viele Datentypen (zusätzlich zu den
+elementaren) gibt, weil Reihungen von jedem Datentyp gebildet werden können: 
+ 
+ 
+ROW 1 INT             ROW 1 REAL 
+ROW 2 INT             ROW 2 REAL 
+ :                     : 
+ROW maxint INT        ROW maxint REAL 
+ 
+ROW 1 TEXT            ROW 1 BOOL 
+ROW 2 TEXT            ROW 2 BOOL 
+ :                     : 
+ROW maxint TEXT       ROW maxint BOOL 
+ 
+ 
+Für die elementaren INT-, REAL-, BOOL- und TEXT-Datentypen sind unter­
+schiedliche Operationen definiert. Man müßte nun für jeden dieser zusammengesetz­
+ten Datentypen z.B. auch 'get'- und 'put'-Prozeduren schreiben, was allein vom
+Schreibaufwand sehr aufwendig wäre. Das ist der Grund dafür, daß es keine vorgege­
+bene Operationen auf zusammengesetzte Datentypen gibt. 
+ 
+Zugegebenermaßen könnte man mit solchen Datentypen, die nur über eine Operation
+verfügen (Zuweisung), nicht sehr viel anfangen, wenn es nicht eine weitere vorgege­
+bene Operation gäbe, die Subskription. Sie erlaubt es, auf die Elemente einer Reih­
+ung zuzugreifen und den Datentyp der Elemente "aufzudecken". 
+ 
+Form: 
+ 
+Rowname #on("i")##on("b")#[#off("i")##off("b")# Indexwert #on("i")##on("b")#]#off("i")##off("b")# 
+ 
+Beispiel: 
+ 
+ 
+feld [3] 
+ 
+ 
+bezieht sich auf das dritte Element der Reihung 'feld' und hat den Datentyp INT. Für
+INT-Objekte haben wir aber einige Operationen, mit denen wir arbeiten können. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiele: ........................ 
+ feld [3] := 7; 
+ feld [4] := feld [3] + 4; 
+ 
+____________________________________________________________________________ 
+ 
+ 
+Eine Subskription "schält" also vom Datentyp ein ROW ab und liefert ein Element der
+Reihung. Die Angabe der Nummer des Elements in der Reihung nennt man Subskript
+oder Index (in obigem Beispiel '3'). Der Subskript wird in ELAN in eckigen Klammern
+angegeben, um eine bessere Unterscheidung zu den runden Klammern in Ausdrücken
+zu erreichen. Ein subskribiertes ROW-Datenobjekt kann also überall da verwendet
+werden, wo ein entsprechender Datentyp benötigt wird (Ausnahme: nicht als Schlei­
+fenvariable). 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ PROC get (ROW 10 INT VAR feld): 
+    INT VAR i; 
+    FOR i FROM 1 UPTO 10 REP 
+      put (i); put ("tes Element bitte:"); 
+      get (feld [i]); 
+      line 
+    END REP 
+ END PROC get; 
+ 
+ PROC put (ROW 10 INT CONST feld): 
+    INT VAR i; 
+    FOR i FROM 1 UPTO 10 REP 
+      put (i); put ("tes Element ist:"); 
+      put (feld [i]); 
+      line 
+    END REP 
+ END PROC put 
+ 
+____________________________________________________________________________ 
+ 
+ 
+In diesen Beispielen werden Reihungen als Parameter benutzt. 
+ 
+Diese beiden Prozeduren werden im folgenden Beispiel benutzt um 10 Werte einzu­
+lesen und die Summe zu berechnen: 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ ROW 10 INT VAR werte; 
+ lies werte ein; 
+ summiere sie; 
+ drucke die summe und einzelwerte. 
+ 
+ lies werte ein: 
+    get (werte). 
+ 
+ summiere sie: 
+    INT VAR summe :: 0, i; 
+    FOR i FROM 1 UPTO 10 REP 
+      summe INCR werte [i] 
+    END REP. 
+ 
+ drucke die summe und einzelwerte: 
+    put (werte); 
+    line; 
+    put ("Summe:"); put (summe). 
+ 
+____________________________________________________________________________ 
+ 
+ 
+Da es möglich ist, von jedem Datentyp eine Reihung zu bilden, kann man natürlich
+auch von einer Reihung eine Reihung bilden: 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ ROW 5 ROW 10 INT VAR matrix 
+ 
+____________________________________________________________________________ 
+ 
+ 
+Für eine "doppelte" Reihung gilt das für "einfache" Reihungen gesagte. Wiederum
+existieren keine Operationen für dieses Datenobjekt (außer der Zuweisung), jedoch ist
+es durch Subskription möglich, auf die Elemente zuzugreifen: 
+ 
+ 
+matrix [3] 
+ 
+ 
+liefert ein Datenobjekt mit dem Datentyp ROW 10 INT. 
+ 
+Subskribiert man jedoch 'matrix' nochmals, so erhält man ein INT: 
+ 
+ 
+matrix [2] [8] 
+ 
+ 
+(jede Subskription "schält" von Außen ein ROW vom Datentyp ab). 
+#page# 
+ 
+2.6.2  Struktur 
+ 
+Strukturen sind Datenverbunde wie Reihungen, aber die Komponenten können unglei­
+chartige Datentypen haben. Die Komponenten von Strukturen heißen Felder (Reihun­
+gen: Elemente) und der Zugriff auf ein Feld Selektion (Reihungen: Subskription). Eine
+Struktur ist - genauso wie bei Reihungen - ein eigener Datentyp, der in einer
+Deklaration angegeben werden muß. 
+ 
+Die Deklaration einer Struktur sieht folgendermaßen aus: 
+ 
+-  Schlüsselwort #schl ("STRUCT#off("i")##off("b")# 
+-  unterschiedliche Datenobjekte in Klammern. Die Datenobjekte werden mit Datentyp und Namen angegeben 
+-  Zugriffsrecht ( #on("i")##on("b")#VAR#off("i")##off("b")# oder #on("i")##on("b")#CONST#off("i")##off("b")# ) 
+-  Name der Struktur. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ STRUCT (TEXT name, INT alter) VAR ich 
+ 
+____________________________________________________________________________ 
+ 
+ 
+Wiederum existieren keine Operationen auf Strukturen außer der Zuweisung und der
+Selektion, die es erlaubt, Komponenten aus einer Struktur herauszulösen. 
+ 
+Die Selektion hat folgende Form: 
+ 
+Objektname #on("i")##on("b")#.#off("i")##off("b")# Feldname 
+ 
+Beispiele: 
+ 
+ 
+ich . name 
+ich . alter 
+ 
+ 
+Die erste Selektion liefert einen TEXT-, die zweite ein INT-Datenobjekt. Mit diesen
+(selektierten) Datenobjekten kann - wie gewohnt - gearbeitet werden (Ausnahme:
+nicht als Schleifenvariable). 
+ 
+Zum Datentyp einer Struktur gehören auch die Feldnamen: 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ STRUCT (TEXT produkt name, INT artikel nr) VAR erzeugnis 
+ 
+____________________________________________________________________________ 
+ 
+ 
+Die obige Struktur ist ein anderer Datentyp als im ersten Beispiel dieses Abschnitts,
+da die Namen der Felder zur Unterscheidung hinzugezogen werden. Für Strukturen -
+genauso wie bei Reihungen - kann man sich neue Operationen definieren. 
+ 
+Im folgenden Programm werden eine Struktur, die Personen beschreibt, die Prozedu­
+ren 'put', 'get' und der dyadische Operator HEIRATET definiert. Anschließend werden
+drei Paare verHEIRATET. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ PROC get (STRUCT (TEXT name, vorname, INT alter) VAR p): 
+    put ("bitte Nachname:"); get ( p.name); 
+    put ("bitte Vorname:");  get ( p.vorname); 
+    put ("bitte Alter:");    get ( p.alter); 
+    line 
+ END PROC get; 
+ 
+ PROC put (STRUCT (TEXT name, vorname, INT alter) CONST p): 
+    put (p.vorname); put (p.name); 
+    put ("ist"); 
+    put (p.alter); 
+    put ("Jahre alt"); 
+    line 
+ END PROC put; 
+ 
+ OP HEIRATET 
+    (STRUCT (TEXT name, vorname, INT alter) VAR w, 
+     STRUCT (TEXT name, vorname, INT alter) CONST m): 
+    w.name := m.name 
+ END OP HEIRATET; 
+ 
+____________________________________________________________________________ 
+ 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ ROW 3 STRUCT (TEXT name, vorname, INT alter) VAR frau, 
+                                                  mann; 
+ 
+ personendaten einlesen; 
+ heiraten lassen; 
+ paardaten ausgeben. 
+ 
+ personendaten einlesen: 
+    INT VAR i; 
+    FOR i FROM 1 UPTO 3 REP 
+      get (frau [i]); 
+      get (mann [i]) 
+    END REP. 
+ 
+ heiraten lassen: 
+    FOR i FROM 1 UPTO 3 REP 
+      frau [i] HEIRATET mann [i] 
+    END REP. 
+ 
+ paardaten ausgeben: 
+    FOR i FROM 1 UPTO 3 REP 
+      put (frau [i]); 
+      put ("hat geheiratet:"); line; 
+      put (mann [i]); line 
+    END REP. 
+  
+____________________________________________________________________________ 
+ 
+ 
+Reihungen und Strukturen dürfen miteinander kombiniert werden, d.h. es darf eine
+Reihung in einer Struktur erscheinen oder es darf eine Reihung von einer Struktur
+vorgenommen werden. Selektion und Subskription sind in diesen Fällen in der Reihen­
+folge vorzunehmen, wie die Datentypen aufgebaut wurden (von außen nach innen). 
+#page# 
+ 
+2.6.3  LET-Konstrukt für zusammengesetzte Datentypen 
+       
+ 
+Die Verwendung von Strukturen oder auch Reihungen kann manchmal schreibauf­
+wendig sein. Mit dem LET-Konstrukt darf man Datentypen einen Namen geben.
+Dieser Name steht als Abkürzung und verringert so die Schreibarbeit. Zusätzlich wird
+durch die Namensgebung die Lesbarkeit des Programms erhöht. 
+ 
+Form: 
+ 
+#on("i")##on("b")#LET#off("i")##off("b")# Name #on("i")##on("b")#=#off("i")##off("b")# Datentyp 
+ 
+Der Name darf nur aus Großbuchstaben (ohne Blanks) bestehen. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ LET PERSON = STRUCT (TEXT name, vorname, INT alter); 
+ 
+ PROC get (PERSON VAR p): 
+    put ("bitte Nachname:"); get ( p.name); 
+    put ("bitte Vorname:");  get ( p.vorname); 
+    put ("bitte Alter:");    get ( p.alter); 
+    line 
+ END PROC get; 
+ 
+ PROC put (PERSON CONST p): 
+    put (p.vorname); put (p.name); put ("ist"); 
+    put (p.alter);   put ("Jahre alt"); line 
+ END PROC put; 
+ 
+ OP HEIRATET (PERSON VAR f, PERSON CONST m): 
+    f.name := m.name 
+ END OP HEIRATET; 
+ 
+ ROW 3 PERSON VAR mann, frau; 
+  
+____________________________________________________________________________ 
+ 
+ 
+Überall, wo der abzukürzende Datentyp verwandt wird, kann stattdessen der Name
+PERSON benutzt werden. Wohlgemerkt: PERSON ist kein neuer Datentyp, sondern
+nur ein Name, der für STRUCT (....) steht. Der Zugriff auf die Komponenten des
+abgekürzten Datentyps bleibt erhalten (was bei abstrakten Datentypen, die später
+erklärt werden, nicht mehr der Fall ist). 
+ 
+Neben der Funktion der Abkürzung von Datentypen kann das LET-Konstrukt auch
+zur Namensgebung für Denoter verwandt werden (siehe 2.3.1.2). 
+ 
+ 
+ 
+2.6.4  Denoter für zusammengesetzte 
+       Datentypen (Konstruktor)
+       
+ 
+Oft ist es notwendig, Datenverbunden Werte zuzuweisen (z.B.: bei der Initialisierung).
+Dies kann durch normale Zuweisungen erfolgen: 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ LET PERSON = STRUCT (TEXT name, vorname, INT alter); 
+ 
+ PERSON VAR mann; 
+ 
+ mann.name := "meier"; 
+ mann.vorname := "egon"; 
+ mann.alter := 27 
+  
+____________________________________________________________________________ 
+ 
+ 
+Eine andere Möglichkeit für die Wertbesetzung von Datenverbunden ist der Konstruk­
+tor: 
+ 
+Form: 
+ 
+Datentyp #on("i")##on("b")#:#off("i")##off("b")# #on("i")##on("b")#(#off("i")##off("b")# Wertliste #on("i")##on("b")#)#off("i")##off("b")# 
+ 
+In der Wertliste wird für jede Komponente des Datentyps, durch Kommata getrennt,
+ein Wert aufgeführt. Besteht eine der Komponenten wiederum aus einem Datenver­
+bund, muß innerhalb des Konstruktors wiederum ein Konstruktor eingesetzt werden. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ LET PERSON = STRUCT (TEXT name, vorname, INT alter); 
+ 
+ PERSON VAR mann, frau; 
+ 
+ frau := PERSON : ( "niemeyer", "einfalt", 65); 
+ frau HEIRATET PERSON : ( "meier", "egon", 27) 
+  
+____________________________________________________________________________ 
+ 
+ 
+Ein Konstruktor ist also ein Mechanismus, um ein Datenobjekt eines Datenverbundes
+in einem Programm zu notieren. 
+ 
+Konstruktoren sind natürlich für Reihungen auch möglich: 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ ROW 7 INT VAR feld; 
+ feld := ROW 7 INT : ( 1, 2, 3, 4, 5, 6, 7); 
+____________________________________________________________________________ 
+#page# 
+ 
+2.7  Abstrakte Datentypen 
+ 
+ 
+2.7.1  Definition neuer Datentypen 
+ 
+Im Gegensatz zur LET-Vereinbarung für Datentypen, bei der lediglich ein neuer
+Name für einen bereits vorhandenen Datentyp eingeführt wird und bei der somit auch
+keine neuen Operationen definiert werden müssen (weil die Operationen für den
+abzukürzenden Datentyp verwandt werden können), wird durch eine TYPE-Verein­
+barung ein gänzlich neuer Datentyp eingeführt. 
+ 
+Form: 
+ 
+#on("i")##on("b")#TYPE#off("i")##off("b")# Name #on("i")##on("b")#=#off("i")##off("b")# Feinstruktur 
+ 
+Der Name darf nur aus Großbuchstaben (ohne Blanks) bestehen. Die Feinstruktur
+(konkreter Typ, Realisierung des Datentyps) kann jeder bereits definierte Datentyp
+sein. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ TYPE PERSON = STRUCT (TEXT name, vorname, INT alter) 
+ 
+____________________________________________________________________________ 
+ 
+ 
+Der neudefinierte Datentyp wird abstrakter Datentyp genannt. Im Gegensatz zu
+Strukturen und Reihungen stehen für solche Datentypen noch nicht einmal die Zuwei­
+sung zur Verfügung. Ein solcher Datentyp kann genau wie alle anderen Datentypen
+verwendet werden (Deklarationen, Parameter, wertliefernde Prozeduren, als Kompo­
+nenten in Reihungen und Strukturen usw.). 
+ 
+Wird der Datentyp über die Schnittstelle des PACKETs anderen Programmteilen zur
+Verfügung gestellt, so müssen Operatoren und/oder Prozeduren für den Datentyp
+ebenfalls "herausgereicht" werden. Da dann der neudefinierte Datentyp genauso wie
+alle anderen Datentypen verwandt werden kann, aber die Komponenten (Feinstruktur)
+nicht zugänglich sind, spricht man von abstrakten Datentypen. 
+ 
+Welche Operationen sollten für einen abstrakten Datentyp zur Verfügung stehen?
+Obwohl das vom Einzelfall abhängt, werden meistens folgende Operationen und
+Prozeduren definiert: 
+ 
+-  'get'- und 'put'-Prozeduren. 
+-  Zuweisung (auch für die Initialisierung notwendig). 
+-  Denotierungs-Prozedur (weil kein Konstruktor für den abstrakten Datentyp außer­
+   halb des definierenden PACKETs zur Verfügung steht) 
+ 
+ 
+ 
+2.7.2  Konkretisierung 
+ 
+Um neue Operatoren und/oder Prozeduren für einen abstrakten Datentyp zu schrei­
+ben, ist es möglich, auf die Komponenten des Datentyps (also auf die Feinstruktur)
+mit Hilfe des Konkretisierers zuzugreifen. Der Konkretisierer arbeitet ähnlich wie die
+Subskription oder Selektion: er ermöglicht eine typmäßige Umbetrachtung vom ab­
+strakten Typ zum Datentyp der Feinstruktur. 
+ 
+Form: 
+ 
+#on("i")##on("b")#CONCR#off("i")##off("b")# #on("i")##on("b")#(#off("i")##off("b")# Ausdruck #on("i")##on("b")#)#off("i")##off("b")# 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ TYPE MONAT = INT; 
+ 
+ PROC put (MONAT CONST m): 
+    put ( CONCR (m)) 
+ END PROC put; 
+  
+____________________________________________________________________________ 
+ 
+ 
+Der Konkretisierer ist bei Feinstrukturen notwendig, die von elementarem Datentyp
+sind. Besteht dagegen die Feinstruktur aus Reihungen oder Strukturen, dann wird
+durch eine Selektion oder Subskription eine implizite Konkretisierung vorgenommen. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ TYPE LISTE = ROW 100 INT; 
+ 
+ LISTE VAR personal nummer; 
+ ... 
+ personal nummer [3] := ... 
+ (* das gleiche wie *) 
+ CONCR (personal nummer) [3] := ... 
+ 
+____________________________________________________________________________ 
+ 
+ 
+2.7.3  Denoter für abstrakte 
+       Datentypen (Konstruktor)
+       
+ 
+Denoter für neudefinierte Datentypen werden mit Hilfe des Konstruktors gebildet: 
+ 
+Form: 
+ 
+Datentyp #on("i")##on("b")#:#off("i")##off("b")# #on("i")##on("b")#(#off("i")##off("b")# Wertliste #on("i")##on("b")#)#off("i")##off("b")# 
+ 
+In der Wertliste wird für jede Komponente des Datentyps, durch Kommata getrennt,
+ein Wert aufgeführt. Besteht eine der Komponenten wiederum aus einem Datenver­
+bund, muß innerhalb des Konstruktors wiederum ein Konstruktor eingesetzt werden. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ TYPE GEHALT = INT; 
+ 
+ GEHALT VAR meins :: GEHALT : (10000); 
+ 
+____________________________________________________________________________ 
+ 
+ 
+Besteht die Feinstruktur aus einem Datenverbund, muß der Konstruktor u.U. mehrfach
+geschachtelt angewandt werden: 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ TYPE KOMPLEX = ROW 2 REAL; 
+ 
+ KOMPLEX CONST x :: KOMPLEX : ( ROW 2 REAL : ( 1.0, 2.0)); 
+ 
+____________________________________________________________________________ 
+ 
+ 
+Auf die Feinstruktur über den Konkretisierer eines neudefinierten Datentyps darf nur in
+dem PACKET zugegriffen werden, in dem der Datentyp definiert wurde. Der Konstruk­
+tor kann ebenfalls nur in dem typdefinierenden PACKET verwandt werden. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ PACKET widerstaende DEFINES WIDERSTAND, REIHE, PARALLEL, 
+                             :=, get, put: 
+ 
+ TYPE WIDERSTAND = INT; 
+ 
+ OP := (WIDERSTAND VAR l, WIDERSTAND CONST r): 
+    CONCR (l) := CONCR (r) 
+ END OP :=; 
+ 
+ PROC get (WIDERSTAND VAR w): 
+    INT VAR i; 
+    get (i); 
+    w := WIDERSTAND : (i) 
+ END PROC get; 
+ 
+ PROC put (WIDERSTAND CONST w): 
+    put (CONCR (w)) 
+ END PROC put; 
+ 
+ WIDERSTAND OP REIHE (WIDERSTAND CONST l, r): 
+    WIDERSTAND : ( CONCR (l) + CONCR (r)) 
+ END OP REIHE; 
+ 
+ WIDERSTAND OP PARALLEL (WIDERSTAND CONST l, r): 
+   WIDERSTAND : 
+     ((CONCR (l) * CONCR (r)) DIV (CONCR (l) + CONCR (r))) 
+ END OP PARALLEL 
+ 
+ END PACKET widerstaende 
+  
+____________________________________________________________________________ 
+ 
+ 
+Dieses Programm realisiert den Datentyp WIDERSTAND und mit den Operationen
+eine Fachsprache, mit dem man nun leicht WIDERSTANDs-Netzwerke berechnen
+kann, wie z.B. folgendes: 
+ 
+ 
+ 
+                          +---R4---+ 
+                          |        | 
+        +---R1---+        +---R5---+ 
+        |        |        |        | 
+     ---+        +---R3---+        +--- 
+        |        |        |        | 
+        +---R2---+        +---R6---+ 
+                          |        | 
+                          +---R7---+ 
+ 
+ 
+Zur Berechnung des Gesamtwiderstandes kann nun folgendes Programm geschrieben
+werden: 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ ROW 7 WIDERSTAND VAR r; 
+ widerstaende einlesen; 
+ gesamtwiderstand berechnen; 
+ ergebnis ausgeben. 
+ 
+ widerstaende einlesen: 
+    INT VAR i; 
+    FOR i FROM 1 UPTO 7 REP 
+       put ("bitte widerstand R"); put (i); put (":"); 
+       get (r [i]); 
+    END REP. 
+ 
+ gesamtwiderstand berechnen: 
+    WIDERSTAND CONST rgesamt :: (r [1] PARALLEL r [2]) REIHE 
+      r [3] REIHE (r [4] PARALLEL r [5] PARALLEL r [6] 
+      PARALLEL r [7]). 
+ 
+ ergebnis ausgeben: 
+    line; 
+    put (rgesamt). 
+____________________________________________________________________________ 
+#page# 
+ 
+2.8  Dateien 
+ 
+Dateien werden benötigt, wenn 
+ 
+-  Daten über die Abarbeitungszeit eines Programms aufbewahrt werden sollen; 
+-  der Zeitpunkt oder Ort der Datenerfassung nicht mit dem Zeitpunkt oder Ort der
+   Datenverarbeitung übereinstimmt; 
+-  die gesamte Datenmenge nicht auf einmal in den Zentralspeicher eines Rechners
+   paßt; 
+-  die Anzahl und/oder Art der Daten nicht von vornherein bekannt sind. 
+ 
+Eine Datei ("file") ist eine Zusammenfassung von Daten, die auf Massenspeichern
+aufbewahrt wird. Dateien sind in bestimmten Informationsmengen, den Sätzen ("re­
+cords") organisiert. 
+ 
+ 
+ 
+2.8.1  Datentypen FILE und DIRFILE 
+ 
+In ELAN gibt es zwei Arten von Dateien. Sie werden durch die Datentypen FILE 
+und DIRFILE realisiert: 
+ 
+ 
+ 
+FILE: 
+sequentielle Dateien. Die Sätze können nur sequentiell gelesen bzw. geschrieben
+werden. Eine Positionierung ist nur zum nächsten Satz möglich. 
+ 
+ 
+DIRFILE: 
+indexsequentielle Dateien. Die Positionierung erfolgt direkt mit Hilfe eines Schlüssels
+("key") oder Index, kann aber auch sequentiell vorgenommen werden. 
+ 
+#on("b")#Wichtig: #off("b")# 
+DIRFILEs sind auf dem EUMEL-System standardmäßig nicht implementiert! Deswe­
+gen wird auf diesen Dateityp hier nicht weiter eingegangen. 
+#page# 
+ 
+2.8.2  Deklaration und Assoziierung 
+ 
+Dateien müssen in einem ELAN-Programm - wie alle anderen Objekte auch -
+deklariert werden. 
+ 
+Form: 
+ 
+#on("i")##on("b")#FILE#off("i")##off("b")# #on("i")##on("b")#VAR#off("i")##off("b")# interner Dateibezeichner 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ FILE VAR f 
+ 
+____________________________________________________________________________ 
+ 
+ 
+Dabei ist zu beachten, daß im EUMEL-System alle FILEs als VAR deklariert werden
+müssen, denn jede Lese/Schreib-Operation verändert einen FILE. 
+ 
+Dateien werden normalerweise vom Betriebsystem eines Rechners aufbewahrt und
+verwaltet. Somit ist eine Verbindung von einem ELAN-Programm, in dem eine Datei
+unter einem Namen - wie jedes andere Datenobjekt auch - angesprochen werden
+soll, und dem Betriebssystem notwendig. Dies erfolgt durch die sogenannte Assozi­
+ierungsprozedur. Die Assoziierungsprozedur 'sequential file' hat die Aufgabe, eine in
+einem Programm deklarierte FILE VAR mit einer bereits vorhandenen oder noch
+einzurichtenden Datei des EUMEL-Systems zu koppeln. 
+ 
+Form: 
+ 
+#on("i")##on("b")#sequential file#off("i")##off("b")# #on("i")##on("b")#(#off("i")##off("b")# Betriebsrichtung, Dateiname #on("i")##on("b")#)#off("i")##off("b")# 
+ 
+Es gibt folgende Betriebsrichtungen (TRANSPUTDIRECTIONs): 
+ 
+ 
+input:  
+Die Datei kann vom Programm nur gelesen werden. Durch 'input' wird bei der Asso­
+ziierung automatisch auf den ersten Satz der Datei positioniert. Ist die zu lesende
+Datei nicht vorhanden, wird ein Fehler gemeldet. 
+ 
+ 
+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 vor­
+handen, wird sie automatisch eingerichtet. 
+ 
+ 
+modify:  
+Im EUMEL-System gibt es noch die Betriebsrichtung '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. 
+ 
+Nach erfolgter Assoziiierung ist auf den zuletzt bearbeiteten Satz positioniert. Die
+Datei wird automatisch eingerichtet, wenn sie vor der Assoziierung nicht vorhanden
+war. 
+ 
+Der zweite Parameter der Assoziierungsprozedur gibt an, unter welchem Namen die
+Datei in der Task existiert oder eingerichtet werden soll. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ FILE VAR meine datei :: sequential file (output, "xyz"); 
+ 
+____________________________________________________________________________ 
+ 
+ 
+Folgendes Beispiel zeigt ein Programm, welches eine Datei liest und auf dem Ausga­
+bemedium ausgibt: 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ FILE VAR f :: sequential file (input, "datei1"); 
+ TEXT VAR satz; 
+ WHILE NOT eof (f) REP 
+    getline (f, satz); 
+    putline (satz); 
+ END REP. 
+  
+____________________________________________________________________________ 
+ 
+ 
+Eine genau Übersicht der für Dateien existierende Operatoren und Prozeduren finden
+Sie im Teil 5.3. 
+#page# 
+
+2.9  Abstrakte Datentypen 
+     im EUMEL-System
+     
+ 
+ 
+2.9.1  Datentyp TASK 
+ 
+Tasks müssen im Rechnersystem eindeutig identifiziert werden; sogar im EUMEL-
+Rechner-Netz sind Tasks eindeutig identifizierbar. Dazu wird der spezielle Datentyp
+'TASK' benutzt, denn die Identifizierung einer Task über den Namen ist nicht eindeu­
+tig. Der Benutzer kann ja einen Tasknamen ändern, eine Task löschen und eine
+neue Task mit gleichem Namen einrichten, die jedoch nicht gleich reagiert. Somit
+werden Tasks eindeutig über Variablen vom  Datentyp TASK identifiziert. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ TASK VAR plotter := task ("PLOTTER 1") 
+  
+____________________________________________________________________________ 
+ 
+ 
+Die Taskvariable 'plotter' bezeichnet jetzt die Task im System, die augenblicklich den
+Namen "PLOTTER 1" hat. Die Prozedur 'task' liefert den systeminternen Taskbe­
+zeichner. 
+ 
+Nun sind Taskvariablen auch unter Berücksichtigung der Zeit und nicht nur im aktuel­
+len Systemzustand eindeutig. Der Programmierer braucht sich also keine Sorgen
+darüber zu machen, daß seine Taskvariable irgendwann einmal eine "falsche" Task
+(nach Löschen von "PLOTTER 1" neu eingerichtete gleichen oder anderen Namens)
+identifiziert. Wenn die Task "PLOTTER 1" gelöscht worden ist, bezeichnet 'plotter'
+keine gültige Task mehr. 
+ 
+Unbenannte Tasks haben alle den Pseudonamen "-". Sie können nur über Taskvari­
+ablen angesprochen werden. 
+ 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ PROC generate shutup manager: 
+    TASK VAR son; 
+    begin ("shutup", PROC shutup manager, son) 
+ END PROC generate shutup manager; 
+ 
+ PROC shutup manager: 
+    disable stop; 
+    command dialogue (TRUE); 
+    REP 
+       break; 
+       line; 
+       IF yes ("shutup") 
+          THEN clear error; 
+               shutup 
+       FI 
+    PER 
+ END PROC shutup manager 
+  
+____________________________________________________________________________ 
+ 
+ 
+Ein Taskvariable wird zum Beispiel als Parameter für die Prozedur 'begin' benötigt. 
+ 
+begin 
+   #on("b")#PROC begin (TEXT CONST son name, PROC start, 
+               TASK VAR new task)#off("b")# 
+   Die Prozedur richtet eine Sohntask mit Namen 'son name' (im Beispiel: shutup)
+   ein, die mit der Prozedur 'start' (im Beispiel: shutup manager) gestartet wird. 'new
+   task' (im Beispiel: son) identifiziert den Sohn, falls die Sohntask korrekt eingerich­
+   tet wurde. 
+#page# 
+ 
+2.9.2   Datentyp THESAURUS 
+ 
+Ein Thesaurus ist ein Namensverzeichnis, das bis zu 200 Namen beinhalten kann.
+Dabei muß jeder Name mindestens ein Zeichen und höchstens 100 Zeichen lang sein.
+Steuerzeichen (code < 32) werden im Namen folgendermaßen umgesetzt: 
+ 
+#on("i")##on("b")#steuerzeichen#off("b")##off("i")# wird umgesetzt in #on("i")##on("b")#"""" + code(steuerzeichen) + """"#off("b")##off("i")# 
+ 
+Ein Thesaurus ordnet jedem eingetragenen Namen einen Index zwischen 1 und 200
+(einschließlich) zu. Diese Indizes bieten dem Anwender die Möglichkeit, Thesauri zur
+Verwaltung benannter Objekte zu verwenden. (Der Zugriff erfolgt dann über den Index
+eines Namens in einem Thesaurus). So werden Thesauri u.a. von der Dateiverwaltung
+benutzt. Sie bilden die Grundlage der ALL- und SOME-Operatoren. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ initialisiere; 
+ arbeite thesaurus ab. 
+ 
+ initialisiere: 
+    THESAURUS VAR eine auswahl :: SOME (myself); 
+    TEXT VAR thesaurus element; 
+    INT VAR index :: 0. 
+ 
+ arbeite thesaurus ab: 
+    REPEAT 
+       get (eine auswahl, thesaurus element, index); 
+       IF thesaurus element = "" 
+          THEN LEAVE arbeite thesaurus ab 
+       FI; 
+       fuehre aktionen durch 
+    PER. 
+ 
+    fuehre aktionen durch: 
+       edit (thesaurus element); 
+       lineform (thesaurus element); 
+       pageform (thesaurus element); 
+       print (thesaurus element). 
+  
+____________________________________________________________________________ 
+ 
+ 
+Dieses Beispiel führt für eine Auswahl der in der Task befindlichen Dateien nachein­
+ander die Kommandos 'edit', 'lineform', 'pageform' und 'print' aus. 
+ 
+Die benutzten Operatoren und Prozeduren leisten folgendes: 
+ 
+#ix("SOME")# 
+   #on("b")#THESAURUS OP SOME (TASK CONST task) #off("b")# 
+   Der Operator bietet das Verzeichnis der in der angegeben Task befindlichen
+   Dateien zum Editieren an. Namen, die nicht gewünscht sind, müssen aus dem
+   Verzeichnis gelöscht werden. 
+ 
+ 
+#ix("get")# 
+   #on("b")#PROC get (THESAURUS CONST t, TEXT VAR name, INT VAR index) 
+   #off("b")# Die Prozedur liefert den nächsten Eintrag aus dem angegebenen Thesaurus 't'.
+   'Nächster' heißt hier, der kleinste vorhandene mit einem Index größer als 'index'.
+   Dabei wird in 'name'der Name und in 'index'der Index des Eintrags geliefert. 
+#page# 
+ 
+2.9.3  Datenräume 
+ 
+Datenräume sind die Grundlage von Dateien im EUMEL-System. Einen Datenraum
+kann man sich als eine Sammlung von Daten vorstellen (u.U. leer). Man kann einem
+Datenraum durch ein Programm einen Datentyp "aufprägen". Nach einem solchen
+"Aufpräge"-Vorgang kann der Datenraum wie ein "normaler" Datentyp behandelt
+werden. 
+ 
+Standarddateien (FILEs) sind eine besondere Form von Datenräumen. Sie 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. Hier­
+für stehen Standardprozeduren 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. Zu diesem Zweck werden im
+EUMEL-System Datenräume eingesetzt, 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
+dem Datenraum gespeicherten Objektes nicht kennen. 
+ 
+ 
+ 
+2.9.3.1  Datentyp DATASPACE 
+ 
+Datenräume können als eigener Datentyp (DATASPACE) in einem Programm behan­
+delt werden. Somit können Datenräume (als Ganzes) ohne Kenntnis eines eventuell
+(vorher oder später) aufgeprägten Typs benutzt werden. 
+ 
+Als Operationen auf DATASPACE-Objekte sind nur Transporte, Löschen und Zuwei­
+sung zugelassen. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ DATASPACE VAR ds 
+ 
+____________________________________________________________________________ 
+ 
+ 
+Für Datenräume ist die Zuweisung definiert. Der Zuweisungsoperator (':=') bewirkt
+eine Kopie des Datenraums vom rechten auf den linken Operanden. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ DATASPACE VAR datenraum :: nilspace; 
+ 
+____________________________________________________________________________ 
+ 
+ 
+Die Prozedur 'nilspace' liefert einen leeren Datenraum. Der Datenraum 'datenraum' ist
+also eine Kopie des leeren Datenraums. 
+ 
+Die Prozeduren und Operatoren für Datenräume werden im Teil 5.4.7 beschrieben. 
+#page# 
+ 
+2.9.3.2  BOUND-Objekte 
+ 
+Wie bereits erwähnt, kann man einem Datenraum einen Datentyp aufprägen. Dazu
+werden #ib#BOUND#ie#-Objekte benutzt. Mit dem Schlüsselwort #on("i")##on("b")#BOUND#off("i")##off("b")#, welches in der
+Deklaration vor den Datentyp gestellt wird, teilt man dem ELAN-Compiler mit, daß
+die Werte eines Datentyps in einem Datenraum gespeichert sind bzw. gespeichert
+werden sollen. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ BOUND ROW 1000 REAL VAR liste 
+ 
+____________________________________________________________________________ 
+ 
+ 
+Die Ankopplung des BOUND-Objekts an eine Datei erfolgt mit dem Operator #on("i")##on("b")#:=#off("i")##off("b")#. 
+ 
+Form: 
+ 
+BOUND-Objekt #on("i")##on("b")#:=#off("i")##off("b")# Datenraum 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ BOUND ROW 1000 REAL VAR gehaltsliste := new ("Gehälter") 
+ 
+____________________________________________________________________________ 
+ 
+ 
+Die Prozedur 'new' kreiert dabei einen leeren Datenraum (hier mit dem Namen 'Ge­
+hälter'), der mit Hilfe der Zuweisung (hier: Initialisierung) an die Variable 'gehaltsliste'
+gekoppelt wird. 
+ 
+Nun kann man mit der 'gehaltsliste' arbeiten wie mit allen anderen Feldern auch. Die
+Daten, die in 'gehaltsliste' gespeichert, werden eigentlich im Datenraum 'Gehälter'
+abgelegt. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ gehaltsliste [5] := 10 000.0;           (* Traumgehalt *) 
+ gehaltsliste [index] INCR 200.0;        (* usw.        *) 
+  
+____________________________________________________________________________ 
+ 
+ 
+Man kann auch Prozeduren schreiben, die auf der Gehaltsliste arbeiten. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ PROC sort (ROW 1000 REAL VAR liste): 
+ ... 
+ END PROC sort; 
+ ... 
+ sort (CONCR (gehaltsliste)); 
+ ... 
+  
+____________________________________________________________________________ 
+ 
+ 
+Man beachte, daß der formale Parameter der Prozedur 'sort' nicht mit BOUND spezi­
+fiziert werden darf (BOUND wird nur bei der Deklaration des Objekts angegeben). Das
+ist übrigens ein weiterer wichtiger Vorteil von BOUND-Objekten: man kann alle
+Prozeduren des EUMEL-Systems auch für BOUND-Objekte verwenden, nur die
+Datentypen müssen natürlich übereinstimmen. 
+ 
+ 
+Häufige Fehler bei der Benutzung von Datenräumen 
+ 
+-  Wenn man an ein DATASPACE-Objekt zuweist (z.B.: DATASPACE VAR ds :=
+   new ("mein datenraum")), so erhält man, wie bereits 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.
+   Für Änderungen in der Quelle, also in der vom Datei-Manager verwalteten Datei,
+   ist stets direkt anzukoppeln. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ BOUND ROW 10 INT VAR reihe; 
+ INT VAR i; 
+ 
+ PROC zeige dsinhalt (TEXT CONST datenraum): 
+    BOUND ROW 10 INT VAR inhalt := old (datenraum); 
+    INT VAR j; 
+    line; 
+    putline ("Inhalt:" + datenraum); 
+    FOR j FROM 1 UPTO 10 REP 
+       put (inhalt (j)) 
+    PER 
+ END PROC zeige dsinhalt; 
+ 
+ (*  falsch: es wird auf der Kopie gearbeitet:           *) 
+ DATASPACE VAR ds := new ("Gegenbeispiel: Zahlen 1 bis 10"); 
+ reihe := ds; 
+ besetze reihe; 
+ zeige dsinhalt ("Gegenbeispiel: Zahlen 1 bis 10"); 
+ 
+ (*  richtig: es wird auf dem Datenraum gearbeitet:      *) 
+ reihe := new ("Beispiel: Zahlen 1 bis 10"); 
+ besetze reihe; 
+ zeige dsinhalt ("Beispiel: Zahlen 1 bis 10"). 
+ 
+ besetze reihe: 
+    FOR i FROM 1 UPTO 10 REP 
+       reihe (i) := i 
+    PER. 
+  
+____________________________________________________________________________ 
+ 
+ 
+   Der Datenraum 'Gegenbeispiel: Zahlen 1 bis 10' wird nicht mit Werten besetzt,
+   sondern die Kopie dieses Datenraums, der unbenannte Datenraum 'ds'. Auf dem
+   direkt angekoppelten Datenraum 'Beispiel: Zahlen 1 bis 10' werden die Werte
+   gespeichert. 
+ 
+ 
+-  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'. Ein automatisches Löschen von DATASPACE-Objekten erfolgt nicht bei
+   Programmende (sonst könnten sie ihre Funktion als Datei nicht erfüllen). Nur
+   durch 'forget' oder beim Löschen einer Task werden alle ihr gehörenden
+   DATASPACE-Objekte gelöscht und der belegte Speicherplatz freigegeben. 
+ 
+ 
+-  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) (* Datenraum löschen, 
+                damit der Platz wieder verwendet wird *) 
+  
+____________________________________________________________________________ 
+ 
+ 
+-  Will man auf die Feinstruktur eines BOUND-Objekts zugreifen, so muß man
+   strenggenommen den Konkretisierer benutzen: 
+ 
+   Form: 
+ 
+   #on("i")##on("b")#CONCR#off("i")##off("b")# #on("i")##on("b")#(#off("i")##off("b")# Ausdruck #on("i")##on("b")#)#off("i")##off("b")# 
+ 
+   Der Konkretisierer ermöglicht eine typmäßige Umbetrachtung vom BOUND-Objekt
+   zum Datentyp der Feinstruktur. Ist der Zugriff jedoch eindeutig, so wird 'CONCR'
+   automatisch vom Compiler ergänzt. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ BOUND INT VAR i := old ("i-Wert"); 
+ INT VAR x; 
+ x := wert. 
+ 
+ wert: 
+    IF x < 0 
+      THEN 0 
+      ELSE CONCR (i) 
+    FI. 
+  
+____________________________________________________________________________ 
+ 
+ 
+In diesem Beispiel muß der Konkretisierer benutzt werden, da sonst der Resultattyp
+des Refinements nicht eindeutig ist (BOUND oder INT?). 
+ 
+ 
+ 
+2.9.3.3  Definition neuer Dateitypen 
+ 
+Durch die Datenräume und die Datentyp-Definition von ELAN ist es für Programmie­
+rer 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 soll an dem Beispiel DIRFILE (welcher zwar im ELAN-Standard
+definiert, aber nicht im EUMEL-System realisiert ist) gezeigt werden, wie ein neuer
+Datei-Datentyp definiert wird: 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ 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 vorhandenen Datenraum oder
+richtet einen neuen ein. Um eine Initialisierung mit der 'dirfile'-Prozedur vorneh­
+men zu können, braucht man auch einen Zuweisungsoperator, 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 benut­
+zen. 
+ 
+____________________________________________________________________________ 
+ ........................... 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; 
+ ... 
+  
+____________________________________________________________________________ 
+#page# 
+ 
+2.9.4  Datentyp INITFLAG 
+ 
+Im Multi-User-System ist es oft notwendig, Pakete beim Einrichten einer neuen
+Task in dieser neu zu initialisieren. Das muß z.B. bei der Dateiverwaltung gemacht
+werden, da die neue Task ja nicht die Dateien des Vaters erbt. Mit Hilfe von
+INITFLAG-Objekten kann man zu diesem Zweck feststellen, ob ein Paket in dieser
+Task schon initialisiert wurde. 
+ 
+ 
+INITFLAG 
+   #on("b")#TYPE INITFLAG #off("b")# 
+   Erlaubt die Deklaration entsprechender Flaggen. 
+ 
+:= 
+   #on("b")#OP := (INITFLAG VAR flag, BOOL CONST flagtrue) #off("b")# 
+   Erlaubt die Initialisierung von INITFLAGs 
+ 
+initialized 
+   #on("b")#BOOL PROC initialized (INITFLAG VAR flag) #off("b")# 
+   Wenn die Flagge in der Task A auf TRUE oder FALSE gesetzt wurde, dann liefert
+   sie beim ersten Aufruf den entsprechenden Wert, danach immer TRUE (in der
+   Task A!). 
+ 
+   Beim Einrichten von Söhnen wird die Flagge in den Sohntasks automatisch auf
+   FALSE gesetzt. So wird erreicht, daß diese Prozedur in den neu eingerichteten
+   Söhnen und Enkeltasks genau beim ersten Aufruf FALSE liefert. 
+ 
+____________________________________________________________________________ 
+ ........................... Beispiel: ......................... 
+ PACKET stack DEFINES push, pop: 
+ 
+ INITFLAG VAR in this task := FALSE ; 
+ INT VAR stack pointer ; 
+ ROW 1000 INT VAR stack ; 
+ 
+ PROC push (INT CONST value) : 
+ 
+    initialize stack if necessary ; 
+    .... 
+ 
+ END PROC push ; 
+ 
+ PROC pop (INT VAR value) : 
+ 
+    initialize stack if necessary ; 
+    .... 
+ 
+ END PROC pop ;. 
+ 
+ initialize stack if necessary : 
+ IF NOT initialized (in this task) 
+    THEN stack pointer := 0 
+ 
+ FI . 
+ 
+ END PACKET stack 
+____________________________________________________________________________ 
+
diff --git a/doc/programmer-manual/1.8.7/doc/programmierhandbuch.3 b/doc/programmer-manual/1.8.7/doc/programmierhandbuch.3
new file mode 100644
index 0000000..eade335
--- /dev/null
+++ b/doc/programmer-manual/1.8.7/doc/programmierhandbuch.3
@@ -0,0 +1,728 @@
+#headandbottom("1","EUMEL-Benutzerhandbuch","TEIL 3 : Editor","3")# 
+#pagenr("%",1)##setcount##block##pageblock# 
+#headeven# 
+#center#EUMEL-Benutzerhandbuch 
+#center#____________________________________________________________ 
+ 
+#end# 
+#headodd# 
+#center#TEIL 3 : Editor 
+#center#____________________________________________________________ 
+ 
+#end# 
+#bottomeven# 
+#center#____________________________________________________________ 
+3 - % #right#GMD 
+#end# 
+#bottomodd# 
+#center#____________________________________________________________ 
+GMD #right#3 - % 
+#end# 
+
+TEIL 3:  Der Editor 
+ 
+Mit dem #ib#EUMEL-Editor#ie# steht für den Teil der Programmierung, der aus der Eingabe
+von Programmtext besteht, dasselbe komfortable Werkzeug zur Verfügung, wie für die
+Textverarbeitung. Merkmale des EUMEL-Editors sind die einfache Fenstertechnik
+und die übersichtliche Bedienung durch wenige Funktionstasten. 
+ 
+Eine mit dem Editor erzeugte Textdatei ist maximal 4075 Zeilen lang, die maximale
+Breite einer Zeile beträgt 16000 Zeichen. 
+ 
+ 
+ 
+3.1  Ein- und Ausschalten des Editors 
+ 
+Der Editor wird eingeschaltet durch Eingabe von: 
+ 
+____________________________________________________________________________ 
+    gib kommando : 
+    #ib#edit#ie# ("dateiname") 
+ 
+____________________________________________________________________________ 
+ 
+ 
+Falls eine Datei unter dem eingegebenen Namen existiert, wird ein Fenster auf dieser
+Datei an der Stelle geöffnet, an der zuletzt ein Zugriff auf diese Datei stattfand. 
+ 
+Existiert noch keine Datei unter dem angegebenen Namen in der Task, folgt eine
+Anfrage, ob eine Datei unter dem eingegebenen Namen neu eingerichtet werden soll: 
+ 
+____________________________________________________________________________ 
+    gib kommando : 
+    edit("dateiname") 
+    "dateiname" neu einrichten (j/n) ? 
+ 
+____________________________________________________________________________ 
+ 
+ 
+Die Abfrage dient der Kontrolle der Schreibweise. Man kann ggf. das Einrichten der
+Datei ablehnen, den Dateinamen verbessern und das Kommando erneut geben. 
+ 
+Bei korrekter Schreibweise bejahen Sie die Kontrollfrage#u# 1)#e#mit 
+ 
+#center#<j> <J> <y> oder <Y> 
+ 
+ 
+Es erscheint ein leerer Editorbildschirm. Die oberste Zeile des Bildschirms ist die
+#ib#Titelzeile#ie#. In ihr kann nicht geschrieben werden. Sie zeigt jedoch verschiedene nütz­
+liche Dinge an: den Namen der Datei, die Nummer der aktuellen Zeile, in der gerade
+geschrieben wird, Tabulatormarken, Einfügemodus, Lernmodus usw. 
+ 
+____________________________________________________________________________ 
+ #mark on# ............... dateiname ....................#mark off# Zeile 1  #mark on#  #mark off# 
+ _ 
+ 
+____________________________________________________________________________ 
+ 
+ 
+ 
+Wollen Sie die #ib#Schreibarbeit beenden#ie# und den #ib#Editor ausschalten#ie#, so drücken Sie die
+beiden Tasten 
+ 
+<ESC> <q> 
+ 
+nacheinander. Sie haben damit den #ib#Editor verlassen#ie# und befinden sich wieder auf
+Monitor-Ebene. 
+#page# 
+
+3.2  Die Funktionstasten 
+ 
+Die Funktionstasten realisieren diejenigen Fähigkeiten des Editor, die über die reine
+Zeicheneingabe hinausgehen. Wo die Tasten auf Ihrem Gerät liegen, hängt von dem
+jeweiligen Gerätetyp ab. Die Wirkung der Tasten ist im Weiteren erläutert. 
+ 
+#l pos (0.0)##l pos(4.0)# 
+#table# 
+#free(0.5)# 
+#taste1(" SHIFT ")#           Umschalttaste 
+#tableend# 
+#free(0.5)# 
+<v> <^> <>> <<>            Positionierungstasten 
+#table# 
+#free(0.5)# 
+<CR>              Eingabe-/ Absatztaste 
+#free(0.5)# 
+<ESC>             Kommandotaste 
+#free(0.5)# 
+<HOP>             Verstärkertaste 
+#free(0.5)# 
+<TAB>             Tabulatortaste 
+#free(0.5)# 
+<MARK>            Markiertaste 
+#free(0.5)# 
+<RUBOUT>          Löschtaste 
+#free(0.5)# 
+<RUBIN>           Einfügetaste 
+#free(0.5)# 
+<SV>              Supervisortaste 
+#free(0.5)# 
+<STOP>            Stoptaste 
+#free(0.5)# 
+<WEITER>          Weitertaste 
+#tableend##clear pos# 
+#free(0.5)# 
+Es kann sein, daß Tasten nicht richtig beschriftet sind. Die Installations-anleitung
+muß dann die Entsprechungen beschreiben. Natürlich können sich weitere Funktions­
+tasten außer den im folgenden beschriebenen auf Ihrer Tastatur befinden. Diese
+haben standardmäßig jedoch keine besondere Bedeutung für den Editor. 
+ 
+#page# 
+
+3.3  Die Wirkung der Funktionstasten 
+ 
+<SHIFT> 
+ 
+#ib#Umschalttaste#ie# 
+ 
+Wird diese Taste gleichzeitig mit einer anderen betätigt, so wird ein Buchstabe in
+Großschreibung, bei den übrigen Tasten das obere Zeichen, ausgegeben. So wird z.B.
+anstelle der "9" das Zeichen ")" ausgegeben. 
+#free(0.5)# 
+<>> <<> 
+ 
+<v> <^> 
+ 
+Positionierungstasten 
+ 
+#ib#Positionierung des Cursors#ie# um eine Spalten-/Zeilenposition in die jeweilige Richtung. 
+#free(0.5)# 
+<CR> 
+ 
+#ib#Eingabetaste / Absatztaste#ie#, Carriage Return, kurz: 'CR' 
+ 
+Diese Taste schließt die aktuelle Zeile explizit ab und es wird an den Beginn der
+nächsten Zeile positioniert. Einrückungen werden beibehalten. 
+ 
+Der EUMEL-Editor ist auf automatischen Wortumbruch voreingestellt, d.h. ein Wort,
+das über das 77. Zeichen der aktuellen Zeile herausreichen würde, wird automatisch
+in die nächste Zeile gerückt (siehe 'word wrap' 4.2.5). Die Absatztaste wird also
+benötigt, um explizite Zeilenwechsel und Einrückungen bei der Textformatierung zu
+erhalten. Eine Absatzmarke wird durch ein 'blank' hinter dem letzten Zeichen der
+Zeile erzeugt und ist im Editor an der Inversmarkierung am rechten Bildschirmrand zu
+erkennen. 
+ 
+Im EUMEL-System werden Kommandos auf einer Kommandozeile, auf der alle
+Editorfunktionen zur Verfügung stehen, eingegeben. Auf dieser Ebene beendet die
+Taste also ausdrücklich die Kommandoeingabe, das gegebene Kommando wird an­
+schließend analysiert und ausgeführt. 
+ 
+<HOP> 
+ 
+"#ib#Verstärkertaste#ie#"; wird als Vorschalttaste bedient. 
+ 
+In Kombination mit anderen Funktionstasten wird deren Wirkung verstärkt. 
+ 
+ 
+<HOP> <v> 
+ 
+Steht der Cursor nicht am unteren Bildrand, so wird er dorthin positioniert. Steht er
+am unteren Bildrand, so wird um einen Bildschirminhalt "weitergeblättert". 
+ 
+Entsprechend werden auch die Tasten : <^> <>> <<> mit der HOP-Taste verstärkt. 
+ 
+#page# 
+<HOP> <RUBIN> 
+ 
+#ib#Einfügen von Textpassagen#ie#. Die HOP-Taste in Verbindung mit RUBIN und RUBOUT
+wird zum 'verstärkten' Löschen und Einfügen verwendet. 
+ 
+Ab der aktuellen Position des Cursors 'verschwindet' der restliche Text. Es kann wie
+bei der anfänglichen Texteingabe fortgefahren werden. Die Anzeige '#ib#REST#ie#' in der
+Titelzeile erinnert daran, daß noch ein Resttext existiert. Dieser erscheint nach einem
+neuerlichen Betätigen der beiden Tasten HOP RUBIN wieder auf dem Bildschirm (die
+Anzeige 'REST' verschwindet dann wieder). 
+ 
+____________________________________________________________________________ 
+   ................ dateiname ..................... Zeile 4     
+  In diesem Text soll vor dem zweiten Satz  
+  etwas eingefügt werden. Hierzu wird der 
+  Cursor an die Position geführt, an der  
+  ein beliebiger Text eingefügt werden soll.#absatz# 
+ 
+____________________________________________________________________________ 
+ 
+ 
+Nach Betätigen der Taste #on("i")##on("b")#HOP#off("i")##off("b")# und #on("i")##on("b")#RUBIN#off("i")##off("b")#sieht der Bildschirm wie folgt aus: 
+ 
+____________________________________________________________________________ 
+   .............. dateiname ........REST.......... Zeile 4     
+  In diesem Text soll vor dem zweiten Satz  
+  etwas eingefügt werden. 
+ 
+ 
+____________________________________________________________________________ 
+ 
+ 
+ 
+Nun kann beliebig viel Text eingefügt werden. Nochmaliges Betätigen von HOP und
+RUBIN führt den Text-Rest wieder bündig heran. 
+ 
+#page# 
+<HOP>  <RUBOUT> 
+ 
+Löscht die Zeile ab Cursor-Position bis Zeilenende. 
+ 
+____________________________________________________________________________ 
+   ................ dateiname ..................... Zeile 4     
+  Soll eine ganze Zeile oder ein Textrest  
+  gelöscht werden, so positioniert man an die  
+  Stelle, ab der gelöscht werden soll. Rest löschen.... 
+  Nach HOP RUBOUT ist der Zeilenrest gelöscht.#absatz# 
+ 
+____________________________________________________________________________ 
+ 
+ 
+ 
+Nach Betätigen der Tasten #on("i")##on("b")#HOP#off("i")##off("b")# und #on("i")##on("b")#RUBOUT#off("i")##off("b")# sieht der Bildschirm wie folgt aus. 
+ 
+____________________________________________________________________________ 
+   ............... dateiname .................... Zeile 4     
+  Soll eine ganze Zeile oder ein Textrest  
+  gelöscht werden, so positioniert man an die  
+  Stelle, ab der gelöscht werden soll. 
+  Nach HOP RUBOUT ist der Zeilenrest gelöscht.#absatz# 
+ 
+____________________________________________________________________________ 
+ 
+ 
+ 
+Steht der Cursor am Zeilenanfang, wird nach HOP RUBOUT dementsprechend die
+ganze Zeile gelöscht und die Lücke durch Nachrücken der Folgezeilen geschlossen
+(HOP RUBOUT betätigen). 
+#page# 
+<TAB> 
+ 
+#ib#Tabulatortaste#ie# 
+ 
+Mit der Tabulatortaste werden die eingestellten Tabulatorpositionen angesprungen.
+Jeder Tastendruck läßt den Cursor auf die nächste eingestellte Tabulatorposition
+springen. 
+ 
+#on("i")#Voreingestellte#off("i")# Tabulatorpositionen sind die beiden Schreibgrenzen, Textanfang in der
+Zeile und Ende der Zeile. 
+ 
+Weitere Tabulatorpositionen können durch Positionierung auf die gewünschte Spalte
+und #on("i")##on("b")#HOP#off("i")##off("b")# #on("i")##on("b")#TAB#off("i")##off("b")# gesetzt werden. Sie können gelöscht werden, indem sie mit #on("i")##on("b")#TAB#off("i")##off("b")#
+angesprungen und mit #on("i")##on("b")#HOP#off("i")##off("b")# #on("i")##on("b")#TAB#off("i")##off("b")# 
+ausgeschaltet werden. 
+ 
+Die gesamte eingestellte Tabulalation kann durch #on("i")##on("b")#ESC#off("i")##off("b")# #on("i")##on("b")#TAB#off("i")##off("b")# ein-/ und ausge­
+schaltet werden. 
+ 
+Die eingestellten Tabulatorpositionen erkennen Sie an den Tabulatorzeichen (Dachzei­
+chen) in der obersten Bildschirmzeile. 
+#page# 
+<MARK> 
+ 
+#ib#Ein- bzw. Ausschalten der Markierung#ie#. 
+ 
+Bei Betätigung dieser Taste wird in einen speziellen #ib#Markierzustand#ie# geschaltet. Alles,
+was Sie jetzt schreiben bzw. durch Bewegen des Cursors in Richtung Dateiende
+kennzeichnen, steht als #on("i")#markierter#off("i")# Bereich für die Bearbeitung zur Verfügung. Zur
+besseren Sichtbarkeit wird der markierte Bereich invers zum übrigen Text dargestellt. 
+ 
+Wird der Cursor in eine Richtung bewegt, wird das gesamte Textstück zwischen
+Einschaltpunkt der Markierung und aktueller Cursorposition markiert. Rückwärtsbewe­
+gungen des Cursors verkürzen den markierten Bereich wieder. 
+ 
+Durch erneutes Betätigen der MARK-Taste schalten Sie den Markier-Zustand
+wieder aus. 
+ 
+Mit weiteren Kommandos kann der Bereich nun bearbeitet werden: 
+ 
+<ESC>  <d>         Markierten Abschnitt in 'Scratch'-Datei kopieren. 
+ 
+<ESC>  <p>         Markierten Abschnitt herauskopieren. 
+ 
+<ESC>  <RUBOUT>    Markierten Abschnitt löschen. 
+ 
+ 
+Der mit #on("i")##on("b")#ESC#off("i")##off("b")# #on("i")##on("b")#p#off("i")##off("b")# oder#on("i")##on("b")#d#off("i")##off("b")# kopierte Bereich kann beliebig oft in derselben oder einer
+anderen Datei ein/angefügt werden. 
+ 
+Der mit #on("i")##on("b")#ESC#off("i")##off("b")# #on("i")##on("b")#RUBOUT#off("i")##off("b")# gelöschte Abschnitt kann genau einmal durch #on("i")##on("b")#ESC#off("i")##off("b")# #on("i")##on("b")#RUBOUT#off("i")##off("b")#
+an anderer Stelle derselben Datei eingefügt werden. 
+ 
+(vgl. ESC-Taste, Operationen auf Markierungen, 3-#topage("ESC")#) 
+#page# 
+<RUBIN> 
+ 
+#ib#Ein- bzw. Ausschalten des Einfügemodus.#ie# 
+ 
+Das Betätigen der Taste schaltet in den Einfügemodus. Der Zustand wird durch das
+Wort "RUBIN" im linken Drittel der Titelzeile der Datei angezeigt. Vor dem Zeichen,
+auf dem der Cursor steht, wird eingefügt. Nochmaliges Betätigen der Taste schaltet
+den Einfügemodus aus. 
+#free(1.0)# 
+<RUBOUT> 
+ 
+#ib#Löschtaste#ie# 
+ 
+Das Zeichen, auf dem der Cursor steht, wird gelöscht. Wenn der Cursor, wie bei
+fortlaufender Eingabe üblich, hinter dem letzten Zeichen einer Zeile steht, wird das
+letzte Zeichen gelöscht. 
+ 
+#page# 
+
+3.4  ESC Kommandos 
+ 
+<ESC> 
+ 
+#ib#Kommandotaste#ie# 
+ 
+Mit der ESC-Taste in Kombination mit einer Folgetaste werden vordefinierte Aktionen
+ausgelöst. Es gibt Aktionen, die vorprogrammiert zur Verfügung stehen, und Sie selbst
+können weitere hinzufügen. 
+ 
+Der Kommandodialog wird eingeschaltet durch: 
+ 
+<ESC> <ESC> 
+ 
+ 
+____________________________________________________________________________ 
+  ............... Beispiel ..................... Zeile 4     
+ 
+  gib kommando:                                              
+ 
+____________________________________________________________________________ 
+ 
+ 
+Der Kommandodialog ermöglicht die Eingabe von beliebigen Kommandos ohne den
+Editor verlassen zu müssen. Insbesondere Such- und Kopieroperationen stellen auch
+für den Programmierer nützliches Werkzeug dar (siehe 3.5). 
+ 
+Auf der Kommandozeile kann jedes Kommando gegeben werden. Die Kommandozeile
+kann wie eine normale Textzeile editiert werden. Nach #on("i")##on("b")#CR#off("i")##off("b")# verschwindet die Kom­
+mandozeile und das Kommando wird ausgeführt. 
+ 
+Falls ein Fehler auftritt erfolgt eine entsprechende Fehlermeldung in der Kopfzeile und
+die Kommandozeile erscheint erneut. 
+ 
+Um ein weiteres Editor-Fenster zu 'öffnen', betätigt man im Editor 
+ 
+<ESC>  <e> 
+ 
+Betätigt man ESC e ungefähr in der Mitte des Bildschirms, hat man das Fenster auf
+die neue Datei in der unteren Hälfte des Bildschirms und die 'alte' Datei in der
+oberen Bildschirmhälfte. Zunächst wird der Dateiname erfragt. Nach dessen Eingabe
+und #on("i")##on("b")#CR#off("i")##off("b")# wird ein Fenster auf eröffnet. Die obere linke Ecke des Fensters befindet
+sich an der aktuellen Cursor-Position. Dabei darf sich der Cursor nicht zu sehr am
+rechten oder unteren Rand befinden, weil das Fenster sonst zu klein würde. In diesem
+'Fenster' kann man dann genauso arbeiten wie im 'normalen' Editor. 
+ 
+Mit der Tastenfolge 
+ 
+<ESC>  <w> 
+ 
+wechselt man von einem Fenster (zyklisch) in das benachbarte. Es gibt eine Hier­
+archie zwischen den Fenstern in der Reihenfolge, in der eines im anderen einge­
+richtet worden ist. Gibt man 
+ 
+<ESC>  <q> 
+ 
+in einem Fenster, so verschwindet dieses und alle darin eingeschachtelten Fenster,
+und man befindet sich im übergeordneten Fenster. 
+ 
+Durch 
+ 
+<ESC>  <p>  oder   <ESC>  <d> 
+ 
+schreibt man einen markierten Teil in eine 'Scratch'-Datei (nicht editierbarer
+Zwischenspeicher); durch ESC p wird ein markierter Text aus der Ursprungsdatei
+entfernt und in die 'Scratch'-Datei geschrieben. Im Gegensatz dazu wird er durch
+ESC d kopiert. Durch 
+ 
+<ESC>  <g> 
+ 
+fügt man ihn in eine andere (oder dieselbe) Datei ein. Im Unterschied zu ESC RUBIN
+wird die temporäre Datei dadurch nicht entleert. 
+ 
+Die für ESC p, bzw. ESC d benutzte #ib#'Scratch'-Datei#ie#, die nicht editierbar ist, ist nicht
+mit dem sogenannten Notizbuch zu verwechseln. Das Notizbuch ist eine Datei, in der
+alle Editorfunktionen benutzt werden können, auf die jedoch ohne Angabe eines
+Dateinamens durch 
+ 
+<ESC> <n> 
+ 
+ab der aktuellen Cursorposition ein Fenster eröffnet wird. Das Notizbuch nimmt
+insbesondere Fehlermeldungen und Meldungen bei der Übersetzung von Programmen
+auf. 
+ 
+<ESC> <v> 
+ 
+erlaubt vom äußeren Fenster aus alle eingeschachtelten Fenster zu verlassen. 
+#page# 
+
+Vorbelegte Tasten 
+ 
+#ib#ESC q#ie#          Verlassen des Editors bzw. der eingeschachtelten Fenster. 
+ 
+#ib#ESC e#ie#          Weiteres Editorfenster einschalten. 
+ 
+#ib#ESC n#ie#          Notizbuch 'anzeigen'. 
+ 
+#ib#ESC v#ie#          Dateifenster auf ganzen Bildschirm vergrößern 
+               bzw. Bildschirm rekonstruieren (eingeschachteltes Fenster verlas­
+               sen). 
+ 
+#ib#ESC w#ie#          Dateiwechsel beim Fenstereditor. 
+ 
+#ib#ESC f#ie#          Nochmalige Ausführung des letzten Kommandos. 
+ 
+#ib#ESC b#ie#          Das Fenster wird auf den linken Rand der aktuellen (ggf. verscho­
+               benen) Zeile gesetzt. 
+ 
+ESC  >         Zum nächsten Wortanfang. 
+ 
+ESC  <         Zum vorherigen Wortanfang. 
+ 
+#ib#ESC 1#ie#          Zum Anfang der Datei. 
+ 
+#ib#ESC 9#ie#          Zum Ende der Datei. 
+#page# 
+
+Operationen auf Markierungen 
+ 
+ 
+#goalpage("ESC")# 
+#ib#ESC RUBOUT#ie#     Markiertes "vorsichtig" löschen. 
+ 
+#ib#ESC RUBIN#ie#      Mit ESC RUBOUT vorsichtig Gelöschtes einfügen. 
+ 
+#ib#ESC p#ie#          Markiertes löschen und in die Notiz-Datei schreiben. Kann mit ESC
+               g an anderer Stelle reproduziert werden. 
+ 
+#ib#ESC d#ie#          Duplizieren: 
+               Markiertes in die Notiz-Datei kopieren, anschließend die
+               Markierung abschalten. Kann mit ESC g beliebig oft reproduziert
+               werden. 
+ 
+#ib#ESC g#ie#          Mit ESC p gelöschten oder mit ESC d duplizierten Text an aktuelle
+               Cursor-Stelle schreiben, d.h. Notiz-Datei an aktueller Stelle einfü­
+               gen. 
+#page# 
+
+Zeichen schreiben 
+Diese Tasten sind standardmäßig so vorbelegt wie hier aufgeführt, sie können aber
+von Benutzern und in Anwenderprogrammen geändert werden. 
+ 
+#ib#ESC a#ie#          Schreibt ein ä. 
+#ib#ESC A#ie#          Schreibt ein Ä. 
+#ib#ESC o#ie#          Schreibt ein ö. 
+#ib#ESC O#ie#          Schreibt ein Ö. 
+#ib#ESC u#ie#          Schreibt ein ü. 
+#ib#ESC U#ie#          Schreibt ein Ü. 
+#ib#ESC s#ie#          Schreibt ein ß. 
+#ib#ESC (#ie#          Schreibt eine [. 
+#ib#ESC )#ie#          Schreibt eine ]. 
+#ib#ESC <#ie#          Schreibt eine {. 
+#ib#ESC >#ie#          Schreibt eine }. 
+#ib#ESC \##ie#          Schreibt ein \#, das auch gedruckt werden kann. 
+#ib#ESC ­#ie#          Schreibt einen (geschützten) Trennstrich, siehe Textverarbeitung. 
+#ib#ESC k#ie#          Schreibt ein (geschütztes) "k", siehe Textverarbeitung. 
+#ib#ESC blank#ie#      Schreibt ein (geschütztes) Leerzeichen, siehe Textverarbeitung. 
+#free(0.7)# 
+
+Kommando auf Taste legen
+
+#ib#ESC ESC#ie#        Kommandodialog einschalten 
+ 
+#ib#ESC ! taste#ie#    Im Kommandodialog: 
+               Geschriebenes Kommando auf Taste legen. 
+ 
+#ib#ESC ? taste#ie#    Im Kommandodialog: 
+               Auf 'taste' gelegtes Kommando zum Editieren anzeigen. 
+ 
+#ib#ESC k#ie#          Im Kommandodialog: 
+               Das zuletzt editierte Kommando (einzeilige ELAN-Programm)
+               anzeigen. 
+ 
+ 
+Der Lernmodus 
+Der Lernmodus ermöglicht beliebige Tastensequenzen zu speichern und auf eine 
+Taste 't' zu legen. Durch #on("i")##on("b")#ESC#off("i")##off("b")# #on("i")##on("b")#t#off("i")##off("b")# wird die gesamte Sequenz ausgeführt. 
+ 
+Nicht belegt werden können die vom System vorbelegten Tasten (3-14). 
+ 
+Beispielsweise könnte es für einen Programmierer sinnvoll sein die Tastenfolge 
+'THEN' 'CR' '>' '>' '>' '>' auf die Taste #on("i")##on("b")#T#off("i")##off("b")# zu legen. Durch #on("i")##on("b")#ESC#off("i")##off("b")# #on("i")##on("b")#T#off("i")##off("b")# wird 'THEN' in
+die aktuelle Zeile geschrieben und der Cursor mit passender Einrückung in die 
+Einrückung in die Folgezeile gesetzt. 
+
+ 
+#ib#ESC HOP#ie#        #ib#Lernen einschalten#ie#. 
+ 
+#ib#ESC HOP taste#ie#  #ib#Lernen ausschalten#ie# und Lernsequenz auf 'taste'legen. 
+ 
+#ib#ESC HOP HOP#ie#    #ib#Gelerntes vergessen#ie#. Bedingung ist, daß man die Lernsequenz in
+                       der Task löscht, in der man sie hat lernen lassen. 
+ 
+ 
+#on("b")# 
+#center#A C H T U N G : 
+Der Lernmodus bleibt eingeschaltet, auch wenn der Editor beendet wird. Dann werden
+die folgenden Monitor-Kommandos usw. usf. 'gelernt'. Durch unsinniges 'Lernen'
+lassen sich schlimmstenfalls beliebige Verwüstungen anrichten. 
+ 
+Der Lernmodus wird in der Editor-Kopfzeile angezeigt. Falls der Editor beendet wird,
+ohne den Lernmodus auszuschalten, erfolgt eine Warnung auf Monitor-Ebene. 
+ 
+Um den Lernmodus zu beenden drücken Sie: 
+ 
+<ESC> <HOP> <HOP>  
+ 
+Dadurch wird der Lernmodus ausgeschaltet und nichts gelernt, die Gefahr ist gebannt.#off("b")# 
+ 
+#page# 
+<SV> 
+ 
+#ib#SUPERVISOR-Taste#ie# 
+ 
+Betätigen Sie diese Taste im Editor, dann unterbrechen Sie Ihre Editierarbeit und
+erhalten die Meldung 
+ 
+____________________________________________________________________________ 
+ 
+                                           Terminal 2  
+ 
+ 
+                      EUMEL Version 1.8/M 
+ 
+ 
+            gib supervisor kommando: 
+ 
+ 
+ 
+ 
+       ESC ? --> help 
+       ESC b --> begin("")            ESC h --> halt 
+       ESC c --> continue("")         ESC s --> storage info 
+       ESC q --> break                ESC t --> task info 
+ 
+____________________________________________________________________________ 
+ 
+ 
+ 
+Wollen Sie nun im Editor fortfahren bzw. haben Sie irrtümlich die SV-Taste betätigt,
+dann geben Sie das Kommando 
+ 
+____________________________________________________________________________ 
+ 
+              gib supervisor kommmando : 
+              continue ("meine task") 
+ 
+____________________________________________________________________________ 
+ 
+ 
+ 
+(falls Ihre Task, in der Sie arbeiteten, wirklich "meine task" hieß!) 
+ 
+Um Ihren in Bearbeitung befindlichen Text wieder vollständig auf dem Bildschirm zu
+sehen, betätigen die die Tasten 
+ 
+<ESC> <b> 
+ 
+Sie sind wieder an der Stelle, an der Sie den Text mit der SV-Taste verlassen ha­
+ben, und können normal weiterarbeiten. 
+ 
+#on("u")#Achtung:#off("u")# Die SV-Taste kann, je nach Terminal, durch das Betätigen von zwei
+Tasten gleichzeitig realisiert sein (oft 'CTRL b'). Beachten Sie die Beschreibung Ihrer
+Tastatur! 
+ 
+ 
+ 
+#on("b")# 
+Für die Programmierung ist die Tastenfolge <SV> <ESC> <h> von Bedeutung, da hier­
+durch der Fehler 'halt vom Terminal' erzeugt wird. Dadurch können unerwünscht
+laufende Programme abgebrochen werden. 
+#off("b")# 
+#page# 
+<STOP> 
+ 
+#ib#Unterbrechen einer Ausgabe#ie# (oft auch als CTRL a realisiert). 
+ 
+Haben Sie diese Taste aus Versehen betätigt, erkennen Sie dies daran, daß der
+Editor nicht "reagiert". Betätigen Sie die WEITER-Taste (oft auch CTRL c). 
+#free(1.0)# 
+<WEITER> 
+ 
+Unterbrochene Ausgabe fortsetzen. 
+ 
+Ein mit der STOP-Taste angehaltene Ausgabe können Sie durch Betätigen der
+#ib#WEITER-Taste#ie# fortsetzen. 
+ 
+ 
+#on("u")#VORSICHT:#off("u")#  Die STOP-Taste unterbricht nur die Ausgabe auf den Bildschirm. Zei­
+           chen, die während des STOP eingegeben werden, werden gespeichert
+           und nach 'WEITER' ausgegeben! 
+ 
+ 
+#page# 
+
+3.5  Positionieren, Suchen, Ersetzen 
+     im Kommandodialog
+      
+ 
+Um das Editorfenster auf eine bestimmte Zeile zu positionieren wird einfach diese
+Zeilennummer angegeben. 
+ 
+____________________________________________________________________________ 
+  ............... Beispiel ..................... Zeile 4     
+ 
+  gib kommando: 123                                           
+ 
+____________________________________________________________________________ 
+ 
+ 
+ 
+Falls die Zeilenzahl der Datei geringer als die angegebene Zeilennummer ist, wird auf
+die letzte Zeile positioniert. 
+ 
+ 
+Um das Editorfenster auf ein bestimmtes Textstück zu positionieren, wird der gesuch­
+te Text, ggf. mit Suchrichtung angegeben. 
+ 
+____________________________________________________________________________ 
+  ............... Beispiel ..................... Zeile 4     
+ 
+   gib kommando: "END PROC"                                   
+ 
+____________________________________________________________________________ 
+ 
+ 
+Die Suchrichtung kann durch 'D' (down) oder 'U' (up) zusätzlich spezifiziert werden. 
+ 
+____________________________________________________________________________ 
+  ............... Beispiel ..................... Zeile 4     
+ 
+  gib kommando: U "INT VAR schleifenzaehler"                  
+ 
+____________________________________________________________________________ 
+ 
+ 
+ 
+Um beliebige Texte durch andere zu ersetzen, dienen die Operatoren 'C' (change)
+bzw. 'CA' (change all). 
+ 
+Bei Ausführung dieses Kommandos wird zunächst nach #on("u")#unten#off("u")# in der editierten Datei
+nach dem zu ersetzenden Text gesucht. Wenn der Text gefunden wird, wird er durch
+den hinter dem Operator stehenden Text ersetzt. 
+ 
+____________________________________________________________________________ 
+  ............... Beispiel ..................... Zeile 4     
+ 
+  gib kommando: "lb" C "lange bezeichnung"                    
+ 
+____________________________________________________________________________ 
+ 
+ 
+ 
+Bei Anwendung von 'CA' wird jedes Auftreten des gesuchten Textes ab der
+Cursorposition durch den Ersatztext ersetzt, bis das Dateiende errreicht ist. 
+ 
+Weitere Erklärungen zum Suchen und Ersetzen in 5.5. 
+#page# 
+
+Weitere Hilfen 
+ 
+ 
+Textabschnitt an anderer Stelle der Datei einsetzen: 
+ 
+- Abschnitt markieren und mit #on("i")##on("b")#ESC#off("i")##off("b")# #on("i")##on("b")#d#off("i")##off("b")# zwischenspeichern. 
+ 
+- Zweites Editorfenster auf die Datei mit #on("i")##on("b")#ESC#off("i")##off("b")# #on("i")##on("b")#e#off("i")##off("b")# öffnen. 
+ 
+- Nach #on("i")##on("b")#ESC#off("i")##off("b")# #on("i")##on("b")#ESC#off("i")##off("b")# Zeilennummer oder Suchbegriff angeben und mit #on("i")##on("b")#ESC#off("i")##off("b")# #on("i")##on("b")#g#off("i")##off("b")# Abschnitt an der gewünschte Stelle einsetzen. 
+ 
+ 
+ 
+Textabschnitt schnell herauskopieren und sichern: 
+ 
+- Gewünschten Abschnitt markieren 
+ 
+- #on("i")##on("b")#ESC#off("i")##off("b")# #on("i")##on("b")#ESC#off("i")##off("b")# PUT("dateiname") #on("i")##on("b")#CR#off("i")##off("b")# 
+  Der Abschnitt wird in die Datei 'dateiname' geschrieben. Falls die Frage 'dateina­
+  me' löschen (j/n) verneint wird, wird der Abschnitt, an das Ende der Datei angefügt.
+  Dadurch können Textabschnitte schnell gesammelt werden. 
+ 
+ 
+Komplette Datei in die editierte Datei einfügen: 
+ 
+- #on("i")##on("b")#ESC#off("i")##off("b")# #on("i")##on("b")#ESC#off("i")##off("b")# GET("dateiname") #on("i")##on("b")#CR#off("i")##off("b")# 
+  Der komplette Inhalt von 'dateiname' wird an die aktuelle Position geschrieben. 
+ 
+ 
+Breitere Zeile erzeugen: 
+ 
+- #on("i")##on("b")#ESC#off("i")##off("b")# #on("i")##on("b")#ESC#off("i")##off("b")# limit(123) #on("i")##on("b")#CR#off("i")##off("b")# 
+  Die Zeilenbreite wird auf 123 Zeichen geändert. Der maximal zulässige Wert ist
+  16000. Dieser Wert bezieht sich auf den Zeilenumbruch. Bei Zeilenbreite > 77 wird
+  nur die aktuelle Zeile verschoben. Um für den ganzen Bildschirm die rechte Seite
+  der Datei zu sehen, kann die linken Spalte des Bildschirmfenster neu gesetzt wer­
+  den: 
+ 
+  #on("i")##on("b")#ESC#off("i")##off("b")# #on("i")##on("b")#ESC#off("i")##off("b")# margin(60) #on("i")##on("b")#CR#off("i")##off("b")# 
+ 
+  Die Normaleinstellung wird durch 'limit(77)' und 'margin(1)' wiederhergestellt. 
+
diff --git a/doc/programmer-manual/1.8.7/doc/programmierhandbuch.4 b/doc/programmer-manual/1.8.7/doc/programmierhandbuch.4
new file mode 100644
index 0000000..650d945
--- /dev/null
+++ b/doc/programmer-manual/1.8.7/doc/programmierhandbuch.4
@@ -0,0 +1,1692 @@
+#headandbottom("1","EUMEL-Benutzerhandbuch","TEIL 4 : Kommandosprache","4")# 
+#pagenr("%",1)##setcount(1)##block##pageblock# 
+#headeven# 
+#center#EUMEL-Benutzerhandbuch 
+#center#____________________________________________________________ 
+ 
+#end# 
+#headodd# 
+#center#TEIL 4 : Kommandosprache 
+#center#____________________________________________________________ 
+ 
+#end# 
+#bottomeven# 
+#center#____________________________________________________________ 
+4 - % #right#GMD 
+#end# 
+#bottomodd# 
+#center#____________________________________________________________ 
+GMD #right#4 - % 
+#end# 
+TEIL 4:  Kommandosprache 
+ 
+In Teil 4 sind diejenigen Kommandos beschrieben, die erfahrungsgemäß eher der
+Handhabung der Arbeitsumgebung zuzurechnen sind. Es ist den Verfassern bewußt,
+daß Auswahl und Zusammenstellung recht willkürlich sind, weil eine klare Abgrenzung
+zum Teil 5, welcher die Kommandos, die dem Thema: 'Programmierung' zugeordnet
+werden, nicht möglich ist. 
+ 
+Der Teil 4 ist in die Themen: 
+ 
+- 4.1.                     Supervisor-Kommandos 
+ 
+- 4.2.1                    Hilfs- und Informationsprozeduren 
+ 
+- 4.2.2                    Thesaurus 
+ 
+- 4.2.3                    Tasks 
+ 
+- 4.2.4                    Handhabung von Dateien 
+ 
+- 4.2.5                    Editor 
+ 
+- 4.2.6                    Dateitransfer 
+ 
+- 4.2.7                    Passwortschutz 
+ 
+- 4.2.8                    Archiv 
+ 
+gegliedert. Insbesondere zu 4.2.4 ist anzumerken, daß nur Kommandos, die ganze
+Dateien betreffen hier erläutert sind. Kommandos, die Dateiinhalte betreffen (Suchen,
+Ersetzen etc.) sind in 3.5, bzw. 5.3 beschrieben. 
+#page# 
+
+4.1  Supervisor 
+ 
+Es gibt genau sieben vom Supervisor akzeptierte Kommandos. Diese Kommandos
+können gegeben werden wenn nach dem Einschalten des Geräts oder dem Abkoppeln
+einer Task die SV-Taste gedrückt wurde und die sogenannte EUMEL-Tapete
+erscheint. 
+ 
+____________________________________________________________________________ 
+ 
+                                           Terminal 2  
+ 
+ 
+                    EUMEL Version 1.8.1/M 
+ 
+ 
+        gib supervisor kommando: 
+          
+ 
+ 
+ 
+   ESC ? --> help 
+   ESC b --> begin("")            ESC h --> halt 
+   ESC c --> continue("")         ESC s --> storage info 
+   ESC q --> break                ESC t --> task info 
+ 
+____________________________________________________________________________ 
+ 
+ 
+ 
+ 
+Desweiteren kann <SV> in einer Task gedrückt werden, um durch <ESC> <h> einen
+Programmabbruch einzuleiten. 
+ 
+Im Gegensatz zu den im weiteren beschriebenen, durch ELAN Prozeduren realisierten
+Kommandos, sind diese Supervisor-Kommandos nicht als Prozeduren im System und
+mithin nicht durch 'help (...)' anzeigbar. 
+#page# 
+'begin' 
+   #on("b")#PROC begin (TEXT CONST taskname) #off("b")# 
+   Richtet eine neue Task als Sohn von PUBLIC ein. 
+ 
+ 
+   #on("b")#PROC begin (TEXT CONST taskname, vatertask) #off("b")# 
+   Richtet eine neue Task als Sohn der Task 'vatertask' ein, falls die Vater-Task
+   eine Manager-Task ist. Falls diese Task keinen Managerstatus besitzt, passiert
+   nichts! In diesem Falle muß das Kommando durch <SV> abgebrochen werden. 
+ 
+ 
+   FEHLER :  "taskname" existiert bereits 
+             "vatertask" gibt es nicht 
+ 
+ 
+ 
+ 
+'continue' 
+   #on("b")#PROC continue (TEXT CONST taskname) #off("b")# 
+   Eine existierende Task wird an das Terminal des Benutzers angekoppelt. 
+ 
+   FEHLER :  "taskname" gibt es nicht 
+ 
+ 
+   Falls 'begin' oder 'continue' trotz korrekter Voraussetzungen kein Resultat zeigen,
+   'hängt' die betroffene Task. Beim 'begin' Kommando kann das der Fall sein, falls
+   die Vater-Task nicht durch 'break' abgekoppelt wurde, sondern mit < SV > verlas­
+   sen wurde. In diesem Fall muß das Kommando durch <SV> abgebrochen werden,
+   die Vater-Task angekoppelt und mit <ESC> <q> korrekt abgekoppelt werden. 
+#page# 
+'break' 
+   #on("b")#PROC break #off("b")# 
+   Das Terminal wird vom Rechner abgekoppelt. 
+ 
+ 
+ 
+'halt' 
+   #on("b")#PROC halt #off("b")# 
+   Das laufende Programm der dem Terminal aktuell zugeordneten Task wird abge­
+   brochen. 
+ 
+   Falls in der an das Terminal gekoppelten Task ein laufendes Programm abgebro­
+   chen werden soll, muß zunächst durch <SV> der Supervisor aufgerufen werden.
+   Durch das Supervisor-Kommando 'halt' wird der Fehler 'halt from terminal'
+   induziert. Das Programm wird wie durch jeden anderen Fehler abgebrochen, falls
+   nicht 'disable stop' gesetzt wurde! 
+ 
+ 
+ 
+#page# 
+'storage info' 
+   #on("b")#PROC storage info #off("b")# 
+   Informationsprozedur über den belegten und den verfügbaren Hintergrund-Spei­
+   cher des gesamten Systems in KByte#u#1)#e#. 
+ 
+#foot# 
+ 
+   1) Bei der derzeit aktuellen '+' Version EUMEL 1.8.1/M+ sind die beiden Anga­
+      ben mit 4 zu multiplizieren ! 
+#end# 
+   Das Terminal wird unmittelbar abgekoppelt! 
+ 
+ 
+ 
+'task info' 
+   #on("b")#PROC task info #off("b")# 
+   Informiert über alle Tasknamen im System unter gleichzeitiger Angabe der Vater/
+   Sohn-Beziehungen durch Einrückungen. 
+ 
+ 
+ 
+ 
+'help' 
+   #on("b")#PROC help #off("b")# 
+   Kurzbeschreibung der SV-Kommandos. 
+#page# 
+
+4.2  Monitor
+ 
+Unter dem Stichwort Monitor-Kommandos sind an dieser Stelle Kommandos be­
+schrieben, die ständig zur Handhabung der Arbeitsumgebung benutzt werden.
+Gleichwohl sei sofort darauf hingewiesen, daß jedes ELAN Programm dem Monitor zur
+Ausführung übergeben werden kann. Es gibt also keine speziellen Monitor-
+Kommandos, sondern nur eine Reihe von Prozeduren (=Kommandos), die in dieser
+Umgebung erfahrungsgemäß besonders häufig benutzt werden. 
+ 
+ 
+#on("u")#4.2.1  Hilfs- und Informationsprozeduren#off("u")# 
+ 
+- Pakete, Prozeduren       :  packets, bulletin , help 
+  Parameter 
+ 
+- Tasksystem zeigen        :  task info , task status 
+ 
+- Speicherplatz zeigen     :  storage , storage info 
+ 
+ 
+#on("u")#4.2.2  Thesaurus #off("u")# 
+ 
+-  besondere Thesauri      :  ALL , all , SOME , remainder 
+ 
+-  Verknüpfung             :  + , - ,  / 
+ 
+ 
+#on("u")#4.2.3  Taskoperationen#off("u")# 
+ 
+- besondere Tasknamen      :  archive , brother , father , myself 
+                              printer , public , son , supervisor 
+- Terminal abkoppeln       :  break 
+- Task löschen             :  end 
+- Manager-Task             :  global manager , free global manager 
+- Umbenennen der Task      :  rename myself 
+ 
+#page# 
+#on("u")#4.2.4  Handhabung von Dateien #off("u")# 
+ 
+                           :  copy , edit , forget , list , rename , show 
+ 
+ 
+#on("u")#4.2.5  Editor #off("u")# 
+ 
+- Editieren                :  edit , editget , show 
+- Tastenbelegung           :  kommando auf taste (legen) , 
+                              lernsequenz auf taste (legen) , 
+                              std tastenbelegung , 
+                              taste enthält kommando , 
+                              word wrap 
+ 
+ 
+#on("u")#4.2.6  Transfer #off("u")# 
+ 
+- Datei holen              :  fetch , fetchall 
+- Datei senden             :  save , saveall 
+- Drucken                  :  print 
+- Datei löschen            :  erase 
+ 
+ 
+#on("u")#4.2.7  Passwortschutz #off("u")# 
+ 
+- 'begin' absichern        :  begin password 
+- 'continue' absichern     :  task password 
+- Dateien absichern        :  enter password 
+- Systemzweig sichern      :  family password 
+ 
+ 
+#on("u")#4.2.8  Das Archiv #off("u")# 
+ 
+- Reservieren/freigeben    :  archive , release 
+- Formatieren              :  format 
+- Löschen                  :  clear 
+- Kontrollesen             :  check 
+ 
+ 
+#page# 
+
+4.2.1  Hilfsprozeduren 
+ 
+Die drei Prozeduren listen ihre Ausgabe jeweils in eine temporäre Datei, die mit
+'show' (s. 4.2.5) gezeigt wird. 
+ 
+ 
+'packets' 
+   #on("b")#PROC packets #off("b")# 
+   Auflisten der Namen aller insertierten Pakete in der Task. 
+ 
+ 
+ 
+ 
+ 
+ 
+'bulletin' 
+   #on("b")#PROC bulletin (TEXT CONST paket name) #off("b")# 
+   Listen aller in der DEFINES-Liste des Pakets mit dem Namen "paket name"
+   enthaltenen Prozeduren. 
+ 
+   FEHLER :  ... ist kein Paketname 
+ 
+ 
+   #on("b")#PROC bulletin #off("b")# 
+   Es wird eine Liste aller bisher insertierten Objekte erstellt. Diese Liste ist paket­
+   weise sortiert. 'bulletin' zeigt also eine Liste #on("u")#aller#off("u")# Prozeduren an, die in der Task
+   benutzt werden können. 
+#page# 
+'help' 
+   #on("b")#PROC help (TEXT CONST name) #off("b")# 
+   Listen aller Prozeduren / Operatoren mit dem Namen "name". Der Name des
+   Packets in dessen Schnittstelle die Prozedur steht wird mit ausgegeben. 
+ 
+   Falls es kein Objekt des erfragten Namens gibt, erfolgt die Ausgabe: 
+ 
+   unbekannt "name". 
+ 
+   Beispiel: 
+____________________________________________________________________________ 
+ 
+     gib kommando : 
+     help("save") 
+ 
+____________________________________________________________________________ 
+ 
+ 
+   liefert: 
+ 
+____________________________________________________________________________ 
+ 
+PACKET nameset: 
+ 
+      save........... (THESAURUS CONST, TASK CONST) 
+      save........... (THESAURUS CONST) 
+ 
+PACKET globalmanager: 
+ 
+      save........... (DATASPACE CONST, TEXT CONST, TASK CONST) 
+      save........... (TEXT CONST, TASK CONST) 
+      save........... (TEXT CONST) 
+      save........... 
+ 
+____________________________________________________________________________ 
+ 
+ 
+ 
+   Desweiteren kann auch nach Prozedurnamen gesucht werden, die nur annähernd
+   bekannt sind, indem ein Suchmuster spezifiziert wird. Das Suchmuster besteht aus
+   dem bekannten Teil des Namens und dem Operator '*', der vor und/oder nach
+   dem Suchbegriff gesetzt werden kann. '*' bezeichnet eine beliebige (auch leere)
+   Zeichenkette. 
+ 
+   Beispiel: Gesucht werden die verschiedenen 'info' Prozeduren: 
+ 
+____________________________________________________________________________ 
+     gib kommando : 
+     help("*info*") 
+ 
+____________________________________________________________________________ 
+ 
+ 
+ 
+____________________________________________________________________________ 
+ 
+      taskinfo....... (INT CONST, INT CONST) 
+      taskinfo....... (INT CONST, FILE VAR) 
+      taskinfo....... (INT CONST) 
+      taskinfo....... 
+      editinfo....... (FILE VAR, INT CONST) 
+      editinfo....... (FILE CONST)  --> INT 
+      storageinfo.... 
+ 
+____________________________________________________________________________ 
+ 
+ 
+ 
+   Dieser Stern darf nicht mit dem 'joker' des 'Pattern Matching' verwechselt werden.
+   In der 'help' Prozedur darf '*' #on("u")#nicht#off("u")# in den Suchbegriff eingesetzt werden, sondern
+   nur an Wortanfang und -Ende gesetzt werden. 
+ 
+ 
+#page# 
+
+Informationsprozeduren 
+ 
+'storage' 
+   #on("b")#INT PROC storage (TASK CONST task) #off("b")# 
+   Informationsprozedur über den logisch belegten Hintergrund-Speicher der Task.
+   (Angabe in KByte, bzw. 4KB Einheiten bei der '+'-Version) 
+ 
+ 
+____________________________________________________________________________ 
+ 
+    gib kommando : 
+    put(storage(myself)) 
+    1234 
+ 
+    gib kommando : 
+ 
+____________________________________________________________________________ 
+ 
+ 
+'storage info' 
+   #on("b")#PROC storage info #off("b")# 
+   Informationsprozedur über den belegten und den verfügbaren Hintergrund-Spei­
+   cher des gesamten Systems. Die Ausgabe erfolgt in KByte, bei der aktuellen
+   '+'-Version in 4 KByte Einheiten. 
+ 
+ 
+____________________________________________________________________________ 
+ 
+    gib kommando : 
+    storage info 
+    1234K von 12000K 
+ 
+    gib kommando : 
+____________________________________________________________________________ 
+#page# 
+ 
+'task info' 
+   #on("b")#PROC task info #off("b")# 
+   Informiert über alle Tasknamen im System unter gleichzeitiger Angabe der Vater/
+   Sohn-Beziehungen (Angabe durch Einrückungen). 
+ 
+ 
+   #on("b")#PROC task info (INT CONST art) #off("b")# 
+   Informiert über alle Tasks im System. Mit 'art' kann man die Art der Zusatz-
+   Information auswählen. 
+ 
+   art=1: entspricht 'task info' ohne Parameter, d.h. es gibt nur die Tasknamen
+          unter Angabe der Vater/Sohn-Beziehungen aus. 
+ 
+   art=2: gibt die Tasknamen aus. Zusätzlich erhalten Sie Informationen über die
+          verbrauchte CPU-Zeit der Task, die Priorität, den Kanal, an dem die
+          Task angekoppelt ist, und den eigentlichen Taskstatus. Hierbei bedeuten: 
+ 
+          0    -busy-        Task ist aktiv. 
+          1    i/o           Task wartet auf Beendigung des Outputs oder auf
+                             Eingabe. 
+          2    wait          Task wartet auf Sendung von einer anderen Task. 
+          4    busy-blocked  Task ist rechenwillig, aber blockiert#u#1)#e#. 
+          5    i/o -blocked  Task wartet auf I/O, ist aber blockiert. 
+          6    wait-blocked  Task wartet auf Sendung, ist aber blockiert. Ach­
+                             tung: Die Task wird beim Eintreffen einer Sendung
+                             automatisch entblockiert. 
+        > 6    dead 
+ 
+    art=3: wie 2, aber zusätzlich wird der belegte Speicher angezeigt. (Achtung:
+           Prozedur ist zeitaufwendig!). 
+ 
+#foot# 
+ 
+1) Eine Blockierung kann von 'Scheduler' veranlaßt werden 
+   (siehe Systemhandbuch) 
+#end# 
+ 
+#page# 
+____________________________________________________________________________ 
+ 
+    gib kommando : 
+    task info(2) 
+ 
+____________________________________________________________________________ 
+ 
+ 
+ 
+    liefert: 
+ 
+____________________________________________________________________________ 
+ 
+ ............................ ............................... 
+ 15.05.87   10:39                         CPU    PRIO CHAN STATUS 
+ SUPERVISOR.......................... 0000:19:47   0   -   wait 
+    -................................ 0000:07:54   0   -   wait 
+    SYSUR............................ 0000:34:02   0   -   wait 
+        shutup dialog................ 0000:05:26   0   -   i/o 
+        configurator................. 0000:04:17   0   -   wait 
+        OPERATOR..................... 0000:00:14   0   -   i/o 
+        ARCHIVE...................... 0000:10:33   0  31   wait 
+        net.......................... 0006:41:56   0   -   wait 
+            net timer................ 0000:02:48   2   -   i/o 
+            net port................. 0000:40:23   0   7   wait 
+        PRINTER...................... 0000:05:59   0   -   wait 
+            -........................ 0000:00:11   0   -   wait 
+ UR.................................. 0000:02:11   0   -   wait 
+    PUBLIC........................... 0002:02:03   0   -   wait 
+        task1........................ 0000:41:50   0   -   -busy- 
+        task2........................ 0000:03:10   0   -   i/o 
+        task3........................ 0000:57:28   0   1   -busy- 
+ 
+____________________________________________________________________________ 
+ 
+ 
+#page# 
+ 
+ 
+   #on("b")#PROC task info (INT CONST art, FILE VAR infodatei) #off("b")# 
+   Wie oben, die Ausgabe wird jedoch in die Datei 'infodatei' geschrieben. 
+ 
+____________________________________________________________________________ 
+ 
+    FILE VAR info := sequential file(output,"infodatei") ; 
+    taskinfo(3, info); 
+     
+____________________________________________________________________________ 
+ 
+ 
+   #on("b")#PROC task info ( INT CONST art, stationsnr) #off("b")# 
+   Ermöglicht im Netzbetrieb 'task info' über die Station mit der Nummer 'stationsnr'. 
+ 
+____________________________________________________________________________ 
+ 
+    gib kommando : 
+    taskinfo(1,12) ; 
+ 
+____________________________________________________________________________ 
+#page# 
+'task status' 
+ 
+   #on("b")#PROC task status #off("b")# 
+   Informationsprozedur über den Zustand der eigenen Task. Informiert über 
+   -  Name der Task, Datum und Uhrzeit; 
+   -  verbrauchte CPU-Zeit; 
+   -  belegten Speicherplatz; 
+   -  Kanal, an den die Task angekoppelt ist; 
+   -  Zustand der Task (rechnend u.a.m.); 
+   -  Priorität. 
+ 
+   #on("b")#PROC task status (TASK CONST t) #off("b")# 
+   Wie obige Prozedur, aber über die Task mit dem internen Tasknamen 't'. 
+ 
+ 
+____________________________________________________________________________ 
+ 
+   gib kommando : 
+   task status (public) 
+ 
+ 15.05.87 10:30   TASK: PUBLIC 
+ 
+ Speicher: 1234K 
+ CPU Zeit: 0011.12:23 
+ Zustand : wait, (Prio 0), Kanal - 
+ 
+____________________________________________________________________________ 
+#page# 
+ 
+4.2.2  Thesaurus 
+ 
+Ein #ib#Thesaurus#ie# ist ein #ib#Namensverzeichnis#ie#, das bis zu 200 Namen beinhalten kann.
+Dabei muß jeder Namen mindestens ein Zeichen und darf höchstens 100 Zeichen
+lang sein. Steuerzeichen (code < 32) in Namen werden umgesetzt (siehe 2.9.2). 
+ 
+Thesauri werden unter anderem von der Dateiverwaltung benutzt, um das Dateiver­
+zeichnis einer Task zu führen. 
+ 
+Man kann einen Thesaurus selbst erstellen, indem eine Datei z.B. mit Namen von
+Dateien gefüllt wird. Diese Datei kann dann als Thesaurus für weitere Aktionen die­
+nen. 
+ 
+ 
+ 
+- Thesaurus liefern        :  ALL , all , SOME , remainder 
+- Auswählen                :  LIKE 
+- Verknüpfen               :  + , - , / 
+ 
+ 
+ 
+#on("b")#ACHTUNG#off("b")# :  Bei der Verwendung von Thesaurus Operationen in Verbindung mit
+'fetch', 'save' etc. ist zu beachten, daß mit 'SOME', 'ALL' und 'all' zunächst nur eine
+Auswahl aus einer Liste getroffen wird. Zusätzlich muß das Ziel oder die Quelle des
+Dateitransfers vereinbart werden. 
+ 
+Ein beliebter Fehler ist z.B.:   'fetch (ALL archive)'. 
+ 
+Hier ist nicht weiter spezifiziert, von wo Dateien geholt werden sollen - also werden
+sie von 'father' geholt!  (s. 4.2.5) 
+ 
+Falls die Dateien vom Archiv geholt werden sollen, ist das Archiv als Quelle zu be­
+nennen: 
+ 
+Also : 'fetch (ALL archive, archive)' = Hole alle Dateien, die in dem Thesaurus von 
+                                  'archive' sind von der Task 'archive'. 
+#page# 
+'ALL' 
+   THESAURUS OP ALL (TASK CONST task) 
+   Liefert einen Thesaurus, der alle Dateinamen der angegebenen Task enthält. 
+ 
+ 
+ 
+   #on("b")#THESAURUS OP ALL (TEXT CONST dateiname) #off("b")# 
+   Liefert einen Thesaurus, der die in der angegebenen Datei vorhandenen Namen
+   (jede Zeile ein Name) enthält. 
+ 
+ 
+ 
+ 
+'all' 
+   #on("b")#THESAURUS PROC all #off("b")# 
+   Liefert einen Thesaurus, der alle Dateinamen der eigenen Task enthält. Entspricht
+   'ALL myself'. 
+ 
+ 
+ 
+ 
+'SOME' 
+   #on("b")#THESAURUS OP SOME (THESAURUS CONST thesaurus) #off("b")# 
+   Bietet den angegebenen Thesaurus zum editieren an. Dort können nicht erwünsch­
+   te Namen gestrichen werden. 
+ 
+ 
+ 
+   #on("b")#THESAURUS OP SOME (TASK CONST task) #off("b")# 
+   Aufruf von: SOME ALL task. 
+ 
+ 
+   #on("b")#THESAURUS OP SOME (TEXT CONST dateiname) #off("b")# 
+   Aufruf von: SOME ALL dateiname. 
+ 
+#page# 
+'remainder' 
+   #on("b")#PROC remainder #off("b")# 
+   Liefert nach einem 'errorstop' die noch nicht bearbeiteten Dateien. 
+ 
+____________________________________________________________________________ 
+ 
+    gib kommando : 
+    save all (archive) 
+ 
+   '"....." kann nicht geschrieben werden (Archiv voll)' 
+ 
+____________________________________________________________________________ 
+ 
+ 
+ 
+   Nachdem man eine neue Floppy ins Archivlaufwerk gelegt hat, kann man mit 
+ 
+ 
+____________________________________________________________________________ 
+    gib kommando : 
+    save (remainder, archive) 
+ 
+____________________________________________________________________________ 
+ 
+   den Rest der Dateien auf die nächste Floppy sichern. 
+#page# 
+'LIKE' 
+   #on("b")#THESAURUS OP LIKE (THESAURUS CONST thesaurus, TEXT CONST muster) #off("b")# 
+   Alle im Thesaurus enthaltenen Dateien, die dem 'muster' entsprechen sind im
+   Ergebnisthesaurus enthalten. 
+ 
+   (Die Syntax von 'muster' ist bei der Beschreibung des Pattern-Matching (5.4)
+   beschrieben) 
+ 
+ 
+____________________________________________________________________________ 
+ 
+    gib kommando : 
+    print (all LIKE "*.p") 
+ 
+____________________________________________________________________________ 
+ 
+ 
+  Alle Dateien, deren Name mit '.p' endet, werden gedruckt. 
+ 
+#page# 
+'+' 
+   #on("b")#THESAURUS OP + (THESAURUS CONST links, rechts) #off("b")# 
+   Liefert die Vereinigungsmenge von 'links' und 'rechts'. 
+   Achtung: Die Vereinigungsmenge enthält keine Namen mehrfach. 
+ 
+   #on("b")#THESAURUS OP + (THESAURUS CONST links, TEXT CONST rechts)#off("b")# 
+   Fügt dem Thesaurus 'rechts' zu, wenn 'rechts' noch nicht im Thesaurus enthal­
+   ten ist. 
+ 
+ 
+ 
+ 
+'-' 
+   #on("b")#THESAURUS OP - (THESAURUS CONST links, rechts) #off("b")# 
+   Liefert die Differenzmenge. Achtung: Die Differenzmenge enthält keine Namen
+   mehrfach. 
+ 
+   #on("b")#THESAURUS OP - (THESAURUS CONST links, TEXT CONST rechts)#off("b")# 
+   Nimmt den Namen 'rechts' aus dem Thesaurus. 
+ 
+____________________________________________________________________________ 
+ 
+    gib kommando : 
+    fetch(ALL father - ALL myself) 
+ 
+____________________________________________________________________________ 
+ 
+ 
+'/' 
+   #on("b")#THESAURUS OP / (THESAURUS CONST links, rechts) #off("b")# 
+   Liefert die Schnittmenge 
+   Achtung: Die Schnittmenge enthält keine Namen mehrfach. 
+ 
+ 
+#page# 
+
+4.2.3  Tasks
+ 
+Zur Identifizierung von Tasks dienen sogenannte 'interne Taskbezeichner'. Ein solcher
+Taskbezeichner wird beim Einrichten einer neuen Task vergeben. Interne Taskbe­
+zeichner sind auch unter Berücksichtigung der Zeit eindeutig. 
+ 
+Der Zugriff auf interne Taskbezeichner erfolgt über Prozeduren und Operatoren, die
+auf Objekte des Datentyps TASK (siehe 2.9.1) angewandt werden. 
+ 
+Zusätzlich zum internen Tasknamen, der nicht auszugeben ist, haben Tasks meistens
+einen Namen#u#1) #e#. 
+#foot# 
+ 
+1) Unbenannte Tasks haben den Pseudonamen "-". 
+#end# 
+ 
+Aus Benutzersicht können benannte Tasks innerhalb eines Rechners vollständig und
+eindeutig über ihren Namen identifiziert werden. 
+ 
+ 
+- Task liefern             :  / , task , niltask 
+ 
+- Verwandtschaften         :  brother , father , myself , son 
+ 
+- Ausgezeichnete Tasks     :  archive , printer , public , supervisor 
+ 
+- Namen liefern            :  name 
+ 
+- Tasknamen ändern         :  rename myself 
+ 
+- Reservieren bes. Tasks   :  reserve 
+ 
+#page# 
+'/' 
+   #on("b")#TASK OP / (TEXT CONST taskname) #off("b")# 
+   Liefert die Task des angegebenen Namens, falls sie existiert. Der eigene Katal­
+   og wird automatisch aktualisiert 
+ 
+   (identisch mit der PROC task (TEXT CONST taskname). 
+ 
+   FEHLER :   "taskname" gibt es nicht 
+ 
+ 
+   #on("b")#TASK OP / (INT CONST station number, TEXT CONST name) #off("b")# 
+   Liefert im Netzbetrieb die Task des angegebenen Namen von der Station mit der
+   angegebenen Nummer. 
+ 
+ 
+ 
+'niltask' 
+   #on("b")#TASK CONST niltask #off("b")# 
+   Bezeichner für "keine Task". So liefern die Prozeduren 'son', 'brother' und 'father'
+   als Resultat 'niltask', wenn keine Sohn-, Bruder- oder Vatertask existiert. 
+ 
+ 
+ 
+'task' 
+   #on("b")#TASK PROC task (TEXT CONST taskname) #off("b")# 
+   Liefert die Task des angegebenen Namens, falls sie existiert. Der eigene Katal­
+   og wird automatisch aktualisiert. 
+ 
+   FEHLER :     "taskname" gibt es nicht 
+ 
+ 
+   #on("b")#TASK PROC task (INT CONST channel number) #off("b")# 
+   Liefert den Namen der Task, die an dem angegebenen Kanal hängt. 
+#page# 
+'brother' 
+   #on("b")#TASK PROC brother (TASK CONST task) #off("b")# 
+   Liefert den nächsten Bruder von 'task'. Falls kein Bruder existiert, wird 'niltask'
+   geliefert. Aktualisiert den eigenen Katalog nicht automatisch! 
+ 
+ 
+ 
+'father' 
+   #on("b")#TASK PROC father #off("b")# 
+   Liefert die eigene Vatertask. 
+ 
+ 
+   #on("b")#TASK PROC father (TASK CONST task) #off("b")# 
+   Liefert den Vater von 'task'. Existiert kein Vater (z.B. bei UR), wird niltask gelie­
+   fert. Aktualisiert den eigenen Katalog nicht automatisch! 
+ 
+ 
+ 
+'myself' 
+   #on("b")#TASK PROC myself #off("b")# 
+   Liefert eigenen Task-Bezeichner. 
+ 
+ 
+ 
+'son' 
+   #on("b")#TASK PROC son (TASK CONST task) #off("b")# 
+   Liefert den ersten Sohn von 'task'. Falls keiner im Katalog vermerkt ist, wird
+   'niltask' geliefert. Aktualisiert den eigenen Katalog nicht automatisch! 
+ 
+ 
+#page# 
+'archive' 
+   #on("b")#TASK PROC archive #off("b")# 
+   Liefert den internen Taskbezeichner der aktuellen Task mit Namen ARCHIVE.
+   Diese Prozedur dient zum schnellen und bequemen Ansprechen der Archivtask. 
+ 
+ 
+ 
+'printer' 
+   #on("b")#TASK PROC printer #off("b")# 
+   Liefert den internen Taskbezeichner der aktuellen Task mit Namen #ib#PRINTER#ie#.
+   Diese Prozedur dient zum schnellen und bequemen Ansprechen des Druckspoo­
+   lers. 
+ 
+ 
+'public' 
+   #on("b")#TASK PROC public #off("b")# 
+   Liefert den internen Taskbezeichner der Task #ib#PUBLIC#ie#. 
+ 
+ 
+ 
+ 
+'supervisor' 
+   #on("b")#TASK PROC supervisor #off("b")# 
+   Liefert den internen Taskbezeichner des Supervisors. 
+ 
+ 
+#page# 
+'name' 
+   #on("b")#TEXT PROC name (TASK CONST task) #off("b")# 
+   Liefert den Namen von 'task'. Die Task muß noch im System existieren, sonst ist
+   der Name nicht mehr bekannt. Falls die 'task' noch nicht im eigenen Katalog
+   enthalten ist, wird er aktualisiert. 
+ 
+ 
+ 
+'rename myself' 
+   #on("b")#PROC rename myself (TEXT CONST neuer name) #off("b")# 
+   Name der eigenen Task wird in 'neuer name' geändert. Wirkt wie Löschung und
+   Wiedereinrichten der Task in Bezug auf alle TASK VAR's die sich auf diese Task
+   beziehen. 
+ 
+   FEHLER :   Task existiert bereits 
+              Name unzulässig 
+              => anderen Namen wählen 
+ 
+ 
+ 
+'reserve' 
+   #on("b")#PROC reserve (TASK CONST task) #off("b")# 
+   Reservieren einer Task für den ausschließlichen Dialog mit der Task, in der das
+   Kommando gegeben wurde. 
+ 
+   #on("b")#PROC reserve (TEXT CONST message, TASK CONST task) #off("b")# 
+   Wie 'reserve (TASK CONST task)' mit Übergabe einer 'message'. 
+ 
+ 
+   Die reservierte Task muß ein spezieller Manager, (z.B. /"DOS" aus dem Werkzeug
+   MS-DOS-DAT) sein ! 
+#page# 
+
+4.2.4  Handhabung von Dateien 
+ 
+'copy' 
+   #on("b")#PROC copy (TEXT CONST quelle, ziel) #off("b")# 
+   Kopiert die Datei 'quelle' in eine neue Datei mit dem Namen 'ziel' in der Benut­
+   zer-Task. 
+ 
+   FEHLER :  "ziel" existiert bereits 
+             "quelle" gibt es nicht 
+             zu viele Dateien 
+ 
+ 
+ 
+'forget' 
+   #on("b")#PROC forget (TEXT CONST dateiname) #off("b")# 
+   Löschen einer Datei mit dem Namen 'dateiname' in der Benutzer-Task. 
+ 
+   FEHLER :  "datei" gibt es nicht 
+ 
+ 
+   #on("b")#PROC forget (THESAURUS CONST thesaurus) #off("b")# 
+   Löscht die im 'thesaurus' enthaltenen Dateien in der Benutzer-Task. 
+ 
+   Im Dialog erfolgt vor dem Löschen einer Datei standardmäßig die Abfrage: 
+ 
+ 
+____________________________________________________________________________ 
+ 
+    gib kommando : 
+    forget("einedatei") 
+ "einedatei" löschen(j/n) ? 
+ 
+____________________________________________________________________________ 
+ 
+#page# 
+'list' 
+   #on("b")#PROC list #off("b")# 
+   Listet alle Dateien der Benutzer-Task mit Namen und Datum des letzten Zugriffs
+   auf dem Terminal auf. 
+ 
+ 
+   #on("b")#PROC list (TASK CONST task) #off("b")# 
+   Listet alle Dateien der angegebenen 'task' mit Namen und Datum der letzten
+   Änderung auf dem Terminal auf. Die Task muß Manager sein. 
+ 
+ 
+   #on("b")#PROC list (FILE VAR liste) #off("b")# 
+   Listet alle Dateinamen in die Datei 'liste', die mit 'output'(s. 5.3.5) assoziiert sein
+   muß. 
+ 
+ 
+   #on("b")#PROC list (FILE VAR liste, TASK CONST manager) #off("b")# 
+   Listet alle Dateien der Task 'manager' mit Namen und Datum der letzten Ände­
+   rung in die Datei 'liste'. 
+ 
+ 
+____________________________________________________________________________ 
+ 
+ gib kommando : 
+ FILE VAR f:= sequential file (output,"list");list(f,archive) 
+ 
+____________________________________________________________________________ 
+ 
+#page# 
+'rename' 
+   #on("b")#PROC rename (TEXT CONST altername, neuername) #off("b")# 
+   Umbenennen einer Datei von 'altername' in 'neuername'. 
+ 
+ 
+ 
+   FEHLER :   "neuername" gibt es bereits 
+              "altername" gibt es nicht 
+#page# 
+ 
+4.2.5  Editor-Prozeduren  
+ 
+'edit' 
+   #on("b")#PROC edit (TEXT CONST dateiname) #off("b")# 
+   Ruft den Editor mit 'dateiname' auf. 
+ 
+ 
+   #on("b")#PROC edit #off("b")# 
+   a) Im Monitor: 
+      Ruft den Editor mit den zuletzt verwandten Dateinamen auf. 
+ 
+   b) Im Editor: 
+      Der Dateiname wird erfragt. 
+ 
+   Für jedes 'edit' gilt: 
+   Wurde 'edit' zum ersten Mal aufgerufen, nimmt das Fenster den gesamten Bild­
+   schirm ein. Bei erneutem 'edit'-Aufruf wird ein Fenster nach rechts unten ab der
+   aktuellen Cursor-Position eröffnet. 
+ 
+ 
+   #on("b")#PROC edit (THESAURUS CONST t) #off("b")# 
+   Editieren aller in dem Thesaurus 't' enthaltenen Dateien nacheinander. 
+ 
+ 
+   Weitere 'edit-Prozeduren', die z.B. Variation der Fenstergröße etc. zulassen, sind
+   in 5.4.6 beschrieben. 
+   
+#page# 
+'editget' 
+   #on("b")#PROC editget  (TEXT VAR editsatz) #off("b")# 
+   Ausgabe einer (Kommando)zeile, in der Editorfunktionen zur Verfügung
+   stehen siehe Teil 5.5.1.4. 
+ 
+ 
+ 
+'show' 
+   #on("b")#PROC show (TEXT CONST dateiname) #off("b")# 
+   Die Datei wird am Bildschirm gezeigt. Positionierung und Suchen funktionieren wie
+   in 'edit', Aktionen die Änderungen in der Datei bewirken würden, werden nicht
+   angenommen. 
+ 
+ 
+ 
+   #on("b")#PROC show #off("b")# 
+   'show' auf der zuletzt bearbeiteten Datei. 
+ 
+#page# 
+'kommando auf taste legen' 
+   #on("b")#PROC kommando auf taste legen (TEXT CONST taste, elan programm)#off("b")# 
+   Die Taste 'taste' wird mit dem angegebenen ELAN-Programm belegt. Durch <ESC>
+   <taste> wird das Programm direkt ausgeführt. 
+ 
+____________________________________________________________________________ 
+ 
+  gib kommando : 
+  kommando auf taste legen ("a","fetch (SOME archive,archive)") 
+ 
+____________________________________________________________________________ 
+ 
+ 
+ 
+'kommando auf taste' 
+   #on("b")#TEXT PROC kommando auf taste (TEXT CONST taste)#off("b")# 
+   Falls 'taste' mit einem ELAN-Programm belegt ist, liefert die Prozedur den
+   Programmtext, andernfalls den leeren Text niltext. 
+ 
+____________________________________________________________________________ 
+ 
+  gib kommando : 
+  put (kommando auf taste("f")) 
+ 
+____________________________________________________________________________ 
+ 
+ 
+ 
+'taste enthaelt kommando' 
+   #on("b")#BOOL PROC taste enthaelt kommando (TEXT CONST taste)#off("b")# 
+   Liefert TRUE falls 'taste' mit einem ELAN-Programm belegt ist. 
+ 
+ 
+'lernsequenz auf taste legen' 
+   #on("b")#PROC lernsequenz auf taste legen (TEXT CONST taste, sequenz)#off("b")# 
+   'taste' wird mit der Zeichenfolge 'sequenz' belegt. Durch <ESC> <taste> wird die
+   Zeichenfolge an der aktuellen Position ausgegeben. 
+ 
+   Als Zeichenfolge sind natürlich auch einzelne Zeichen und EUMEL-Codes zuläs­
+   sig. 
+ 
+   Die vom System vorbelegten Tasten sind in 3.4 'Zeichen schreiben' aufgelistet. 
+ 
+____________________________________________________________________________ 
+ 
+  gib kommando : 
+  lernsequenz auf taste legen ("x","gib kommando :"13""2""2"") 
+ 
+____________________________________________________________________________ 
+ 
+ 
+ 
+'lernsequenz auf taste' 
+   #on("b")#TEXT PROC lernsequenz auf taste (TEXT CONST taste) #off("b")# 
+   Liefert die auf 'taste' gelegte Zeichenfolge. 
+ 
+ 
+'std tastenbelegung' 
+   #on("b")#PROC std tastenbelegung #off("b")# 
+   Die Standard-Tastenbelegung (s.3.4) wird (wieder) hergestellt. 
+ 
+ 
+'word wrap' 
+   #on("b")#PROC word wrap (BOOL CONST b) #off("b")# 
+   Der automatische Zeilenumbruch wird durch 'word wrap (FALSE)' aus- und durch
+   'word wrap (TRUE)' eingeschaltet. Wird diese Prozedur während des Editierens
+   aufgerufen, gilt die Einstellung für die aktuelle Textdatei. Wird die Prozedur als
+   Monitor-Kommando gegeben, so gilt die Eingabe als Voreinstellung für neue
+   Dateien. 
+#page# 
+ 
+4.2.6  Dateitransfer
+ 
+Unter diesem Abschnitt sind diejenigen Prozeduren beschrieben, die der simplen
+Kommunikation mit Manager-Tasks dienen: Holen oder Senden einer Dateikopie,
+Löschen in der Manager-Task. 
+ 
+#on("b")#ACHTUNG :  Für alle Prozeduren gilt: falls die Manager-Task nicht existiert, wird eine
+Fehlermeldung erzeugt, existiert eine Task des angegebenen Namens, die aber nicht
+Managertask ist, so terminieren die Prozeduren nicht! 
+#off("b")# 
+ 
+ 
+'fetch' 
+   #on("b")#PROC fetch (TEXT CONST dateiname, TASK CONST manager) #off("b")# 
+   Kopiert die Datei 'dateiname' aus der Task 'manager' 
+ 
+ 
+   #on("b")#PROC fetch (THESAURUS CONST th, TASK CONST manager) #off("b")# 
+   Kopiert alle Dateien, deren Namen im Thesaurus th enthalten sind, aus der Task
+   'manager'. 
+ 
+ 
+____________________________________________________________________________ 
+ 
+   gib kommando : 
+   fetch(ALL(12/"PUBLIC"), 12/"PUBLIC") 
+ 
+____________________________________________________________________________ 
+ 
+ 
+ 
+   Mit diesem Kommando werden (in einem EUMEL Netz) alle Dateien der Task
+   'PUBLIC' des Rechners mit der Stationsnummer 12 in diesem Netz kopiert. 
+ 
+#page# 
+____________________________________________________________________________ 
+ 
+   gib kommando : 
+   fetch(SOME archive , archive) 
+ 
+____________________________________________________________________________ 
+ 
+ 
+ 
+   Bietet den Thesaurus von 'ARCHIVE' an, nach Auswahl werden alle Dateien deren
+   Namen nicht gelöscht wurden, von der Diskette kopiert. 
+ 
+ 
+   #on("b")#PROC fetch (TEXT CONST dateiname) #off("b")# 
+   Kopiert die Datei 'dateiname' aus der Task 'father' 
+ 
+ 
+   #on("b")#PROC fetch (THESAURUS CONST th) #off("b")# 
+   Kopiert alle Dateien, deren Namen in 'th' sind aus der Task 'father'. 
+ 
+ 
+ 
+'fetchall' 
+ 
+   #on("b")#PROC fetchall #off("b")# 
+   entspricht: fetch (ALL father, father) 
+ 
+ 
+   #on("b")#PROC fetchall (TASK CONST manager)#off("b")# 
+   entspricht: fetch(ALL manager, manager) 
+ 
+#page# 
+'save' 
+   #on("b")#PROC save (TEXT CONST dateiname, TASK CONST manager) #off("b")# 
+   Kopiert die Datei 'dateiname' in die Task 'manager' 
+ 
+ 
+   #on("b")#PROC save (THESAURUS CONST th, TASK CONST manager) #off("b")# 
+   Kopiert alle Dateien, deren Namen im Thesaurus th enthalten sind, in die Task
+   'manager'. 
+ 
+____________________________________________________________________________ 
+ 
+    gib kommando : 
+    save(all, (12/"PUBLIC")) 
+ 
+____________________________________________________________________________ 
+ 
+ 
+   Mit diesem Kommando werden (in einem EUMEL Netz) alle Dateien der eigenen
+   Task in die Task 'PUBLIC' des Rechners mit der Stationsnummer 12 in diesem
+   Netz kopiert. 
+ 
+____________________________________________________________________________ 
+ 
+    gib kommando : 
+    save(SOME myself, manager) 
+ 
+____________________________________________________________________________ 
+ 
+ 
+   Bietet den eigenen Thesaurus an, nach Auswahl werden alle Dateien deren
+   Namen nicht gelöscht wurden, zur Task 'manager' kopiert. 
+ 
+ 
+   #on("b")#PROC save (TEXT CONST dateiname) #off("b")# 
+   Kopiert die Datei 'dateiname' in die Task 'father' 
+ 
+ 
+   #on("b")#PROC save (THESAURUS CONST th) #off("b")# 
+   Kopiert alle Dateien, deren Namen in 'th' enthalten sind, in die Task 'father'. 
+ 
+ 
+   #on("b")#PROC save #off("b")# 
+   Kopiert die zuletzt bearbeitete Datei in die Task 'father' 
+ 
+ 
+ 
+ 
+'saveall' 
+   #on("b")#PROC saveall #off("b")# 
+   entspricht: save (all, father) 
+ 
+ 
+   #on("b")#PROC saveall (TASK CONST manager) #off("b")# 
+   entspricht: save (ALL myself, manager) 
+ 
+#page# 
+'erase' 
+   #on("b")#PROC erase (TEXT CONST dateiname, TASK CONST manager) #off("b")# 
+   Löscht die Datei 'dateiname' aus der Task 'manager' 
+ 
+ 
+   #on("b")#PROC erase (THESAURUS CONST th, TASK CONST manager) #off("b")# 
+   Löscht alle Dateien, deren Namen im Thesaurus th enthalten sind, aus der Task
+   'manager'. 
+ 
+ 
+   #on("b")#PROC erase (TEXT CONST dateiname) #off("b")# 
+   Löscht die Datei 'dateiname' aus der Task 'father' 
+ 
+ 
+   #on("b")#PROC erase (THESAURUS CONST th) #off("b")# 
+   Löscht alle Dateien, deren Namen in 'th' sind, aus der Task 'father' 
+ 
+ 
+   #on("b")#PROC erase #off("b")# 
+   Löscht die zuletzt bearbeitete Datei aus der Task 'father' 
+ 
+ 
+#page# 
+'print' 
+   Das Kommando 'print' beinhaltet den Auftrag an die Task 'PRINTER' die enthal­
+   tene(n) Datei(en) auszudrucken. 
+ 
+   Voraussetzung ist natürlich, daß die Druckersoftware ordnungsgemäß benutzt
+   wurde, um 'PRINTER' einzurichten. Siehe dazu Systemhandbuch Teil 6. 
+ 
+ 
+   #on("b")#PROC print (TEXT CONST dateiname) #off("b")# 
+   Kopiert die Datei 'dateiname' in die Task 'PRINTER'. 
+ 
+ 
+   #on("b")#PROC print (THESAURUS CONST th) #off("b")# 
+   Kopiert alle Dateien, deren Namen im Thesaurus 'th' enthalten sind, in die Task
+   'PRINTER'. 
+ 
+ 
+   #on("b")#PROC print #off("b")# 
+   Kopiert die zuletzt bearbeitete Datei in die Task 'PRINTER'. 
+ 
+ 
+#page# 
+ 
+4.2.7  Passwortschutz 
+ 
+Der Passwortschutz im EUMEL-System ist in verschiedener Ausprägung möglich.
+Einfachste Möglichkeit ist der Schutz einer Task durch ein Passwort. Falls diese Task
+nicht Manager ist, können alle Daten und Programme, die nur in dieser Task zur
+Verfügung stehen, auch nur vom Besitzer der Task benutzt werden. 
+ 
+Ähnlich kann auch von einer Manager-Task aus der gesamte Zweig unterhalb dieser
+Task mit einem Passwort geschützt werden: beispielsweise kann es empfehlenswert
+sein, den Systemzweig komplett zu schützen, indem in SYSUR ein entsprechendes
+Passwort vereinbart wird. 
+ 
+Ein Umgehen des Passwortschutzes bei Manager-Tasks (durch Einrichten einer
+Sohn-Task und 'fetchall') wird durch ein 'begin password' verhindert. 
+ 
+Auch einzelne Dateien lassen sich schützen, indem Lese/Schreibpasswörter für den
+Dateitransfer vereinbart werden. 
+ 
+Generell gilt für die Verwendung von Passworten: 
+ 
+-  Passworte, die zu naheliegend gewählt sind (Vorname des Lebenspartners o.ä.)
+   sind meistens sinnlos, falls wirklich Datenschutz bezweckt ist. 
+ 
+-  Passworte, die so raffiniert sind, daß sogar ihr Schöpfer sie vergißt, führen zu
+   100%igem Datenverlust, da die betroffene Task oder Datei nur noch gelöscht
+   werden kann. 
+ 
+-  Die Vereinbarung von "-" als Passwort bewirkt, daß die entsprechende Aktion
+   nicht mehr durchgeführt werden kann. Wird z.B. '-' als 'task password'
+   eingegeben, so kann die Task nie wieder an ein Terminal gekoppelt werden. 
+ 
+-  Passwörter können geändert werden, indem das entsprechende Kommando noch
+   einmal mit dem neuen Passwort gegeben wird. 
+ 
+#page# 
+'begin password' 
+ 
+   #on("b")#PROC begin password (TEXT CONST passwort) #off("b")# 
+ 
+   Auf Supervisor-Ebene wird vor Einrichten einer neuen Task als Sohn der Task in
+   der das 'begin password' gegeben wurde, dieses erfragt. 
+ 
+   Das Password vererbt sich auf die hinzukommenden Sohn-Tasks. 
+ 
+____________________________________________________________________________ 
+ 
+    #on("b")#SYSUR#off("b")# 
+    maintenance : 
+    begin password ("alles dicht") 
+ 
+____________________________________________________________________________ 
+ 
+ 
+bewirkt: 
+ 
+____________________________________________________________________________ 
+ 
+                                           Terminal 2  
+ 
+ 
+                    EUMEL Version 1.8.1/M 
+ 
+ 
+        gib supervisor kommando: 
+        begin ("sabotage","SYSUR") 
+              Passwort:  
+ 
+ 
+   ESC ? --> help 
+   ESC b --> begin("")            ESC h --> halt 
+   ESC c --> continue("")         ESC s --> storage info 
+   ESC q --> break                ESC t --> task info 
+ 
+ 
+____________________________________________________________________________ 
+ 
+ 
+#page# 
+'enter password' 
+   #on("b")#PROC enter password (TEXT CONST datei, schreibpass, lesepass) 
+   #off("b")# 
+   Hiermit können ausgewählte Dateien einer Manager-Task geschützt werden. Die
+   angegebene Datei wird mit Schreib- und Lesepassword versehen. Die Pass­
+   wörter werden in der eigenen Task nicht berücksichtigt. 
+ 
+   Bei einem lesenden Zugriff (fetch) von irgendeiner Task aus auf die entsprechende
+   Datei in der Manager-Task muß das Lesepasswort, bei schreibendem Zugriff
+   (save/erase) das Schreibpasswort vereinbart sein. 
+ 
+ 
+____________________________________________________________________________ 
+ 
+    maintenance : 
+    enter password ("wichtige datei","sicher","heit") 
+ 
+____________________________________________________________________________ 
+ 
+ 
+ 
+ 
+   #on("b")#PROC enter password (TEXT CONST password) #off("b")# 
+   Passwort für den Dateitransfer einstellen. Falls zwei verschiedene Passwörter für
+   Lesen und Schreiben vereinbart werden sollen, so sind sie als ein Text durch "/"
+   getrennt einzugeben. 
+ 
+____________________________________________________________________________ 
+ 
+    gib kommando : 
+    enter password ("sicher/heit") 
+ 
+    gib kommando : 
+    save(SOME all) 
+ 
+____________________________________________________________________________ 
+#page# 
+'family password' 
+   #on("b")#PROC family password (TEXT CONST geheim) #off("b")# 
+   Einstellen eines Passworts für den Zweig des Systems , der unterhalb der (Mana­
+   ger) Task liegt, in der das 'family password' eingegeben wurde. Dabei erhalten
+   alle Tasks, die kein Password oder dasselbe wie diese Manager-Task haben, das
+   'family password'. Tasks in dem Zweig, die ein eigenes anderes besitzen, behal­
+   ten dieses. 
+ 
+____________________________________________________________________________ 
+ 
+   PUBLIC 
+ 
+     Task1 "" 
+ 
+     Task2 family password("fingerweg") 
+        Task21 geheim 
+        Task22 "" 
+ 
+     Task3 "" 
+        Task31 "" 
+ 
+____________________________________________________________________________ 
+ 
+ 
+ 
+ 
+bewirkt: 
+ 
+____________________________________________________________________________ 
+   PUBLIC 
+ 
+     Task1 "" 
+ 
+     Task2 fingerweg 
+        Task21 geheim 
+        Task22 fingerweg 
+ 
+     Task3 "" 
+        Task31 "" 
+ 
+____________________________________________________________________________ 
+ 
+ 
+#page# 
+ 
+'task password' 
+ 
+   #on("b")#PROC task password (TEXT CONST geheim) #off("b")# 
+   Einstellen eines Passworts für die Task in der es gegeben wird. Ist eine Task mit
+   einem Passwort geschützt, so wird durch den Supervisor nach dem 'continue'-
+   Kommando das Passwort angefragt (Entsprechend dem 'begin password'). Nur
+   nach Eingabe des richtigen Passworts gelangt man in die gewünschte Task. Das
+   Passwort kann durch nochmaligen Aufruf von 'task password' geändert werden,
+   z.B. wenn es in regelmäßigen Abständen geändert werden muß, um personenbe­
+   zogene Daten zu schützen. 
+ 
+#page# 
+ 
+4.2.8  Das Archiv 
+ 
+Mit dem Terminus 'Archiv' wird beim EUMEL-System ein Diskettenlaufwerk bezeich­
+net, das nur Datensicherungsaufgaben dient. Falls ein Rechner eins von zwei vorhan­
+denen Diskettenlaufwerk als Arbeitsspeicher benutzt, so wird dieses als Hintergrund
+bezeichnet. Falls Sie einen derartigen Rechner benutzen, können Sie der Installa­
+tionsanleitung entnehmen, welches Laufwerk welcher Aufgabe zugeordnet ist. 
+ 
+Das #ib#Archiv#ie# übernimmt im EUMEL-System die Verwaltung der langfristigen Daten­
+haltung. Das Archiv sollen Sie benutzen, um: 
+ 
+-  Sicherungskopien wichtiger Dateien außerhalb des Rechners zu besitzen; 
+ 
+-  nicht benötigte Dateien außerhalb einer Task zu halten (Speicherplatzersparnis!); 
+ 
+-  Dateien auf andere Rechner zu übertragen. 
+ 
+Das Archiv wird im EUMEL-System durch die Task 'ARCHIVE', die das Disketten­
+laufwerk des Rechners verwaltet, realisiert. 
+ 
+- reservieren              :  archive 
+ 
+- freigeben                :  release 
+ 
+- löschen                  :  clear , format 
+ 
+- prüfen                   :  check 
+ 
+#page# 
+'archive' 
+   #on("b")#PROC archive (TEXT CONST archivname) #off("b")# 
+   Reservierung der Task ARCHIVE für den exklusiven Dialog mit der aufrufenden
+   Task. 'archivname' wird bei allen folgenden Archivoperationen mit dem der Disket­
+   te zugewiesenen (und hoffentlich auf dem Aufkleber vermerkten) Namen abgegli­
+   chen. 
+ 
+ 
+ 
+'release' 
+   #on("b")#PROC release (TASK CONST archive) #off("b")# 
+   Nach diesem Kommando kann die Task 'ARCHIVE' mit ihren Leistungen von einer
+   anderen Task in Anspruch genommen werden. Falls dieses Kommando nicht
+   gegeben wird, aber seit 5 Minuten kein Dialog mit 'archive' stattfand, kann eine
+   andere Task durch die Anforderung 'archive("diskettenname")' das Archiv reser­
+   vieren. Durch diese Maßnahme wird verhindert, daß ein vergeßlicher Benutzer bei
+   einem System mit mehreren Benutzern das Archiv blockiert. 
+ 
+#page# 
+ 
+'clear' 
+   #on("b")#PROC clear (TASK CONST archive) #off("b")# 
+   Löschen des Disketten-Inhaltsverzeichnisses und Zuweisung des in der Reservie­
+   rung eingegebenen Namens. 
+ 
+____________________________________________________________________________ 
+ 
+    gib kommando : 
+    archive("name"); #ib#clear#ie# (archive) 
+ 
+____________________________________________________________________________ 
+ 
+ 
+   Durch die Ausführung des Kommandos erhält die eingelegte Diskette den in der
+   Reservierung angegebenen Namen. #on("b")#Das Inhaltsverzeichnis, das sich auf der
+   Diskette befindet, wird gelöscht. Damit sind die Daten, die sich eventuell auf
+   dieser Diskette befanden, nicht mehr auffindbar#off("b")#. Die Diskette entspricht einer neu
+   formatierten Diskette#u#1)#e#. 
+ 
+   Man kann also eine beschriebene Diskette nicht umbenennen, ohne die darauf
+   befindlichen Daten zu löschen. 
+ 
+   #foot# 
+ 
+   #u#1)#e# Das Kommando 'format' enthält implizit 'clear'. 
+#end# 
+ 
+   Eine Neuformatierung ist demnach bei Wiederverwendung der Diskette nicht
+   notwendig. 
+ 
+#page# 
+'format' 
+   #on("b")#PROC format (TASK CONST archive) #off("b")# 
+   Formatieren einer Diskette. Vor der erstmaligen Benutzung einer Archivdiskette
+   muß diese formatiert, d.h. in Spuren und Sektoren für die Positionierung des
+   Schreib-/Lesekopfes des Diskettenlaufwerks eingeteilt werden, um überhaupt ein
+   Beschreiben der Diskette zu ermöglichen. Die Einteilung ist geräteabhängig, häufi­
+   ge Formate sind: 
+ 
+              40 Spuren zu je 9 Sektoren (360 K) 
+              80 Spuren zu je 9 Sektoren (720 K). 
+ 
+   Die #on("b")#Erst#off("b")#benutzung einer #ib#Archivdiskette#ie# erfordert nach der Reservierung des Ar­
+   chivs das Kommando: 
+ 
+____________________________________________________________________________ 
+ 
+    gib kommando : 
+    archive("diskname"); 
+ 
+    gib kommando : 
+    format (archive); 
+ 
+____________________________________________________________________________ 
+ 
+ 
+Erst nach einer Kontrollabfrage: 
+ 
+____________________________________________________________________________ 
+ 
+    gib kommando: 
+    format (archive) 
+ 
+  Archiv "diskname" formatieren ? (j/n) 
+ 
+____________________________________________________________________________ 
+ 
+ 
+ 
+   wird tatsächlich formatiert und die Diskette steht mit dem Namen "diskname" für
+   Archivoperationen zur Verfügung. 
+ 
+#page# 
+ 
+   #on("b")#PROC format (INT CONST code, TASK CONST archive) #off("b")# 
+   Bei einigen Rechnern ist es möglich, die Formatierung zu variieren. Falls beim
+   Formatieren auf einem solchen Rechner ein anderes als das Standardformat
+   erzeugt werden soll, so ist die Codierung des gewünschten Formats mitanzuge­
+   ben. 
+ 
+ 
+   Beispiel:    Für ein Gerät mit 5,25 Zoll Disketten wäre z.B. einstellbar: 
+                code 0 : Standardformat 
+                code 1 : 2D , 40 Spuren , 9 Sektoren 
+                code 2 : 2D , 80 Spuren , 9 Sektoren 
+                code 3 : HD , 80 Spuren ,15 Sektoren 
+ 
+                'format (archive)' erzeugt ebenso wie 'format (0,archive)' eine
+                standardformatierte Diskette, 'format (3,archive)' erzeugt eine High
+                Density Formatierung (HD Floppy benutzen!). 
+ 
+#on("b")# 
+   ACHTUNG:   Wird eine bereits beschriebene Diskette noch einmal formatiert, so
+              sind alle Daten, die auf der Diskette waren, verloren. 
+ 
+              Die Umformatierung einer Diskette (z.B. von 720K auf 360K) auf
+              unterschiedlichen Laufwerken kann zu Problemen führen. 
+#off("b")# 
+#page# 
+'check' 
+   #on("b")#PROC check (TEXT CONST dateiname, TASK CONST task) #off("b")# 
+   Überprüft, ob die Datei 'dateiname' auf dem Archiv lesbar ist. 
+ 
+ 
+   #on("b")#PROC check (THESAURUS CONST t, TASK CONST task) #off("b")# 
+   Überprüft, ob die in dem Thesaurus 't' enthaltenen Dateien auf dem Archiv lesbar
+   sind. 
+ 
+ 
+   Mit diesem Kommando kann nach dem Beschreiben einer Diskette überprüft wer­
+   den, ob die Datei(en) lesbar sind. Hierdurch können also verschmutzte oder
+   beschädigte Disketten erkannt werden. 
+ 
+ 
+____________________________________________________________________________ 
+ 
+    gib kommando : 
+    save (all , archive) 
+ 
+    gib kommando : 
+    check (ALL archive, archive) 
+ 
+____________________________________________________________________________ 
+ 
+#page# 
+ 
+Beispiel: 
+ 
+ 
+____________________________________________________________________________ 
+ 
+    gib kommando : 
+    archive ("neu") 
+ 
+    gib kommando : 
+    format (archive) 
+ 
+____________________________________________________________________________ 
+ 
+ 
+liefert zunächst die Kontollfrage: 
+ 
+____________________________________________________________________________ 
+ 
+    gib kommando : 
+    format (archive) 
+ 
+    Archiv "neu" formatieren ? (j/n) 
+ 
+____________________________________________________________________________ 
+ 
+ 
+Nach Eingabe 'j' 
+ 
+____________________________________________________________________________ 
+ 
+    gib kommando : 
+    saveall (archive) 
+ 
+    gib kommando : 
+    archive("alt") (* nächste Diskette *) 
+ 
+    gib kommando : 
+    fetch(SOME archive ,archive) 
+ 
+____________________________________________________________________________ 
+ 
+ 
+Der Thesaurus des Archivs wird angezeigt: 
+#page# 
+____________________________________________________________________________ 
+ 
+  .................alt (100 K belegt von 720 K)...............  
+ 
+ 01.02.87   25 K  "handbuch teil 1" 
+ 01.03.87   23 K  "handbuch teil 2" 
+ 01.04.87   20 K  "handbuch teil 3" 
+ 01.05.87   32 K  "handbuch teil 4" 
+ 
+____________________________________________________________________________ 
+ 
+ 
+ 
+ 
+ 
+Zum Abschluß Archiv freigeben! 
+____________________________________________________________________________ 
+ 
+    gib kommando : 
+    release(archive) 
+ 
+____________________________________________________________________________ 
+#page# 
+
+Fehlermeldungen des Archivs
+Versucht man, eine Datei vom Archiv zu holen, kann es vorkommen, daß das Ar­
+chiv-System 
+ 
+____________________________________________________________________________ 
+ 
+    gib kommando : 
+    fetch ("datei", archive) 
+    #ib#Lese-Fehler (Archiv)#ie# 
+ 
+____________________________________________________________________________ 
+ 
+ 
+ 
+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 Disket­
+ten-Geräte). In einem solchen Fall vermerkt das Archiv-System intern, daß die Datei
+nicht korrekt gelesen werden kann. Das sieht man z.B. bei 'list (archive)'. Dort ist der
+betreffende Datei-Name mit dem Zusatz 'mit Lese-Fehler' gekennzeichnet. Um
+diese Datei trotzdem zu lesen, muß man sie unter ihrem Dateinamen mit dem Zusatz
+'mit Lese-Fehler' lesen. 
+ 
+____________________________________________________________________________ 
+ 
+    gib kommando: 
+    fetch ("datei mit Lese-Fehler", archive) 
+ 
+____________________________________________________________________________ 
+ 
+ 
+ 
+Die Datei wird in diesem Fall trotz Lese-Fehler (Informationsverlust!) vom Archiv
+gelesen. 
+#page# 
+
+Weitere Fehlermeldungen des Archivs: 
+ 
+ 
+FEHLER : Lesen unmöglich (Archiv) 
+         Die Archiv-Diskette ist nicht eingelegt oder die Tür des Laufwerks ist nicht
+         geschlossen. 
+         => Diskette einlegen bzw. Tür schließen. 
+ 
+FEHLER : Schreiben unmöglich (Archiv) 
+         Die Diskette ist schreibgeschützt. 
+         => falls wirklich gewünscht, Schreibschutz entfernen. 
+ 
+FEHLER : Archiv nicht angemeldet 
+         Das Archiv wurde nicht angemeldet 
+         => 'archive ("name")' geben. 
+ 
+FEHLER : Lese-Fehler (Archiv) 
+         Siehe Lesen unmöglich 
+ 
+FEHLER : Schreibfehler (Archiv) 
+         Die Diskette kann nicht (mehr) beschrieben werden. 
+         => Andere Diskette verwenden. 
+ 
+FEHLER : Speicherengpass 
+         Im System ist nicht mehr genügend Platz, um eine Datei vom Archiv zu
+         laden. 
+         => ggf. Dateien löschen. 
+ 
+FEHLER : RERUN bei Archiv-Zugriff Das System wurde bei einer Archiv-Operation
+         durch Ausschalten bzw. Reset unterbrochen. 
+ 
+FEHLER : "dateiname" gibt es nicht 
+         Die Datei "dateiname" gibt es nicht auf dem Archiv. 
+         => mit 'list(archive)' Archiv prüfen. 
+ 
+FEHLER : Archiv heißt ... 
+         Die eingelegte Diskette hat einen anderen als den eingegebenen Archivna­
+         men. 
+         => Kommando 'archive' mit korrektem Namen geben. 
+ 
+FEHLER : Archiv wird von Task ... benutzt 
+         Das Archiv wurde von einem anderen Benutzer reserviert. 
+         => Abwarten. 
+ 
+FEHLER : "dateiname" kann nicht geschrieben werden (Archiv voll) 
+         Die Datei ist zu groß für die eingelegte Diskette. 
+         => Andere Diskette für diese Datei nehmen. 
+ 
+FEHLER : Archiv inkonsistent 
+         Die eingelegte Diskette hat nicht die Struktur einer Archiv-Diskette. 
+         => 'format (archive)' vergessen. 
+ 
+FEHLER : save/erase wegen Lese-Fehler verboten 
+         Bei Archiven mit Lese-Fehler sind Schreiboperationen verboten, weil ein
+         Erfolg nicht garantiert werden kann. 
+
diff --git a/doc/programmer-manual/1.8.7/doc/programmierhandbuch.5 b/doc/programmer-manual/1.8.7/doc/programmierhandbuch.5
new file mode 100644
index 0000000..a921572
--- /dev/null
+++ b/doc/programmer-manual/1.8.7/doc/programmierhandbuch.5
@@ -0,0 +1,1329 @@
+#pagenr("%",1)##setcount(1)##block##pageblock# 
+#headeven# 
+#center#EUMEL-Benutzerhandbuch 
+#center#____________________________________________________________ 
+ 
+#end# 
+#headodd# 
+#center#TEIL 5 : Programmierung 
+#center#____________________________________________________________ 
+ 
+#end# 
+#bottomeven# 
+#center#____________________________________________________________ 
+5 - % #right#GMD 
+#end# 
+#bottomodd# 
+#center#____________________________________________________________ 
+GMD #right#5 - % 
+#end# 
+ 
+TEIL 5:  Programmierung 
+ 
+ 
+5.1  Der ELAN-Compiler  
+ 
+Der ELAN-Compiler des EUMEL-Systems dient zweierlei Aufgaben: zum einen der
+Übersetzung von ELAN-Programmen, zum anderen der Verwaltung der taskeigenen
+Modulbibliothek. 
+ 
+Diese Moduln, in ELAN Pakete (siehe 2.4.3.4ff.) genannt, stellen als vorübersetzte,
+und damit abrufbereite#u#1)#e# Prozeduren den Kommandovorrat einer Task dar. 
+ 
+Der Codebereich einer Task liegt in ihrem Standarddatenraum (ds4). Die Größe dieses
+Codebereiches beträgt 256K. Der Inhalt besteht zunächst aus den von der Vatertask
+ererbten (durch Kopie des ds4 dieser Task) Moduln, im weiteren allen in dieser Task
+neu hinzu insertierten Packeten. 
+#on("b")# 
+ 
+ 
+ACHTUNG:   Durch ständiges Neuinsertieren eines Packets kann der
+           Codebereich der betroffenen Task zum Überlaufen
+           gebracht werden! 
+ 
+ 
+#foot# 
+ 
+1) Die von anderen Systemen her gewohnten Phasen 'Binden' und 'Laden' sind
+   durch das EUMEL-ELAN-Compiler-Konzept unnötig. 
+#end# 
+Jedes Kommando im EUMEL-System ist der Aufruf einer, in der Schnittstelle eines
+bereits insertierten Packetes stehenden, Prozedur. 
+ 
+Kommandos für den ELAN-Compiler: 
+ 
+- Übersetzen               :  do , insert , run , runagain 
+ 
+- Protokollieren           :  check , checkon/off , 
+                              prot , protoff , warnings on/off 
+ 
+ 
+#page# 
+'do' 
+   #on("b")#PROC do (TEXT CONST program)#off("b")# 
+   Übersetzen und Ausführen von 'program' von einem Programm aus. 'program'
+   muß ein ausführbares ELAN Programm sein. 
+ 
+ 
+____________________________________________________________________________ 
+ 
+ ........................... Beispiel .......................... 
+ PACKET reo DEFINES reorganize all: 
+ 
+ PROC reorganize all(THESAURUS CONST thes): 
+ do (PROC (TEXT CONST) reorganize ,thes) 
+    (* Die Prozedur 'reorganize' (siehe 5-52), die einen*) 
+    (* Dateinamen als Parameter verlangt, wird auf alle *) 
+    (* Dateien des Thesaurus 'thes' angewandt.          *) 
+ END PROC reorganize all; 
+ END PACKET reo; 
+ 
+____________________________________________________________________________ 
+ 
+ 
+'insert' 
+   #on("b")#PROC insert (TEXT CONST dateiname) #off("b")# 
+   Insertieren eines oder mehrerer PACKETs aus der Datei 'dateiname'. Der Pro­
+   grammtext muß sich in #on("u")#einer#off("u")# Datei befinden. 
+ 
+ 
+   #on("b")#PROC insert #off("b")# 
+   Insertieren eines oder mehrerer PACKETs. Der Dateiname ist der zuletzt benutzte
+   Dateiname. 
+ 
+ 
+   #on("b")#PROC insert (THESAURUS CONST t) #off("b")# 
+   Insertieren aller PACKETs, die in den Dateien des Thesaurus 't' enthalten sind. 
+ 
+ 
+#page# 
+'run' 
+   #on("b")#PROC run #off("b")# 
+   Übersetzen und Ausführen eines ELAN-Programms. Der Programmtext muß sich
+   in einer Datei befinden. Der Dateiname ist der zuletzt benutzte Dateiname. 
+ 
+ 
+   #on("b")#PROC run (TEXT CONST dateiname) #off("b")# 
+   Wie oben. Der Programmtext wird aus der Datei mit dem Namen 'dateiname'
+   geholt. 
+ 
+ 
+ 
+'runagain' 
+   #on("b")#PROC runagain #off("b")# 
+   Nochmaliges Ausführen des zuletzt mit 'run' übersetzten ELAN-Programms.
+   Wurde in der letzten Übersetzung ein Fehler gefunden, erfolgt die Meldung: 
+ 
+   FEHLER :  "run again nicht möglich" 
+ 
+#page# 
+'check' 
+   #on("b")#BOOL PROC check #off("b")# 
+   Informationsprozedur, die TRUE liefert, wenn 'check' eingeschaltet ist. 
+ 
+   #on("b")#PROC check on #off("b")# 
+   Einschalten der Generierung von Zeilennummern durch den ELAN-Compiler. Der
+   bei der Übersetzung erzeugte Code wird ca. 25% umfangreicher! 
+   Voreinstellung im 'PUBLIC'- Zweig: 'check on'. 
+ 
+   #on("b")#PROC check off #off("b")# 
+   Ausschalten der Generierung von Zeilennummern durch den ELAN-Compiler. 
+   Voreinstellung im 'SYSUR' - Zweig: 'check off. 
+ 
+ 
+'prot' 
+   #on("b")#BOOL PROC prot #off("b")# 
+   Informationsprozedur, die TRUE liefert, gdw. 'prot' eingeschaltet ist. 
+ 
+   #on("b")#PROC prot (TEXT CONST dateiname) #off("b")# 
+   Einschalten des Compilerlistings auf dem Bildschirm. Das Listing wird gleichzeitig
+   in die Datei 'dateiname' geschrieben. 
+ 
+   #on("b")#PROC prot off #off("b")# 
+   Ausschalten des Listings. 
+ 
+ 
+'warnings' 
+   #on("b")#BOOL PROC warnings #off("b")# 
+   Informationsprozedur, die TRUE liefert gdw. 'warnings' eingeschaltet ist. 
+ 
+   #on("b")#PROC warnings on #off("b")# 
+   Warnungen werden wie Fehlermeldungen ins Notizbuch ausgegeben. 
+ 
+   #on("b")#PROC warnings off#off("b")# 
+   Warnungen werden nicht mit in das Notizbuch ausgegeben. 
+#page# 
+
+5.1.1  Fehlermeldungen des ELAN-Compilers 
+erfolgen stets in der Form: 
+ 
+#ib#COMPILER ERROR#ie#: <zahl> 
+ 
+wobei <zahl> folgende Werte annehmen kann: 
+ 
+#on("bold")#<zahl>   Bedeutung und eventuelle Abhilfe#off ("bold")#: 
+ 
+ 101      Überlauf der Namenstabelle 
+          Die Anzahl der Namen aller sichtbaren Pakete ist zu groß oder es wurden
+          die Anführungstriche eines TEXT-Denoters vergessen. 
+          => Keine Abhilfe. 
+ 
+ 102      Überlauf der Symboltabelle 
+          Die Anzahl der deklarierten Objekte ist zu groß. 
+          => Programm in Pakete unterteilen. 
+ 
+ 103      Überlauf des Zwischencodebereiches 
+          => Programm in Pakete unterteilen. 
+ 
+ 104      Überlauf der Permanenttabelle 
+          Zu viele Pakete insertiert. 
+          => Keine (neue Task beginnen). 
+ 
+ 106      Paketdatenadresse zu groß 
+          Im Paket wird zuviel Platz ( > 64K ) von globalen Datenobjekten und
+          Denotern eingenommen. 
+          => Keine Abhilfe. 
+ 
+ 107      Lokale Datenadresse zu groß 
+          Im Paket wird zuviel Platz ( > 32K ) von lokalen Datenobjekten belegt. 
+          => Keine Abhilfe. 
+ #page# 
+ 204      Überlauf des Compilerstack 
+          => Keine Abhilfe. 
+ 
+ 301      Modulnummern-Überlauf 
+          Zu viele sichtbare Pakete, Prozeduren und Operatoren ( > 2048 ). 
+         =>  Keine Abhilfe. 
+ 
+ 303 
+          siehe 304 
+ 
+ 304      Zu viele Ansprungadressen 
+          In dem gerade übersetzten Modul (Prozedur, Operator oder Paketrumpf)
+          werden vom Compiler zu viele Marken benötigt (mehr als 2000). Marken
+          werden z.B. für die Codegenerierung von Auswahl (IF ...) und Wieder­
+          holung (REP ...) gebraucht. Insbesondere bei SELECT-Anweisungen
+          werden 'casemax - casemin + 2' Marken benötigt, wobei 'casemax' der
+          INT-Wert des maximalen, 'casemin' der des minimalen CASE-Wertes
+          ist. Dieser Fehler ist somit fast immer auf zu viele und/oder zu weit ge­
+          spannte SELECT-Anweisungen zurückzuführen. 
+          => SELECT-Anweisungen über mehrere Prozeduren verteilen oder
+             Spannweiten verringern. 
+ 
+ 305      Codeüberlauf 
+          Der insgesamt erzeugte sichtbare Code ist zu umfangreich ( > 256K ). 
+          => Keine Abhilfe. 
+ 
+ 306      Paketdatenadresse zu groß 
+          Insgesamt zu viele Datenobjekte in den Paketen ( > 128K ). 
+          => Keine Abhilfe. 
+ 
+ 307      Temporäre Datenadresse zu groß 
+          Zu viele (lokale) Datenobjekte in einer Prozedur ( > 32K ). 
+          => Prozedur in mehrere unterteilen, so daß die Datenobjekte sich über
+             mehrere Prozeduren verteilen. 
+ 
+ 308      Modulcode-Überlauf 
+          Ein Modul (Prozedur, Operator oder Paket-Initialisierungsteil) ist zu groß
+          ( > 7.5 KB Code). 
+          => In mehrere Prozeduren oder Pakete zerlegen. 
+ 
+ 309      Zuviele Paketdaten 
+          (Insgesamt mehr als 128K Paketdaten) 
+          => Keine Abhilfe 
+ 
+ 
+#page# 
+ 
+5.2  Standardtypen 
+ 
+ 
+5.2.1  Bool 
+ 
+Der Wertebereich für Datenobjekte vom Typ BOOL besteht aus den Werten TRUE
+und FALSE. 
+ 
+'AND' 
+   #on("b")#BOOL OP AND (BOOL CONST a, b) #off("b")# 
+   Logisches UND, liefert TRUE gdw. a und b TRUE sind. 
+ 
+ 
+'CAND' 
+   #on("b")#BOOL OP CAND #off("b")# 
+   Bedingtes logisches UND, entspricht: 'IF a THEN b ELSE false FI'. Der zweite
+   Operand wird nicht ausgewertet, falls er für das Ergebnis nicht relevant ist. 
+ 
+ 
+'COR' 
+   #on("b")#BOOL OP COR #off("b")# 
+   Bedingtes logisches ODER, entspricht: 'IF a THEN true ELSE b FI'. Der zweite
+   Operand wird nicht ausgewertet, falls er für das Ergebnis nicht relevant ist. 
+ 
+
+'false' 
+   #on("b")#BOOL CONST false #off("b")# 
+ 
+ 
+'NOT' 
+   #on("b")#BOOL OP NOT (BOOL CONST a) #off("b")# 
+   Logische Negation. 
+ 
+ 
+'OR' 
+   #on("b")#BOOL OP OR (BOOL CONST a, b) #off("b")# 
+   Logisches ODER, liefert TRUE gdw. a und/oder b TRUE ist. 
+ 
+ 
+'true' 
+   #on("b")#BOOL CONST true #off("b")# 
+ 
+ 
+'XOR' 
+   #on("b")#BOOL OP XOR (BOOL CONST a, b) #off("b")# 
+   Exklusives ODER, liefert TRUE gdw. entweder a oder b TRUE ist. 
+ 
+#page# 
+
+5.2.2  Integer-Arithmetik 
+ 
+Ein Datenobjekt vom Typ INT belegt im Speicher 2 Bytes. Zulässige INT - Werte
+sind die ganzen Zahlen von -32768 bis +32767 einschließlich. 
+ 
+Falls größere ganze Zahlen benötigt werden, muß das Packet 'LONGINT', welches
+sich auf dem Archive 'std.zusatz' befindet, nachinsertiert werden (siehe 6.1.2). 
+ 
+Operationen für Integers: 
+ 
+- Vergleich                :  = , <> , < , <= , > , >= 
+ 
+- Verknüpfung              :  + , - , * , ** , DECR , DIV , INCR 
+ 
+- Sonstiges                :  abs , ABS , initialize random , max , maxint , min , 
+                              minint , MOD , random , sign , SIGN , text 
+#page# 
+':=' 
+   #on("b")#INT OP := (INT VAR a, INT CONST b) #off("b")# 
+   Zuweisung. 
+ 
+ 
+'=' 
+   #on("b")#BOOL OP = (INT CONST a, b) #off("b")# 
+   Vergleich. 
+ 
+ 
+'<>' 
+   #on("b")#BOOL OP <> (INT CONST a, b) #off("b")# 
+   Vergleich auf Ungleichheit. 
+ 
+ 
+'<' 
+   #on("b")#BOOL OP < (INT CONST a, b) #off("b")# 
+   Vergleich auf kleiner. 
+ 
+ 
+'<=' 
+   #on("b")#BOOL OP <= (INT CONST a, b) #off("b")# 
+   Vergleich auf kleiner gleich. 
+ 
+ 
+'>' 
+   #on("b")#BOOL OP > (INT CONST a, b) #off("b")# 
+   Vergleich auf größer. 
+ 
+ 
+'>=' 
+   #on("b")#BOOL OP >= (INT CONST a, b) #off("b")# 
+   Vergleich auf größer gleich. 
+ 
+#page# 
+'+' 
+   #on("b")#INT OP + (INT CONST a) #off("b")# 
+   Monadischer Operator (Vorzeichen, ohne Wirkung). 
+ 
+   #on("b")#INT OP + (INT CONST a, b) #off("b")# 
+   Addition. 
+ 
+ 
+'-' 
+   #on("b")#INT OP - (INT CONST a) #off("b")# 
+   Vorzeichen-Umkehrung. 
+ 
+ 
+   #on("b")#INT OP - (INT CONST a, b) #off("b")# 
+   Subtraktion. 
+ 
+ 
+'*' 
+   #on("b")#INT OP * (INT CONST a, b) #off("b")# 
+   Multiplikation. 
+ 
+ 
+'**' 
+   #on("b")#INT OP ** (INT CONST arg, exp) #off("b")# 
+   Exponentiation mit 'exp' >= 0 
+ 
+ 
+'DECR' 
+   #on("b")#OP DECR (INT VAR links, INT CONST rechts) #off("b")# 
+   Wirkt wie links := links - rechts 
+ 
+ 
+'DIV' 
+   #on("b")#INT OP DIV (INT CONST a, b) #off("b")# 
+   INT-Division. 
+ 
+   FEHLER : 
+   - DIV durch 0 
+ 
+ 
+'INCR' 
+   #on("b")#OP INCR (INT VAR links, INT CONST rechts) #off("b")# 
+   Wirkt wie links := links + rechts 
+ 
+#page# 
+'abs' 
+   #on("b")#INT PROC abs (INT CONST argument) #off("b")# 
+   Absolutbetrag eines INT-Wertes. 
+ 
+ 
+   #on("b")#INT OP ABS (INT CONST argument) #off("b")# 
+   Absolutbetrag eines INT-Wertes. 
+ 
+ 
+'initialize random' 
+   #on("b")#PROC initialize random (INT CONST wert) #off("b")# 
+   Initialisieren der 'random'-Prozedur, um nicht reproduzierbare Zufallszahlen zu
+   bekommen. Diese 'initialize random'-Prozedur gilt für den "INT-Random Gene­
+   rator". 
+ 
+ 
+'max' 
+   #on("b")#INT PROC max (INT CONST links, rechts) #off("b")# 
+   Liefert den Größten der beiden INT-Werte. 
+ 
+ 
+'maxint' 
+   #on("b")#INT CONST maxint #off("b")# 
+   Größter INT-Wert im EUMEL-System (32 767). 
+ 
+ 
+'min' 
+   #on("b")#INT PROC min (INT CONST links, rechts) #off("b")# 
+   Liefert den Kleinsten der beiden INT-Werte. 
+ 
+ 
+        min ( 3.0, 2.0) ==>  2.0 
+        min (-2.0, 3.0) ==> -2.0 
+ 
+ 
+ 
+'minint' 
+   #on("b")#INT CONST minint #off("b")# 
+   Kleinster INT-Wert im EUMEL-System (-32768). 
+ 
+ 
+'MOD' 
+   #on("b")#INT OP MOD (INT CONST links, rechts) #off("b")# 
+   Liefert den Rest einer INT-Division. 
+ 
+ 
+        3 MOD 2 ==> 1 
+       -3 MOD 2 ==> 1 
+ 
+ 
+  FEHLER : 
+  - DIV durch 0 
+ 
+ 
+'random' 
+   #on("b")#INT PROC random (INT CONST lower bound, upper bound) #off("b")# 
+   Pseudo-Zufallszahlen-Generator im Intervall 'upper bound' und 'lower bound'
+   einschließlich. Es handelt sich hier um den "INT Random Generator". 
+ 
+ 
+'real' 
+   #on("b")#REAL PROC real (INT CONST a) #off("b")# 
+   Konvertierungsprozedur. 
+ 
+#page# 
+'sign' 
+   #on("b")#INT PROC sign (INT CONST argument) #off("b")# 
+   Feststellen des Vorzeichens eines INT-Wertes. Folgende Werte werden geliefert: 
+ 
+ 
+        argument > 0     ==>  1 
+        argument = 0     ==>  0 
+        argument < 0     ==> -1 
+ 
+ 
+ 
+   #on("b")#INT OP SIGN (INT CONST argument) #off("b")# 
+   Feststellen des Vorzeichens eines INT-Wertes. 
+ 
+ 
+'text' 
+   #on("b")#TEXT PROC text (INT CONST zahl) #off("b")# 
+   Konvertierung des INT Wertes 'zahl' in den kürzest möglichen Text. Das Vorzei­
+   chen bleibt erhalten. 
+ 
+   #on("b")#TEXT PROC text (INT CONST zahl, länge) #off("b")# 
+   Konvertierung des INT Wertes 'zahl' in einen Text der Länge 'länge'. Das
+   Vorzeichen bleibt erhalten. Falls der Text kürzer als 'länge' ist, wird er links
+   (vorne) mit Leerzeichen aufgefüllt, falls er länder ist wird 'länge' mal "*"
+   ausgegeben. 
+ 
+____________________________________________________________________________ 
+ 
+    out ("X:"); out(text(12345,7)) ; line; 
+    out ("Y:"); out(text(12345,3)) ; 
+        (* ergibt *) 
+    X:  12345 
+    Y:*** 
+ 
+____________________________________________________________________________ 
+#page# 
+ 
+5.2.3  Real-Arithmetik 
+ 
+Für den Datentyp REAL gibt es außer den üblichen Verknüpfungs- und Vergleichs­
+operationen noch eine Anzahl mathematischer Prozeduren und Operationen. Teilweise
+stehen diese in mehr als einer Version zur Verfügung. 
+ 
+Jedes Datenobjekt vom Typ REAL belegt im Speicher 8 Byte. 
+ 
+REALs haben eine 13-stellige #ib#Mantisse#ie#, die im Rechner dezimal geführt wird. (Das
+heißt, bei Konversionen zwischen interner und TEXT-Darstellung treten keine Run­
+dungsfehler auf.) Der Wertebereich wird durch folgende Eckwerte abgegrenzt: 
+#dpos(0.5,".")##lpos(4.5)# 
+ 
+#table# 
+   9.999999999999e+126    größter REAL-Wert 
+   0.000000000001         kleinster positiver REAL-Wert mit x + 1.0 > 1.0 
+   9.999999999999e-126    kleinster positiver REAL-Wert > 0.0 
+  -9.999999999999e-126    größter negativer REAL-Wert 
+  -9.999999999999e+126    kleinster REAL-Wert 
+ 
+#clearpos# 
+#tableend# 
+ 
+- Vergleiche               :  = , <> , < , <= , > , >= 
+ 
+- Verknüpfungen            :  + , - , * , / , ** , DECR , INCR 
+ 
+- Diverse                  :  abs , arctan , arctand , cos , cosd , decimal 
+                              exponent , e , exp , floor , frac , initialize 
+                              random , int , ln , log2 , log10 , max , 
+                              maxreal , min , MOD , pi , random , round , 
+                              sign , SIGN , sin , sind , smallreal , sqrt , 
+                              tan , tand , text 
+ 
+#page# 
+':=' 
+   #on("b")#REAL OP := (REAL VAR a, REAL CONST b) #off("b")# 
+   Zuweisung. 
+ 
+ 
+'=' 
+   #on("b")#BOOL OP = (REAL CONST a, b) #off("b")# 
+   Vergleich. 
+ 
+ 
+'<>' 
+   #on("b")#BOOL OP <> (REAL CONST a, b) #off("b")# 
+   Vergleich auf Ungleichheit. 
+ 
+ 
+'<' 
+   #on("b")#BOOL OP < (REAL CONST a, b) #off("b")# 
+   Vergleich auf kleiner. 
+ 
+ 
+'<=' 
+   #on("b")#BOOL OP <= (REAL CONST a, b) #off("b")# 
+   Vergleich auf kleiner gleich. 
+ 
+ 
+'>' 
+   #on("b")#BOOL OP > (REAL CONST a, b) #off("b")# 
+   Vergleich auf größer. 
+ 
+ 
+'>=' 
+   #on("b")#BOOL OP >= (REAL CONST a, b) #off("b")# 
+   Vergleich auf größer gleich. 
+ 
+#page# 
+'+' 
+   #on("b")#REAL OP + (REAL CONST a) #off("b")# 
+   Monadischer Operator (Vorzeichen, ohne Wirkung). 
+ 
+ 
+   #on("b")#REAL OP + (REAL CONST a, b) #off("b")# 
+   Addition. 
+ 
+ 
+'-' 
+   #on("b")#REAL OP - (REAL CONST a) #off("b")# 
+   Vorzeichen-Umkehrung. 
+ 
+ 
+   #on("b")#REAL OP - (REAL CONST a, b) #off("b")# 
+   Subtraktion. 
+ 
+ 
+'*' 
+   #on("b")#REAL OP * (REAL CONST a, b) #off("b")# 
+   Multiplikation. 
+ 
+ 
+'/' 
+   #on("b")#REAL OP / (REAL CONST a, b) #off("b")# 
+   Division. 
+ 
+   FEHLER : 
+   - Division durch 0 
+ 
+ 
+'**' 
+   #on("b")#REAL OP ** (REAL CONST arg, exp) #off("b")# 
+   Exponentiation. 
+ 
+   #on("b")#REAL OP ** (REAL CONST arg, INT CONST exp) #off("b")# 
+   Exponentiation. 
+ 
+ 
+'DECR' 
+   #on("b")#OP DECR (REAL VAR links, REAL CONST rechts) #off("b")# 
+   Wirkt wie links := links - rechts 
+ 
+ 
+'INCR' 
+   #on("b")#OP INCR (REAL VAR links, REAL CONST rechts) #off("b")# 
+   Wirkt wie links := links + rechts 
+ 
+#page# 
+'abs' 
+   #on("b")#REAL PROC abs (REAL CONST wert) #off("b")# 
+   Absolutbetrag eines REAL-Wertes. 
+ 
+   #on("b")#REAL OP ABS (REAL CONST wert) #off("b")# 
+   Absolutbetrag eines REAL-Wertes. 
+ 
+ 
+'arctan' 
+   #on("b")#REAL PROC arctan (REAL CONST x) #off("b")# 
+   Arcus Tangens-Funktion. Liefert einen Wert in Radiant. 
+ 
+ 
+'arctand' 
+   #on("b")#REAL PROC arctand (REAL CONST x) #off("b")# 
+   Arcus Tangens-Funktion. Liefert einen Wert in Grad. 
+ 
+ 
+'cos' 
+   #on("b")#REAL PROC cos (REAL CONST x) #off("b")# 
+   Cosinus-Funktion. 'x' muß in Radiant angegeben werden. 
+ 
+ 
+'cosd' 
+   #on("b")#REAL PROC cosd (REAL CONST x) #off("b")# 
+   Cosinus-Funktion. 'x' muß in Winkelgrad angegeben werden. 
+ 
+ 
+'decimal exponent' 
+   #on("b")#INT PROC decimal exponent (REAL CONST mantisse) #off("b")# 
+   Liefert aus einem REAL-Wert den dezimalen Exponenten als INT-Wert. 
+ 
+ 
+'e' 
+   #on("b")#REAL PROC e #off("b")# 
+   Eulersche Zahl (2.718282). 
+ 
+ 
+'exp' 
+   #on("b")#REAL PROC exp (REAL CONST z) #off("b")# 
+   Exponentialfunktion. 
+ 
+ 
+'floor' 
+   #on("b")#REAL PROC floor (REAL CONST real) #off("b")# 
+   Schneidet die Nachkommastellen des REAL-Wertes 'real' ab. 
+ 
+ 
+'frac' 
+   #on("b")#REAL PROC frac (REAL CONST z) #off("b")# 
+   Liefert die Stellen eines REAL-Wertes hinter dem Dezimalpunkt. 
+ 
+ 
+'initialize random' 
+   #on("b")#PROC initialize random (REAL CONST z) #off("b")# 
+   Initialisieren der 'random'-Prozedur mit verschiedenen Werten für 'z', um nicht
+   reproduzierbare Zufallszahlen zu bekommen. Diese Prozedur gilt für den
+   'REAL-Random Generator'. 
+ 
+ 
+'int' 
+   #on("b")#INT PROC int (REAL CONST a) #off("b")# 
+   Konvertierungsprozedur. Die Nachkommastellen werden abgeschnitten. 
+   Bsp:   int (3.9)  => 3 
+ 
+ 
+'ln' 
+   #on("b")#REAL PROC ln (REAL CONST x) #off("b")# 
+   Natürlicher Logarithmus. 
+ 
+   FEHLER : 
+   - ln mit negativer Zahl 
+     Nur echt positive Argumente sind zulässig. 
+ 
+ 
+'log2' 
+   #on("b")#REAL PROC log2 (REAL CONST z) #off("b")# 
+   Logarithmus zur Basis 2. 
+ 
+   FEHLER : 
+   - log2 mit negativer zahl 
+     Nur echt positive Argumente sind zulässig. 
+ 
+ 
+'log10' 
+   #on("b")#REAL PROC log10 (REAL CONST x) #off("b")# 
+   Logarithmus zur Basis 10. 
+ 
+   FEHLER : 
+   - log10 mit negativer zahl 
+     Nur echt positive Argumente sind zulässig. 
+ 
+ 
+'max' 
+   #on("b")#REAL PROC max (REAL CONST links, rechts) #off("b")# 
+   Liefert den Größten der beiden REAL-Werte. 
+ 
+ 
+'maxreal' 
+   #on("b")#REAL CONST maxreal #off("b")# 
+   Größter REAL-Wert im EUMEL-System (9.999999999999e126). 
+ 
+ 
+'min' 
+   #on("b")#REAL PROC min (REAL CONST links, rechts) #off("b")# 
+   Liefert den Kleinsten der beiden REAL-Werte. 
+ 
+ 
+'MOD' 
+   #on("b")#REAL OP MOD (REAL CONST links, rechts) #off("b")# 
+   Modulo-Funktion für REALs (liefert den Rest). Beispiele: 
+ 
+ 
+             5.0 MOD 2.0 ==> 1.0 
+             4.5 MOD 4.0 ==> 0.5 
+ 
+ 
+ 
+'pi' 
+   #on("b")#REAL CONST pi #off("b")# 
+   Die Zahl pi (3.141593). 
+ 
+ 
+'random' 
+   #on("b")#REAL PROC random #off("b")# 
+   Pseudo-Zufallszahlen-Generator im Intervall 0 und 1. Es handelt sich hier um
+   den "REAL Random Generator". 
+ 
+ 
+'round' 
+   #on("b")#REAL PROC round (REAL CONST real, INT CONST digits) #off("b")# 
+   Runden eines REAL-Wertes auf 'digits' Stellen. Für positive Werte wird auf
+   Nachkommastellen gerundet. Beispiel: 
+ 
+ 
+              round (3.14159, 3) 
+ 
+ 
+   liefert '3.142'. Für negative 'digits'-Werte wird auf Vorkommastellen gerundet. 
+ 
+ 
+              round (123.456, -2) 
+ 
+ 
+   liefert '100.0'. Abweichung vom Standard: Es wird mit 'digits'-Ziffern gerundet. 
+ 
+ 
+'sign' 
+   #on("b")#INT PROC sign (REAL CONST argument) #off("b")# 
+   Feststellen des Vorzeichens eines REAL-Wertes. 
+ 
+   #on("b")#INT OP SIGN (REAL CONST argument) #off("b")# 
+   Feststellen des Vorzeichens eines REAL-Wertes. 
+ 
+ 
+'sin' 
+   #on("b")#REAL PROC sin (REAL CONST x) #off("b")# 
+   Sinus-Funktion. 'x' muß in Radiant (Bogenmaß) angegeben werden. 
+ 
+ 
+'sind' 
+   #on("b")#REAL PROC sind (REAL CONST x) #off("b")# 
+   Sinus-Funktion. 'x' muß im Winkelgrad angegeben werden. 
+ 
+ 
+'smallreal' 
+   #on("b")#REAL PROC smallreal #off("b")# 
+   Kleinster darstellbarer REAL-Wert im EUMEL-System für den 
+ 
+ 
+        1.0 - smallreal <> 1.0 
+        1.0 + smallreal <> 1.0 
+ 
+ 
+   gilt (1.0E-12). 
+ 
+ 
+'sqrt' 
+   #on("b")#REAL PROC sqrt (REAL CONST z) #off("b")# 
+   Wurzel-Funktion. 
+ 
+   FEHLER : 
+   - sqrt von negativer Zahl 
+     Das Argument muß größer gleich 0.0 sein. 
+ 
+ 
+'tan' 
+   #on("b")#REAL PROC tan (REAL CONST x) #off("b")# 
+   Tangens-Funktion. 'x' muß in Radiant angegeben werden. 
+ 
+ 
+'tand' 
+   #on("b")#REAL PROC tand (REAL CONST x) #off("b")# 
+   Tangens-Funktion. 'x' muß in Winkelgrad angegeben werden. 
+ 
+ 
+'text' 
+   #on("b")#TEXT PROC text (REAL CONST real) #off("b")# 
+   Konvertierung eines REAL-Wertes in einen TEXT. Ggf. wird der TEXT in Expo­
+   nenten-Darstellung geliefert. 
+ 
+   #on("b")#TEXT PROC text (REAL CONST real, laenge) #off("b")# 
+   Konvertierung eines REAL-Wertes in einen TEXT. Der TEXT wird in Exponen­
+   ten-Darstellung geliefert. Um diese Darstellung zu ermöglichen ist der Wert
+   'laenge' größer oder gleich 8 anzugeben. 
+ 
+   #on("b")#TEXT PROC text (REAL CONST real, INT CONST laenge, fracs)#off("b")# 
+   Konvertierung eines REAL-Wertes in einen TEXT. Dabei gibt 'laenge' die Länge
+   des Resultats einschließlich des Dezimalpunktes und 'fracs' die Anzahl der Dezi­
+   malstellen an. Kann der REAL-Wert nicht wie gewünscht dargestellt werden, wird 
+ 
+ 
+              laenge * "*" 
+ 
+ 
+   geliefert. 
+ 
+#page# 
+ 
+5.2.4  Text 
+ 
+Jedes Datenobjekt vom Typ TEXT besteht aus einem festen Teil von 16 Bytes und
+möglicherweise aus einem flexiblen Teil auf dem #on("i")##on("b")#Heap#off("i")##off("b")#. Im festen Teil werden Texte
+bis zur Länge von 13 Zeichen untergebracht. Wenn eine TEXT-Variable einen Wert
+mit mehr als 13 Zeichen Länge annimmt, werden alle Zeichen auf dem Heap unterge­
+bracht. Genauer ergibt sich folgendes Bild: 
+ 
+     kurzer Text (Länge <= 13): 
+ 
+          Heap-Link    2 Bytes 
+          Textlänge    1 Byte 
+          Text        13 Bytes 
+ 
+     langer Text (Länge > 13): 
+ 
+          Heap-Link    2 Bytes 
+          255          1 Byte 
+          Länge        2 Bytes 
+          ungenutzt   11 Bytes 
+ 
+Wenn eine Variable einmal Platz auf dem Heap bekommen hat, behält sie diesen
+vorbeugend auch dann, wenn sie wieder einen kurzen Text als Wert erhält. So muß
+wahrscheinlich kein neuer Platz auf dem Heap zugewiesen werden, wenn sie wieder
+länger wird. Das gilt allerdings nur bis zur nächsten #ib#Garbage Collection#ie# auf den
+TEXT-Heap, denn dabei werden alle Heap-Container minimal gemacht bzw. ge­
+löscht, wenn sie nicht mehr benötigt werden. Der Platz auf dem Heap wird in Vielfa­
+chen von 16 Bytes vergeben. In Fremddatenräumen wird in jedem #ib#Container#ie# neben
+dem eigentlichen Text auch die Containerlänge untergebracht. 
+#page# 
+Beispiele:     TEXT-Länge    Speicherbedarf (Byte) 
+ 
+                   0                 16 
+                  13                 16 
+                  14                 32 
+                  15                 48 
+                  30                 48 
+                  31                 64 
+                  46                 64 
+                  47                 80 
+                  62                 80 
+ 
+ 
+Die Heapgröße eines Fremddatenraums berechnet sich als: 
+ 
+      1024 * 1024 = 1048056 - stat Bytes 
+ 
+'stat' ist dabei die statische Größe der Datenstruktur, die dem Datenraum aufgeprägt
+wurde. Bei einem BOUND ROW 1000 TEXT ergibt sich also eine Heapgröße von 
+ 
+      1048056 - (1000 * 16) = 1032056 Bytes. 
+ 
+ 
+ 
+'heap size' 
+   #on("b")#INT PROC heap size #off("b")# 
+   Informationsprozedur für die Größe (in KB) des TEXT-Heaps. 
+ 
+#page# 
+ 
+TEXT- Operationen: 
+ 
+- Vergleich                :  = , <> , < , <= , > , >= 
+                              LEXEQUAL , LEXGREATER , 
+                              LEXGREATEREQUAL 
+ 
+- Verkettung               :  + , * , CAT 
+ 
+- Veränderung              :  change , change all , code , compress , delete 
+                              char , insert char , length , LENGTH , max 
+                              text length , pos , real , replace , SUB , 
+                              subtext , text 
+#page# 
+
+Der EUMEL-Zeichensatz
+#goalpage("codetab")# 
+Das EUMEL System definiert einen Zeichensatz, der gewährleistet, daß gleiche Text­
+zeichen auf allen Maschinen gleich codiert werden. 
+     Die interne Darstellung wird durch die folgende EUMEL-Codetabelle
+beschrieben. Der Zeichensatz beruht auf dem ASCII-Zeichensatz mit Erweiterungen.
+Der in der Tabelle freie Bereich (z.B code(127) bis code(213)) ist nicht einheitlich
+verfügbar und wird deshalb nicht beschrieben. Die Codierung bildet mithin auch
+Grundlage für Vergleiche und Sortierungen. 
+ 
+Die Korrekte Darstellung dieser Zeichen auf Bildschirm, Drucker etc. setzt natürlich
+eine korrekte Konfiguration der Geräte voraus. Die Anpassung eines Geräts an diesen
+Zeichensatz ist im EUMEL-Systemhandbuch in Teil 2 beschrieben. 
+ 
+ 
+   I 0   1   2   3   4   5   6   7   8   9 
+---+-------------------------------------- 
+3  I        SP   !   "   \#   $   %   &   ' 
+   I 
+4  I (   )   *   +   ,   -   .   /   0   1 
+   I 
+5  I 2   3   4   5   6   7   8   9   :   ; 
+   I 
+6  I <   =   >   ?   §   A   B   C   D   E 
+   I 
+7  I F   G   H   I   J   K   L   M   N   O 
+   I 
+8  I P   Q   R   S   T   U   V   W   X   Y 
+   I 
+9  I Z   [   \   ]   ^   _   `   a   b   c 
+   I 
+10 I d   e   f   g   h   i   j   k   l   m 
+   I 
+11 I n   o   p   q   r   s   t   u   v   w 
+   I 
+12 I x   y   z   {   |   }   ~ 
+   I 
+13 I 
+.  I 
+.  I 
+.  I 
+20 I 
+   I 
+21 I                 Ä   Ö   Ü   ä   ö   ü 
+   I 
+22 I k   ­   \#   SP 
+   I 
+23 I 
+   I 
+24 I 
+   I 
+25 I     ß 
+#page# 
+':=' 
+   #on("b")#TEXT OP := (TEXT VAR a, TEXT CONST b) #off("b")# 
+   Zuweisung. 
+ 
+ 
+'=' 
+   #on("b")#BOOL OP = (TEXT CONST links, rechts) #off("b")# 
+   Vergleich von zwei Texten auf Gleichheit (Texte mit ungleichen Längen sind
+   immer ungleich). 
+ 
+ 
+'<>' 
+   #on("b")#BOOL OP <> (TEXT CONST links, rechts) #off("b")# 
+   Vergleich von zwei Texten auf Ungleichheit (Texte mit ungleichen Längen sind
+   stets ungleich). 
+ 
+ 
+'<' 
+   #on("b")#BOOL OP < (TEXT CONST links, rechts) #off("b")# 
+   Vergleich zweier Texte auf kleiner ('links' kommt lexikographisch vor 'rechts'). 
+ 
+ 
+'<=' 
+   #on("b")#BOOL OP <= (TEXT CONST links, rechts) #off("b")# 
+   Vergleich von zwei Texten auf kleiner gleich ('links' kommt lexikographisch vor
+   oder ist gleich 'rechts'). 
+ 
+ 
+'>' 
+   #on("b")#BOOL OP > (TEXT CONST links, rechts) #off("b")# 
+   Vergleich zweier Texte auf größer ('links' kommt lexikographisch nach 'rechts'). 
+ 
+ 
+'>=' 
+   #on("b")#BOOL OP >= (TEXT CONST links, rechts) #off("b")# 
+   Vergleich zweier Texte auf größer gleich ('links' kommt lexikographisch nach oder
+   ist gleich 'rechts'). 
+ 
+#page# 
+'LEXEQUAL' 
+   #on("b")#BOOL OP LEXEQUAL (TEXT CONST links, rechts) #off("b")# 
+   Prüfung auf lexikalische Gleichheit. 
+ 
+ 
+'LEXGREATER' 
+   #on("b")#BOOL OP LEXGREATER (TEXT CONST links, rechts) #off("b")# 
+   Prüfung ob der Text 'links' lexikalisch größer als 'rechts' ist. 
+ 
+ 
+'LEXGREATEREQUAL' 
+   #on("b")#BOOL OP LEXGREATEREQUAL (TEXT CONST links, rechts) #off("b")# 
+   Prüfung ob der Text 'links' lexikalisch größer oder gleich dem Text 'rechts' ist. 
+ 
+ 
+ 
+   Die drei Operatoren prüfen nach folgenden Regeln: 
+ 
+   - Buchstaben haben die aufsteigende Reihenfolge 'A' bis 'Z'. Dabei werden kleine
+     und große Buchstaben gleich behandelt. 
+ 
+   - Umlaute werden wie üblich ausgeschrieben. (Ä = Ae usw.) 
+                                           (ß = ss) 
+ 
+   - Alle Sonderzeichen (auch Ziffern) außer ' '(Leerzeichen) und '-' werden igno­
+     riert, diese beiden Zeichen werden gleich behandelt. 
+ 
+#page# 
+'+' 
+   #on("b")#TEXT OP + (TEXT CONST links, rechts) #off("b")# 
+   Verkettung der Texte 'links' und 'rechts' in dieser Reihenfolge. Die Länge des
+   Resultats ergibt sich aus der Addition der Längen der Operanden. 
+ 
+ 
+'*' 
+   #on("b")#TEXT OP * (INT CONST faktor, TEXT CONST quelle) #off("b")# 
+   'faktor' fache Erstellung von 'quelle' und Verkettung. Dabei muß 
+ 
+ 
+              times >= 0 
+ 
+ 
+   sein, sonst wird 'niltext' geliefert. 
+ 
+ 
+'CAT' 
+   #on("b")#OP CAT (TEXT VAR links, TEXT CONST rechts) #off("b")# 
+   hat die gleiche Wirkung wie 
+ 
+ 
+              links := links + rechts 
+ 
+ 
+   Hinweis: Der Operator 'CAT' hat eine geringere Heap-Belastung als die Opera­
+            tion mit expliziter Zuweisung. 
+ 
+#page# 
+'change' 
+   #on("b")#PROC change (TEXT VAR senke, TEXT CONST alt, neu) #off("b")# 
+   Ersetzung des (Teil-) TEXTes 'alt' in 'senke' durch 'neu' bei dem erstmaligen
+   Auftreten. Ist 'alt' nicht in 'senke' vorhanden, so wird keine Meldung abgesetzt
+   (Abweichung vom Standard). Die Länge von 'senke' kann sich dabei verändern. 
+   Beispiel: 
+ 
+ 
+        TEXT VAR mein text :: "EUMEL-Benutzerhandbuch"; 
+        change (mein text, "Ben", "N"); 
+                            (* EUMEL-Nutzerhandbuch *) 
+ 
+ 
+   #on("b")#PROC change (TEXT VAR senke, INT CONST von, bis, TEXT CONST neu) #off("b")# 
+   Der TEXT 'neu' wird in den TEXT 'senke' anstatt des TEXTes, der zwischen 'von'
+   und 'bis' steht, eingesetzt. Die Länge von 'senke' kann sich dabei verändern. 
+   Beispiel: 
+ 
+ 
+        TEXT VAR mein text :: "EUMEL-Benutzerhandbuch"; 
+        change (mein text, 7, 9, "N");   (* wie oben *) 
+ 
+ 
+ 
+'change all' 
+   #on("b")#PROC change all (TEXT VAR senke, TEXT CONST alt, neu) #off("b")# 
+   Der Teiltext 'alt' wird durch 'neu' in 'senke' ersetzt. Im Unterschied zur 'chan­
+   ge'-Prozedur findet die Ersetzung nicht nur bei dem erstmaligen Auftreten von
+   'alt' statt, sondern so oft, wie 'alt' in 'senke' vorhanden ist. Beispiel: 
+ 
+  
+        TEXT VAR x :: "Das ist ein Satz"; 
+        change all (x, " ", "");     (* DasisteinSatz *)  
+ 
+#page# 
+'code' 
+   #on("b")#TEXT PROC code (INT CONST code) #off("b")# 
+   Wandelt einen INT-Wert 'code' in ein Zeichen um. 'code' muß 
+ 
+ 
+        0 <= code <= 255 
+ 
+ 
+   sein. 
+ 
+   #on("b")#INT PROC code (TEXT CONST text) #off("b")# 
+   Wandelt ein Zeichen 'text' in einen INT-Wert um. Ist 
+ 
+ 
+        LENGTH text <> 1 
+ 
+ 
+   dann wird der Wert -1 geliefert (also bei mehr als ein Zeichen oder niltext). 
+   (Codetabelle auf Seite 5- #topage("codetab")#) 
+ 
+ 
+'compress' 
+   #on("b")#TEXT PROC compress (TEXT CONST text) #off("b")# 
+   Liefert den TEXT 'text' ohne führende und nachfolgende Leerzeichen. 
+ 
+ 
+'delete char' 
+   #on("b")#PROC delete char (TEXT VAR string, INT CONST delete pos)#off("b")# 
+   Löscht ein Zeichen aus dem Text 'string' an der Position 'delete pos'. Für 
+ 
+ 
+        delete pos <= 0 
+ 
+ 
+          oder 
+ 
+ 
+        delete pos > LENGTH string 
+ 
+ 
+   wird keine Aktion vorgenommen. 
+ 
+#page# 
+'insert char' 
+   #on("b")#PROC insert char (TEXT VAR string, TEXT CONST char,INT CONST insert pos)#off("b")# 
+   Fügt ein Zeichen 'char' in den Text 'string' an der Position 'insert pos' ein. Für 
+ 
+ 
+        insert pos > LENGTH string + 1 
+ 
+ 
+   wird keine Aktion vorgenommen. Daher ist es möglich, mit dieser Prozedur auch
+   am Ende eines Textes (Position: LENGTH string + 1) ein Zeichen anzufügen. 
+ 
+ 
+'length' 
+   #on("b")#INT PROC length (TEXT CONST text) #off("b")# 
+   Anzahl von Zeichen ("Länge") von 'text' einschließlich Leerzeichen. 
+ 
+ 
+'LENGTH' 
+   #on("b")#INT OP LENGTH (TEXT CONST text) #off("b")# 
+   Anzahl von Zeichen ("Länge") von 'text' einschließlich Leerzeichen. 
+ 
+ 
+'max text length' 
+   #on("b")#INT CONST max text length #off("b")# 
+   Maximale Anzahl von Zeichen in einem TEXT (32 000). 
+ 
+#page# 
+'pos' 
+   #on("b")#INT PROC pos (TEXT CONST quelle, pattern) #off("b")# 
+   Liefert die erste Position des ersten Zeichens von 'pattern' in 'quelle', falls 'pat­
+   tern' gefunden wird. Wird 'pattern' nicht gefunden oder ist 'pattern' niltext, so wird
+   der Wert '0' geliefert. Beispiel: 
+ 
+ 
+        TEXT VAR t1 :: "abcdefghijk...xyz", 
+                 t2 :: "cd"; 
+        ... pos (t1, t2) ... (* liefert 3 *) 
+        ... pos (t2, t1) ... (* liefert 0 *) 
+ 
+ 
+ 
+   #on("b")#INT PROC pos (TEXT CONST quelle, pattern, INT CONST von)#off("b")# 
+   Wie obige Prozedur, jedoch wird erst ab der Position 'von' ab gesucht. Dabei gilt
+   folgende Einschränkung: 
+ 
+ 
+        length (pattern) < 255 
+ 
+ 
+ 
+   #on("b")#INT PROC pos (TEXT CONST quelle, low char, high char, INT CONST von#off("b")# 
+   Liefert die Position des ersten Zeichens 'x' in 'quelle' ab der Position 'von', so daß 
+ 
+ 
+        low char <= x <= high char 
+ 
+ 
+   'low char' und 'high char' müssen TEXTe der Länge 1 sein. Wird kein Zeichen in
+   'quelle' in dem Bereich zwischen 'low char' und 'high char' gefunden, wird der
+   Wert '0' geliefert. Beispiel: 
+ 
+____________________________________________________________________________ 
+ 
+ (*Suche nach dem ersten Zeichen <> blank nach einer Leerspalte*) 
+   TEXT VAR zeile :: "BlaBla       Hier gehts weiter"; 
+   INT VAR pos erstes blank :: pos (zeile, " "), 
+   ende leerspalte  :: 
+         pos (zeile, ""33"",""254"", pos erstes blank); 
+ 
+____________________________________________________________________________ 
+ 
+#page# 
+'real' 
+   #on("b")#REAL PROC real (TEXT CONST text) #off("b")# 
+   Konvertierung eines TEXTes 'text' in einen REAL-Wert. Achtung: Zur Zeit werden
+   keine Überprüfungen vorgenommen, d.h. in dem TEXT muß ein REAL-Wert
+   stehen. 
+ 
+ 
+'replace' 
+   #on("b")#PROC replace (TEXT VAR senke, INT CONST position, TEXT CONST quelle)#off("b")# 
+   Ersetzung eines Teiltextes in 'senke' durch 'quelle' an der Position 'position' in
+   'senke'. Es muß gelten 
+ 
+ 
+        1 <= position <= LENGTH senke 
+ 
+ 
+   d.h. 'position' muß innerhalb von 'senke' liegen und 'quelle' muß von der Posi­
+   tion 'position' ab in 'senke' einsetzbar sein. Dabei bleibt die Länge von 'senke'
+   unverändert. 
+ 
+ 
+'SUB' 
+   #on("b")#TEXT OP SUB (TEXT CONST text, INT CONST pos) #off("b")# 
+   Liefert ein Zeichen aus 'text' an der Position 'pos'. Entspricht 
+ 
+ 
+        subtext (text, pos, pos) 
+ 
+ 
+   Anmerkung: Effizienter als obiger Prozedur-Aufruf. Für 
+ 
+ 
+        pos <= 0 
+        pos > LENGTH text 
+ 
+ 
+   wird niltext geliefert. 
+ 
+#page# 
+'subtext' 
+   #on("b")#TEXT PROC subtext (TEXT CONST quelle, INT CONST von) #off("b")# 
+   Teiltext von 'quelle', der bei der Position 'von' anfängt. Die Länge des Resultats
+   ergibt sich also zu 
+ 
+ 
+        LENGTH quelle - von + 1 
+ 
+ 
+   d.h. von der Position 'von' bis zum Ende von 'quelle'. 'von' muß innerhalb von
+   'quelle' liegen. Ist von < 1, dann wird 'quelle' geliefert. Falls von > LENGTH
+   quelle ist, wird niltext geliefert. 
+ 
+ 
+   #on("b")#TEXT PROC subtext (TEXT CONST quelle, INT CONST von, bis)#off("b")# 
+   Teiltext von 'quelle' von der Position 'von' bis einschließlich der Position 'bis'. Die
+   Länge des Resultats ist also 
+ 
+ 
+        bis -  von + 1 
+ 
+ 
+   Dabei muß gelten 
+ 
+ 
+        1 <= von <= bis <= LENGTH quelle 
+ 
+ 
+   d.h. die Positionen 'von' und 'bis' müssen in dieser Reihenfolge innerhalb von
+   'quelle' liegen. Ist 
+ 
+ 
+        bis >= LENGTH quelle 
+ 
+ 
+   wird 'subtext (quelle, von)' ausgeführt. Für die Bedingungen für 'von' siehe vor­
+   stehende Beschreibung von 'subtext'. 
+ 
+ 
+'text' 
+   #on("b")#TEXT PROC text (TEXT CONST quelle, INT CONST laenge) #off("b")# 
+   Teiltext aus 'quelle' mit der Länge 'laenge', beginnend bei der Position 1 von
+   'quelle'. Es muß gelten 
+ 
+ 
+              1 <= laenge <= LENGTH quelle 
+ 
+ 
+   d.h. der gewünschte Teiltext muß aus 'quelle' ausblendbar sein. 
+   Wenn gilt: 
+ 
+        laenge > LENGTH quelle 
+ 
+ 
+   wird der zu liefernde TEXT mit der an 'laenge' fehlenden Zeichen mit Leerzeichen
+   aufgefüllt. 
+ 
+   #on("b")#TEXT PROC text (TEXT CONST quelle, INT CONST laenge, von)#off("b")# 
+   Teiltext aus 'quelle' mit der Länge 'laenge', beginnend an der Position 'von' in
+   dem TEXT 'quelle'. Entspricht 
+ 
+ 
+        text (subtext (quelle, von, LENGTH quelle),laenge) 
+ 
+ 
+   Es muß 
+ 
+ 
+        laenge >= 0 
+        1 <= von <= LENGTH quelle 
+ 
+ 
+   gelten, d.h. 'von' muß eine Position angeben, die innerhalb von 'quelle' liegt. Für 
+ 
+ 
+        laenge > LENGTH quelle - von + 1 
+ 
+ 
+   also wenn die angegebene Länge 'laenge' größer ist als der auszublendende Text,
+   wird das Resultat rechts mit Leerzeichen aufgefüllt. Wenn 
+ 
+ 
+        laenge < LENGTH quelle - von + 1 
+ 
+ 
+    d.h. wenn die angegebene Länge kleiner ist als der Teiltext von 'von' bis zum
+    letzten Zeichen von 'quelle', wird das Resultat mit der Länge 
+ 
+ 
+        LENGTH quelle - von + 1 
+ 
+ 
+    geliefert. 
+
diff --git a/doc/programmer-manual/1.8.7/doc/programmierhandbuch.5b b/doc/programmer-manual/1.8.7/doc/programmierhandbuch.5b
new file mode 100644
index 0000000..d91bcc9
--- /dev/null
+++ b/doc/programmer-manual/1.8.7/doc/programmierhandbuch.5b
@@ -0,0 +1,1481 @@
+#pagenr("%",40)##setcount(1)##block##pageblock# 
+#headeven# 
+#center#EUMEL-Benutzerhandbuch 
+#center#____________________________________________________________ 
+ 
+#end# 
+#headodd# 
+#center#TEIL 5 : Programmierung 
+#center#____________________________________________________________ 
+ 
+#end# 
+#bottomeven# 
+#center#____________________________________________________________ 
+5 - % #right#GMD 
+#end# 
+#bottomodd# 
+#center#____________________________________________________________ 
+GMD #right#5 - % 
+#end# 
+ 
+5.3  Der Datentyp FILE (Textdateien) 
+ 
+Der Datentyp FILE definiert Dateien von sequentieller Struktur, die Texte enthalten.
+Ein Objekt vom Datentyp FILE ist charakterisiert durch: 
+ 
+1) seine Betriebsrichtung  :  input = nur lesender Zugriff 
+  (TRANSPUTDIRECTION)         output= nur schreibender Zugriff 
+                              modify= lesender und schreibender Zugriff. 
+2) seinen Namen. 
+ 
+Betriebsrichtung und Name werden in der Assoziierungsprozedur 'sequential file'
+(siehe Kap 2.8.2) festgelegt. 
+ 
+ 
+____________________________________________________________________________ 
+ 
+ ........................... Beispiel .......................... 
+  TEXT VAR name := ausgabe ; 
+ 
+  FILE VAR f := sequential file(output,name) ; 
+    
+ 
+____________________________________________________________________________ 
+ 
+ 
+ 
+Das Festlegen einer Betriebsrichtung impliziert eine Kontrolle der Benutzung der
+betreffenden Datei, hilft somit Programmierfehler zu vermeiden. 
+ 
+ACHTUNG :  #on("b")##on("u")#Alle#off("b")##off("u")# Prozeduren, die auf FILEs zugreifen, verlangen Objekte vom Typ
+           FILE VAR, da die Lese/Schreiboperationen als ändernd betrachtet wer­
+           den (müssen). 
+ 
+#page# 
+
+5.3.1  Assoziierung 
+ 
+'sequential file' 
+   #on("b")#FILE PROC sequential file (TRANSPUTDIRECTION CONST mode, DATASPACE VAR ds)  #off("b")# 
+   Assoziierung einer sequentiellen Datei mit dem Dataspace 'ds' und der Betriebs­
+   richtung 'mode' (vergl. 'modify', 'input' bzw. 'output'). Diese Prozedur dient zur
+   Assoziierung eines temporä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. 
+ 
+ 
+   #on("b")#FILE PROC sequential file (TRANSPUTDIRECTION CONST mode,TEXT CONST name)#off("b")# 
+   Assoziierung einer sequentiellen Datei mit dem Namen 'name' und der Betriebs­
+   richtung 'mode' (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 dagagen der FILE noch nicht und ist die
+   TRANSPUTDIRECTION 'output' oder 'modify', wird ein neuer FILE eingerich­
+   tet. 
+ 
+   FEHLER : "name" gibt es nicht" 
+             Es wurde versucht, einen nicht vorhandenen FILE mit 'input' zu asso­
+             ziieren. 
+ 
+#page# 
+ 
+'input' 
+   #on("b")#PROC input (FILE VAR f) #off("b")# 
+   Ändern der Verarbeitungsart von 'modify' oder 'output' in 'input'. Dabei wird auf
+   den ersten Satz der Datei positioniert. 
+ 
+   #on("b")#TRANSPUTDIRECTION CONST input #off("b")# 
+   Assoziierung in Zusammenhang mit der Prozedur 'sequential file' einer sequentiel­
+   len Datei mit der 'TRANSPUTDIRECTION' 'input' (nur lesen). 
+ 
+ 
+'output' 
+   #on("b")#PROC output (FILE VAR file) #off("b")# 
+   Ändern der Verarbeitungsart von 'input' oder 'modify' in 'output'. Dabei wird hinter
+   den letzten Satz der Datei positioniert. 
+ 
+   #on("b")#TRANSPUTDIRECTION CONST output #off("b")# 
+   In Verbindung mit der Prozedur 'sequential file' kann eine Datei assoziiert werden
+   mit der Betriebsrichtung 'output' (nur schreiben). 
+ 
+ 
+'modify' 
+   #on("b")#PROC modify (FILE VAR f) #off("b")# 
+   Ändern der Betriebsrichtung von 'input' oder 'output' in die Betriebsrichtung 'mo­
+   dify'. 
+ 
+   #on("b")#TRANSPUTDIRECTION CONST modify #off("b")# 
+   Diese Betriebsrichtung erlaubt das Vorwärts- und Rückwärts-Positionieren und
+   das beliebige Einfügen und Löschen von Sätzen. 'modify' wird für die Assoziie­
+   rungsprozedur 'sequential file' benötigt. 
+ 
+ 
+ 
+#page# 
+
+5.3.2  Informationsprozeduren 
+ 
+'eof' 
+   #on("b")#BOOL PROC eof (FILE CONST file) #off("b")# 
+   Informationsprozedur auf das Ende eines FILEs. Liefert den Wert TRUE, sofern
+   hinter den letzten Satz eines FILEs positioniert wurde. 
+ 
+ 
+'line no' 
+   #on("b")#INT PROC line no (FILE CONST file) #off("b")# 
+   Liefert die aktuelle Zeilennummer. 
+ 
+ 
+'lines' 
+   #on("b")#PROC lines (FILE VAR f) #off("b")# 
+   Liefert die Anzahl der Zeilen der Datei 'f'. 
+ 
+ 
+'headline' 
+   #on("b")#TEXT PROC headline (FILE CONST f) #off("b")# 
+   Liefert den Inhalt der Kopfzeile der Datei 'f'. 
+ 
+   #on("b")#PROC headline (FILE VAR f, TEXT CONST ueberschrift) #off("b")# 
+   Setzt #ib#'ueberschrift' in die Kopfzeile#ie# der Datei 'f'. 
+#page# 
+ 
+5.3.3  Betriebsrichtung INPUT  
+ 
+In der Betriebsrichtung 'input' sind nur Leseoperationen auf der Datei zugelassen. Die
+Assoziierungsprozedur 'sequential file' bewirkt: 
+ 
+1) Falls die Eingabedatei noch nicht existiert, wird eine Fehlermeldung ausgegeben. 
+ 
+2) Falls es eine Datei des Namens gibt, wird auf das erste Zeichen des ersten
+   Satzes positioniert. 
+ 
+ 
+ 
+'get' 
+   #on("b")#PROC get (FILE VAR f, INT VAR number) #off("b")# 
+   Lesen des nächsten Wortes aus der Datei 'f' und Konvertierung des Wortes zu
+   einem Integer-Objekt. 
+ 
+   #on("b")#PROC get (FILE VAR f, REAL VAR number) #off("b")# 
+   Lesen des nächsten Wortes aus der Datei 'f' und Konvertierung des Wortes zu
+   einem Real-Objekt. 
+ 
+ 
+   #on("b")#PROC get (FILE VAR f, TEXT VAR text) #off("b")# 
+   Lesen des nächsten Wortes aus der Datei 'f'. 
+ 
+   #on("b")#PROC get (FILE VAR f, TEXT VAR text, TEXT CONST delimiter)#off("b")# 
+   Lesen eines TEXT-Wertes 'text' von der Datei 'f', bis das Zeichen 'delimiter'
+   angetroffen wird. Ein eventueller Zeilenwechsel in der Datei wird dabei übergan­
+   gen. 
+ 
+   #on("b")#PROC get (FILE VAR f, TEXT VAR text, INT CONST maxlength)#off("b")# 
+   Lesen eines TEXT-Wertes 'text' von der Datei 'f' mit 'maxlength' Zeichen. Ein
+   eventueller Zeilenwechsel in der Datei wird dabei nicht übergangen. 
+ 
+ 
+ 
+'getline' 
+   #on("b")#PROC get line (FILE VAR file, TEXT VAR record) #off("b")# 
+   Lesen der nächsten Zeile aus der sequentiellen Datei 'file'. 
+   Mögliche Fehler bei Betriebsrichtung 'input': 
+ 
+            "Datei zu" 
+             Die Datei 'file' ist gegenwärtig nicht assoziiert. 
+ 
+            "Leseversuch nach Dateiende" 
+             Es wurde versucht, über die letzte Zeile einer Datei zu lesen. 
+ 
+            "Leseversuch auf output file" 
+             Es wurde versucht, von einem mit 'output' assoziierten FILE zu lesen. 
+ 
+            "Unzulässiger Zugriff auf modify-FILE" 
+ 
+#page# 
+
+5.3.4  Betriebsrichtung OUTPUT  
+ 
+In der Betriebsrichtung 'output' sind nur Schreiboperationen auf der Datei zugelassen.
+Die Assoziierungsprozedur 'sequential file' bewirkt: 
+ 
+1) Falls die Ausgabedatei noch nicht existiert, wird sie angelegt und auf den ersten
+   Satz positioniert. 
+ 
+2) Falls es bereits eine Datei des Namens gibt, wird hinter den letzten Satz positio­
+   niert, die Datei wird also fortgeschrieben. 
+ 
+ 
+'put' 
+   #on("b")#PROC put (FILE VAR f, INT CONST number) #off("b")# 
+   Ausgabe eines INT-Wertes 'number' in die Datei 'f'. Dabei wird ein Leerzeichen
+   an die Ausgabe angefügt. 
+ 
+   #on("b")#PROC put (FILE VAR f, REAL CONST number) #off("b")# 
+   Ausgabe eines REAL-Wertes 'number' in die Datei 'f'. Dabei wird ein Leerzei­
+   chen an die Ausgabe angefügt. 
+ 
+   #on("b")#PROC put (FILE VAR f, TEXT CONST text) #off("b")# 
+   Ausgabe eines TEXT-Wertes 'text' in die Datei 'f'. Dabei wird ein Leerzeichen an
+   die Ausgabe angefügt. 
+ 
+ 
+ 
+'putline' 
+   #on("b")#PROC putline (FILE VAR file, TEXT CONST record) #off("b")# 
+   Ausgabe eines TEXTes 'record' in die Datei 'file'. Danach wird auf die nächste
+   Zeile positioniert. 'file' muß mit 'output' assoziiert sein. 
+ 
+ 
+'write' 
+   #on("b")#PROC write (FILE VAR f, TEXT CONST text) #off("b")# 
+   Schreibt 'text' in die Datei 'f' (analog 'put (f, text)'), aber ohne Trennblank. 
+ 
+ 
+'line' 
+   #on("b")#PROC line (FILE VAR file) #off("b")# 
+   Positionierung auf die nächste Zeile der Datei 'file'. Wird versucht, über das Ende
+   eines mit 'input' assoziierten FILEs zu positionieren, wird keine Aktion vorgenom­
+   men. 
+ 
+   #on("b")#PROC line (FILE VAR file, INT CONST lines) #off("b")# 
+   Positionierung mit 'lines' Zeilen Vorschub in der Datei 'file'. 
+ 
+ 
+   FEHLER:  "Datei zu!" 
+             Die Datei 'file' ist gegenwärtig nicht assoziiert. 
+ 
+            "Schreibversuch auf input-File" 
+             Es wurde versucht, auf einen mit 'input' assoziierten FILE zu
+             schreiben. 
+ 
+ 
+   Bei Textdateien, die mit dem Editor weiterbearbeitet werden sollen, ist also zu
+   beachten: ine Ausgabe mit 'put' setzt ein 'blank' hinter die Ausgabe. Falls dieses
+   Leerzeichen das letzte Zeichen in der Zeile ist, wird eine Absatzmarke in der Zeile
+   gesetzt. Wird mit 'write' oder 'putline' ausgegeben, steht kein Leerzeichen und
+   somit keine Absatzmarke am Zeilenende. 
+#page# 
+
+5.3.5  Betriebsrichtung MODIFY  
+ 
+In der Betriebsrichtung 'modify' sind Lese- und Schreiboperationen auf der Datei
+zugelassen. Desweiteren ist beliebiges Positionieren in der Datei erlaubt. Neue Sätze
+können an beliebiger Stelle in die Datei eingefügt werden, die sequentielle Struktur
+der Datei bleibt erhalten. Die Assoziierungsprozedur 'sequential file' bewirkt: 
+ 
+1) Falls die Ausgabedatei noch nicht existiert, wird sie angelegt. 
+ 
+2) Falls es bereits eine Datei des Namens gibt, ist undefiniert wo positioniert ist. Die
+   erste Positionierung muß explizit vorgenommen werden! 
+ 
+ 
+ 
+'col' 
+   #on("b")#PROC col (FILE VAR f, INT CONST position) #off("b")# 
+   Positionierung auf die Spalte 'position' innerhalb der aktuellen Zeile. 
+ 
+   #on("b")#INT PROC col (FILE CONST f) #off("b")# 
+   Liefert die aktuelle Position innerhalb der aktuellen Zeile. 
+ 
+ 
+'down' 
+   #on("b")#PROC down (FILE VAR f) #off("b")# 
+   Positionieren um eine Zeile vorwärts. 
+ 
+   #on("b")#PROC down (FILE VAR f, INT CONST number) #off("b")# 
+   Positionieren um 'number' Zeilen vorwärts. 
+ 
+ 
+'to line' 
+   #on("b")#PROC to line (FILE VAR f, INT CONST number) #off("b")# 
+   Positionierung auf die Zeile 'number'. 
+ 
+ 
+'up' 
+   #on("b")#PROC up (FILE VAR f) #off("b")# 
+   Positionieren um eine Zeile rückwärts. 
+ 
+   #on("b")#PROC up (FILE VAR f, INT CONST number) #off("b")# 
+   Positionieren um 'number' Zeilen rückwärts. 
+ 
+#page# 
+'delete record' 
+   #on("b")#PROC delete record (FILE VAR file) #off("b")# 
+   Der aktuelle Satz der Datei 'file' wird gelöscht. Der folgende Satz wird der aktuelle
+   Satz. 
+ 
+ 
+'insert record' 
+   #on("b'PROC insert record (FILE VAR file) #off("b")# 
+   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). 
+ 
+ 
+ 
+'read record' 
+   #on("b")#PROC read record (FILE CONST file, TEXT VAR record) #off("b")# 
+   Liest den aktuellen Satz der Datei 'file' in den TEXT 'record'. Die Position wird
+   dabei nicht verändert. 
+ 
+ 
+ 
+'write record' 
+   #on("b")#PROC write record (FILE VAR file, TEXT CONST record) #off("b")# 
+   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. 
+ 
+ 
+#page# 
+
+5.3.6  FILE -Ausschnitte 
+ 
+Ähnlich den Editorfunktionen 'ESC RUBOUT' und 'ESC RUBIN', die erlauben ganze
+Abschnitte einer Datei zu löschen und das Gelöschte an anderer Stelle wiedereinzu­
+fügen, gibt es die Möglichkeit per Programm solche Segmente 
+eines 'modify-FILEs' zu verschieben. 
+ 
+ 
+'clear removed' 
+   #on("b")#PROC clear removed (FILE VAR f) #off("b")# 
+   Das mit 'remove' entfernte Segment wird gelöscht und nicht an anderer Stelle
+   eingefügt. 
+ 
+ 
+'reinsert' 
+   #on("b")#PROC reinsert (FILE VAR f) #off("b")# 
+   Das mit 'remove' entfernte Segment wird vor die aktuelle Zeile wiedereingefügt. 
+ 
+ 
+'remove' 
+   #on("b")#PROC remove (FILE VAR f, INT CONST size) #off("b")# 
+   Löscht 'size' Zeilen vor der aktuellen Position aus 'f'. Das Segment wird in einen
+   internen Puffer geschrieben. 
+ 
+ 
+'reorganize' 
+   #on("b")#PROC reorganize (TEXT CONST datei)#off("b")# 
+   Reorganisation von 'datei'. Die durch Löschen und Einfügen aus vielen
+   Segmenten bestehende Datei wird zu einem Segment zusammengefügt, die
+   aktuelle Position ist danach das erste Zeichen der ersten Zeile. 
+ 
+   Durch diese Prozedur kann ggf. Speicherplatz gespart werden. 
+ 
+   #on("b")#PROC reorganize#off("b")# 
+   Reorganisation der zuletzt bearbeiteten Datei. 
+ 
+ 
+'segments' 
+   #on("b")#PROC segments (FILE VAR f) #off("b")# 
+   Liefert die Anzahl der Segmente von 'f'. Eine große Anzahl von Segmenten kann
+   langsamere Zugriffe zur Folge haben. 
+ 
+#page# 
+ 
+5.4  Suchen und Ersetzen in Textdateien 
+ 
+Such- und Ersetzungsprozeduren können sowohl interaktiv beim Editieren (siehe
+dazu 3.3), als auch in Prozeduren, die auf FILEs (siehe 5.3) arbeiten, angewandt
+werden. 
+ 
+Die dazu dienenden Prozeduren sind im Paket 'pattern match' enthalten. Mit 'Pattern
+Matching' (Muster treffen) wird ein Verfahren bezeichnet Gleichheit von Objekten
+anhand von Regeln, denen diese Objekte genügen, zu überprüfen. 
+ 
+Da oft nach Texten gesucht werden muß, deren genaue Ausprägung nicht bekannt ist,
+oder deren Auftreten nur in einem bestimmten Zusammenhang interessiert, gibt es die
+Möglichkeit feststehende Textelemente mit Elementen ungewisser Ausprägung zu
+kombinieren, also Textmuster zu erzeugen. 
+ 
+Um einen Text zu suchen, muß die Suchrichtung und der gesuchte Text oder ein
+Muster, welches diesen Text beschreibt, angegeben werden. 
+ 
+- Aufbauen von Textmustern :  + , - , OR , any , bound , notion 
+ 
+- Suchen nach Textmustern  :  down , downety , up , uppety 
+ 
+- Treffer registrieren     :  LIKE , UNLIKE , at , pattern found 
+ 
+- Treffer herausnehmen     :  ** , match , matchend , matchpos , 
+                              somefix , word 
+ 
+- Ändern in Dateien        :  change 
+ 
+ 
+Nach einem erfolgreichen Suchvorgang ist stets auf das erste Zeichen der zu such­
+enden Zeichenkette positioniert. 
+ 
+ 
+Eine besondere Funktion kommt dem 'joker' zu: Dieses Symbol (Defaultwert: '*') steht
+für eine beliebige Zeichenkette beliebiger Länge. Insbesondere bei Ersetzungsaktionen
+in denen dieses Zeichen zur Musterbeschreibung verwendet wird, ist daher Vorsicht
+geboten und sorgfältig zu testen. 
+ 
+#page# 
+
+5.4.1  Aufbau von Textmustern 
+ 
+'+' 
+   #on("b")#TEXT OP + (TEXT CONST links, rechts) #off("b")# 
+   Verkettung der Texte 'links' und 'rechts' zu 'linksrechts'. Falls das Ergebnis länger
+   als die maximal zulässige Textlänge ist, ist es undefiniert. 
+ 
+   Wenn 'muster1' einen beliebigen Text finden sollte, ( Siehe: PROC any) wird das
+   Ende des von 'muster1' erkannten Textes durch den Anfang des von 'muster2'
+   erkannten Textes im Nachhinein definiert. 
+ 
+ 
+ 
+'-' 
+   #on("b")#TEXT OP - (TEXT CONST alphabet) #off("b")# 
+   Der Operator liefert das zu 'alphabet' komplementäre Alphabet, also alle Zeichen
+   gemäß der EUMEL Codetabelle (5.2.4), die nicht in 'alphabet' enthalten sind.
+   Sinnvoll im Zusammenhang mit der Textprozedur 'any'. 
+ 
+ 
+'OR' 
+   #on("b")#TEXT OP OR (TEXT CONST links, rechts) #off("b")# 
+   Liefert die Alternative von 'links' und 'rechts'. Die Reihenfolge spielt beim Suchen
+   keine Rolle. 
+ 
+ 
+ 
+'any' 
+   Die Textprozedur 'any' liefert einen unbekannten Text unbestimmter Länge.
+   Dieser Text sollte entweder durch festen Text sinnvoll eingegrenzt werden, oder
+   direkt eingeschränkt werden. 
+ 
+ 
+   #on("b")#TEXT PROC any #off("b")# 
+   Beschreibt einen beliebigen Text. 
+ 
+   #on("b")#TEXT PROC any (INT CONST laenge) #off("b")# 
+   Beschreibt einen beliebigen Text der angebenen Länge. 
+ 
+ 
+   #on("b")#TEXT PROC any (TEXT CONST alphabet) #off("b")# 
+   Beschreibt einen beliebigen Text, der nur aus Zeichen besteht, die in 'alphabet'
+   enthalten sind. 
+ 
+ 
+   #on("b")#TEXT PROC any (INT CONST laenge, TEXT CONST alphabet) #off("b")# 
+   Beschreibt einen Text der vorgegebenen Länge, der nur aus den in 'alphabet'
+   vorgegebenen Zeichen besteht. 
+ 
+ 
+____________________________________________________________________________ 
+ 
+ ........................... Beispiel .......................... 
+  Die Textprozedur 'any' liefert einen unbekannten Text unbe­ 
+  stimmter Länge. Dieser Text sollte entweder durch festen Text 
+  sinnvoll eingegrenzt werden, oder direkt eingeschränkt werden. 
+gib kommando: D("D" OR "d" + any (2,"aeirs")                    
+  Sucht nach bestimmten Artikeln: 'der', 'die', 'das'  etc. 
+ 
+____________________________________________________________________________ 
+ 
+ 
+ 
+'bound' 
+   #on("b")#TEXT PROC bound #off("b")# 
+   Bezeichnet ein Muster der Länge null, das nur am Zeilenanfang oder am Zeilenen­
+   de gefunden wird. Ein Präfix 'bound' fordert, daß das gesuchte Muster in der
+   ersten Spalte beginnen muß, ein Postfix 'bound' fordert, daß das Muster mit dem
+   Zeilenende abschließt. 
+ 
+____________________________________________________________________________ 
+ 
+ ........................... Beispiel .......................... 
+      Die Textprozedur 'any' liefert einen unbekannten Text unbe­ 
+      stimmter Länge. Dieser Text sollte entweder durch festen 
+      Textsinnvoll eingegrenzt werden, oder direkt eingeschränkt 
+      werden. 
+gib kommando: U(bound + any (" "))                              
+ 
+____________________________________________________________________________ 
+ 
+ 
+ 
+  liefert Treffer bei eingerückten Zeilen. 
+ 
+ 
+ 
+'notion' 
+   #on("b")#PROC notion (TEXT CONST suchwort) #off("b")# 
+   Mit dieser Prozedur kann ein #on("u")#Wort#off("u")# spezifiziert werden, nach dem gesucht werden
+   soll. Bei der Suche nach 'suchwort' wird nur dann ein Treffer geliefert, wenn
+   'suchwort' als Wort, also begrenzt von ' ' (blank), '.' , ','  oder anderen Sonderzei­
+   chen ist. 
+ 
+   #on("b")#PROC notion (TEXT CONST suchwort, INT CONST reg) #off("b")# 
+   Wie oben, der Treffer wird im Register 'reg' gespeichert. 
+ 
+#page# 
+
+5.4.2  Suche nach Textmustern 
+ 
+'down' 
+   #on("b")#PROC down (FILE VAR f, TEXT CONST muster) #off("b")# 
+   Suche nach 'muster' in der Datei 'f' in Richtung Dateiende. Wird 'muster' gefun­
+   den, ist die Position das erste Zeichen von 'muster'. 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. 
+ 
+ 
+   #on("b")#PROC down (FILE VAR f, TEXT CONST muster, INT CONST number)#off("b")# 
+   Wie obiges 'down', es wird aber maximal nur 'number'-Zeilen weit nach 'muster'
+   gesucht. 
+ 
+ 
+ 
+'downety' 
+   #on("b")#PROC downety (FILE VAR f, TEXT CONST muster) #off("b")# 
+   Suche nach 'muster' in der Datei 'f' in Richtung Dateiende. Wird 'muster' gefun­
+   den, ist die Position das erste Zeichen von 'muster'. Andernfalls steht man auf
+   dem letzten Zeichen der Datei. 
+ 
+   Achtung: 'downety' sucht (im Gegensatz zu 'down') vom aktuellen Zeichen an.
+            Daher muß explizit vorwärts positioniert werden. 
+ 
+ 
+   #on("b")#PROC downety (FILE VAR f, TEXT CONST muster, INT CONST number) #off("b")# 
+   Wie obiges 'downety', aber maximal nur 'number'-Zeilen weit. 
+#page# 
+'up' 
+   #on("b")#PROC up (FILE VAR f, TEXT CONST muster) #off("b")# 
+   Suche nach 'muster' in der Datei 'f' in Richtung Dateianfang. Wird 'muster'
+   gefunden, ist die Position das erste Zeichen von 'muster'. Andernfalls steht man
+   auf dem ersten Zeichen der Datei. 
+ 
+   Achtung: 'up' sucht vom nächsten Zeichen links ab, so daß wiederholtes Suchen
+            keine Endlosschleife ergibt. 
+ 
+ 
+   #on("b")#PROC up (FILE VAR f, TEXT CONST muster, INT CONST number)#off("b")# 
+   Wie obiges 'up', aber maximal nur 'number'-Zeilen weit. 
+ 
+ 
+ 
+'uppety' 
+   #on("b")#PROC uppety (FILE VAR f, TEXT CONST muster) #off("b")# 
+   Suche nach 'muster' in der Datei 'f' in Richtung Dateianfang. Wird 'muster'
+   gefunden, ist die Position das erste Zeichen von 'muster'. Andernfalls steht man
+   auf dem ersten Zeichen der Datei. 
+ 
+   Achtung: 'uppety' sucht (im Gegensatz zu 'up') vom aktuellen Zeichen. 
+ 
+ 
+   #on("b")#PROC uppety (FILE VAR f, TEXT CONST muster, INT CONST number)#off("b")# 
+   Wie obiges 'uppety', aber maximal nur 'number'-Zeilen weit. 
+ 
+#page# 
+
+5.4.3  Treffer registrieren 
+ 
+'LIKE' 
+   #on("b")#BOOL OP LIKE (TEXT CONST text , muster) #off("b")# 
+   Liefert TRUE, falls der Text 'text' 'muster' entspricht. In 'muster' kann das
+   Spezialzeichen '*' verwandt werden, das abkürzend für die Konkatenation mit
+   'any' steht. 
+ 
+   Daraus folgt, daß das Suchen oder Ersetzen des Zeichens '*' nur durch
+   any (1,"*") zu bewerkstelligen ist. 
+ 
+ 
+____________________________________________________________________________ 
+ 
+ ........................... Beispiel .......................... 
+ \#Druckdateien aus Thesaurus löschen\# 
+ gib kommando:"*.p" C ""                                        
+ 16.04.87       "Handbuch teil1" 
+ 04.05.87       "Handbuch teil1.p" 
+ 16.04.87       "Handbuch teil2" 
+ 06.05.87       "Handbuch teil2.p" 
+ 
+____________________________________________________________________________ 
+ 
+ 
+ 
+  aber: 
+ 
+____________________________________________________________________________ 
+ 
+ ........................... Beispiel .......................... 
+ \#Vordere Kommentarklammern löschen \# 
+ gib kommando:"(" + any(1,"*") C ""                              
+ lernsequenz auf taste legen("a" , "archive") ; 
+ (* lernsequenz auf taste legen("(" , ""91"") ; *) 
+ (* lernsequenz auf taste legen(")" , ""93"") ; *) 
+    kommando auf taste legen("P" , "print("""")"8""8""11"") . 
+ 
+____________________________________________________________________________ 
+ 
+ 
+ 
+'UNLIKE' 
+   #on("b")#BOOL OP UNLIKE (TEXT CONST text , muster) #off("b")# 
+   Wirkt wie: '(NOT text LIKE muster)' 
+#page# 
+ 
+5.4.4  Treffer herausnehmen 
+ 
+Mit Hilfe der 'Register' ist es möglich identifizierte Texte zwischenzuspeichern und in
+weiteren Aktionen weiterzuverwenden. 
+ 
+ 
+'**' 
+   #on("b")#TEXT OP ** (TEXT CONST muster, INT CONST register)#off("b")# 
+   Der als 'muster' erkannte Text wird einem 'Register' mit der Nummer 'register'
+   zugeordnet. Es können 256 Register (1 bis 256) benutzt werden. 
+ 
+ 
+'match' 
+   #on("b")#TEXT PROC match (INT CONST nr) #off("b")# 
+   Liefert den Text der dem Register 'nr' zuletzt zugeordnet wurde. 
+ 
+ 
+'matchpos' 
+   #on("b")#INT PROC matchpos (INT CONST nummer) #off("b")# 
+   Liefert die Spaltennummer, auf der das dem Register 'nummer' zugeordnete Mu­
+   ster in der Zeile beginnt. 
+ 
+____________________________________________________________________________ 
+ 
+ ........................... Beispiel .......................... 
+ 
+ gib kommando:D("file"+any+"("+(any ** (1)...                    
+ 
+____________________________________________________________________________ 
+#page# 
+
+5.4.5  Ändern in Dateien  
+ 
+'change' 
+   #on("b")#PROC change (FILE VAR datei, INT CONST von, bis , TEXT CONST neuertext)#off("b")# 
+   In der Datei wird in der aktuellen Zeile in den Ausschnitt zwischen 'von' und 'bis'
+   der Text 'neuertext' eingesetzt. 
+ 
+   entspricht: 
+ 
+ 
+____________________________________________________________________________ 
+ 
+ ........................... Beispiel .......................... 
+ FILE VAR file := sequential file (modify, name) 
+ TEXT VAR zeile; 
+      . 
+      . 
+    read record (file ,zeile); 
+    change (zeile, von, bis ,"neuertext"); 
+    write record (file, zeile); 
+      . 
+ 
+____________________________________________________________________________ 
+ 
+#page# 
+
+5.4.6  Editor-Prozeduren 
+ 
+'edit' 
+   #on("b")#edit (TEXT CONST datei)#off("b")# 
+   Editieren der Datei 'datei'. Das Editorfenster ist maximal groß (von 1,1 bis
+   max,max). Der Standard-Kommandointerpreter ist gültig, so daß Eingaben, die
+   mit #schl("ESC")# beginnen, interpretiert werden, wie in 3.4 'Vorbelegte Tasten' beschrie­
+   ben. 
+ 
+   #on("b")#edit#off("b")# 
+   Wie oben, editiert wird die Datei mit dem zuletzt benutzten Namen. 
+ 
+   #on("b")#edit (THESAURUS CONST thes)#off("b")# 
+   Wie oben, editiert werden alle Dateien, deren Namen im Thesaurus 'thes' enthal­
+   ten sind. 
+ 
+   #on("b")#edit (TEXT CONST datei, INT CONST von x, von y, bis x, bis y)#off("b")# 
+   Editieren der Datei 'datei'. Das Editorfenster hat die linke obere Ecke bei 'von x,
+   von y' und die rechte untere Ecke bei 'bis x, bis y'. 
+ 
+   #on("b")#edit (FILE VAR f)#off("b")# 
+   Editieren der als 'sequential file' assoziierten Textdatei 'f'. 
+ 
+   #on("b")#edit (FILE VAR, INT CONST von x, von y, bis x, bis y)#off("b")# 
+   Editieren der als 'sequential file' assoziierten Textdatei in einem Fenster mit der
+   linken, oberen Ecke 'von x, von y' und der rechten, unteren Ecke 'bis x, bis y'. 
+ 
+   #on("b")#edit (FILE VAR f, TEXT CONST res, 
+                  PROC (TEXT CONST) kdo interpreter)#off("b")# 
+   Editieren der als 'sequential file' assoziierten Textdatei 'f'. In 'res' werden reser­
+   vierte Zeichen übergeben, die von der Prozedur 'kdo interpreter' als Kommandos
+   interpretiert werden, wenn sie als ESC-Sequenz eingegeben werden. 
+   Beispiel : #schl("ESC ")# #schl("e")# 
+ 
+#page# 
+'editget' 
+   #on("b")#editget (TEXT VAR ausgabe) #off("b")# 
+   Aufruf des Zeileneditor. An der aktuellen Cursorposition wird eine Zeile ausgegeben in
+   der 'ausgabe' steht. Für diese Zeile stehen alle Editiermöglichkeiten zur
+   Verfügung, 'ausgabe' kann also beliebig überschrieben, ergänzt etc. werden. Die
+   Eingabe wird durch #schl("CR")# abgeschlossen. Im Gegensatz zur Prozedur 'get' ist auch
+   eine leere Eingabe möglich. 
+ 
+   #on("b")#editget (TEXT VAR ausgabe, INT CONST zeile, INT CONST scroll, 
+             TEXT CONST sep, TEXT CONST res, TEXT VAR exit)  #off("b")# 
+   Wie oben, die Zeilenlänge ist jedoch auf 'zeile' Zeichen begrenzt. Die Eingabe
+   wird durch #schl("CR")# oder durch eine Cursorbewegung über die Position 'zeile' hinaus
+   abgeschlossen. 
+ 
+   Die Angabe 'scroll' setzt die Breite des Zeilenfensters fest, wird diese Breite
+   überschritten, so wird 'ausgabe' gerollt. 
+ 
+   In 'sep' (Separator) können Zeichen festgesetzt werden, mit denen die Eingabe
+   beendet wird (zusätzlich zu CR !). 
+ 
+   In 'res' (reservierte Tasten) können Tasten festgelegt werden, die in Verbindung
+   mit <ESC> die Eingabe beenden. 
+ 
+   Wurde der Zeileneditor durch einen Separator verlassen, so steht in 'exit' dieses
+   Zeichen. Falls der Zeileneditor durch eine reservierte Taste verlassen, so enthält 
+   'exit' 'ESC' und die Taste. 
+ 
+   #on("b")#editget (TEXT VAR ausgabe, INT CONST zeile, INT CONST scroll)#off("b")# 
+   Bedeutung der Parameter siehe oben. 
+ 
+   #on("b")#editget (TEXT VAR ausgabe, TEXT CONST sep, TEXT CONST res, 
+                     TEXT VAR exit) #off("b")# 
+   Bedeutung der Parameter siehe oben. 
+ 
+   #on("b")#editget (TEXT VAR ausgabe, INT CONST zeile, TEXT VAR exit) #off("b")# 
+   Bedeutung der Parameter siehe oben. 
+#page# 
+
+5.4.7  Sortierung von Textdateien 
+ 
+Für die Sortierung von Textdateien gibt es zwei Sortierprogramme: 
+ 
+- Sortierung nach ASCII    :  sort 
+ 
+- Sortierung nach 
+  deutschem Alphabet       :  lexsort 
+ 
+ 
+'sort' 
+   #on("b")#PROC sort (TEXT CONST datei) #off("b")# 
+   Diese Prozedur sortiert die Datei 'datei' zeilenweise gemäß der von der EUMEL
+   Codetabelle (siehe 5.2.4) vorgegebenen Reihenfolge. Zur Sortierung werden die
+   Zeilen vom ersten Zeichen der Zeile beginnend, zeichenweise verglichen und
+   dementsprechend sortiert. 
+ 
+   #on("b")#PROC sort (TEXT CONST datei, INT CONST position) #off("b")# 
+   Sortierkriterien wie oben, jedoch wird bei Vergleich und Sortierung der Satz erst
+   ab der Position 'position' beachtet. Sortiert wird der ganze Satz! 
+ 
+ 
+'lex sort' 
+   #on("b")#PROC lex sort (TEXT CONST datei) #off("b")# 
+   Zeilenweise Sortierung nach lexikographischer Reihenfolge gemäß DIN 5007. Zu
+   den Vergleichen werden die Operatoren LEXEQUAL, LEXGRATER,
+   LEXGRATEREQUAL benutzt (siehe 5.2.4). 
+ 
+   #on("b")#PROC lex sort (TEXT CONST datei, INT CONST position) #off("b")# 
+   Lexikalische Sortierung durch Vergleich ab Position 'position'. 
+ 
+#page# 
+
+5.4.8  Prozeduren auf Datenräumen 
+ 
+Neben den Textdateien gibt es im EUMEL-System den Typ Datenraum, der Objekte
+jeglichen Typs aufnehmen kann und direkten Zugriff auf die Objekte gewährt (siehe
+2.9.2). 
+ 
+Für Objekte von Type Datenraum (nicht für die in Datenräumen enthaltenen Objekte!)
+existieren folgende Standardprozeduren: 
+ 
+ 
+':=' 
+   #on("b")#OP := ( DATASPACE VAR ds1, DATASPACE CONST ds2)#off("b")# 
+   Der Datenraum 'ds1' wird als Kopie von 'ds2' angelegt. Es handelt sich zunächst
+   um eine logische Kopie, eine physische Kopie wird erst nach einem Schreibzugriff
+   auf 'ds1' oder 'ds2' nötig. 
+ 
+ 
+'new' 
+   #on("b")#DATASPACE PROC new (TEXT CONST dsname) #off("b")# 
+   Liefert einen neuen Datenraum namens 'dsname'. 
+ 
+____________________________________________________________________________ 
+ 
+ DATASPACE VAR ds := new ("datenraum") 
+ (* ergibt zwei Datenräume 'ds' und 'datenraum'! *) 
+ 
+____________________________________________________________________________ 
+ 
+ 
+ 
+'nilspace' 
+   #on("b")#DATASPACE PROC nilspace#off("b")# 
+   Der 'nilspace' ist ein leerer Datenraum, der ausschließlich als Quelle zum Kopie­
+   ren bei der Initialisierung Verwendung finden darf. 
+ 
+ 
+'old' 
+   #on("b")#DATASPACE PROC old (TEXT CONST dsname) #off("b")# 
+   Liefert einen bereits existierenden Datenraum (oder auch eine Datei) mit dem
+   Namen 'dsname'. 
+ 
+   FEHLER :  "dsname" gibt es nicht 
+ 
+ 
+'type' 
+   #on("b")#PROC type (DATASPACE CONST ds, INT CONST typ)#off("b")# 
+   Der Datenraum 'ds' erhält den frei wählbaren Schlüssel 'typ'. Es muß eine positive
+   Zahl gewählt werden. Der Datenraum muß zum Zeitpunkt der Typzuweisung an
+   ein BOUND Objekt gekoppelt (gewesen) sein. 
+ 
+   #on("b")#INT PROC type (DATASPACE CONST ds)#off("b")# 
+   Liefert den Schlüssel des Datenraums 'ds'. Falls 'ds' nie an ein BOUND Objekt
+   gekoppelt war, liefert die Prozedur einen Wert < 0, sonst 0 (keine Zuweisung
+   erfolgt) oder die zugewiesene Typnummer. 
+ 
+ 
+'dataspaces' 
+   #on("b")#INT PROC dataspaces (TASK CONST task) #off("b")# 
+   Liefert die Anzahl der Datenräume der Task 'task'. 
+ 
+   #on("b")#INT PROC dataspaces #off("b")# 
+   Anzahl der Datenräume von 'myself'. 
+ 
+ 
+'ds pages' 
+   #on("b")#INT PROC ds pages (DATASPACE CONST ds)#off("b")# 
+   Liefert die Anzahl der durch 'ds' belegten Seiten (je 512 Byte). 
+ 
+ 
+'storage' 
+   #on("b")#INT PROC storage (DATASPACE CONST ds)#off("b")# 
+   Liefert den von 'ds' belegten Speicherplatz in KB. 
+ 
+#page# 
+'copy' 
+   #on("b")#PROC copy (DATASPACE CONST ds, TEXT CONST datei) #off("b")# 
+   Eine neue Datei mit dem Namen 'datei' wird angelegt. Der Inhalt der Datei ist eine
+   Kopie des Inhalts des Datenraumes 'ds'. 
+ 
+ 
+'forget' 
+   #on("b")#PROC forget (DATASPACE CONST ds)#off("b")# 
+   Der Datenraum 'ds' wird gelöscht#u#1)#e#. 
+ 
+#foot# 
+ 
+   1) Durch diese Prozedur steht nicht unmittelbar mehr freier Speicherplatz zur
+      Verfügung. Die physische Räumung von Speicherplatz erfolgt durch die
+      'Müllabfuhr' bei einem Fixpunkt. 
+#end# 
+ 
+'fetch' 
+   #on("b")#PROC fetch (DATASPACE CONST ziel, TEXT CONST datei, 
+               TASK CONST manager) #off("b")# 
+   Aus der Task 'manager' wird der Datenraum der Datei 'datei' in den eigenen
+   Datenraum 'ziel' kopiert. 
+ 
+ 
+'save' 
+   #on("b")#PROC save (DATASPACE CONST quelle, TEXT CONST datei, 
+               TASK CONST manager) #off("b")# 
+   Der eigene Datenraum 'quelle' wird in die Datei 'datei' in der Task 'manager'
+   kopiert. 
+#page# 
+ 
+5.5  Eingabe/Ausgabe 
+ 
+- Eingabesteuerzeichen     :  HOP , � � � � , TAB , RUBIN , RUBOUT 
+                              CR , MARK , ESC 
+ 
+- Ausgabesteuerzeichen     :  HOME , � � � � , CL EOP , CL EOL 
+                              CPOS , BELL , CR , ENDMARK , BEGINMARK 
+ 
+- Positionierung           :  cursor , get cursor , line , page 
+ 
+- Eingabe                  :  get , getline , inchar , incharety 
+ 
+- Ausgabe                  :  cout , out , out subtext , put , putline , 
+                              TIMESOUT , write 
+ 
+- Kontrolle                :  online , pause , sysin , sysout 
+ 
+- Zeitmessung              :  clock , date , day , hour , pause , time 
+                              time of day 
+ 
+#page# 
+ 
+5.5.1  E/A auf Bildschirm  
+ 
+Steuerzeichen und Standardprozeduren zur Ein- Ausgabe am Bildschirm werden
+zur Steuerung des Dialogverhaltens von Prozeduren benutzt.
+
+ 
+5.5.1.1  Eingabesteuerzeichen 
+Eingabesteuerzeichen werden durch die Funktionstasten (s. 3.2) erzeugt. Die Wirkung
+der Tasten ist ebenfalls an dieser Stelle beschrieben. 
+ 
+Durch die Tasten werden folgende Codes an Programme gegeben: 
+ 
+Codierung  I   Bezeichnung 
+-----------+-------------- 
+HOP        I     1 
+RECHTS     I     2 
+OBEN       I     3 
+LINKS      I     8 
+TAB        I     9 
+UNTEN      I    10 
+RUBIN      I    11 
+RUBOUT     I    12 
+CR         I    13 
+MARK       I    16 
+ESC        I    27 
+ 
+ 
+#page# 
+
+5.5.1.2  Ausgabesteuerzeichen 
+ 
+Die Ausgabe dieser Zeichen bewirkt folgendes Verhalten der Bildschirmausgabe. 
+ 
+Code I   Name      I  Wirkung 
+-----+-------------+------------------------------------------------------- 
+ 0   I   NUL       I  keine Wirkung 
+ 1   I   HOME      I  Cursor in die linke obere Ecke setzen (Position 0,0!) 
+ 2   I   RECHTS    I  Cursor eine Stelle nach rechts setzen 
+ 3   I   OBEN      I  Cursor eine Zeile höher setzen 
+ 4   I   CL EOP    I  Rest der Seite löschen 
+ 5   I   CL EOL    I  Rest der Zeile löschen 
+ 6   I   CPOS      I  Cursor setzen, nächstes Ausgabezeichen bestimmt die
+     I             I  y-Position, das darauf folgende die x-Position. 
+ 7   I   BELL      I  akustisches Signal 
+ 8   I   LINKS     I  Cursor eine Stelle nach links setzen 
+10   I   UNTEN     I  Cursor eine Stelle nach unten setzen 
+13   I   CR        I  Cursor an den Anfang der nächsten Zeile setzen 
+14   I   ENDMARK   I  Ende des markierten Bereichs 
+15   I   BEGINMARK I  Anfang des markierten Bereichs 
+ 
+ 
+ 
+ 
+____________________________________________________________________________ 
+ 
+ ........................... Beispiel .......................... 
+  TEXT VAR ausgabe := (""7""15"V O R S I C H T"14"7"");  
+       out(ausgabe); 
+ 
+____________________________________________________________________________ 
+ 
+#page# 
+
+5.5.1.3  Positionierung 
+ 
+'cursor' 
+   #on("b")#PROC cursor (INT CONST column, row) #off("b")# 
+   Positioniert den Cursor auf dem Bildschirm, wobei 'column' die Spalte und 'row'
+   die Zeile angibt. Die zulässigen Bereiche von 'column' und 'row' sind geräteab­
+   hängig. 
+ 
+ 
+ 
+'get cursor' 
+   #on("b")#PROC get cursor (INT VAR x, y) #off("b")# 
+   Erfragung der aktuellen Cursor-Position. Die Koordinaten des Cursors werden in
+   'x' und 'y' geliefert. Die aktuelle Cursor-Position ist nach Ausgabe von 'HOME'
+   (Code = 1) oder einer Positionierung des Cursors mit der Prozedur 'cursor' stets
+   definiert. Die Prozedur 'get cursor' liefert jedoch undefinierte Werte, wenn über
+   den rechten Rand einer Zeile hinausgeschrieben wurde (die Wirkung einer solchen
+   Operation hängt von der Hardware eines Terminals ab). 
+ 
+ 
+'line' 
+   #on("b")#PROC line #off("b")# 
+   Es wird zum Anfang einer neuen Zeile positioniert. 
+ 
+   #on("b")#PROC line (INT CONST number) #off("b")# 
+   Es werden 'number' Zeilenwechsel vorgenommen. 
+ 
+ 
+'page' 
+   #on("b")#PROC page #off("b")# 
+   Es wird zum Anfang einer neuen Seite positioniert (hier: linke obere Ecke (Position
+   1,1 !) des Bildschirms, wobei der Bildschirm gelöscht wird). 
+ 
+#page# 
+
+5.5.1.4  Eingabe 
+ 
+
+Grundlegende Prozeduren
+Die folgenden Prozeduren dienen ausschließlich der Eingabe vom Terminal. 
+ 
+'editget' 
+   Siehe 5.4.6 
+ 
+ 
+'getchar' 
+   #on("b")#PROC getchar (TEXT VAR zeichen)#off("b")# 
+   Liest genau ein Zeichen von der Tastatur und schreibt es in die Variable 'zeichen'. 
+ 
+ 
+'inchar' 
+   #on("b")#PROC inchar (TEXT VAR character) #off("b")# 
+   Wartet solange, bis ein Zeichen von der Tastatur eingegeben wird, und schreibt
+   dieses Zeichen in die Variable 'character'. 
+ 
+ 
+'incharety' 
+   #on("b")#TEXT PROC incharety #off("b")# 
+   Versucht, ein Zeichen von der Tastatur zu lesen. Wurde kein Zeichen eingegeben,
+   wird niltext geliefert. 
+ 
+   #on("b")#TEXT PROC incharety (INT CONST time limit) #off("b")# 
+   Versucht, ein Zeichen vom Bildschirm zu lesen. Dabei wird maximal eine 'time
+   limit' lange Zeit auf das Zeichen gewartet (gemessen in Zehntel-Sekunden). 
+ 
+#page# 
+
+Umleitbare Eingabeprozeduren
+Die folgenden Eingabeprozeduren lesen ebenfalls vom Terminal, die Eingabequelle
+kann jedoch durch die Prozedur 'sysin' umgestellt werden. Falls in 'sysin' eine Datei
+angegeben wird wird die Eingabe statt vom Terminal aus dieser Datei gelesen. 
+ 
+ 
+'sysin' 
+   #on("b")#PROC sysin (TEXT CONST file name) #off("b")# 
+   Eingabe-Routinen lesen nicht mehr vom Benutzer-Terminal, sondern aus der
+   Datei 'file name'. 
+ 
+   #on("b")#TEXT PROC sysin #off("b")# 
+   Liefert den Namen der eingestellten 'sysin'-Datei. "" bezeichnet das Benutzer-
+   Terminal. 
+ 
+ 
+'get' 
+   #on("b")#PROC get (INT VAR number) #off("b")# 
+   Einlesen eines INT-Wertes vom Bildschirm. Der einzulesende INT-Wert kann
+   bei der Eingabe vom Terminal editiert werden. 
+ 
+   #on("b")#PROC get (REAL VAR value) #off("b")# 
+   Einlesen eines REAL-Wertes vom Bildschirm. Der einzulesende REAL-Wert
+   kann bei der Eingabe vom Terminal editiert werden. 
+ 
+   #on("b")#PROC get (TEXT VAR word) #off("b")# 
+   Liest einen Text in die Variable 'word' mit maximal 255 Zeichen. Es werden
+   solange Zeichen vom Terminal gelesen, bis ein Leerzeichen oder #schl("CR")# eingegeben
+   wird. Dabei werden führende Leerzeichen übergeben. Der einzulesende Text
+   kann bei der Eingabe editiert werden. Eine leere Eingabe ist nicht erlaubt. 
+ 
+   #on("b")#PROC get (TEXT VAR word, INT CONST laenge) #off("b")# 
+   Liest einen Text vom Bildschirm mit der Länge 'laenge' oder bis #schl("CR")# eingegeben
+   wird. Der einzulesende Wert kann bei der Eingabe editiert werden. 
+ 
+   #on("b")#PROC get (TEXT VAR word, TEXT CONST separator) #off("b")# 
+   Liest einen Text vom Bildschirm, bis ein Zeichen 'separator' angetroffen oder #schl("CR")#
+   eingegeben wird. Der einzulesende Text kann bei der Eingabe editiert werden. 
+ 
+ 
+'getline' 
+   #on("b")#PROC get line (TEXT VAR line) #off("b")# 
+   Das System wartet auf eine Zeile vom Bildschirm (max. 255 Zeichen). #schl("CR")# been­
+   det die Eingabe. 
+ 
+#page# 
+
+5.5.1.5  Ausgabe 
+ 
+
+Grundlegende Prozeduren
+Die folgenden Prozeduren dienen ausschließlich der Ausgabe auf das Terminal. 
+ 
+ 
+'cout' 
+   #on("b")#PROC cout (INT CONST number) #off("b")# 
+   Schreibt 'number' an die aktuelle Cursor-Position auf den Bildschirm. Anschlie­
+   ßend wird an diese Position wieder zurück positioniert. 'number' muß > 0 sein.
+   Paßt 'number' nicht mehr auf die Zeile, so ist die Wirkung von 'cout' nicht de­
+   finiert. 'cout' gibt den Wert von 'number' nur aus, wenn genügend freie Kanal-
+   Kapazität für diese Ausgabe vorhanden ist. Das hat zur Folge, daß Programme
+   nicht auf die Beendigung einer Ausgabe von 'number' warten müssen und ggf.
+   Ausgaben überschlagen werden. 
+ 
+ 
+'out' 
+   #on("b")#PROC out (TEXT CONST text) #off("b")# 
+   Ausgabe eines Textes auf dem Bildschirm. Im Unterschied zu 'put' wird kein
+   Blank an den ausgegebenen Text angefügt. 
+ 
+ 
+ 
+'out subtext' 
+   #on("b")#PROC out subtext (TEXT CONST source, INT CONST from) #off("b")# 
+   Ausgabe eines Teiltextes von 'source' von der Position 'from' bis Textende. Es
+   wird keine Aktion vorgenommen für 
+ 
+ 
+              from > LENGTH source 
+ 
+ 
+   #on("b")#PROC out subtext (TEXT CONST source, INT CONST from, to)#off("b")# 
+   Ausgabe eines Teiltextes von 'source' von der Position 'from' bis zur Position 'to'.
+   Für 
+ 
+ 
+              to > LENGTH source 
+ 
+ 
+   wird out subtext (source, from) ausgeführt. 
+ 
+   #on("b")#PROC out text (TEXT CONST source, INT CONST from, to) #off("b")# 
+   Ausgabe eines Teiltextes von 'source' von der Position 'from' bis zur Position 'to'.
+   Für 
+ 
+ 
+              to > LENGTH source 
+ 
+ 
+   wird für die fehlenden Zeichen Blanks ausgegeben. 
+ 
+ 
+ 
+'TIMESOUT' 
+   #on("b")#OP TIMESOUT (INT CONST times, TEXT CONST text) #off("b")# 
+   Ausgabe eines TEXTes 'text' 'times'mal. An die Ausgabe wird im Gegensatz zu
+   'put' kein Leerzeichen angefügt. Es wird kein Text ausgegeben für 
+ 
+ 
+              times < 1 
+ 
+ 
+#page# 
+
+Umleitbare Ausgabeprozeduren
+Die folgenden Ausgabeprozeduren schreiben ebenfalls auf das Terminal, die Ausgabe
+kann jedoch durch die Prozedur 'sysout' umgeleitet werden. Falls in 'sysout' eine
+Datei angegeben wird wird die Ausgabe statt zum 
+Terminal in die angegebene Datei geleitet. 
+ 
+ 
+'sysout' 
+   #on("b")#PROC sysout (TEXT CONST file name) #off("b")# 
+   Ausgabe-Routinen gehen nicht mehr zum Benutzer-Terminal, sondern in die
+   Datei 'file name'. 
+ 
+   #on("b")#TEXT PROC sysout #off("b")# 
+   Liefert den Namen der eingestellten 'sysout'-Datei. "" bezeichnet das Benut­
+   zer-Terminal. 
+ 
+ 
+'line' 
+   #on("b")#line#off("b")# 
+   Positionierung auf den Anfang einer neuen Ausgabezeile. 
+ 
+   #on("b")#line (INT CONST faktor)#off("b")# 
+   Nächste Ausgabezeile um 'faktor' Zeilen weiter positionieren. 
+ 
+ 
+'put' 
+   #on("b")#PROC put (INT CONST number) #off("b")# 
+   Ausgabe eines INT-Wertes auf dem Bildschirm. Anschließend wird ein Leer­
+   zeichen ausgegeben. 
+ 
+   #on("b")#PROC put (REAL CONST real) #off("b")# 
+   Ausgabe eines REAL-Wertes auf dem Bildschirm. Anschließend wird ein Leer­
+   zeichen ausgegeben. 
+ 
+   #on("b")#PROC put (TEXT CONST text) #off("b")# 
+   Ausgabe eines Textes auf dem Bildschirm. Nach der Ausgabe von 'text' wird ein
+   Blank ausgegeben, um nachfolgenden Ausgaben auf der gleichen Zeile voneinan­
+   der zu trennen. Hardwareabhängig sind die Aktionen, wenn eine Ausgabe über
+   eine Zeilengrenze (hier: Bildschirmzeile) vorgenommen wird. Meist wird die Ausga­
+   be auf der nächsten Zeile fortgesetzt. 
+ 
+ 
+'putline' 
+   #on("b")#PROC putline (TEXT CONST text) #off("b")# 
+   Ausgabe von 'text' auf dem Bildschirm. Nach der Ausgabe wird auf den Anfang
+   der nächsten Zeile positioniert. Gibt man TEXTe nur mit 'putline' aus, so ist
+   gesichert, daß jede Ausgabe auf einer neuen Zeile beginnt. Hardwareabhängig
+   sind die Aktionen, wenn eine Ausgabe über eine Zeilengrenze (hier: Bildschirm­
+   zeile) vorgenommen wird. Meist wird die Ausgabe auf der nächsten Zeile fort­
+   gesetzt. 
+ 
+ 
+'write' 
+   #on("b")#PROC write (TEXT CONST text) #off("b")# 
+   Gibt 'text' ohne Trennblank aus ('put' mit Trennblank). 
+ 
+#page# 
+ 
+5.5.1.6  Kontrolle 
+ 
+'online' 
+   #on("b")#BOOL PROC online #off("b")# 
+   Liefert TRUE, wenn die Task mit einem Terminal gekoppelt ist. 
+ 
+ 
+'pause' 
+   #on("b")#PROC pause (INT CONST time limit) #off("b")# 
+   Wartet 'time limit' in Zehntel-Sekunden. Bei negativen Werten ist die Wirkung
+   nicht definiert. Die Wartezeit wird nicht nur durch das Erreichen der Grenze ab­
+   gebrochen, sondern auch durch die Eingabe eines beliebigen Zeichens. 
+ 
+   #on("b")#PROC pause#off("b")# 
+   Wartet bis zur Eingabe eines beliebigen Zeichens. 
+ 
+ 
+#page# 
+ 
+5.5.2  Zeitmessung 
+ 
+'clock' 
+   #on("b")#REAL PROC clock (INT CONST index) #off("b")# 
+   Datum und Uhrzeit werden vom EUMEL-System für alle Tasks geführt. Neben
+   einer Uhr ('Realzeituhr'), die das Datum und die aktuelle Uhrzeit enthält, wird eine
+   Uhr für die von der Task verbrauchte CPU-Zeit geführt ('CPU-Zeituhr'). Beide
+   Zeiten werden vom System als REALs realisiert. Die Prozedur 'clock' liefert die
+   aktuellen Werte dieser Uhren. Bei 'index = 0' wird die akkumulierte CPU-Zeit
+   der Task, bei 'index = 1' der Wert der Realzeituhr geliefert. 
+ 
+   Mit den REAL-Werten der Uhren kann ohne weiteres gerechnet werden, jedoch
+   sind nur Werte > 0 definiert. Die REAL-Werte der Realzeituhr beginnen beim
+   1.1.1900 um 0 Uhr. Es sind nur Werte für dieses Jahrhundert zugelassen. Werte
+   der Realzeituhr in lesbarer Form kann man durch die Konvertierungsprozeduren
+   'date' (vergl. 5- #topage("date")# ) (für den aktuellen Tag) und 'time of day' (Uhrzeit, vergl.
+   5-#topage("time")#) erhalten. 
+ 
+   Um die benötigte CPU-Zeit eines Programms zu berechnen, muß man die
+   CPU-Zeituhr zweimal abfragen. Um solche Zeiten in lesbarer Form zu erhalten,
+   kann man die Konvertierungsprozedur 'time' (vergl. 5- #topage("time")#) verwenden. Beispiel: 
+ 
+____________________________________________________________________________ 
+ 
+ ........................... Beispiel .......................... 
+        REAL CONST anfang :: clock (0); 
+              berechnungen; 
+        REAL CONST ende   :: clock (0); 
+           put ("benoetigte CPU-Zeit in Sek:"); 
+           put (time (ende - anfang)) 
+ 
+____________________________________________________________________________ 
+#page# 
+'date' 
+#goalpage("date")# 
+   #on("b")#TEXT PROC date (REAL CONST time) #off("b")# 
+   Konvertierungsprozedur für das Datum, welches sich aus dem Aufruf der Prozedur
+   'clock (1)' ergibt. Das Datum wird in der Form 'tt.mm.jj' geliefert. Beispiel: 
+ 
+____________________________________________________________________________ 
+ 
+           put (date (clock (1)))  (* z.B.: 24.12.87 *) 
+ 
+____________________________________________________________________________ 
+ 
+ 
+   #on("b")#REAL PROC date (TEXT CONST datum) #off("b")# 
+   Konvertierungsprozedur für ein Datum in der Form 'tt.mm.jj'. Liefert einen
+   REAL-Wert, wie ihn die Prozedur 'clock (1)' liefern würde. Beispiel: 
+ 
+____________________________________________________________________________ 
+ 
+              put (date ("24.12.87")) (* 6.273539e10 *) 
+ 
+____________________________________________________________________________ 
+ 
+ 
+   #on("b")#TEXT PROC date#off("b")# 
+   Liefert das Tagesdatum. Wirkt wie 'date (clock (1))', ist jedoch erheblich schneller. 
+ 
+ 
+ 
+'day' 
+   #on("b")#REAL CONST day #off("b")# 
+   Liefert die Anzahl der Sekunden eines Tages (86 400.0). 
+ 
+ 
+ 
+'hour' 
+   #on("b")#REAL CONST hour #off("b")# 
+   Liefert die Anzahl der Sekunden einer Stunde (3600.0). 
+ 
+ 
+ 
+'pause' 
+   #on("b")#PROC pause (INT CONST time limit) #off("b")# 
+   Wartet 'time limit' in Zehntel-Sekunden. Bei negativen Werten ist die Wirkung
+   nicht definiert. Die Wartezeit wird nicht nur durch das Erreichen der Grenze ab­
+   gebrochen, sondern auch durch die Eingabe eines beliebigen Zeichens. 
+ 
+ 
+ 
+'time' 
+#goalpage("time")# 
+   #on("b")#TEXT PROC time (REAL CONST time) #off("b")# 
+   Konvertierungsprozedur für die Zeiten der CPU-Zeituhr. Liefert die Zeiten in der
+   Form 'hh:mm:ss.s'. Vergl. dazu 'clock'. 
+ 
+   #on("b")#TEXT PROC time (REAL CONST value, INT CONST laenge) #off("b")# 
+   Konvertiert die Zeit in externe Darstellung. Für die 'laenge'-Werte ergibt sich: 
+ 
+ 
+        laenge = 10              (*   hh:mm:ss.s *) 
+        laenge = 12              (* hhhh:mm:ss.s *) 
+ 
+ 
+ 
+   #on("b")#REAL PROC time (TEXT CONST time) #off("b")# 
+   Konvertierungsprozedur für Texte der CPU-Zeituhr in REAL-Werte. 
+ 
+ 
+ 
+'time of day' 
+   #on("b")#TEXT PROC time of day (REAL CONST time) #off("b")# 
+   Konvertierungsprozedur für REALs, wie sie die Realzeituhr 
+   liefert. Es wird die Tageszeit in der Form 'hh:mm' geliefert. Beispiel: 
+ 
+____________________________________________________________________________ 
+ 
+              put (time of day (clock (1)))  (* z.B.: 17:25 *) 
+ 
+____________________________________________________________________________ 
+ 
+ 
+   #on("b")#TEXT PROC time of day #off("b")# 
+   Liefert die aktuelle Tageszeit. Entspricht 
+ 
+____________________________________________________________________________ 
+ 
+              time of day (clock (1)) 
+ 
+____________________________________________________________________________ 
+#page# 
+
+5.6  Scanner
+ 
+Der Scanner kann benutzt werden, um festzustellen, welche Art von Symbolen in
+einem TEXT enthalten sind. Die Repräsentation der Symbole müssen dabei der
+ELAN-Syntax entsprechen. Folgende #ib#Symbole#ie# kann der Scanner erkennen: 
+ 
+   - "tags", d.h. Namen, 
+   - "bolds", d.h. Schlüsselworte, 
+   - "number", d.h. INT oder REAL Zahlen, 
+   - Operatoren, 
+   - "delimiter", d.h. Begrenzer wie z.B. ";", 
+   - und das Ende des Scan-Textes. 
+ 
+ 
+Der Scanner überliest Kommentare und Leerzeichen zwischen den Symbolen. Der
+(erste) zu verarbeitende Text muß mit der Prozedur 
+ 
+ 
+     #ib#scan#ie# 
+ 
+ 
+in den Scanner "hineingesteckt" werden. Mit der Prozedur 
+ 
+ 
+     #ib#next symbol#ie# 
+ 
+ 
+wird das jeweils nächste Symbol des TEXTes geholt. Am Ende wird "end of scan"
+und als Symbol 'niltext' geliefert. Falls innerhalb eines TEXT-Denoters oder eines
+Kommentars "end of scan" auftritt, wird "within text" bzw. "within comment" gemel­
+det. Der Scan-Prozeß kann dann mit dem nächsten zu scannenden TEXT (der
+nächsten Zeile) fortgesetzt werden. Dafür wird nicht die Prozedur 'scan', sondern 
+ 
+ 
+     #ib#continue scan#ie# 
+ 
+ 
+verwandt. Sie setzt im letzten Scan-Zustand (z.B. Kommentar oder TEXT-Deno­
+ter) wieder auf, so daß auch Folgen von TEXTen (Zeilen) wie z.B. Dateien leicht
+gescannt werden können. 
+ 
+Mit den Prozeduren 
+ 
+ 
+     scan              (* meldet eine Datei zum scannen an *) 
+     next symbol       (* holt die Symbole                 *) 
+ 
+ 
+kann man auch eine Datei nach ELAN-Symbolen untersuchen. 
+ 
+____________________________________________________________________________ 
+ 
+     FILE VAR f :: ... 
+     ... 
+     scan (f);          (* beginnt das Scanning in 
+                           der nächsten Zeile      *) 
+     TEXT VAR symbol; 
+     INT VAR type; 
+     REP 
+       next symbol (f, symbol, type); 
+       verarbeite symbol 
+     UNTIL type >= 7 END REP. 
+ 
+____________________________________________________________________________ 
+ 
+#page# 
+ 
+Scanner-Kommandos 
+ 
+ 
+'continue scan' 
+   #on("b")#PROC continue scan (TEXT CONST scan text) #off("b")# 
+   Das Scanning soll mit 'scan text' fortgesetzt werden. Falls der Scan-Vorgang
+   beim vorigen 'scan text' innerhalb eines TEXT-Denoters oder eines Kommentars
+   abgebrochen wurde, wird er jetzt entsprechend mit dem nächsten 'next symbol'
+   fortgesetzt. Der erste Teil-Scan einer Folge muß aber stets mit 'scan' eingeleitet
+   werden! 
+ 
+'next symbol' 
+   #on("b")#PROC next symbol (TEXT VAR symbol, INT VAR type) #off("b")# 
+   Holt das nächste Symbol. In "symbol" steht der TEXT des Symbols, so z.B. die
+   Ziffern eines INT-Denoters. Bei TEXT-Denotern werden die führenden und
+   abschließenden Anführungsstriche abgeschnitten. Leerzeichen oder Kommentare
+   spielen in "tags" oder "numbers" keine Rolle. Zwischen Symbolen spielen Leer­
+   zeichen oder Kommentare keine Rolle. In "type" steht eine Kennzeichung für den
+   Typ des Symbols: 
+ 
+               tag             = 1 , 
+               bold            = 2 , 
+               number          = 3 , 
+               text            = 4 , 
+               operator        = 5 , 
+               delimiter       = 6 , 
+               end of file     = 7 , 
+               within comment  = 8 , 
+               within text     = 9 . 
+ 
+   Wird Scan-Ende innerhalb eines Kommentars gefunden, so wird 'niltext' und
+   'within comment' geliefert. Wird Scan-Ende innerhalb eines TEXT-Denoters
+   gefunden, so wird der schon analysierte Teil des Denoters und 'within text' gelie­
+   fert. 
+ 
+   #on("b")#PROC next symbol (TEXT VAR symbol) #off("b")# 
+   s.o. Es wird aber nur der Text des Symbols (ohne Typ) geliefert. 
+ 
+   #on("b")#PROC next symbol (FILE VAR f, TEXT CONST symbol) #off("b")# 
+   Arbeitet wie obige Prozeduren, jedoch auf einen FILE. 
+ 
+   #on("b")#PROC next symbol (FILE VAR f, TEXT CONST symbol, INT VAR type)#off("b")# 
+   Arbeitet wie obige Prozeduren, jedoch auf einen FILE. 
+ 
+ 
+'scan' 
+   #on("b")#PROC scan (TEXT CONST scan text) #off("b")# 
+   Meldet einen 'scan text' für den Scanner zur Verarbeitung an. Die Prozedur 'scan'
+   muß vor dem ersten Aufruf von 'next symbol' gegeben werden. Im Gegensatz zu
+   'continue scan' normiert 'scan' den inneren Zustand des Scanners, d.h. vorherige
+   Scan-Vorgänge haben keinen Einfluß mehr auf das Scanning. 
+ 
+   #on("b")#PROC scan (FILE VAR f) #off("b")# 
+   Wie obige Prozedur, jedoch auf einen FILE. Die zu scannende Zeile ist die näch­
+   ste Zeile im FILE 'f' ('scan' macht zuerst ein 'getline'). 
+
diff --git a/doc/programmer-manual/1.8.7/doc/programmierhandbuch.6 b/doc/programmer-manual/1.8.7/doc/programmierhandbuch.6
new file mode 100644
index 0000000..ce11f6f
--- /dev/null
+++ b/doc/programmer-manual/1.8.7/doc/programmierhandbuch.6
@@ -0,0 +1,1441 @@
+#pagenr("%",1)##setcount(1)##block##pageblock# 
+#headeven# 
+#center#EUMEL-Benutzerhandbuch 
+#center#____________________________________________________________ 
+ 
+#end# 
+#headodd# 
+#center#TEIL 6 : Das Archiv 'std.zusatz' 
+#center#____________________________________________________________ 
+ 
+#end# 
+#bottomeven# 
+#center#____________________________________________________________ 
+6 - % #right#GMD 
+#end# 
+#bottomodd# 
+#center#____________________________________________________________ 
+GMD #right#6 - % 
+#end# 
+ 
+TEIL 6:  Das Archiv 'std.zusatz' 
+ 
+Das Archiv 'std.zusatz' enthält Pakete, die nur bei Bedarf insertiert werden sollen.
+Eine Einbindung in das EUMEL Grundsystem würde dieses ungebührlich unfangreich
+machen. 
+ 
+Das Archiv enthält zusätzliche Software für: 
+ 
+- mathematische Operationen :  complex , longint , vector , matrix 
+ 
+- Analyse                   :  reporter , referencer 
+ 
+- Taschenrechnerfunktion 
+  zur Editor-Erweiterung    :  TeCal , TeCal Auskunft 
+ 
+ 
+#page# 
+
+6.1.  Erweiterungen um 
+      Mathematische Operationen
+ 
+ 
+6.1.1  COMPLEX 
+ 
+Das Packet COMPLEX erweitert das System um den Datentyp COMPLEX (komplexe
+Zahlen) und Operationen auf komplexen Zahlen. Folgende Operationen stehen für
+COMPLEX zur Verfügung: 
+ 
+- Einfache Operatoren       :  := , = , <> , + ,- , * 
+ 
+- Eingabe/Ausgabe           :  get , put 
+ 
+- Denotierungsprozedur      :  complex , complex i , complex one , com­ 
+                               plex zero 
+ 
+- Komponenten               :  real part , imag part 
+ 
+- bes. Funktionen           :  ABS , CONJ , phi , dphi , sqrt 
+ 
+#page# 
+
+COMPLEX Operationen 
+ 
+ 
+'TYPE COMPLEX' 
+   Komplexe Zahl, bestehend aud Realteil 're' und Imaginärteil 'im'. 
+ 
+ 
+':=' 
+   #on("b")#OP := (COMPLEX VAR a, COMPLEX CONST b) #off("b")# 
+   Zuweisung. 
+ 
+ 
+'=' 
+   #on("b")#BOOL OP = (COMPLEX CONST a, b) #off("b")# 
+   Vergleich von 'a' und 'b' auf Gleichheit. 
+ 
+ 
+'<>' 
+   #on("b")#BOOL OP <> (COMPLEX CONST a, b) #off("b")# 
+   Vergleich von 'a' und 'b' auf Ungleichheit. 
+ 
+ 
+'+' 
+   #on("b")#COMPLEX OP + (COMPLEX CONST a, b) #off("b")# 
+   Summe von 'a' und 'b'. 
+ 
+ 
+'-' 
+   #on("b")#COMPLEX OP - (COMPLEX CONST a, b) #off("b")# 
+   Differenz von 'a' und 'b'. 
+ 
+ 
+'*' 
+   #on("b")#COMPLEX OP * (COMPLEX CONST a, b) #off("b")# 
+   Multiplikation von 'a' mit 'b'. 
+ 
+ 
+'/' 
+   #on("b")#COMPLEX OP / (COMPLEX CONST a, b) #off("b")# 
+   Division von 'a' mit 'b'. 
+ 
+#page# 
+'get' 
+   #on("b")#PROC get (COMPLEX VAR a) #off("b")# 
+   Einlesen eines komplexen Wertes vom Bildschirm in der Form zweier REAL-De­
+   noter. Die Eingabe kann editiert werden. 
+ 
+ 
+'put' 
+   #on("b")#PROC put (COMPLEX CONST a) #off("b")# 
+   Ausgabe eines komplexen Wertes auf dem Bildschirm in Form zweier REAL-
+   Werte. Hinter jedem REAL-Wert wird ein Leerzeichen angefügt. 
+ 
+ 
+'complex' 
+   #on("b")#COMPLEX PROC complex (REAL CONST re, im) #off("b")# 
+   Denotierungsprozedur. Angabe in kartesischen Koordinaten. 
+ 
+ 
+'complex i' 
+   #on("b")#COMPLEX PROC complex i #off("b")# 
+   Denotierungsprozedur für den komplexen Wert '0.0 + i 1.0'. 
+ 
+ 
+'complex one' 
+   #on("b")#COMPLEX PROC complex one #off("b")# 
+   Denotierungsprozedur für den komplexen Wert '1.0 + i 0.0'. 
+ 
+ 
+'complex zero' 
+   #on("b")#COMPLEX PROC complex zero #off("b")# 
+   Denotierungsprozedur für den komplexen Wert '0.0 + i 0.0'. 
+ 
+ 
+'imag part' 
+   #on("b")#REAL PROC imag part (COMPLEX CONST number) #off("b")# 
+   Liefert den Imaginärteil des komplexen Wertes 'number'. 
+ 
+ 
+'real part' 
+   #on("b")#REAL PROC real part (COMPLEX CONST number) #off("b")# 
+   Liefert den Real-Teil des komplexen Wertes 'number'. 
+ 
+ 
+'ABS' 
+   #on("b")#REAL OP ABS (COMPLEX CONST x) #off("b")# 
+   REAL-Betrag von 'x'. 
+ 
+ 
+'CONJ' 
+   #on("b")#COMPLEX OP CONJ (COMPLEX CONST number) #off("b")# 
+   Liefert den konjugiert komplexen Wert von 'number'. 
+ 
+ 
+'dphi' 
+   #on("b")#REAL PROC dphi (COMPLEX CONST x) #off("b")# 
+   Winkel von 'x' (Polardarstellung). 
+ 
+ 
+'phi' 
+   #on("b")#REAL PROC phi (COMPLEX CONST x) #off("b")# 
+   Winkel von 'x' (Polardarstellung) in Radiant. 
+ 
+ 
+'sqrt' 
+   #on("b")#COMPLEX PROC sqrt (COMPLEX CONST x) #off("b")# 
+   Wurzelfunktion für komplexe Werte. 
+ 
+#page# 
+
+6.1.2  LONGINT 
+ 
+LONGINT ist ein Datentyp, für den (fast) alle Prozeduren und Operatoren des Daten­
+typs INT implementiert wurden. LONGINT unterscheidet sich von INT dadurch, daß
+erheblich größere Werte darstellbar sind. 
+ 
+Für den Datentyp LONGINT stehen folgende Operationen zur Verfügung: 
+ 
+- Operatoren                :  := , = , <> , < , <= ,> , >= , + , - , * , 
+                               ** , 
+                               ABS , DECR , DIV , INCR , MOD , SIGN 
+ 
+- Eingabe/Ausgabe           :  get , put 
+ 
+ 
+- Math. Prozeduren          :  abs , int , longint , max , max logint , min , 
+                               random , sign , text , zero 
+ 
+ 
+ 
+LONGINT-Operationen 
+ 
+ 
+'TYPE LONGINT' 
+   Datentyp 
+ 
+ 
+':=' 
+   #on("b")#OP := (LONGINT VAR links, LONGINT CONST rechts) : #off("b")# 
+   Zuweisungsoperator 
+ 
+ 
+'= ' 
+   #on("b")#BOOL OP = (LONGINT CONST links, rechts) #off("b")# 
+   Vergleichen zweier LONGINTs auf Gleichheit. 
+ 
+ 
+'<>' 
+   #on("b")#BOOL OP <> (LONGINT CONST links, rechts) #off("b")# 
+   Vergleichen zweier LONGINTs auf Ungleichheit. 
+ 
+ 
+'< ' 
+   #on("b")#BOOL OP < (LONGINT CONST links, rechts) #off("b")# 
+   Vergleichen zweier LONGINTs auf kleiner. 
+ 
+ 
+'<=' 
+   #on("b")#BOOL OP <= (LONGINT CONST links, rechts) #off("b")# 
+   Vergleichen zweier LONGINTs auf kleiner gleich. 
+ 
+ 
+'> ' 
+   #on("b")#BOOL OP > (LONGINT CONST links, rechts) #off("b")# 
+   Vergleichen zweier LONGINTs auf größer. 
+ 
+ 
+'>=' 
+   #on("b")#BOOL OP >= (LONGINT CONST links, rechts) #off("b")# 
+   Vergleichen zweier LONGINTs auf größer gleich. 
+ 
+ 
+'+ ' 
+   #on("b")#LONGINT OP + (LONGINT CONST argument) #off("b")# 
+   Monadischer Operator. Ohne Wirkung. 
+ 
+   #on("b")#LONGINT OP + (LONGINT CONST links, rechts) #off("b")# 
+   Addition zweier LONGINTs. 
+ 
+ 
+'- ' 
+   #on("b")#LONGINT OP - (LONGINT CONST argument) #off("b")# 
+   Vorzeichenumkehrung. 
+ 
+   #on("b")#LONGINT OP - (LONGINT CONST links, rechts) #off("b")# 
+   Subtraktion zweier LONGINTs. 
+ 
+ 
+'* ' 
+   #on("b")#LONGINT OP * (LONGINT CONST links, rechts) #off("b")# 
+   Multiplikation von zwei LONGINTs. 
+ 
+ 
+'**' 
+   #on("b")#LONGINT OP ** (LONGINT CONST argument, exponent) #off("b")# 
+   Exponentiation zweier LONGINTs mit positivem Exponenten. 
+ 
+   FEHLER : 
+            LONGINT OP ** : negative exponent 
+            Der 'exponent' muß >= 0 sein. 
+            0 ** 0 is not defined 
+            'argument' und 'exponent' dürfen nicht gleich 0 sein. 
+ 
+ 
+   #on("b")#LONGINT OP ** (LONGINT CONST argument, INT CONST exponent)#off("b")# 
+   Exponentiation eines LONGINT mit positiven INT Exponenten. 
+ 
+   FEHLER : 
+            LONGINT OP ** : negative exponent 
+            Der 'exponent' muß >= 0 sein. 
+            0 ** 0 is not defined 
+            'argument' und 'exponent' dürfen nicht gleich 0 sein. 
+ 
+'ABS' 
+   #on("b")#LONGINT OP ABS (LONGINT CONST argument) #off("b")# 
+   Absolutbetrag eines LONGINT. 
+ 
+ 
+'DECR' 
+   #on("b")#OP DECR (LONGINT VAR resultat, LONGINT CONST ab) #off("b")# 
+   resultat := resultat - ab 
+ 
+ 
+'DIV' 
+   #on("b")#LONGINT OP DIV (LONGINT CONST links, rechts) #off("b")# 
+   Division zweier LONGINTs. 
+ 
+   FEHLER : 
+             Division durch 0 
+            'rechts' muß <> 0 sein. 
+ 
+ 
+'INCR' 
+   #on("b")#LONGINT OP INCR (LONGINT VAR resultat, LONGINT CONST dazu)#off("b")# 
+   resultat := resultat + dazu 
+ 
+ 
+ 
+'MOD' 
+   #on("b")#LONGINT OP MOD (LONGINT CONST links, rechts) #off("b")# 
+   Modulo-Funktion für LONGINTs. Der Rest einer LONGINT-Division wird ermit­
+   telt. 
+ 
+   FEHLER : 
+           text (links) + 'MOD 0' 
+           'rechts' muß ungleich null sein. 
+ 
+ 
+'SIGN' 
+   #on("b")#INT OP SIGN (LONGINT CONST longint) #off("b")# 
+   Feststellen des Vorzeichens von 'longint'. Liefert: 
+ 
+ 
+           0 wenn 'longint' = 0, 
+           1 wenn 'longint' > 0, 
+          -1 wenn 'longint' < 0. 
+ 
+ 
+#page# 
+'get' 
+   #on("b")#PROC get (LONGINT VAR zahl) #off("b")# 
+   Eingabe eines LONGINTs vom Terminal. 
+ 
+   #on("b")#PROC get (FILE VAR file, LONGINT VAR zahl) #off("b")# 
+   Einlesen von 'zahl' aus der sequentiellen Datei 'file'. Die Datei muß mit 'input'
+   assoziiert sein (vergl. 'sequential file'). 
+ 
+   FEHLER : 
+           Datei zu 
+           Leseversuch nach Daateiende 
+           Leseversuch auf output-FILE 
+ 
+ 
+'put' 
+   #on("b")#PROC put (LONGINT CONST longint) #off("b")# 
+   Ausgabe eines LONGINTs auf dem Bildschirm. Anschließend wird ein Leerzeichen
+   ausgegeben. Hardwareabhängig sind die Aktionen, wenn eine Ausgabe über die
+   Bildschirmzeilengrenze vorgenommen wird. Meist wird jedoch die Ausgabe auf der
+   nächsten Zeile fortgesetzt. 
+ 
+   #on("b")#PROC put (FILE VAR file, LONGINT CONST zahl) #off("b")# 
+   Ausgabe von 'zahl' in die sequentielle Datei 'file'. 'file' muß mit 'output' assoziiert
+   sein. 
+ 
+   FEHLER : 
+           Datei zu 
+           Schreibversuch auf input-FILE 
+#page# 
+'abs' 
+   #on("b")#LONGINT PROC abs (LONGINT CONST argument) #off("b")# 
+   Absolutbetrag eines LONGINT. 
+ 
+ 
+'int' 
+   #on("b")#INT PROC int (LONGINT CONST longint) #off("b")# 
+   Konvertierung von LONGINT nach INT. 
+ 
+   FEHLER : 
+           integer overflow 
+           'longint' ist größer als 'maxint'. 
+ 
+ 
+'longint' 
+   #on("b")#LONGINT PROC longint (INT CONST int) #off("b")# 
+   Konvertierung von 'int' nach LONGINT. 
+ 
+   #on("b")#LONGINT PROC longint (TEXT CONST text) #off("b")# 
+   Konvertierung von 'text' nach LONGINT. 
+ 
+ 
+'max' 
+   #on("b")#LONGINT PROC max (LONGINT CONST links, rechts) #off("b")# 
+   Liefert das Maximum zweier LONGINTs. 
+ 
+ 
+'maxlongint' 
+   #on("b")#LONGINT PROC max longint #off("b")# 
+   Liefert größten LONGINT Wert. 
+ 
+ 
+'min' 
+   #on("b")#LONGINT PROC min (LONGINT CONST links, rechts) #off("b")# 
+   Liefert das Minimum zweier LONGINTs. 
+ 
+ 
+'random' 
+   #on("b")#LONGINT PROC random (LONGINT CONST lower bound, upper bound)#off("b")# 
+   Pseudo-Zufallszahlen-Generator im Intervall 'lower bound' und 'upper bound'
+   einschließlich. Es handelt sich hier um den 'LONGINT Random Generator'. 
+ 
+ 
+'sign' 
+   #on("b")#INT PROC sign (LONGINT CONST longint) #off("b")# 
+   Feststellen des Vorzeichens von 'longint'. Liefert: 
+ 
+ 
+           0 wenn 'longint' = 0, 
+           1 wenn 'longint' > 0, 
+          -1 wenn 'longint' < 0. 
+ 
+ 
+ 
+'text' 
+   #on("b")#TEXT PROC text (LONGINT CONST longint) #off("b")# 
+   Konvertierung von 'longint' nach TEXT. 
+ 
+   #on("b")#TEXT PROC text (LONGINT CONST longint, INT CONST laenge) #off("b")# 
+   Konvertierung von 'longint' nach TEXT. Die Anzahl der Zeichen soll 'laenge'
+   betragen. Für 
+ 
+ 
+           LENGTH (text (longint)) < laenge 
+ 
+ 
+   werden die Zeichen rechtsbündig in einen Text mit der Länge 'laenge' eingetra­
+   gen. Ist der daraus entstehende TEXT kleiner als 'laenge', werden die an 'laenge'
+   fehlenden Zeichen im TEXT mit Leerzeichen aufgefüllt. Für 
+ 
+ 
+          LENGTH (text (longint)) > laenge 
+ 
+ 
+   wird ein Text mit der Länge 'laenge' geliefert, der mit '*'-Zeichen gefüllt ist. 
+ 
+ 
+'zero' 
+   #on("b")#LONGINT PROC zero #off("b")# 
+   Liefert LONGINT Wert Null. 
+ 
+ 
+#page# 
+
+6.1.3  VECTOR 
+ 
+Der Datentyp VECTOR erlaubt Operationen auf Vektoren aus Elementen vom Typ
+REAL. Im Gegensatz zur Struktur 'ROW m REAL' muß die Anzahl der Elemente nicht
+zur Übersetzungszeit deklariert werden, sondern kann zur Laufzeit festgelegt werden.
+Somit kann eine zur Übersetzungszeit unbekannte Anzahl von REALs bearbeitet
+werden, wobei nur soviel Speicherplatz wie nötig verwendet wird. Die maximale Größe
+eines VECTOR beträgt 4000 Elemente. 
+ 
+Der in den Operationen ':=', 'idn' und 'vector' benutzte Datentyp INITVECTOR wird
+nur intern gehalten. Er dient der Speicherplatzersparnis bei der Initialisierung. 
+ 
+ 
+- Operatoren                :  := , = , <> , + , - , * , / 
+                               LENGTH , SUB 
+ 
+- Eingabe/Ausgabe           :  get , put 
+ 
+- Besondere Vector-         :  length , nilvector , norm , vector , replace 
+  Operationen 
+ 
+#page# 
+':=' 
+   #on("b")#OP := (VECTOR VAR ziel, VECTOR CONST quelle) #off("b")# 
+   Zuweisung. Nach der Zuweisung gilt auch 
+ 
+ 
+           length (quelle) = length (ziel) 
+ 
+ 
+   d.h. der linke Operand besitzt nach der Zuweisung genauso viele Elemente wie
+   'quelle', unabhängig davon, ob 'ziel' vor der Zuweisung mehr oder weniger Ele­
+   mente als 'quelle' besaß. Beispiel: 
+ 
+ 
+           VECTOR VAR y :: vector (10, 1.0), 
+                      z :: vector (15, 2.0); 
+                ... 
+           y := z; (* length (y) liefert nun 15 ! *) 
+ 
+ 
+   #on("b")#OP := (VECTOR VAR ziel, INITVECTOR CONST quelle) #off("b")# 
+   Dient zur Initialisierung eines VECTORs. Beispiel: 
+ 
+ 
+           VECTOR VAR x :: vector (17); 
+ 
+ 
+   'vector' erzeugt ein Objekt vom Datentyp INITVECTOR. Dieses Objekt braucht
+   nicht soviel Speicherplatz wie ein VECTOR-Objekt. Dadurch wird vermieden, daß
+   nach erfolgter Zuweisung nicht ein durch 'vector' erzeugtes Objekt auf dem Heap
+   unnötig Speicherplatz verbraucht. 
+ 
+ 
+'=' 
+   #on("b")#BOOL OP = (VECTOR CONST a, b) #off("b")# 
+   Vergleich zweier Vektoren. Der Operator liefert FALSE, wenn die Anzahl der
+   Elemente von 'a' und 'b' ungleich ist oder wenn zwei Elemente mit gleichem
+   Index ungleich sind. Beispiel: 
+ 
+ 
+           VECTOR VAR x :: vector (10, 1.0), 
+                      y :: vector (15, 2.0), 
+                      z :: vector (10, 1.0); 
+                   ... x = y ... (* FALSE *) 
+                   ... x = z ... (* TRUE  *) 
+ 
+ 
+'<>' 
+   #on("b")#BOOL OP <> (VECTOR CONST a, b) #off("b")# 
+   Vergleich zweier Vektoren auf Ungleichheit (NOT (a = b)). 
+ 
+ 
+'+' 
+   #on("b")#VECTOR OP + (VECTOR CONST a) #off("b")# 
+   Monadisches '+' für VECTOR. Keine Auswirkung. 
+ 
+   #on("b")#VECTOR OP + (VECTOR CONST a, b) #off("b")# 
+   Elementweise Addition der Vektoren 'a' und 'b'. Beispiel: 
+ 
+ 
+           VECTOR VAR x, (* 'x' hat undefinierte Länge *) 
+                      a :: vector (10, 1.0), 
+                      b :: vector (10, 2.0); 
+                 ... 
+           x := a + b; (* 'x' hat nun 10 Elemente mit Werten'3.0'
+           *) 
+ 
+   FEHLER : 
+           VECTOR OP + : LENGTH a <> LENGTH b 
+           'a' und 'b' haben nicht die gleiche Anzahl von Elementen. 
+ 
+ 
+'-' 
+   #on("b")#VECTOR OP - (VECTOR CONST a) #off("b")# 
+   Monadisches '-'. 
+ 
+   #on("b")#VECTOR OP - (VECTOR CONST a, b) #off("b")# 
+   Elementweise Subtraktion der Vektoren 'a' und 'b'. 
+ 
+   FEHLER : 
+           VECTOR OP - : LENGTH a <> LENGTH b 
+           'a' und 'b' haben nicht die gleiche Anzahl von Elementen. 
+ 
+'*' 
+   #on("b")#REAL OP * (VECTOR CONST a, b) #off("b")# 
+   Skalarprodukt zweier Vektoren. Liefert die Summe der elementweisen Multiplika­
+   tion der Vektoren 'a' und 'b'. Beachte eventuelle Rundungsfehler! Beispiel: 
+ 
+ 
+           REAL VAR a; 
+           VECTOR VAR b :: vector (10, 2.0), 
+                      c :: vector (10, 2.0); 
+                 ... 
+           a := b * c; (* 40.0 *) 
+ 
+   FEHLER : 
+           REAL OP * : LENGTH a <> LENGTH b 
+           'a' und 'b' haben nicht die gleiche Anzahl von Elementen. 
+ 
+   #on("b")#VECTOR OP * (VECTOR CONST a, REAL CONST s) #off("b")# 
+   Multiplikation des Vektors 'a' mit dem Skalar 's'. 
+ 
+   #on("b")#VECTOR OP * (REAL CONST s, VECTOR CONST a) #off("b")# 
+   Multiplikation des Skalars 's' mit dem Vektor 'a'. 
+ 
+ 
+'/' 
+   #on("b")#VECTOR OP / (VECTOR CONST a, REAL CONST s) #off("b")# 
+   Division des Vektors 'a' durch den Skalar 's'. Beispiel: 
+ 
+ 
+           VECTOR VAR a, (* 'a' hat undefinierte Laenge *) 
+                      b :: vector (10, 4.0); 
+                ... 
+           a := b / 2.0; 
+           (* 'a' hat nun 10 Elemente mit Werten '2.0' *) 
+ 
+ 
+ 
+'LENGTH' 
+   #on("b")#INT OP LENGTH (VECTOR CONST a) #off("b")# 
+   Liefert die Anzahl der Elemente von 'a'. 
+ 
+ 
+'SUB' 
+   #on("b")#REAL OP SUB (VECTOR CONST v, INT CONST i) #off("b")# 
+   Liefert das 'i'-te Element von 'v'. 
+ 
+   FEHLER : 
+           OP SUB : subscript overflow 
+           Der Index 'i' liegt außerhalb des Vektors (i > LENGTH v). 
+           OP SUB : subscript underflow 
+           Der Index 'i' liegt außerhalb des Vektors (i < 1). 
+ 
+#page# 
+'get' 
+   #on("b")#PROC get (VECTOR VAR a, INT CONST l) #off("b")# 
+   Einlesen der Elemente von 'a' vom Terminal, wobei 'l' die Anzahl der Elemente
+   angibt. 
+ 
+   FEHLER : 
+           PROC get : size <= 0 
+           Die angeforderte Elementanzahl 'l' muß > 0 sein. 
+ 
+ 
+'put' 
+   #on("b")#PROC put (VECTOR CONST v) #off("b")# 
+   Ausgabe der Werte der Elemente von 'v' auf dem Terminal. 
+ 
+ 
+#page# 
+'length' 
+   #on("b")#INT PROC length (VECTOR CONST a) #off("b")# 
+   Liefert die Anzahl der Elemente von 'a'. Beispiel: 
+ 
+ 
+           VECTOR VAR a :: vector (10, 1.0), 
+                      b :: vector (15, 2.0); 
+                ... 
+            ... length (a) ... (* 10 *) 
+            ... length (b) ... (* 15 *) 
+ 
+ 
+ 
+'nilvector' 
+   #on("b")#INITVECTOR PROC nilvector #off("b")# 
+   Erzeugen eines Vektors mit einem Element mit dem Wert '0.0'. 
+ 
+ 
+'norm' 
+   #on("b")#REAL PROC norm (VECTOR CONST v) #off("b")# 
+   Euklidische Norm (Wurzel aus der Summe der Quadrate der Elemente). 
+ 
+ 
+ 
+'replace' 
+   #on("b")#PROC replace (VECTOR VAR v, INT CONST i, REAL CONST r)#off("b")# 
+   Zuweisung des i-ten Elementes von 'v' mit dem Wert von 'r'. Beispiel: 
+ 
+ 
+           VECTOR VAR v :: ...; 
+               ... 
+           replace (v, 13, 3.14); 
+           (* Das 13. Element von 'v' bekommt den Wert '3.14' *) 
+ 
+   FEHLER : 
+           PROC replace : subscript overflow 
+           Der Index 'i' liegt außerhalb des Vektors (i > LENGTH v). 
+           PROC replace : subscript underflow 
+           Der Index 'i' liegt außerhalb des Vektors (i < 1). 
+ 
+ 
+'vector' 
+   #on("b")#INITVECTOR PROC vector (INT CONST l) #off("b")# 
+   Erzeugen eines Vektors mit 'l' Elementen. Ein INITVECTOR-Objekt benötigt nicht
+   soviel Speicherplatz wie ein VECTOR-Objekt. Die Elemente werden mit dem
+   Wert '0.0' initialisiert. 
+ 
+   FEHLER : 
+           PROC vector : size <= 0 
+           Die angeforderte Elementanzahl 'l' muß > 0 sein. 
+ 
+   #on("b")#INITVECTOR PROC vector (INT CONST l, REAL CONST value)#off("b")# 
+   Erzeugen eines Vektors mit 'l' Elementen. Ein INITVECTOR-Objekt benötigt nicht
+   soviel Speicherplatz wie ein VECTOR-Objekt. Die Elemente werden mit dem
+   Wert 'value' initialisiert. Beispiel: 
+ 
+ 
+           VECTOR VAR v := vector (17, 3.14159); 
+           (* 'v' hat 17 Elemente mit den Wert '3.14159' *) 
+ 
+    FEHLER : 
+           PROC vector : size <= 0 
+           Die angeforderte Elementanzahl 'l' muß > 0 sein. 
+ 
+#page# 
+
+6.1.4  MATRIX
+
+Der Datentyp MATRIX erlaubt Operationen auf m x n Matrizen. Im Gegensatz zur
+Struktur 'ROW m ROW n REAL' muß die Anzahl der Elemente nicht zur Überset­
+zungszeit deklariert werden, sondern kann zur Laufzeit festgelegt werden. Somit kann
+eine zur Übersetzungszeit unbekannte Anzahl von REALs bearbeitet werden, wobei
+nur soviel Speicherplatz wie nötig verwendet wird. Die maximale Größe einer MATRIX
+beträgt 4000 Elemente. 
+ 
+Der in den Operationen ':=', 'idn' und 'matrix' benutzte Datentyp INITMATRIX wird
+nur intern gehalten. Er dient der Speicherplatzersparnis bei der Initialisierung. 
+ 
+ 
+- Operatoren                :  := , = , <> , + , - , * 
+                               COLUMNS , DET , INV , ROWS , TRANSP , 
+ 
+- Eingabe/Ausgabe           :  get , put 
+ 
+- Besondere Matrix-         :  column , idn , matrix , row , sub 
+  Operationen                  transp , 
+                               replace column , replace element , 
+                               replace row 
+ 
+ 
+ 
+#page# 
+':=' 
+   #on("b")#OP := (MATRIX VAR l, MATRIX CONST r) #off("b")# 
+   Zuweisung von 'r' auf 'l'. Die MATRIX 'l' bekommt u.U. eine neue Anzahl von
+   Elementen. Beispiel: 
+    
+ 
+           MATRIX VAR a :: matrix (3, 4, 0.0), 
+                      b :: matrix (5, 5, 3.0); 
+                          ... 
+           a := b; (* 'a' hat jetzt 5 x 5 Elemente *) 
+ 
+ 
+   #on("b")#OP := (MATRIX VAR l, INITMATRIX CONST r) #off("b")# 
+   Dient zur Initialisierung einer Matrix. Beispiel: 
+ 
+ 
+           MATRIX VAR x :: matrix (17, 4); 
+ 
+ 
+   'matrix' erzeugt ein Objekt vom Datentyp INITMATRIX. Dieses Objekt braucht
+   nicht soviel Speicherplatz wie ein MATRIX-Objekt. Dadurch wird vermieden, daß
+   nach erfolgter Zuweisung nicht ein durch 'matrix' erzeugtes Objekt auf dem Heap
+   unnötig Speicherplatz verbraucht. 
+ 
+'=' 
+   #on("b")#BOOL OP = (MATRIX CONST l, r) #off("b")# 
+   Vergleich zweier Matrizen. Der Operator '=' liefert FALSE, wenn die Anzahl
+   Spalten oder Reihen der Matrizen 'l' und 'r' ungleich ist und wenn mindestens ein
+   Element mit gleichen Indizes der zwei Matrizen ungleiche Werte haben. Beispiel: 
+ 
+ 
+           MATRIX VAR a :: matrix (3, 3), 
+                      b :: matrix (3, 3, 1.0), 
+                      c :: matrix (4, 4); 
+                 ... a = b ... 
+           (* FALSE wegen ungleicher Werte   *) 
+                 ... a = c ... 
+           (* FALSE wegen ungleicher Groesse *) 
+                 ... b = c ... 
+           (* FALSE wegen ungleicher Groesse *) 
+ 
+ 
+ 
+'<>' 
+   #on("b")#BOOL OP <> (MATRIX CONST l, r) #off("b")# 
+   Vergleich der Matrizen 'l' und 'r' auf Ungleichheit. 
+ 
+ 
+'+' 
+   #on("b")#MATRIX OP + (MATRIX CONST m) #off("b")# 
+   Monadisches '+'. Keine Auswirkungen. 
+ 
+   #on("b")#MATRIX OP + (MATRIX CONST l, r) #off("b")# 
+   Addition zweier Matrizen. Die Anzahl der Reihen und der Spalten muß gleich sein.
+   Beispiel: 
+ 
+           MATRIX VAR a :: matrix (3, 43, 1.0), 
+                      b :: matrix (3, 43, 2.0), 
+                           summe; 
+                      summe := a + b; 
+           (* Alle Elemente haben den Wert '3.0' *) 
+ 
+ 
+     FEHLER: 
+           MATRIX OP + : COLUMNS l <> COLUMNS r 
+           Die Anzahl der Spalten von 'l' und 'r' sind nicht gleich. 
+           MATRIX OP + : ROWS l <> ROWS r 
+           Die Anzahl der Zeilen von 'l' und 'r' sind nicht gleich. 
+ 
+ 
+'-' 
+   #on("b")#MATRIX OP - (MATRIX CONST m) #off("b")# 
+   Monadisches Minus. Beispiel: 
+ 
+ 
+           MATRIX VAR a :: matrix (3, 4, 10.0) 
+           a := - a; (* Alle Elemente haben den Wert '- 10.0' *) 
+ 
+ 
+   #on("b")#MATRIX OP - (MATRIX CONST l, r) #off("b")# 
+   Subtraktion zweier Matrizen. Die Anzahl der Reihen und Spalten muß gleich sein. 
+ 
+   FEHLER: 
+           MATRIX OP - : COLUMNS l <> COLUMNS r 
+           Die Anzahl der Spalten von 'l' und 'r' sind nicht gleich. 
+           MATRIX OP - : ROWS l <> ROWS r 
+           Die Anzahl der Zeilen von 'l' und 'r' sind nicht gleich. 
+ 
+'*' 
+   #on("b")#MATRIX OP * (REAL CONST r, MATRIX CONST m) #off("b")# 
+   Multiplikation einer Matrix 'm' mit einem Skalar 'r'. Beispiel: 
+ 
+ 
+           MATRIX VAR a :: matrix (3, 4, 2.0); 
+                ... 
+           a := 3 * a; (* Alle Elemente haben den Wert '6.0' *) 
+ 
+ 
+   #on("b")#MATRIX OP * (MATRIX CONST m, REAL CONST r) #off("b")# 
+   Multiplikation einer Matrix 'm' mit einem Skalar 'r'. 
+ 
+   #on("b")#MATRIX OP * (MATRIX CONST l, r) #off("b")# 
+   Multiplikation zweier Matrizen. Die Anzahl der Spalten von 'l' und die Anzahl der
+   Zeilen von 'r' müssen gleich sein. Beispiel: 
+ 
+ 
+           MATRIX VAR a :: matrix (3, 4, 2.0), 
+                      b :: matrix (4, 2, 3.0), 
+                      produkt; 
+           produkt := a * b; 
+           (* Alle Elemente haben den Wert '24.0' *) 
+ 
+ 
+   FEHLER : 
+           MATRIX OP * : COLUMNS l <> ROWS r 
+           Die Anzahl der Spalten von 'l' muß mit der Anzahl der Zeilen von 'r'
+           übereinstimmen. 
+ 
+   #on("b")#VECTOR OP * (VECTOR CONST v, MATRIX CONST m) #off("b")# 
+   Multiplikation des Vektors 'v' mit der Matrix 'm'. 
+ 
+   FEHLER : 
+            VECTOR OP * : LENGTH v <> ROWS m 
+            Die Anzahl der Elemente von 'v' stimmt nicht mit den Anzahl der Zeilen
+            von 'm' überein. 
+ 
+   #on("b")#VECTOR OP * (MATRIX CONST m, VECTOR CONST v) #off("b")# 
+   Multiplikation der Matrix 'm' mit dem Vektor 'v'. 
+ 
+   FEHLER : 
+            VECTOR OP * : COLUMNS m <> LENGTH v 
+            Die Anzahl der Spalten von 'm' stimmt nicht mit der Anzahl der Ele­
+            menten von 'v' überein. 
+ 
+ 
+'COLUMNS' 
+   #on("b")#INT OP COLUMNS (MATRIX CONST m) #off("b")# 
+   Liefert die Anzahl der Spalten von 'm'. Beispiel: 
+ 
+ 
+           MATRIX VAR a :: matrix (3, 4), 
+                      b :: matrix (7, 10); 
+           put (COLUMNS a); (* 4 *) 
+           put (COLUMNS b); (* 10 *) 
+ 
+ 
+ 
+'DET' 
+   #on("b")#REAL OP DET (MATRIX CONST m) #off("b")# 
+   Es wird der Wert der Determinanten von 'm' geliefert. 
+ 
+   FEHLER : 
+           OP DET : no square matrix 
+           Die Matrix ist nicht quadratisch, d.h. ROWS m <> COLUMNS m 
+ 
+ 
+'INV' 
+   #on("b")#MATRIX OP INV (MATRIX CONST m) #off("b")# 
+   Liefert als Ergebnis die Inverse von 'm' (Achtung: starke Rundungsfehler möglich). 
+ 
+   FEHLER: 
+           OP INV : no square matrix 
+           Die Matrix 'm' ist nicht quadratisch, 
+           d.h. ROWS m <> COLUMNS m 
+           OP INV : singular matrix 
+           Die Matrix ist singulär. 
+ 
+ 
+'ROWS' 
+   #on("b")#INT OP ROWS (MATRIX CONST m) #off("b")# 
+   Liefert die Anzahl der Zeilen von 'm'. Beispiel: 
+ 
+ 
+           MATRIX VAR a :: matrix (3, 4), 
+                      b :: matrix (7, 10); 
+                ... 
+           put (ROWS a); (* 3 *) 
+           put (ROWS b); (* 7 *) 
+ 
+ 
+ 
+'TRANSP' 
+   #on("b")#MATRIX OP TRANSP (MATRIX CONST m) #off("b")# 
+   Liefert als Ergebnis die transponierte Matrix 'm'. 
+ 
+#page# 
+'get' 
+   #on("b")#PROC get (MATRIX VAR m, INT CONST rows, columns) #off("b")# 
+   Einlesen von Werten für die Matrix 'm' vom Terminal mit 'rows'-Zeilen und
+   'columns'-Spalten. 
+ 
+ 
+'put' 
+   #on("b")#PROC put (MATRIX CONST m) #off("b")# 
+   Ausgabe der Werte einer Matrix auf dem Terminal. 
+#page# 
+'column' 
+   #on("b")#VECTOR PROC column (MATRIX CONST m, INT CONST i) #off("b")# 
+   Die 'i'-te Spalte von 'm' wird als VECTOR mit 'ROWS m' Elementen geliefert.
+   Beispiel: 
+ 
+ 
+           MATRIX CONST a :: matrix (3, 4); 
+           VECTOR VAR b   :: column (a, 1); 
+           (* 'b' hat drei Elemente mit den Werten '0.0' *) 
+ 
+   FEHLER: 
+           PROC column : subscript overflow 
+           Der Index 'i' liegt außerhalb der Matrix 'm' (i > COLUMNS m). 
+           PROC column : subscript underflow 
+           Der Index 'i' liegt außerhalb der Matrix 'm' (i < 1). 
+ 
+'idn' 
+   #on("b")#INITMATRIX PROC idn (INT CONST size) #off("b")# 
+   Erzeugen einer Einheitsmatrix vom Datentyp INITMATRIX. Beispiel: 
+ 
+ 
+           MATRIX VAR a :: idn (10); 
+           (* Erzeugt eine Matrix mit 10 x 10 Elementen, deren
+            Werte '0.0' sind, mit der Ausnahme der Diagonalele­
+            mente, die den Wert '1.0' haben.*) 
+ 
+   FEHLER : 
+           PROC idn : size <= 0 
+           Die angeforderte 'size' Anzahl Spalten oder Zeilen muß > 0 sein. 
+ 
+ 
+'matrix' 
+   #on("b")#INITMATRIX PROC matrix (INT CONST rows, columns) #off("b")# 
+   Erzeugen eines Datenobjekts vom Datentyp INITMATRIX mit 'rows' Zeilen und
+   'columns' Spalten. Alle Elemente werden mit dem Wert '0.0' initialisiert. Beispiel: 
+ 
+ 
+           MATRIX CONST :: matrix (3, 3); 
+ 
+   FEHLER: 
+           PROC matrix : rows <= 0 
+           Die angeforderte Zeilenanzahl 'rows' muß > 0 sein. 
+           PROC matrix : columns <= 0 
+           Die angeforderte Spaltenanzahl 'columns' muß > 0 sein. 
+ 
+   #on("b")#INITMATRIX PROC matrix (INT CONST rows, columns, REAL CONST value)#off("b")# 
+   Erzeugen eines Datenobjekts vom Datentyp MATRIX mit 'rows' Zeilen und 'co­
+   lumns' Spalten. Alle Elemente der erzeugten MATRIX werden mit dem Wert
+   'value' initialisiert. Beispiel: 
+ 
+ 
+           MATRIX CONST :: matrix (3, 3, 3.14); 
+ 
+   FEHLER: 
+           PROC matrix : rows <= 0 
+           Die angeforderte Zeilenanzahl 'rows' muß > 0 sein. 
+           PROC matrix : columns <= 0 
+           Die angeforderte Spaltenanzahl 'columns' muß > 0 sein. 
+ 
+ 
+'row' 
+   #on("b")#VECTOR PROC row (MATRIX CONST m, INT CONST i) #off("b")# 
+   Die 'i'-te Reihe von 'm' wird als VECTOR mit 'COLUMNS m' Elementen gelie­
+   fert. Beispiel: 
+ 
+ 
+           MATRIX CONST a :: matrix (3, 4); 
+           VECTOR VAR b   :: row (a, 1); 
+           (* 'b' hat vier Elemente mit den Werten '0.0'*) 
+ 
+   FEHLER: 
+           PROC row : subscript overflow 
+           Der Index 'i' liegt außerhalb der Matrix 'm' (i > ROWS m). 
+           PROC row : subscript underflow 
+           Der Index 'i' liegt außerhalb der Matrix 'm' (i < 1). 
+ 
+ 
+'sub' 
+   #on("b")#REAL PROC sub (MATRIX CONST m, INT CONST row, column) #off("b")# 
+   Liefert den Wert eines Elementes von 'm', welches durch die Indizes 'row' und
+   'column' bestimmt wird. Beispiel: 
+ 
+ 
+           MATRIX VAR m :: matrix (5, 10, 1.0); 
+           put (sub (m, 3, 7)); 
+ 
+   FEHLER: 
+           PROC sub : row subscript overflow 
+           Der Index 'row' liegt außerhalb von 'm' (row > ROWS m). 
+           PROC sub : row subscript underflow 
+           Der Index 'row' liegt außerhalb von 'm' (row < 1). 
+           PROC sub : column subscript overflow 
+           Der Index 'column' liegt außerhalb von 'm' (column > ROWS m). 
+           PROC sub : row subscript underflow 
+           Der Index 'column' liegt außerhalb von 'm' (column < 1). 
+ 
+ 
+'transp' 
+   #on("b")#PROC transp (MATRIX VAR m) #off("b")# 
+   Transponieren der Matrix 'm', wobei kaum zusätzlicher Speicherplatz benötigt
+   wird. 
+ 
+#page# 
+'replace column' 
+   #on("b")#PROC replace column (MATRIX VAR m, INT CONST column index, VECTOR
+                        CONST column value)  #off("b")# 
+   Ersetzung der durch 'column index' definierten Spalte in der MATRIX 'm' durch
+   den VECTOR 'column value'. Beispiel: 
+ 
+ 
+           MATRIX VAR a :: matrix (3, 5, 1.0); 
+           VECTOR VAR b :: vector (3, 2.0); 
+                 ... 
+           replace column (a, 2, b); 
+           (* Die zweite Spalte von 'a' wird durch die Werte von
+              'b' ersetzt *) 
+ 
+   FEHLER: 
+           PROC replace column : LENGTH columnvalue <> ROWS m 
+           Die Anzahl der Zeilen der MATRIX 'm' stimmt nicht mit der Anzahl der
+           Elemente von 'columnvalue' überein. 
+           PROC replace column : column subscript overflow 
+           Der Index 'columnindex' liegt außerhalb von 'm' 
+           (columnindex > COLUMNS m). 
+           PROC sub : column subscript underflow 
+           Der Index 'columnindex' liegt außerhalb von 'm' (columnindex < 1). 
+ 
+ 
+'replace element' 
+   #on("b")#PROC replace element (MATRIX VAR m , INT CONST row, column, 
+                        REAL CONST value) #off("b")# 
+   Ersetzung eines Elementes von 'm' in der 'row'-ten Zeile und 'column'-ten
+   Spalte durch den Wert 'value'. Beispiel: 
+ 
+ 
+           MATRIX VAR a :: matrix (5, 5); 
+                 ... 
+           replace element (1, 1, 3.14159); 
+ 
+   FEHLER: 
+           PROC replace element : row subscript overflow 
+           Der Index 'row' liegt außerhalb von 'm' (row > ROWS m). 
+           PROC replace element : row subscript underflow 
+           Der Index 'row' liegt außerhalb von 'm' (row < 1). 
+           PROC replace element : column subscript overflow 
+           Der Index 'column' liegt außerhalb von 'm' (column > COLUMNS m). 
+           PROC replace element : row subscript underflow 
+           Der Index 'column' liegt außerhalb von 'm' (column < 1). 
+ 
+ 
+'replace row' 
+   #on("b")#PROC replace row (MATRIX VAR m, INT CONST rowindex, 
+                    VECTOR CONST rowvalue) #off("b")# 
+   Ersetzung der Reihe 'rowindex' in der MATRIX 'm' durch den VECTOR 'rowvalue'.
+   Beispiel: 
+ 
+ 
+           MATRIX VAR a :: matrix (3, 5, 1.0); 
+           VECTOR VAR b :: vector (5, 2.0); 
+                 ... 
+           replace row (a, 2, b); 
+           (* Die 2. Reihe von 'a' wird durch Werte von 'b'ersetzt *) 
+ 
+   FEHLER: 
+           PROC replace row : LENGTH rowvalue <> COLUMNS m 
+           Die Anzahl der Spalten der MATRIX 'm' stimmt nicht mit der Anzahl der
+           Elemente von 'rowvalue' überein. 
+           PROC replace row : row subscript overflow 
+           Der Index 'rowindex' liegt außerhalb von 'm' 
+           (rowindex > ROWS m). 
+           PROC sub : row subscript underflow 
+           Der Index 'rowindex' liegt außerhalb von 'm' (rowindex < 1). 
+
+6.2  Programmanalyse 
+ 
+Das Packet 'reporter' ermöglicht: 
+ 
+a) Ablaufinformationen ("trace"); 
+b) #ib#Häufigkeitszählung#ie# ("frequency count"); 
+c) Programmunterbrechung bei Nichterfüllung einer Bedingung ("#ib#assertion#ie#"). 
+ 
+ 
+'Installation' 
+Das Programm befindet sich in der Datei 'reporter' und kann wie üblich insertiert
+werden. Jedoch muß es mit 'check off' übersetzt werden, damit keine Zeilennummern
+für 'reporter' generiert werden. Dies ist notwendig, damit die Zeilennummern des zu
+testenden Programms nicht mit den Zeilennummern des Programms 'reporter' ver­
+wechselt werden können. Beispiel: 
+ 
+ 
+     check off; insert ("reporter"); check on 
+ 
+ 
+Mit dem Kommando 
+ 
+ 
+     #ib#generate reports#ie# ("testdatei") 
+ 
+ 
+werden die oben erwähnten Prozeduraufrufe ('#ib#report#ie#') in das zu testende Programm,
+welches in der Datei 'testdatei' steht, geschrieben. Die Prozeduraufrufe werden nach
+jedem Prozedur-, Operator- oder Refinement-Kopf eingefügt und erhalten den
+entsprechenden Namen als Parameter. Diese Prozeduraufrufe werden gekennzeichnet,
+damit sie von der Prozedur 
+ 
+ 
+     eliminate reports ("testdatei") 
+ 
+ 
+automatisch wieder entfernt werden können. Beispiel (für die eingefügten Prozedurauf­
+rufe): 
+ 
+ 
+    ... 
+    PROC beispiel (INT CONST mist): 
+    \#\#report ("PROC beispiel");\#\# 
+    ... 
+ 
+ 
+ 
+'Automatische Ablaufinformation' 
+Ist ein Programm mit 'generate reports' mit 'report'-Aufrufen versehen worden, kann
+es wie gewohnt übersetzt werden. Wird das Programm vom ELAN-Compiler kor­
+rekt übersetzt und dann gestartet, wird bei jedem Antreffen eines 'report'-Aufrufs der
+Parameter (Name der Prozedur, Operator oder Refinement) in eine Datei, die
+TRACE-Datei geschrieben. Die TRACE-Datei wird beim Programmlauf automatisch
+von 'reporter' unter dem Namen 'TRACE' eingerichtet. 
+ 
+Mit Hilfe dieser Datei kann der Programmablauf verfolgt werden. Es ist damit auch
+möglich festzustellen, wo eine "Endlos-Rekursion" auftritt. Die Ablaufinformationen
+bestehen nur aus den Namen der angetroffenen Prozeduren und Refinements. Trotz­
+dem können die Anzahl der Informationen sehr umfangreich werden. Deshalb gibt es
+die Möglichkeit, die Erzeugung der Ablaufinformationen ab- bzw. wieder anzuschal­
+ten. Dazu gibt es die Möglichkeit, in das zu testende Programm die Prozeduren 
+ 
+ 
+     #ib#report on#ie# 
+     #ib#report off#ie# 
+ 
+ 
+einzufügen und das zu testende Programm mit diesen Prozeduraufrufen (erneut) zu
+übersetzen. 
+ 
+ 
+'Benutzereigene Ablaufinformation' 
+Zusätzlich zu den von 'generate reports' eingefügten 'report'-Aufrufen kann ein
+Benutzer eigene Aufrufe an geeigneten Stellen in ein Programm schreiben. Dafür
+werden weitere 'report'-Prozeduren zur Verfügung gestellt, die als ersten Parameter
+ein TEXT-Objekt (meist Name des Objekts oder der Ausdruck selbst) und als zwei­
+ten ein INT/REAL/TEXT/ BOOL-Objekt (der zu überprüfende Wert oder Ausdruck)
+enthalten. Beispiel: 
+ 
+ 
+    ... 
+    PROC beispiel (INT CONST mist): 
+    \#\#report ("beispiel");\#\#     (* automatisch eingefuegte *) 
+    INT VAR mist :: ...; ... 
+    \#\#report ("mist:", mist);\#\#  (* vom Benutzer per Hand einge­
+                                    fuegt *) 
+    ... 
+ 
+ 
+Folgende 'report'-Routinen stehen zur Verfügung, damit man sie "von Hand" in ein
+zu testendes Programm einfügen kann: 
+ 
+ 
+     PROC report on 
+     PROC report off 
+     PROC report (TEXT CONST message) 
+     PROC report (TEXT CONST message,  INT CONST value) 
+     PROC report (TEXT CONST message, REAL CONST value) 
+     PROC report (TEXT CONST message, TEXT CONST value) 
+     PROC report (TEXT CONST message, BOOL CONST value) 
+ 
+ 
+Wichtig: Hier - wie bei allen anderen "von Hand eingefügten" Aufrufen - sollte
+ein Nutzer sich an die Konvention halten, diese in "\#\#" einzuklammern. Mit 'eliminate
+reports' werden diese Einfügungen automatisch entfernt. Sollen diese Aufrufe aber
+immer im Programm erhalten bleiben (jedoch nicht wirksam sein), sollten sie 
+ 
+a) vor 'generate reports'-Aufruf mit jeweils '\#\#\#' eingefaßt werden. Beispiel: 
+   \#\#\# report ("...") \#\#\# 
+   So steht das 'report'-Statement in einem Kommentar. 'generate reports' wandelt
+   '\#\#\#' --> '\#\#\#\#' um, so daß ein solches Statement wirksam wird. 'eliminate
+   reports' wandelt ein '\#\#\#\#' --> '\#\#\#' zurück. 
+ 
+b) nach 'generate reports' in '\#\#\#\#' eingefaßt werden. 
+ 
+ 
+'Häufigkeitszählung' 
+Eine Häufigkeitszählung erhält man, in dem man in das zu testende Programm die
+Aufrufe 
+ 
+ 
+     count on 
+     count off 
+ 
+ 
+einfügt. Ist die Häufigkeitszählung eingeschaltet, merkt sich 'reporter' die Anzahl der
+Durchläufe für jede Prozedur bzw. Refinement. Mit der Prozedur 
+ 
+ 
+     #ib#generate counts#ie# ("zu testende datei") 
+ 
+ 
+werden die vermerkten Häufigkeiten in das zu testende Programm direkt eingefügt.
+Die Häufigkeiten werden wie oben beschrieben gekennzeichnet, so daß sie mit 'elimi­
+nate reports' entfernt werden können. 
+ 
+ 
+'Assertions' 
+Zusätzlich zu den oben erwähnten Möglichkeiten bietet 'reporter' noch die Prozedur 
+ 
+ 
+     #ib#assert#ie# 
+ 
+ 
+an. Diese Prozedur kann von einem Programmierer an einer Stelle in das zu testende
+Programm eingefügt werden, an der bestimmte Bedingungen erfüllt sein müssen. Die
+Prozedur 'assert' steht in zwei Formen zur Verfügung: 
+ 
+ 
+     PROC #ib#assert#ie# (BOOL CONST zusicherung) 
+     PROC assert (TEXT CONST message, BOOL CONST zusicherung) 
+ 
+ 
+Ist der Wert von 'zusicherung' nicht TRUE, wird der Programmlauf abgebrochen. 
+ 
+ 
+ 
+reporter - Kommandos 
+ 
+ 
+'count on' 
+   #on("b")#PROC count on #off("b")# 
+   Schaltet die Häufigkeitszählung ein. 
+ 
+'count off' 
+   #on("b")#PROC count off #off("b")# 
+   Schaltet die Häufigkeitszählung aus. 
+ 
+'eliminate reports' 
+   #on("b")#PROC eliminate reports (TEXT CONST datei) #off("b")# 
+   Entfernt gekennzeichnete 'report'-Aufrufe aus der Datei 'datei'. 
+ 
+'generate reports' 
+   #on("b")#PROC generate reports (TEXT CONST datei) #off("b")# 
+   Fügt 'report'-Aufrufe in die Datei 'datei' ein und kennzeichnet diese mit '\#\#'. 
+ 
+'report on' 
+   #on("b")#PROC report on #off("b")# 
+   Schaltet die Ablaufinformationen in die Datei 'TRACE' ein. 
+ 
+'report off' 
+   #on("b")#PROC report off #off("b")# 
+   Schaltet die Ablaufinformationen wieder aus. 
+ 
+'generate counts' 
+   #on("b")#PROC generate counts (TEXT CONST datei) #off("b")# 
+   Bringt die Häufigkeitszählung (wie oft eine Prozedur oder Refinement durchlaufen
+   wurde) in die Programmdatei 'datei'. Mit 'eliminate reports' werden diese wieder
+   automatisch entfernt. 
+ 
+'assert' 
+   #on("b")#PROC assert (TEXT CONST message, BOOL CONST value) #off("b")# 
+   Schreibt 'message' und den Wert von 'value' in die TRACE-Datei. Ist 'value'
+   FALSE, wird angefragt, ob das Programm fortgesetzt werden soll. 
+#page# 
+
+Referencer 
+ 
+ 
+'referencer' wird durch 
+ 
+ 
+     referencer ("ref datei", "referenz liste") 
+ 
+ 
+aufgerufen, wobei die Datei 'referenz liste' nicht existieren darf. 'referenz liste' enthält
+nach Ablauf des Programms die gewünschte Liste, die sogenannte #ib# Referenzliste#ie#. 
+ 
+#ub#Achtung#ue#: 'referencer' arbeitet ausschließlich mit Namen und verarbeitet nur wenige
+syntaktische Konstrukte. Darum ist es nur erlaubt, ein PACKET auf einmal von 'refe­
+rencer' verarbeiten zu lassen. Verarbeitet man mehrere PACKETs auf einmal, kann es
+geschehen, daß gleichnamige Objekte in unterschiedlichen Paketen zu Warnungen
+(vergl. die unten beschriebenen Überprüfungen) führen. 
+ 
+In der Referenzliste sind 
+ 
+- alle Objekte mit ihrem Namen (in der Reihenfolge ihres Auftretens im Programm) 
+ 
+- alle Zeilennummern, in der das Objekt angesprochen wird 
+ 
+- die Zeilennummern, in der das Objekt deklariert wurde ('L' für ein lokales und 'G'
+  für ein globales Objekt, 'R' für ein Refinement) 
+ 
+verzeichnet. 
+ 
+Die Referenzliste kann u.a. dazu dienen, zu kontrollieren, ob und wie (bzw. wo) ein
+Objekt angesprochen wird. Dies lohnt sich selbstverständlich nur bei etwas umfan­
+greicheren Programmen (bei "Mini"-Programmen kann man dies sofort sehen). 
+ 
+Bei der Erstellung der Referenzliste nimmt das Programm 'referencer' gleichzeitig
+einige Überprüfungen vor, die helfen können, ein Programm zu verbessern: 
+ 
+1. Warnung bei mehrzeiligen Kommentaren. 
+ 
+2. Überdeckungsfehler. Wird ein Objekt global (auf PACKET-Ebene) und nochmals
+   lokal in einer Prozedur deklariert, ist das globale Objekt nicht mehr ansprechbar.
+   Überdeckungen sind nach der gültigen Sprachdefinition z.Zt. noch erlaubt, werden
+   aber bei einer Revision des Sprachstandards verboten sein. 
+ 
+3. Mehrmaliges Einsetzen von Refinements. Wird ein Refinement mehrmals einge­
+   setzt (das ist völlig legal), sollte man überlegen, ob sich dieses Refinement nicht
+   zu einer Prozedur umgestalten läßt. 
+ 
+4. Nicht angewandte Refinements. Wird ein Refinement zwar deklariert, aber nicht
+   "aufgerufen", erfolgt eine Warnung. 
+ 
+5. Nicht angesprochene Daten-Objekte. Werden Daten-Objekte zwar deklariert,
+   aber im folgenden nicht angesprochen, wird eine Warnung ausgegeben. Hinweis:
+   Alle Objekte, die nur wenig angesprochen werden, also nur wenige Zeilennum­
+   mern in der Referenzliste besitzen, sind verdächtig (Ausnahmen: importierte
+   Prozeduren, LET-Objekte u.a.m.). 
+ 
+ 
+
+referencer - Kommandos
+ 
+ 
+'referencer' 
+   #on("b")#PROC referencer (TEXT CONST check file, dump file) #off("b")# 
+   Überprüft 'check file'. In 'dump file' steht nach Abschluß die Referenzliste. 
+ 
+#page# 
+
+6.3  Rechnen im Editor 
+ 
+Das Programm TeCal ermöglicht einfache Rechnungen (ähnlich wie mit einem Ta­
+schenrechner) unter der Benutzung des Editors. Gleichzeitig stehen dem Benutzer
+aber alle Fähigkeiten des Editors zur Verfügung. TeCal ermöglicht Rechnungen auf
+einfache Weise zu erstellen oder Tabellenspalten zu berechnen. Zur Benutzung 
+müssen 'TeCal' und 'TeCal Auskunft' insertiert werden. 
+ 
+TeCal wird aus dem Editor heraus durch 'ESC t' oder durch das Editor-Kommando 
+ 
+ 
+           tecal 
+ 
+ 
+aktiviert. Dadurch wird in der untersten Zeile des Bildschirms eine Informationszeile
+aufgebaut, in der die (Zwischen-) Ergebnisse einer Rechnung zur Kontrolle fest­
+gehalten werden. 
+ 
+ 
+ 
+Arbeitsweise 
+ 
+ 
+Wenn TeCal insertiert ist, kann die Taschenrechnerfunktion jederzeit durch <ESC> <t>
+aufgerufen werden. Aus der editierten Datei werden Werte mit <ESC> <L> gelesen,
+durch <ESC> <+> (bzw. -,*,/) verknüpft und mit <ESC> <S> an die aktuelle Cursor­
+position geschrieben werden. 
+ 
+Der von TeCal errechnete Wert wird durch <ESC> <S> derart ausgegeben, daß an der
+Stelle an der der Cursor steht die letzte Stelle vor dem Dezimalpunkt geschrieben
+wird. 
+ 
+Die Eingabe von Klammern geschieht durch <ESC> <(> <ESC> <)>. 
+ 
+Durch die Hilfsfunktion <ESC> <?> lassen sich die TeCal Funktionen auflisten. 
+ 
+Der Prozentoperator <ESC> <%> erlaubt einfache Rechnungen der Form: 'zahl' <ESC> <+>
+<ESC> <%> <ESC> <=> . 
+ 
+Derartige Folgen können natürlich mit der bekannten Editor-Lernfunktion auch ge­
+lernt werden, so daß sich z.B. die Mehrwertsteuerberechnung auf wenige Tasten 
+reduziert. 
+ 
+Spalten können summiert werden, indem auf der #on("u")#untersten#off("u")# Zahl einer Spalte <ESC> <V>
+eingegeben wird. Daraufhin werden alle darüberliegende Zahlen addiert, bis ein
+Zeichen auftritt, das nicht in einer Zahl auftritt (Leerzeichen stören nicht!). 
+ 
+____________________________________________________________________________ 
+         ............ 
+               55.00 
+               66.99 
+              123.45 
+ 
+               99.99 
+ 
+             9876.54 
+         ........... 
+ 
+ Anzeige:            0.00  14.00%  Memory:       0.00 
+ 
+____________________________________________________________________________ 
+ 
+ 
+TeCal Prozeduren 
+ 
+ 
+'evaluate' 
+   #on("b")#evaluate (TEXT CONST zeile, INT CONST von) #off("b")# 
+   Ausdruck 'zeile' ab der Stelle 'von' berechnen. 
+ 
+   #on("b")#evaluate (TEXT CONST zeile) #off("b")# 
+   Ausdruck 'zeile' ab Stelle 1 berechnen. 
+ 
+ 
+'kommastellen' 
+   #on("b")#kommastellen (INT CONST stellen) #off("b")# 
+   Berechnungen auf 'stellen' Zahlen hinter dem Komma einstellen. 
+ 
+ 
+'merke' 
+   #on("b")#PROC merke (INT CONST zahl)#off("b")# 
+   Integer 'zahl' im Merkregister abspeichern. 
+ 
+   #on("b")#PROC merke (REAL CONST zahl)#off("b")# 
+   Real 'zahl' im Merkregister abspeichern. 
+ 
+'prozentsatz' 
+   #on("b")#PROC prozentsatz (INT CONST zahl) #off("b")# 
+   Prozentsatz von 'zahl' Prozent einstellen. Der Wert wird automatisch konvertiert. 
+ 
+   #on("b")#PROC prozentsatz (REAL CONST zahl) #off("b")# 
+   Prozentsatz von 'zahl' Prozent einstellen. 
+ 
+ 
+'tecal' 
+   #on("b")#PROC tecal (FILE VAR f) #off("b")# 
+   Datei 'f', die mit 'sequential file' assoziiert ist, mit TeCal editieren. 
+ 
+   #on("b")#PROC tecal (TEXT VAR datei) #off("b")# 
+   'datei' mit TeCal editieren. 
+ 
+   #on("b")#PROC tecal #off("b")# 
+   Zuletzt editierte Datei mit TeCal editieren. 
+ 
+ 
+'tecalauskunft' 
+   #on("b")#PROC tecalauskunft #off("b")# 
+   Auskunft zeigen. 
+ 
+   #on("b")#PROC tecalauskunft (TEXT CONST zeichen) #off("b")# 
+   Auskunft zu 'zeichen' zeigen. 
+
diff --git a/doc/programmer-manual/1.8.7/doc/programmierhandbuch.index b/doc/programmer-manual/1.8.7/doc/programmierhandbuch.index
new file mode 100644
index 0000000..f3f4ede
--- /dev/null
+++ b/doc/programmer-manual/1.8.7/doc/programmierhandbuch.index
@@ -0,0 +1,449 @@
+#pagenr("%",1)##block##pageblock# 
+#headandbottom("1","EUMEL-Benutzerhandbuch","INDEX","Index")# 
+#headeven# 
+#center#EUMEL-Benutzerhandbuch 
+#center#____________________________________________________________ 
+ 
+#end# 
+#headodd# 
+#center#INDEX 
+#center#____________________________________________________________ 
+ 
+#end# 
+#bottomeven# 
+#center#____________________________________________________________ 
+Index - % #right#GMD 
+#end# 
+#bottomodd# 
+#center#____________________________________________________________ 
+GMD #right#Index - % 
+#end# 
+#lpos(0.2)##lpos(6.2)# 
+ 
+INDEX  
+ 
+#table# 
+*              5-11, 5-18, 5-32, 6-19, 6-27, 6-4, 6-9 
+**           5-11, 5-19, 5-60, 6-10 
++        4-20, 5-11, 5-18, 5-32, 5-54, 6-18, 6-26, 6-3, 6-9 
+-        4-20, 5-11, 5-18, 5-54, 6-18, 6-26, 6-3, 6-9 
+/        4-20, 4-22, 5-18, 6-19, 6-4 
+:=       2-91, 5-10, 5-17, 5-30, 5-65, 6-17, 6-25, 6-3, 6-8 
+<        5-10, 5-17, 5-30, 6-8 
+<=       5-10, 5-17, 5-30, 6-8 
+<>       5-10, 5-17, 5-30, 6-18, 6-26, 6-3, 6-8 
+=        5-10, 5-17, 5-30, 6-17, 6-25, 6-3, 6-8 
+>        5-10, 5-17, 5-30, 6-9 
+>=       5-10, 5-17, 5-30, 6-9 
+ 
+Abfragekette                                      2-25 
+ABS             6-10, 6-6 
+abs                                               5-13, 5-20, 6-13 
+Abweisende Schleife                               2-29 
+ALL                                               4-17 
+all                                               4-17 
+AND                                               5-7 
+any                                               5-54 
+Archiv                                            4-44 
+Archivdiskette                                    4-47 
+archive                                           1-9, 4-24, 4-45 
+arctan                                            5-20 
+arctand                                           5-20 
+assert                                            6-39 
+assertion                                         6-36 
+Assertions                                        6-39 
+Ausgabesteuerzeichen                     5-70 
+Ausschalten des Geräts                            1-17 
+Automatische Ablaufinformation                    6-37 
+ 
+begin                                             2-78, 4-3 
+begin password                                    4-40 
+Benutzereigene Ablaufinformation                  6-37 
+BOOL-Denoter:                                     2-9 
+BOUND                                             2-83 
+bound                                             5-56 
+break                                             4-4 
+brother                                           4-23 
+bulletin                                          4-8 
+ 
+CAND                                              5-7 
+CAT                                               5-32 
+change                                            5-33 
+change                                            5-61 
+change all                                        5-33 
+check                                             4-49, 5-4 
+clear                                             4-46 
+clear removed                                     5-51 
+clock                                             5-80 
+code                                              5-34 
+col                                               5-48 
+column                                            6-31 
+COLUMNS                                           6-28 
+COMPILER ERROR                                    5-5 
+complex                                           6-5 
+complex i                                         6-5 
+complex one                                       6-5 
+complex zero                                      6-5 
+compress                                          5-34 
+configurator                                      1-9 
+CONJ                                              6-6 
+Container                                         5-26 
+continue                                          4-3 
+continue scan                                     5-83 
+copy                                              4-26, 5-67 
+COR                                               5-7 
+cos                                               5-20 
+cosd                                              5-20 
+count off                                         6-39 
+count on                                          6-39 
+cout                                              5-75 
+cursor                                            5-71 
+ 
+dataspaces                                        5-66 
+date                                              5-81 
+Datenraum                                         1-3 
+Datensicherheit                                   1-8 
+day                                               5-81 
+decimal exponent                                  5-20 
+DECR                                              5-12, 5-19, 6-10 
+delete char                                       5-34 
+delete record                                     5-50 
+Der EUMEL-Zeichensatz                             5-29 
+Der Lernmodus                                     3-17 
+DET                                               6-28 
+DIRFILE                                          2-73 
+DIV                                               5-12, 6-11 
+do                                                5-2 
+down                                              5-48, 5-57 
+downety                                           5-57 
+dphi                                              6-6 
+ds pages                                          5-66 
+ 
+e                                                 5-21 
+edit                                              3-1, 4-29, 5-62 
+editget                                           4-30, 5-63, 5-72 
+editor                                            1-9 
+Editor verlassen                                  3-2 
+Ein- bzw. Ausschalten der Markierung              3-9 
+Ein- bzw. Ausschalten des Einfügemodus            3-10 
+Einfügen von Textpassagen                         3-6 
+Eingabesteuerzeichen                     5-69 
+Eingabetaste / Absatztaste                        3-4 
+eliminate reports                                 6-39 
+Endlosschleife                                    2-28 
+enter password                                    4-41 
+eof                                               5-43 
+erase                                             4-37 
+Erweiterbarkeit                                   1-6 
+ 
+ESC )                                             3-16 
+ESC (                                             3-16 
+ESC >                                             3-16 
+ESC <                                             3-16 
+ESC 9                                             3-14 
+ESC 1                                             3-14 
+ESC a                                             3-16 
+ESC A                                             3-16 
+ESC b                                             3-14 
+ESC blank                                         3-16 
+ESC d                                             3-15 
+ESC e                                             3-14 
+ESC ESC                                           3-16 
+ESC f                                             3-14 
+ESC g                                             3-15 
+ESC HOP                                           3-17 
+ESC HOP HOP                                       3-17 
+ESC HOP taste                                     3-17 
+ESC k                                             3-16 
+ESC n                                             3-14 
+ESC O                                             3-16 
+ESC o                                             3-16 
+ESC p                                             3-15 
+ESC q                                             3-14 
+ESC RUBIN                                         3-15 
+ESC RUBOUT                                        3-15 
+ESC s                                             3-16 
+ESC ? taste                                       3-16 
+ESC ! taste                                       3-16 
+ESC U                                             3-16 
+ESC u                                             3-16 
+ESC v                                             3-14 
+ESC w                                             3-14 
+ESC k                                             3-16 
+ESC ­                                             3-16 
+ 
+EUMEL-Editor                                      3-1 
+evaluate                                          6-44 
+exp                                               5-21 
+ 
+false                                             5-7 
+family password                                   4-42 
+father                                            4-23 
+Fehlermeldungen des Archivs                       4-52 
+fetch                                             4-33, 5-67 
+fetchall                                          4-34 
+FILE                                             2-73 
+Fixpunkt                                          1-8 
+floor                                             5-21 
+forget                                            4-26, 4-47, 5-67 
+frac                                              5-21 
+ 
+Garbage Collection                                5-26 
+Gelerntes vergessen                               3-17 
+generate counts                                   6-40 
+generate reports                                  6-40 
+get               2-80, 5-44, 5-73, 6-5, 6-12, 6-21, 6-30 
+getchar                                           5-72 
+get cursor                                        5-71 
+getline                                           5-45, 5-74 
+ 
+Häufige Fehler bei der Benutzung von Datenräumen    2-85 
+Häufigkeitszählung                                6-36 
+halt                                              4-4 
+headline                                          5-43 
+heap size                                         5-27 
+help                                              4-5, 4-9 
+hour                                              5-81 
+ 
+idn                                               6-31 
+imag part                                         6-6 
+inchar                                            5-72 
+incharety                                         5-72 
+INCR                                              5-12, 5-19, 6-11 
+INITFLAG                                          2-91 
+initialized                                       2-91 
+initialize random                                 5-13, 5-21 
+input                                          2-75, 5-42 
+insert                                            5-2 
+insert char                                       5-35 
+insert record                                     5-50 
+Installation                                      6-36 
+int                                               5-21 
+int                                               6-13 
+INT-Denoter:                                      2-7 
+INV                                               6-28 
+ 
+Kommando                                          1-9 
+kommando auf taste                                4-31 
+kommando auf taste legen                          4-31 
+Kommando auf Taste legen                          3-16 
+Kommandotaste                                     3-11 
+kommastellen                                      6-44 
+Konfiguration                                     1-9 
+ 
+length                                            5-35, 6-22 
+LENGTH                                            5-35, 6-19 
+Lernen ausschalten                                3-17 
+Lernen einschalten                                3-17 
+lernsequenz auf taste                             4-32 
+lernsequenz auf taste legen                       4-32 
+Lese-Fehler (Archiv)                              4-52 
+LEXEQUAL                                          5-31 
+LEXGREATER                                        5-31 
+LEXGREATEREQUAL                                   5-31 
+lex sort                                          5-64 
+LIKE                                              4-19, 5-59 
+line                                              5-47, 5-71, 5-77 
+line no                                           5-43 
+lines                                             5-43 
+list                                              4-27 
+ln                                                5-22 
+Löschtaste                                        3-10 
+log10                                             5-22 
+log2                                              5-22 
+longint                                           6-13 
+ 
+manager task                                      1-9 
+Mantisse                                          5-16 
+Markierzustand                                    3-9 
+match                                             5-60 
+matchpos                                          5-60 
+matrix                                            6-32 
+max                    5-13, 5-22, 6-13 
+maxint                                            5-13 
+maxlongint                                        6-13 
+maxreal                                           5-22 
+max text length                                   5-35 
+merke                                             6-45 
+min                                               5-13, 5-23, 6-14 
+minint                                            5-14 
+MOD                                               5-14, 5-23, 6-11 
+modify                                           2-75, 5-42 
+Monitor                                           1-9 
+Multi-Tasking-/Multi-User-Betrieb                 1-5 
+myself                                            4-23 
+ 
+name                                              4-25 
+Namensverzeichnis                                 4-16 
+Netzwerkfähigkeit         1-6 
+new                                               5-65 
+next symbol                                       5-83 
+next symbol                                       5-85 
+Nicht abweisende Schleife                         2-29 
+nilspace                                          5-65 
+niltask                                           4-22 
+nilvector                                         6-22 
+norm                                              6-22 
+NOT                                               5-8 
+notion                                            5-56 
+ 
+old                                               5-66 
+online                                            5-79 
+Operationen auf Markierungen                      3-15 
+Operatoren                                        2-14 
+OR                                                5-8 
+OR                                                5-54 
+out                                               5-75 
+output                                            2-75, 5-42 
+out subtext                                       5-76 
+ 
+packets                                           4-8 
+page                                              5-71 
+Paketkonzept                                    2-1 
+pause                                             5-79, 5-82 
+phi                                               6-6 
+pi                                                5-23 
+pos                                               5-36 
+Positionierung                           5-71 
+Positionierung des Cursors                        3-4 
+print                                             4-38 
+PRINTER                                           4-24 
+printer                                           4-24 
+Priorität von generischen Operatoren              2-49 
+Priorität von Operatoren                          2-16 
+prot                                              5-4 
+Prozeduren als Parameter                          2-39 
+Prozeduren mit Parametern                         2-38 
+prozentsatz                                       6-45 
+Prozeßkommunikation         1-6 
+PUBLIC                                            4-24 
+public                                            4-24 
+put         5-46, 5-78, 6-12, 6-21, 6-30, 6-5 
+putline                                           5-46, 5-78 
+ 
+random                                            5-14, 5-23, 6-14 
+read record                                       5-50 
+real                                              5-14, 5-37 
+REAL-Denoter:                                     2-8 
+Realisierung von abstrakten Datentypen            2-47 
+real part                                         6-6 
+referencer                                        6-42 
+Referenzliste                                     6-41 
+Refinements                                       2-1 
+reinsert                                          5-51 
+release                                           4-45 
+remainder                                         4-18 
+remove                                            5-51 
+rename                                            4-28 
+rename myself                                     4-25 
+reorganize                                        5-52 
+replace                                           5-37, 6-22 
+replace column                                    6-34 
+replace element                                   6-34 
+replace row                                       6-35 
+report                                            6-36 
+report off                                        6-40 
+report on                                         6-40 
+reserve                                           4-25 
+REST                                              3-6 
+round                                             5-23 
+row                                               6-32 
+ROWS                                              6-29 
+run                                               5-3 
+runagain                                          5-3 
+ 
+save                                              4-35, 5-67 
+saveall                                           4-36 
+scan                                              5-86 
+Schreibarbeit beenden                             3-2 
+Schutz vor fehlerhaftem Zugriff auf Datenobjekte    2-45 
+Scratch-Datei                                   3-13 
+segments                                          5-52 
+sequential file                                   5-41 
+SHard                                             1-5 
+show                                              4-30 
+shutup                                            1-17 
+sign                                              5-15, 5-24, 6-14 
+SIGN                                              6-11 
+sin                                               5-24 
+sind                                              5-24 
+smallreal                                         5-24 
+SOME                                              2-80, 4-17 
+son                                               4-23 
+sort                                              5-64 
+Spracherweiterung                                 2-44 
+sqrt                                              5-24, 6-6 
+Standard-Datenraum                                1-9 
+std tastenbelegung                                4-32 
+STOP-Taste                                      3-20 
+storage                                           4-11, 5-66 
+storage info                                      4-5, 4-11 
+sub                                               6-33 
+SUB                                               5-37, 6-20 
+subtext                                           5-38 
+supervisor                                        4-24 
+Supervisor                                        1-9 
+SUPERVISOR-Taste                                  3-18 
+Symbole                                           5-83 
+sysin                                             5-73 
+sysout                                            5-77 
+ 
+Tabulatortaste                                    3-8 
+tan                                               5-25 
+tand                                              5-25 
+task                                              4-22 
+Task                                              1-9 
+task info                                         4-5, 4-12 
+Task-Organisation                                 1-2 
+task password                                     4-43 
+task status                                       4-15 
+taste enthaelt kommando                           4-31 
+tecal                                             6-45 
+tecalauskunft                                     6-45 
+text                                              5-15, 5-25, 5-39, 6-15 
+TEXT-Denoter:                                     2-9 
+Thesaurus                                         4-16 
+time                                              5-82 
+time of day                                       5-82 
+TIMESOUT                                          5-76 
+Titelzeile                                        3-2 
+to line                                           5-48 
+transp                                            6-33 
+TRANSP                                            6-29 
+true                                              5-8 
+type                                              5-66 
+TYPE COMPLEX                                      6-3 
+TYPE LONGINT                                      6-8 
+ 
+Überschrift in die Kopfzeile                   5-43 
+Umschalttaste                                     3-4 
+UNLIKE                                            5-59 
+Unterbrechen einer Ausgabe                        3-20 
+up                                                5-49 
+up                                                5-58 
+uppety                                            5-58 
+ 
+vector                                            6-23 
+Vereinbarung eines dyadischen Operators           2-42 
+Vereinbarung eines monadischen Operators          2-42 
+Verstärkertaste                                   3-5 
+Verwendung von Prozeduren                         2-35 
+Virtuelle Speicherverwaltung                      1-7 
+Vorbelegte Tasten                                 3-17 
+ 
+warnings                                          5-4 
+WEITER-Taste                                      3-20 
+Wertliefernde Prozeduren                          2-40 
+Wertliefernde Refinements                         2-34 
+word wrap                                         4-32 
+write                                             5-78 
+write                                             5-47 
+write record                                      5-50 
+ 
+XOR                                               5-8 
+ 
+Zählschleife                                      2-30 
+Zeichen schreiben                                 3-16 
+zero                                              6-15 
+#tableend# 
+
diff --git a/doc/programmer-manual/1.8.7/doc/programmierhandbuch.inhalt b/doc/programmer-manual/1.8.7/doc/programmierhandbuch.inhalt
new file mode 100644
index 0000000..45b3f1f
--- /dev/null
+++ b/doc/programmer-manual/1.8.7/doc/programmierhandbuch.inhalt
@@ -0,0 +1,249 @@
+#setcount (1)# 
+#block##pageblock# 
+#pagenr ("%", 1)# 
+#headeven# 
+#center#EUMEL-Benutzerhandbuch 
+#center#____________________________________________________________ 
+ 
+#end# 
+#headodd# 
+#center#Inhalt 
+#center#____________________________________________________________ 
+ 
+#end# 
+#bottomeven# 
+ 
+#center#____________________________________________________________ 
+I - % #right#GMD 
+#end# 
+#bottomodd# 
+ 
+#center#____________________________________________________________ 
+GMD #right# I - % 
+#end# 
+ 
+#lpos(0.2)##lpos(1.8)##lpos(9.0)# 
+ 
+TEIL 1 : Einleitung 
+#table# 
+1.1  Allgemeines über EUMEL                         1 
+1.2  Struktur des Betriebssystems EUMEL             2 
+1.3  Eigenschaften des Betriebssystems              4 
+     Multi-Tasking-/Multi-User-Betrieb              5 
+     Prozeßkommunikation und Netzwerkfähigkeit      6 
+     Erweiterbarkeit                                6 
+     Virtuelle Speicherverwaltung                   7 
+     Datensicherheit                                8 
+1.4  Wichtige Begriffe                              9 
+1.5  Die Notation in diesem Buch                    10 
+1.6  Die Funktionstasten des EUMEL-Systems          11 
+1.7  Eine Beispielsitzung                           12 
+#tableend# 
+ 
+ 
+ 
+ 
+TEIL 2 : ELAN 
+#table# 
+2.1  Besondere Eigenschaften von ELAN               1 
+2.2  Lexikalische Elemente                          2 
+2.2.1  Schlüsselwörter                              2 
+2.2.2  Bezeichner                                   3 
+2.2.3  Sonderzeichen                                4 
+2.2.4  Kommentare                                   5 
+2.3  Datenobjekte                                   6 
+2.3.1   Elementare Datentypen                       6 
+2.3.1.1  Denoter für elementare Datentypen          7 
+     INT-Denoter:                                   7 
+     REAL-Denoter:                                  8 
+     TEXT-Denoter:                                  9 
+     BOOL-Denoter:                                  9 
+2.3.1.2  LET-Konstrukt für Denoter                  10 
+2.3.2   Zugriffsrecht                               11 
+2.3.3  Deklaration                                  11 
+2.3.4  Initialisierung                              12 
+2.4  Programmeinheiten                              13 
+2.4.1  Elementare Programmeinheiten                 14 
+2.4.1.1  Ausdruck                                   14 
+     Operatoren                                     14 
+     Priorität von Operatoren                       16 
+2.4.1.2  Zuweisung                                  18 
+2.4.1.3  Refinementanwendung                        19 
+2.4.1.4  Prozeduraufruf                             20 
+2.4.2  Zusammengesetzte Programmeinheiten           22 
+2.4.2.1  Folge                                      22 
+2.4.2.2  Abfrage                                    23 
+2.4.2.3  Auswahl                                    26 
+2.4.2.4  Wertliefernde Abfrage                       
+         und wertliefernde Auswahl                  27 
+2.4.2.5  Wiederholung                               27 
+     Abfragekette                                   25 
+     Endlosschleife                                 28 
+     Abweisende Schleife                            29 
+     Nicht abweisende Schleife                      29 
+     Zählschleife                                   30 
+2.4.3  Abstrahierende Programmeinheiten             32 
+2.4.3.1  Refinementvereinbarung                     32 
+     Vorteile der Refinementanwendung               33 
+     Wertliefernde Refinements                      34 
+2.4.3.2  Prozedurvereinbarung                       35 
+2.4.3.3  Operatorvereinbarung                       41 
+     Verwendung von Prozeduren                      35 
+     Prozeduren mit Parametern                      38 
+     Prozeduren als Parameter                       39 
+     Wertliefernde Prozeduren                       40 
+     Vereinbarung eines monadischen Operators       42 
+     Vereinbarung eines dyadischen Operators        42 
+2.4.3.4  Paketvereinbarung                          43 
+     Spracherweiterung                              44 
+     Schutz vor fehlerhaftem Zugriff                
+     auf Datenobjekte                           45 
+     Realisierung von abstrakten Datentypen         47 
+2.4.4  Terminatoren für Refinements,             
+       Prozeduren und Operatoren                    48 
+2.4.5  Generizität von Prozeduren und Operatoren      49 
+     Priorität von generischen Operatoren           49 
+2.4.6   Rekursive Prozeduren und Operatoren        50 
+2.5     Programmstruktur                            52 
+2.6  Zusammengesetzte Datentypen                    56 
+2.6.1  Reihung                                      56 
+2.6.2  Struktur                                     61 
+2.6.3  LET-Konstrukt für                        
+       zusammengesetzte Datentypen      64 
+2.6.4  Denoter für zusammengesetzte     
+       Datentypen (Konstruktor)      65 
+2.7  Abstrakte Datentypen                           67 
+2.7.1  Definition neuer Datentypen                  67 
+2.7.2  Konkretisierung                              69 
+2.7.3  Denoter für abstrakte Datentypen (Konstruktor)      70 
+2.8  Dateien                                        73 
+2.8.1  Datentypen FILE und DIRFILE                  73 
+     FILE:                                          73 
+     DIRFILE:                                       73 
+2.8.2  Deklaration und Assoziierung                 74 
+     input:                                         75 
+     output:                                        75 
+     modify:                                        75 
+2.9  Abstrakte Datentypen im EUMEL-System          77 
+2.9.1  Datentyp TASK                                77 
+2.9.2   Datentyp THESAURUS                          79 
+2.9.3  Datenräume                                   81 
+2.9.3.1  Datentyp DATASPACE                         82 
+2.9.3.2  BOUND-Objekte                              83 
+     Häufige Fehler bei der Benutzung von Datenräume  85 
+2.9.3.3  Definition neuer Dateitypen                88 
+2.9.4  Datentyp INITFLAG                            91 
+#tableend# 
+ 
+ 
+ 
+ 
+TEIL 3 : Der Editor 
+#table# 
+3.1  Ein- und Ausschalten des Editors               1 
+3.2  Die Funktionstasten                            3 
+3.3  Die Wirkung der Funktionstasten                4 
+3.4  ESC Kommandos                                  11 
+     Operationen auf Markierungen                   15 
+     Zeichen schreiben                              16 
+     Kommando auf Taste legen                       16 
+     Vorbelegte Tasten                              17 
+     Der Lernmodus                                  17 
+3.5  Positionieren, Suchen, Ersetzen          
+     im Kommandodialog                          21 
+     Weitere Hilfen                                 23 
+#tableend# 
+ 
+ 
+ 
+ 
+TEIL 4 : Kommandosprache 
+#table# 
+4.1  Supervisor                                     2 
+4.2  Monitor                                        6 
+4.2.1  Hilfsprozeduren                              8 
+     Informationsprozeduren                         11 
+4.2.2  Thesaurus                                    16 
+4.2.3  Tasks                                        21 
+4.2.4  Handhabung von Dateien                       26 
+4.2.5  Editor-Prozeduren                            29 
+4.2.6  Dateitransfer                                33 
+4.2.7  Passwortschutz                               39 
+4.2.8  Das Archiv                                   44 
+     Fehlermeldungen des Archivs                    52 
+#tableend# 
+ 
+ 
+ 
+ 
+TEIL 5 : Programmierung 
+#table# 
+5.1  Der ELAN-Compiler                              1 
+5.1.1  Fehlermeldungen des ELAN-Compilers           5 
+5.2  Standardtypen                                  7 
+5.2.1  Bool                                         7 
+5.2.2  Integer-Arithmetik                           9 
+5.2.3  Real-Arithmetik                              16 
+5.2.4  Text                                         26 
+     Der EUMEL-Zeichensatz                          29 
+5.3.1  Assoziierung                                 41 
+5.3.2  Informationsprozeduren                       43 
+5.3.3  Betriebsrichtung INPUT                       44 
+5.3.4  Betriebsrichtung OUTPUT                      46 
+5.3.5  Betriebsrichtung MODIFY                      48 
+5.3.6  FILE -Ausschnitte                            51 
+5.4  Suchen und Ersetzen in Textdateien             53 
+5.4.1  Aufbau von Textmustern                       54 
+5.4.2  Suche nach Textmustern                       57 
+5.4.3  Treffer registrieren                         59 
+5.4.4  Treffer herausnehmen                         60 
+5.4.5  Ändern in Dateien                            61 
+5.4.6  Editor-Prozeduren                            62 
+5.4.7  Sortierung von Textdateien                   64 
+5.4.8  Prozeduren auf Datenräumen                   65 
+5.5  Eingabe/Ausgabe                                68 
+5.5.1  E/A auf Bildschirm                           69 
+5.5.1.1  Eingabesteuerzeichen                       69 
+5.5.1.2  Ausgabesteuerzeichen                       70 
+5.5.1.3  Positionierung                             71 
+     Grundlegende Prozeduren                        72 
+     Umleitbare Eingabeprozeduren                   73 
+     Grundlegende Prozeduren                        75 
+     Umleitbare Ausgabeprozeduren                   77 
+5.5.1.4  Eingabe                                    72 
+5.5.1.5  Ausgabe                                    75 
+5.5.1.6  Kontrolle                                  79 
+5.5.2  Zeitmessung                                  80 
+5.6  Scanner                                        83 
+     Scanner-Kommandos                              85 
+#tableend# 
+ 
+ 
+ 
+ 
+TEIL 6 : Das Archiv 'std zusatz' 
+#table# 
+6.1   Erweiterungen um Mathematische Operationen      2 
+6.1.1  COMPLEX                                      2 
+6.1.2  LONGINT                                      7 
+6.1.3  VECTOR                                       16 
+6.1.4  MATRIX                                       24 
+6.2  Programmanalyse                                36 
+     reporter - Kommandos                           39 
+     Referencer                                     41 
+     referencer - Kommandos                         42 
+6.3  Rechnen im Editor                              43 
+     Arbeitsweise                                   43 
+     TeCal Prozeduren                               44 
+#tableend# 
+ 
+ 
+ 
+ 
+Anhang : ELAN-Syntaxdiagramme 
+ 
+ 
+ 
+ 
+INDEX 
+
diff --git a/doc/programmer-manual/1.8.7/doc/programmierhandbuch.titel b/doc/programmer-manual/1.8.7/doc/programmierhandbuch.titel
new file mode 100644
index 0000000..79b09b0
--- /dev/null
+++ b/doc/programmer-manual/1.8.7/doc/programmierhandbuch.titel
@@ -0,0 +1,52 @@
+____________________________________________________________________________ 
+ 
+ 
+#on("b")##on ("u")# 
+#center#Betriebssystem E U M E L 
+#off ("u")# 
+ 
+ 
+#center#Programmierhandbuch 
+ 
+ 
+ 
+ 
+#off("b")# 
+#center#Lizenzfreie Software der 
+#on ("b")# 
+ 
+#center#Gesellschaft für Mathematik und Datenverarbeitung mbH, 
+#center#5205 Sankt Augustin 
+ 
+ 
+#off("b")# 
+#center#Die Nutzung der Software ist nur im Schul- und Hochschulbereich für 
+#center#nichtkommerzielle Zwecke gestattet. 
+ 
+#center#Gewährleistung und Haftung werden ausgeschlossen 
+ 
+ 
+____________________________________________________________________________ 
+#page# 
+#block##pageblock# 
+#start(5.0,1.5)# 
+ 
+#lpos(3.0)# 
+#table# 
+ 
+ 
+ 
+ 
+ 
+ 
+Benutzerhandbuch 
+ 
+Programmierung 
+ 
+ 
+ 
+Stand:  1.7.87 
+ 
+#tableend##page# 
+
+
diff --git a/doc/programmer-manual/1.8.7/source-disk b/doc/programmer-manual/1.8.7/source-disk
new file mode 100644
index 0000000..13e2021
--- /dev/null
+++ b/doc/programmer-manual/1.8.7/source-disk
@@ -0,0 +1 @@
+grundpaket/10_handbuecher.2.img