Initial import

4 files changed, 4446 insertions, 0 deletions

diff --git a/lang/basic/1.8.7/doc/basic handbuch.1 b/lang/basic/1.8.7/doc/basic handbuch.1
new file mode 100644
index 0000000..2e604cb
--- /dev/null
+++ b/lang/basic/1.8.7/doc/basic handbuch.1
@@ -0,0 +1,1075 @@
+____________________________________________________________________________ 
+ 
+ 
+#on("b")##on ("u")# 
+#center#Betriebssystem E U M E L 
+#off ("u")# 
+ 
+ 
+#center#Basic 
+ 
+ 
+ 
+ 
+#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# 
+#page nr ("%", 1)# 
+#head# 
+EUMEL-BASIC-Compiler         Inhalt                          % 
+#end# 
+ 
+Inhalt 
+ 
+1  Einleitung                                                3 
+ 
+2  Installation des BASIC-Compilers                          4 
+ 
+3  Aufruf und Steuerung des BASIC-Compilers                  5 
+ 
+4  Umgang mit dem BASIC-Compiler                             7 
+4.1  Erläuterungen zur Syntax                                7 
+4.2  Datentypen und Konstanten                               10 
+4.3  Variablen und Felder                                    12 
+4.4  Operatoren                                              14 
+4.5  Funktionen                                              19 
+4.6  Typanpassung                                            22 
+4.7  Aufruf von EUMEL-Prozeduren in BASIC-Programmen         23 
+ 
+5  Steuerung der Bildschirmausgaben                          25 
+ 
+6  Grenzen des Compilers                                     26 
+ 
+7  Fehlerbehandlung                                          28 
+7.1  Fehler zur Übersetzungszeit                             28 
+7.2  Fehler zur Laufzeit                                     30 
+ 
+8  Übersicht über die Anweisungen und Funktionen             31 
+ 
+9  Anpassung von Programmen an den EUMEL-BASIC-Compiler      96 
+9.1  Unterschiede zwischen BASIC-Interpretern 
+     und dem EUMEL-BASIC-Compiler                            96 
+9.2  Abweichungen von ISO 6373-1984 (Minimal-BASIC)          97 
+9.3  Anpassung von Microsoft-BASIC Programmen 
+     an den EUMEL-BASIC-Compiler                             98 
+ 
+Anhang A: Reservierte Wörter                                100 
+Anhang B: Vom Scanner erkannte Symboltypen                  103 
+Anhang C: Übersicht über die Fehlermeldungen                106 
+Anhang D: ELAN-Prozeduren des Compilers                     113 
+#page# 
+ 
+ 
+#page nr ("%", 3)# 
+#head# 
+EUMEL-BASIC-Compiler                1. Einleitung              % 
+ 
+#end# 
+ 
+1. Einleitung 
+ 
+ 
+BASIC entspricht heute nicht mehr den Vorstellungen von einer modernen Program­
+miersprache. Dennoch wurde für das EUMEL-Betriebssystem ein Compiler für BASIC
+entwickelt. Er soll vor allem dazu dienen, schon bestehende BASIC-Programme -
+gegebenenfalls nach entsprechender Anpassung -  auch unter EUMEL verfügbar zu
+machen. 
+Der Compiler ist weitgehend an die ISO-Norm 6373 für Minimal-BASIC angelehnt.
+Die Syntax und Bedeutung der Anweisungen orientiert sich in den meisten Fällen an
+Microsoft-BASIC. Anweichungen treten insbesondere an den Stellen auf, an denen
+Prinzipien des Betriebssystems EUMEL verletzt würden. 
+Verglichen mit dem ELAN-Compiler des EUMEL-Systems ist der BASIC-Compiler
+beim Übersetzen recht langsam. Auch aus diesem Grund scheint es nicht sinnvoll,
+den BASIC-Compiler zur Neuentwicklung größerer Programme einzusetzen. 
+ 
+Sinn dieses Handbuchs ist es vor allem, Kenntnisse über den Umgang mit dem
+EUMEL-BASIC-Compiler zu vermitteln. Das Handbuch ist auf keinen Fall als Ein­
+führung in die Programmiersprache BASIC gedacht, sondern es soll dem Benutzer mit
+BASIC-Erfahrung die Arbeit mit dem EUMEL-BASIC-Compiler ermöglichen und
+erleichtern. Neben Erfahrung in BASIC setzt dieses Buch an einigen Stellen auch
+Grundkenntnisse über das EUMEL-System voraus. 
+ 
+ 
+ 
+Zur #ib(4)#Notation#ie(4)# in dieser Beschreibung 
+ 
+Bei der Beschreibung der Anweisungen und Funktionen und auch an anderen Stellen
+werden in dieser Beschreibung Syntaxregeln für BASIC-Programme oder Teile davon
+angegeben. Dabei werden folgende Zeichen mit besonderer Bedeutung verwendet: 
+ 
+[ ]       optionale Angabe 
+[...]     beliebig häufige Wiederholung der letzten optionalen Angabe 
+|         alternative Angabe, d.h. entweder die letzte links stehende Angabe oder
+          die nächste rechts stehende Angabe, aber nicht beide 
+< >       in spitzen Klammern stehende Begriffe sind entweder definiert (z.B. <Va­
+          riable>) oder werden hinter der Syntaxregel erläutert 
+ 
+Die Notation der exportierten ELAN-Prozeduren des Compilers (besonders in An­
+hangD) entspricht der in den EUMEL-Handbüchern üblichen Prozedurkopf-
+Schreibweise. 
+#page# 
+#head# 
+EUMEL-BASIC-Compiler      2. Installation des BASIC-Compilers       % 
+ 
+#end#
+ 
+2. #ib(3)#Installation des BASIC-Compilers#ie(3)# 
+ 
+ 
+Der EUMEL-BASIC-Compiler wird auf zwei Disketten mit jeweils 360 KByte
+Speicherkapazität ausgeliefert. 
+Auf der Diskette "BASIC.1" befindet sich das #ib(3)#Generatorprogramm#ie(3)#("gen.BASIC") zur 
+Installation des EUMEL-BASIC-Systems. 
+Legen Sie diese Diskette in das Laufwerk ihres Rechners ein und geben Sie in der
+Task, in der das BASIC-System installiert werden soll, folgende Zeile nach 'gib
+kommando :' (oder 'maintenance :') ein: 
+ 
+archive ("BASIC.1"); fetch ("gen.BASIC", archive); run 
+ 
+Lassen Sie die Diskette 'BASIC.1' im Laufwerk und antworten Sie auf die Frage
+"Archiv "BASIC.1" eingelegt(j/n)?" mit "j". Das Generatorprogramm holt nun einige
+Dateien von der Diskette. Nach Zugriff auf das Archiv erscheint die Meldung "Archiv
+abgemeldet!" und die Frage "Archiv 'BASIC.2' eingelegt(j/n)?". Legen Sie nun statt
+des Archivs 'BASIC.1' das Archiv 'BASIC.2' in das Laufwerk ein und drücken Sie bitte
+wiederum "j". Nach weiteren Archivoperationen erscheint dann wieder die Meldung
+"Archiv abgemeldet". Sie können nun die Diskette "BASIC.2" aus dem Laufwerk
+entnehmen. 
+Das Generatorprogramm insertiert nun alle Programme des BASIC-Systems in der
+Task. Dieser Vorgang nimmt einige Zeit in Anspruch. Zum Abschluß erscheint die
+Meldung "BASIC-System installiert". 
+Der EUMEL-BASIC-Compiler steht Ihnen nun in der Task (und in nachfolgend
+eingerichteten Söhnen) zur Verfügung. 
+#page# 
+#head# 
+EUMEL-BASIC-Compiler     3. Aufruf und Steuerung des BASIC-Compilers   % 
+ 
+#end# 
+ 
+3. #ib(4)#Aufruf und #ib(3)#Steuerung des BASIC-Compilers#ie(3)##ie(4)# 
+    
+ 
+ 
+ 
+Übersetzen von BASIC-Programmen 
+ 
+Ein BASIC-Programm, das vom Compiler übersetzt werden soll, muß sich dazu in
+einer EUMEL-Textdatei befinden (Syntax vgl. Kap. 4.). Steht das BASIC-Programm
+zum Beispiel in der Datei "Programm.17+4", so wird der Compiler mit 
+ 
+    #ib(3)#basic#ie(3)# ("Programm.17+4") 
+ 
+zum Übersetzen dieses Programms aufgerufen. 
+In einem Vordurchlauf werden die Zeilennummern des Programms auf Richtigkeit
+überprüft. Beim eigentlichen Compilerdurchlauf wird das BASIC-Programm dann mit
+Hilfe des EUMEL-Coders in einen von der EUMEL-0-Maschine ausführbaren Code
+übersetzt. 
+ 
+Das Programm wird mit 'check on' (Zeilennummergenerierung) übersetzt. 
+Ein 'runagain' wie bei ELAN-Programmen ist bei BASIC-Programmen zur Zeit
+leider nicht möglich. 
+ 
+ 
+ 
+Insertieren von BASIC-Programmen 
+ 
+Der BASIC-Compiler kann BASIC-Programme auch insertieren. Das ganze Pro­
+gramm bildet dabei eine Prozedur, die nach dem Insertieren wie eine 'normale'
+ELAN-Prozedur aufgerufen werden kann. 
+Zum Insertieren wird der Compiler mit einem zusätzlichen Text-Parameter aufge­
+rufen: 
+ 
+    #ib(3)#basic#ie(3)# ("Programm.17+4", "blackjack") 
+ 
+Das Programm wird übersetzt und, falls keine Fehler gefunden wurden, fest einge­
+tragen ('insertiert'). Gestartet wird das Programm aber nicht. 
+"blackjack" ist nun der Prozedurname, unter dem das BASIC-Programm nach erfolg­
+reichem Insertieren aufgerufen werden kann. 
+Bei 'packets' erscheint jetzt der Eintrag 'BASIC.blackjack' in der Liste der insertierten
+Pakete, und ein 'help ("blackjack")' zeigt, daß eine Prozedur 'blackjack' nun tatsäch­
+lich in der Task bekannt ist. Die Prozedur 'bulletin' funktioniert für insertierte
+BASIC-Programme nicht. Sie ist aber auch nicht nötig, da das 'Paket' mit dem
+BASIC-Programm ohnehin nur eine Prozedur enthält und ihr Name ja schon aus
+dem Namen des Paketes hervorgeht. 
+ 
+#on ("b")# 
+Beachten Sie: 
+  - Der Prozedurname muß der Syntax für ELAN-Prozedurnamen entsprechen, darf
+    aber #on ("b")#keine Leerzeichen enthalten. 
+  - Die BASIC-Programme können über den Prozedurnamen nur aufgerufen wer­
+    den; die Übergabe von Parametern ist ebenso wie Wertlieferung nicht möglich. 
+  - Jedes Insertieren belegt Speicherplatz im Codebereich der Task. Weil der Coder
+    und der Compiler ebenfalls recht viel Code belegen, kann es (vor allem, wenn
+    die BASIC-Programme lang sind) schnell zu einem Code-Überlauf kommen
+    (Compiler Error 305). Es sollten daher nur die Programme insertiert werden, für
+    die dies wirklich nötig ist. 
+  - Achten Sie bei der Wahl des Namens für die gelieferte Prozedur darauf, daß sie
+    nicht ungewollt Prozeduren des Betriebssystems überdecken. (Der Aufruf 'ba­
+    sic("tadellos","help")' wäre z.B. gar nicht tadellos, denn 'help' wäre nach dem
+    Insertieren überdeckt). 
+  - Auch beim Insertieren werden die BASIC-Programme mit 'check on' übersetzt. 
+#off ("b")#  
+ 
+ 
+Ausgabe der übersetzten Zeilen während des
+Compilierens 
+Mit '#ib(3)#basic list#ie(3)# (TRUE)' wird der Compiler so eingestellt, daß beim Übersetzen die
+aktuelle Programmzeile ausgegeben wird. Diese Ausgabe kann auch mit '#ib(3)#sysout#ie(3)#'
+umgeleitet werden. Zum Beispiel: 
+ 
+   sysout ("Fehlerprotokoll"); basic ("Programm.17+4") 
+ 
+Dies kann beim #ib(3)#Debugging#ie(3)# von BASIC-Programmen eine wertvolle Hilfe sein, da in
+der Ausgabedatei die Fehler sofort hinter der betreffenden Programmzeile vermerkt
+werden. Das 'sysout' muß in Monitortasks ('gib kommando:') direkt vor dem Aufruf
+des Compilers gegeben werden, weil der Monitor 'sysout' sonst wieder zurücksetzt. 
+ 
+Mit 'basic list (FALSE)' kann die Ausgabe der Programmzeilen beim Übersetzen
+wieder ausgeschaltet werden. 
+ 
+#page# 
+#head# 
+EUMEL-BASIC-Compiler       4. Umgang mit dem BASIC-Compiler       % 
+ 
+#end# 
+ 
+4. Umgang mit dem BASIC-Compiler 
+ 
+ 
+ 
+4.1. Erläuterungen zur #ib(3)#Syntax#ie(3)# 
+ 
+ 
+Ein zu übersetzendes Programm muß dem BASIC-Compiler in Form einer
+#ib(3)#EUMEL-Textdatei#ie(3)# übergeben werden. (Es gelten somit auch die für EUMEL-Text­
+dateien üblichen Begrenzungen, z.B. höchstens 32000 Zeichen pro Zeile und höch­
+stens 4075 Dateizeilen pro Datei.) 
+BASIC-Programme setzen sich aus Programmzeilen zusammen; jede Dateizeile der
+#ib(3)#Programmdatei#ie(3)# bildet eine BASIC-Programmzeile. Die Syntax für ein Programm sieht
+damit so aus: 
+ 
+ 
+<Programmzeile>[<Programmzeile>][...]EOF 
+ 
+Dabei bedeutet #ib(3)#EOF (end of file)#ie(3)# das Ende der Programmdatei. 
+ 
+Eine #ib(3)#Programmzeile#ie(3)# hat folgende Syntax: 
+ 
+ 
+[<Zeilennummer>][<Anweisung>][:<Anweisung>][...][:]EOL 
+ 
+Die #ib(3)#Zeilennummer#ie(3)# dient unter anderem als Sprungadresse an den Anfang der Pro­
+grammzeile während der Laufzeit des Programms (vgl. 'GOTO' und 'GOSUB'). Sie ist
+fakultativ (d.h. sie muß nicht geschrieben werden). Durch sparsame Verwendung von
+Zeilennummern (nämlich nur da, wo sie benötigt werden) kann eine gewisse Steige­
+rung der #ib(3)#Übersichtlichkeit von BASIC-Programmen#ie(3)# erreicht werden. Hat eine Pro­
+grammzeile keine Zeilennummer, so wird bei Fehlermeldungen (sowohl während der
+Übersetzung als auch zur Laufzeit des Programms) die letzte Zeilennummer mit
+angegeben, die davor auftrat. 
+Zeilennummern dürfen im Bereich von 1 bis 32767 liegen und müssen unbedingt in
+aufsteigender Reihenfolge vergeben werden. Zeilennummern dürfen keine Leerzeichen
+enthalten und müssen mit einem Leerzeichen abgeschlossen werden. Um spätere
+Ergänzungen zu ermöglichen, ist eine Numerierung im Abstand zehn empfehlenswert. 
+ 
+Hier ein Beispiel, wie ein BASIC-Programm in einer EUMEL-Datei aussehen
+könnte: 
+ 
+ 
+...........................Einmaleins............................ 
+10 CLS: PRINT "Kleines Einmaleins" 
+   FOR zahl% = 1 TO 10 
+     PRINT 
+     'Erzeugung einer Zeile 
+     FOR faktor% = 1 TO 10 
+       PRINT TAB (faktor% * 5); 
+       PRINT USING "\#\#\#"; faktor% * zahl%; 
+     NEXT faktor% 
+   NEXT zahl% 
+ 
+ 
+ 
+ 
+Die Syntax der Anweisungen, die vom EUMEL-BASIC-Compiler übersetzt werden
+können, ist ausführlich im Kapitel 8 beschrieben. 
+ 
+Der #ib(3)#Doppelpunkt#ie(3)# dient als Trennzeichen zwischen Anweisungen. Ihm muß nicht
+unbedingt eine Anweisung folgen. Er kann somit als explizites "Ende der
+Anweisung"-Symbol aufgefaßt werden (#ib(3)#EOS, "end of statement"#ie(3)#). 
+ 
+#ib(3)#EOL (end of line)#ie(3)# ist das Ende einer Dateizeile. (Dieses "Zeichen" ist ebenso wie
+EOF beim Editieren der Datei nicht sichtbar.) 
+Das #ib(3)#Hochkomma#ie(3)# ("'", Code 39) wird vom Compiler ebenfalls als EOL interpretiert.
+Alle dem Hochkomma in der Dateizeile folgenden Zeichen werden überlesen. Dies
+ermöglicht das Schreiben von Kommentaren ohne Verwendung der
+'REM'-Anweisung. 
+ 
+Es sei hier bereits bemerkt, daß sich durch die Realisierung des Übersetzers als
+#on ("b")#Compiler gewisse Unterschiede gegenüber Interpretern #off ("b")#ergeben (siehe hierzu Kap. 9).
+Der wesentliche Unterschied ist, daß der Interpreter dem Programmtext analog zum
+Programmablauf folgt, der Compiler das Programm aber von vorne bis hinten Zeile für
+Zeile übersetzt. Dies hat zur Folge, daß z.B. die Dimensionierungen von Feldvariablen
+#on ("b")#textuell vor der Verwendung der Variablen stattfinden müssen#off ("b")# und nicht, wie bei
+Interpretern, nur im Ablauf des Programms vorher ausgeführt werden müssen. 
+ 
+ 
+ 
+Weitere Schreibregeln 
+ 
+#on ("b")# 
+1. #ib(3)#Groß-/Kleinschreibung#ie(3)##off ("b")# 
+Für den BASIC-Compiler bestehen zwischen kleinen und großen Buchstaben keiner­
+lei Unterschiede, es sei denn es handelt sich um Textdenoter (Textkonstanten). 
+Daher können alle #ib(3)#Schlüsselwörter#ie(3)# und #ib(3)#Variablennamen#ie(3)# mit kleinen oder großen
+Buchstaben geschrieben werden. Aus der Tatsache, daß zwischen großen und kleinen
+Buchstaben nicht unterschieden wird, folgt aber bespielsweise auch, daß die Variab­
+lennamen (vgl. 4.3.) 'hallo' und 'HALLO' ein und dieselbe Variable bezeichnen. 
+ 
+#on ("b")# 
+2. #ib(3)#Reservierte Wörter#ie(3)##off ("b")# 
+Der BASIC-Compiler erkennt eine ganze Reihe #on("i")#reservierter Wörter#off("i")#. Es handelt sich
+hierbei im wesentlichen um die Namen der Anweisungen und Funktionen. Sie sollten
+im eigenen Interesse darauf achten, daß sich sowohl vor als auch hinter reservier­ 
+ten Wörtern stets mindestens ein #on ("b")##ib(3)#Leerzeichen#ie(3)##off ("b")# (Blank) befindet. Der #ib(3)#Scanner#ie(3)# (ver­
+gleiche AnhangB) erkennt zwar manchmal die reservierten Wörter auch ohne Leer­
+zeichen, aber unter bestimmten Umständen kann es auch zu erkannten oder - noch
+schlimmer -  vom Compiler unerkannten Fehlern kommen. 
+Hierzu zwei Beispiele: 
+Die Anweisung 'IF a > b THENPRINT "größer"' führt beim Compilieren zur Fehler­
+meldung "Syntaxfehler:   THEN oder GOTO erwartet". 
+Wesentlich gefährlicher ist da schon die Programmzeile 
+     "LEThallo = 3 : PRINT hallo", 
+denn die unerwartete Wirkung ist die Ausgabe von "0" auf dem Bildschirm. Der Wert
+"3" wurde nämlich nicht der Variablen mit dem Namen "hallo" zugewiesen, sondern
+einer Variablen namens "LEThallo". 
+ 
+#on ("b")# 
+3. Bedeutung der #ib(3)#Leerstelle#ie(3)# ("Blank") für den Compiler#off("b")# 
+Wie schon aus dem vorhergehenden Punkt ersichtlich kann das Fehlen von trennen­
+den Leerstellen unschöne Effekte haben, denn der #ib(3)#Scanner#ie(3)# (vgl. AnhangB) des
+BASIC-Compilers erkennt anhand der Leerstelle (Code 32) beim Durchlauf durch das
+Programm, daß ein #ib(3)#Symbol#ie(3)# zu Ende ist. 
+Es kommt somit immer dann zu Fehlern, wenn zwei Symbole (z.B. reservierte Wörter,
+Konstanten, Variablen etc.) nicht durch Leerzeichen getrennt sind, und der Scanner
+sie als ein Symbol "versteht". 
+Beispiel: 
+     "a = 3 : b = 4 : PRINT a b"   erzeugt die Ausgabe "34". 
+     "a = 3 : b = 4 : PRINT ab"    erzeugt hingegen die Ausgabe "0", denn der
+Compiler sieht "ab" als #on ("b")#einen Variablennamen an. #off ("b")# 
+ 
+ 
+ 
+4.2. #ib(3)#Datentypen#ie(3)# und #ib(3)#Konstanten#ie(3)# 
+ 
+ 
+Der EUMEL-BASIC-Compiler unterscheidet grundsätzlich zwischen zwei Daten­
+typen, nämlich zwischen #ib(3)#Texte#ie(3)#n und #ib(3)#Zahlen#ie(3)#. 
+ 
+#on ("b")# 
+#ib(3)#Datentyp TEXT#ie(3)# #off ("b")# 
+Texte dürfen alle Zeichen enthalten (Codes 0 bis 255) und bis zu 32000 Zeichen lang
+sein. 
+Die zugehörigen Konstanten werden von #ib(3)#Anführungszeichen#ie(3)# begrenzt, z.B.: 
+  "Anzahl Einträge: " 
+  "2.32 DM" 
+  "General-Musik-Direktor" 
+Anführungszeichen (Code 34) dürfen #on("i")#innerhalb#off("i")# von Text-Konstanten nicht vor­
+kommen. 
+ 
+Bei Zahlen unterscheidet der Compiler noch zwischen #ib(3)#INTs#ie(3)# (#ib(3)#Ganzzahlen#ie(3)#) und REALs
+(#ib(3)#Gleitkommazahlen#ie(3)#). Diese entsprechen im Hinblick auf den Wertebereich genau den
+in ELAN bekannten INTs und REALs. 
+ 
+#on ("b")# 
+#ib(3)#Datentyp INT#ie(3)# #off ("b")# 
+INT-Werte dürfen zwischen -32768 und 32767 liegen. INT-Konstanten dürfen aber
+#on("i")#nur#off("i")# aus Ziffern und einem optionalen '%'-Zeichen am Ende bestehen. Das bedeutet,
+daß die INT-Konstanten im Bereich von 0 bis 32767 liegen können. 
+Ein nachgestelltes '%'-Zeichen kennzeichnet eine Konstante nochmals explizit als
+INT. (Diese Option wurde aus Kompatibilitätsgründen implementiert.) 
+ 
+#on ("b")# 
+#ib(3)#Datentyp REAL#ie(3)# #off ("b")# 
+REALs können Werte zwischen -9.999999999999*10#u#126#e# und 
+9.999999999999*10#u#126#e# annehmen. 
+Die kleinste positive von Null verschiedene Zahl ist 9.999999999999*10#u#-126#e#. 
+Der kleinste REAL-Wert mit x + 1.0 > 1.0 ist gleich 10#u#-12#e#. 
+REAL-Konstanten werden gebildet aus Vorkommastellen, Dezimalpunkt, Nachkom­
+mastellen, Zeichen "E" oder "D" (jeweils auch klein) für den #ib(3)#Exponent#ie(3)#en gefolgt vom
+Vorzeichen und den Ziffern des Exponenten. 
+Dabei müssen nicht für jede REAL-Konstante alle diese Elemente benutzt werden.
+Unverzichtbar sind #on("i")#entweder#off("i")# der Dezimalpunkt #on("i")#oder#off("i")# der Exponent. Ebenso müssen
+zumindest entweder Vor- oder Nachkommastellen vorhanden sein. 
+ 
+Beispiele für gültige REAL-Konstanten sind: 
+  0. 
+  .01 
+  1E-17 
+  2.9979D8 
+  .3e-102 
+  100.e+7 
+ 
+Nicht erlaubt sind dagegen folgende Schreibweisen für REAL-Konstanten: 
+  e12         (#ib(3)#Mantisse#ie(3)# fehlt) 
+  100         (ist INT-Konstante) 
+  .           (weder Vor- noch Nachkommastellen) 
+  .E-12       (dito) 
+  1exp-3      ('exp' nicht erlaubt) 
+  -1.99e30    (Mantisse hat Vorzeichen) 
+ 
+Das letzte Beispiel zeigt, daß auch vor REAL-Konstanten keine #ib(3)#Vorzeichen#ie(3)# erlaubt
+sind. Da normalerweise keine REAL-Konstanten, sondern vielmehr numerische
+Ausdrücke verlangt werden, können durch Voranstellen des Operators '-' (vgl. 4.4.)
+auch #ib(3)#negative Zahlenwerte#ie(3)# leicht erzeugt werden. 
+ 
+An REAL-Konstanten darf eines der Zeichen "!" und "\#" angehängt werden. Diese
+Option wurde aus Kompatibilitätsgründen eingebaut. Wird ein "!" oder "\#" an eine
+INT-Konstante angehängt, so verwandelt es diese in eine REAL-Konstante. 
+Beispiel: 10000! oder 10000\# entspricht 10000. oder 1E4 
+ 
+ 
+#page# 
+ 
+4.3. Variablen und Felder 
+ 
+ 
+Variablen 
+ 
+Der BASIC-Compiler stellt für die in 4.2. vorgestellten Datentypen TEXT, INT und
+REAL auch Variablen zur Verfügung. 
+Die #ib(3)#Variablennamen#ie(3)# müssen folgenden Bedingungen genügen: 
+- Ein Variablenname muß mit einem Buchstaben beginnen. 
+- Variablennamen dürfen ab der zweiten Stelle außer Buchstaben auch Ziffern, Dezi­
+  malpunkte sowie die Zeichen "!", "\#", "$" und "%" enthalten. Leerzeichen dürfen
+  in Variablennamen dagegen nicht vorkommen. 
+- Variablennamen dürfen nicht mit FN beginnen (vgl. 4.5. benutzer-definierte Funk­
+  tionen). 
+- #ib(3)#Reservierte Wörter#ie(3)# (siehe Anhang A) dürfen kein Variablenname sein. Als Teiltexte
+  dürfen reservierte Wörter aber in Variablennamen enthalten sein (auch am Anfang). 
+ 
+Variablennamen dürfen beliebig lang sein, und alle Zeichen eines Variablennamens
+sind signifikant. 
+ 
+Welchen Typ eine Variable hat, entscheidet der Compiler nach folgenden #ib(3)#Kriterien#ie(3, " für den Typ einer Variablen")# (in
+der Reihenfolge ihrer Beachtung): 
+- Ist das letzte Zeichen des Namens ein "!" oder "\#", so bezeichnet er eine
+  REAL-Variable. 
+- Ist das letzte Zeichen ein "%", so handelt es sich um eine INT-Variable. 
+- Ist das letzte Zeichen des Namens ein "$", so ist die Variable vom Typ TEXT. 
+- Liegt das erste Zeichen des Namens im Bereich der mit einer #ib(3)#DEFINT#ie(3)#-Anweisung
+  (vgl. Kap. 8) festgelegten Buchstaben, so ist die Variable eine INT-Variable. 
+- Liegt das erste Zeichen im Bereich der mit einer #ib(3)#DEFSTR#ie(3)#-Anweisung (vgl. Kap. 8)
+  festgelegten Buchstaben, so handelt es sich um eine TEXT-Variable. 
+- Wenn keine der obigen Bedingungen erfüllt ist, dann bezeichnet der Name eine
+  Variable des Datentyps REAL. 
+ 
+Variablen, denen noch kein Wert zugewiesen wurde, haben den Inhalt null (bei INT
+und REAL) beziehungsweise Leertext (bei TEXT). 
+ 
+ 
+ 
+Felder (#ib(4)#Arrays#ie(4)#) 
+ 
+Ein Feld (Array) ist eine Ansammlung von mehreren Variablen gleichen Typs. Jedes
+Feld hat einen Namen. Für die #ib(3)#Feldnamen#ie(3)# gelten die gleichen Regeln wie für die
+Namen von normalen Variablen. Auch die Datentypen werden nach den gleichen
+Kriterien bestimmt wie bei einfachen Variablen. 
+In einem Feld können die Elemente in bis zu 100 #ib(3)#Dimensionen#ie(3)# abgelegt werden. Auf
+ein Element eines Feldes wird über den Feldnamen und den Index / die #ib(3)#Indizes#ie(3)# des
+Elements zugegriffen. Beim Zugriff auf das Element müssen so viele Indizes ange­
+geben werden, wie das Feld Dimensionen hat. 
+Beispiel: 
+Das Feld 'tabelle' habe zwei Dimensionen. Mit 'tabelle (3, 5)' wird auf das Element
+mit dem Index 3 in der ersten Dimension und dem Index 5 in der zweiten Dimension
+zugegriffen. 
+ 
+Beim ersten Zugriff auf ein Element eines Feldes wird anhand der Zahl der Indizes
+die Anzahl der Dimensionen festgestellt und das Feld so eingerichtet, daß in jeder
+Dimension der größte Index zehn ist. 
+Soll ein Feld mit anderen größten Indizes eingerichtet werden, so muß hierzu die
+#ib(3)#DIM#ie(3)#-Anweisung verwendet werden (siehe Kapitel 8). 
+ 
+Der kleinste Index ist voreingestellt auf null, kann aber mit der #ib(3)#OPTION BASE#ie(3)#-
+Anweisung (vgl. Kap. 8) auch auf eins eingestellt werden. 
+ 
+Die Elemente eines Feldes sind, wie auch die einfachen Variablen, mit den Werten
+null (INT und REAL) beziehungsweise Leertext (TEXT) vorbesetzt, sofern ihnen noch
+nichts zugewiesen wurde. 
+ 
+#page# 
+ 
+4.4. Operatoren 
+ 
+Nachfolgend sind alle Operatoren aufgelistet, die vom EUMEL-BASIC-Compiler
+übersetzt werden. 
+ 
+ 
+Arithmetische #ib(4)#Operatoren#ie(4, ", arithmetische")# 
+ 
+#ib(3)##ie(3, "+")##ib(3)##ie(3, "-")##ib(3)##ie(3, "*")##ib(3)##ie(3, "/")# 
+#ib(3)##ie(3, "\")##ib(3)##ie(3, "MOD")##ib(3)##ie(3, "^")# 
+ 
+      Operand(en)    Zweck                            Ergebnistyp 
+ 
+ +    INT            positives Vorzeichen             INT 
+      REAL           positives Vorzeichen             REAL 
+ 
+      INT, INT       INT-Addition                     INT 
+      REAL, REAL     REAL-Addition                    REAL 
+ 
+ -    INT            negatives Vorzeichen             INT 
+      REAL           negatives Vorzeichen             REAL 
+ 
+      INT, INT       INT-Subtraktion                  INT 
+      REAL, REAL     REAL-Subtraktion                 REAL 
+ 
+ *    INT, INT       INT-Multiplikation               INT 
+      REAL, REAL     REAL-Multiplikation              REAL 
+ 
+ /    (INT, INT)   #linefeed (0.5)# 
+                     REAL-Division                    REAL 
+      REAL, REAL   #linefeed (1.0)# 
+ 
+ \    INT, INT     #linefeed (0.5)# 
+                     INT-Division                     INT 
+      (REAL, REAL) #linefeed (1.0)# 
+ 
+MOD   INT, INT       INT-Divisionsrest                INT 
+      REAL, REAL     Divisionsrest nach               REAL 
+                     Runden auf Ganzzahl (nicht INT) 
+ 
+ ^    (INT, INT)   #linefeed (0.5)# 
+                     Potenzierung                     REAL 
+      REAL, REAL   #linefeed (1.0)# 
+ 
+ 
+#on ("b")# 
+Hinweis: #off ("b")# 
+Wird ein Operator mit numerischen Operanden unterschiedlichen Typs (also INT und
+REAL) aufgerufen, so wird der INT-Operand nach REAL konvertiert und der Operator
+mit den beiden REAL-Operanden aufgerufen. 
+Sind die Operandtypen in Klammern angegeben, so werden vor Ausführung der Ope­
+ration die Operanden zu den nicht eingeklammerten Typen konvertiert. 
+Da jede #ib(3)#Konvertierung#ie(3)# Zeit benötigt, sollte der Benutzer darauf achten, daß möglichst
+wenig konvertiert werden muß. 
+Hierzu ein (etwas extremes, aber nicht seltenes) Beispiel: 
+Der Aufruf a%\b bewirkt zunächst eine Konvertierung von a% nach REAL:
+CDBL(a%)\b. Intern wird die Berechnung dann aber wieder mit INTs ausgeführt:
+CINT(CDBL(a%))\CINT(b). Das Ergebnis wird also erst nach drei Konvertierungen
+geliefert. Schreibt man dagegen sofort a%\CINT(b), dann reicht eine Konvertierung
+aus. 
+ 
+Es muß außerdem bei den Operatoren +, - und * für INTs darauf geachtet werden,
+daß das Ergebnis innerhalb des INT-Wertebereichs liegen muß, da es sonst zu
+einem #ib(3)#INT-Überlauf#ie(3)# kommt. 
+ 
+ 
+ 
+Text-Operator #ib(4)#+#ie(4)# 
+ 
+#ib(3)##ie(3, "Operatoren, Text-")# 
+Für Text-Manipulationen wird der Operator '+' mit zwei TEXT-Operanden zur
+Verfügung gestellt. Mit '+' werden zwei Texte aneinandergehängt (konkateniert). 
+ 
+ 
+ 
+Vergleichsoperatoren#ib(4)##ie(4, "Operatoren, Vergleichs-")# 
+ 
+Im EUMEL-BASIC gibt es folgende Vergleichsoperatoren: 
+ 
+#ib(3)#=#ie(3)#     gleich 
+#ib(3)#<>#ie(3)#    ungleich 
+#ib(3)#<#ie(3)#     kleiner 
+#ib(3)#>#ie(3)#     größer 
+#ib(3)#<=#ie(3)#    kleiner oder gleich 
+#ib(3)#>=#ie(3)#    größer oder gleich 
+ 
+Bei den numerischen Datentypen werden mit den Vergleichsoperatoren die Zahlen­
+werte verglichen. 
+Sollen ein INT und ein REAL verglichen werden, dann wird der INT vorher nach
+REAL konvertiert und ein REAL-Vergleich vorgenommen. 
+ 
+Bei Texten dienen die Vergleichsoperatoren zum Vergleich der Zeichencodes. Dies
+ermöglicht zum Beispiel ein alphabetisches Sortieren von Wörtern, mit der Einschrän­
+kung, daß Groß- und Kleinbuchstaben unterschiedliche Zeichencodes haben (ver­
+gleiche EUMEL-Zeichensatz-Tabelle im Benutzerhandbuch) und somit verschieden
+eingeordnet werden. 
+Es gilt a$ < b$, wenn die Zeichenkette in a$ codemäßig vor der Zeichenkette in b$
+           steht:     "a" < "b"  (TRUE) "aa"< "a"  (FALSE) 
+ 
+ 
+Die Vergleichsoperatoren liefern, je nachdem ob die Aussage wahr oder falsch ist, die
+INT-Werte 0 (falsch) oder -1 (wahr). 
+Anhand des Ergebnisses einer Vergleichsoperation kann zum Beispiel der Programm­
+ablauf gesteuert werden (siehe Kapitel 8, IF-Anweisung). 
+ 
+ 
+ 
+Logische Operatoren 
+ 
+#ib(3)##ie(3, "Operatoren, logische")# 
+Die logischen Operatoren haben zwei Aufgaben: 
+1. logische (Boolsche) Verknüpfung von #ib(3)#Wahrheitswerte#ie(3)#n, die zum Beispiel von
+   Vergleichsoperationen geliefert werden und 
+2. bitweise Ausführung von logischen Verknüpfungen auf den internen (Zweierkom­
+   plement-) Darstellungen von INT-Werten. 
+ 
+Da für beide Aufgaben die gleichen Operatoren benutzt werden, wurden für die Wahr­
+heitswerte die INT-Werte 0 für falsch (Bitmuster: 0000000000000000) und -1 für
+wahr (Bitmuster: 1111111111111111) gewählt. 
+ 
+      Operand(en)       Zweck                       insbesondere gilt 
+ 
+#ib(3)#NOT#ie(3)#   INT       #linefeed (0.5)#                                        NOT0->-1 
+                        #ib(3)#Negation#ie(3)# 
+      (REAL)    #linefeed (1.0)#                                        NOT-1->0 
+ 
+#ib(3)#AND#ie(3)#   INT, INT          #ib(3)#UND-Verknüpfung#ie(3)#              0AND0->0 
+                                                     0AND-1->0 
+                                                     -1AND0->0 
+                                                     -1AND-1->-1 
+ 
+ #ib(3)#OR#ie(3)#   INT, INT          #ib(3)#ODER-Verknüpfung#ie(3)#             0OR0->0 
+                                                     0OR-1->-1 
+                                                     -1OR0->-1 
+                                                     -1OR-1->-1 
+ 
+#ib(3)#XOR#ie(3)#   INT, INT          #ib(3)#Exklusiv-ODER-Verknüpfung#ie(3)#    0XOR0->0 
+                                                     0XOR-1->-1 
+                                                     -1XOR0->-1 
+                                                     -1XOR-1->0 
+ 
+#ib(3)#EQV#ie(3)#   INT, INT          #ib(3)#Äquivalenz-Verknüpfung#ie(3)#       0EQV0->-1 
+                                                     0EQV-1->0 
+                                                     -1EQV0->0 
+                                                     -1EQV-1->-1 
+ 
+#ib(3)#IMP#ie(3)#   INT, INT          #ib(3)#Implikations-Verknüpfung#ie(3)#     0IMP0->-1 
+                                                     0IMP-1->-1 
+                                                     -1IMP0->0 
+                                                     -1IMP-1->-1 
+ 
+ 
+ 
+Prioritäten der Operanden 
+ 
+ 
+Hier die Übersicht über alle Operatoren in der Reihenfolge ihrer Ausführung 
+ 
+ 
+  Operator                                           Priorität 
+ 
+     ^           Potenzierung                           13 
+     +, -        positives/negatives Vorzeichen         12 
+     *, /        Multiplikation, REAL-Division          11 
+     \           INT-Division                           10 
+     MOD         Divisionsrest- (MOD-) Operation         9 
+     +, -        Addition, Subtraktion                   8 
+     =, <>, <, >, <=, >=       Vergleichsoperatoren      7 
+     NOT         Negation                                6 
+     AND         UND-Verknüpfung                         5 
+     OR          ODER-Verknüpfung                        4 
+     XOR         Exklusiv-ODER-Verknüpfung               3 
+     EQV         Äquivalenz-Verknüpfung                  2 
+     IMP         Implikations-Verknüpfung                1 
+ 
+ 
+Die Reihenfolge der Auswertung von Ausdrücken kann durch Klammern geändert
+werden. 
+ 
+Beachten Sie, daß der Operator '=' in BASIC die Funktion eines Vergleichsoperators
+und des #ib(3)#Zuweisungsoperators#ie(3)##ib(3)##ie(3, "Operator, Zuweisungs-")# (siehe Kapitel 8, LET-Anweisung) hat. 
+ 
+#page# 
+ 
+4.5. #ib(3)#Funktionen#ie(3)# 
+ 
+ 
+ 
+Standard-Funktionen 
+ 
+Der EUMEL-BASIC-Compiler unterstützt eine ganze Reihe von Funktionen. Diese
+Funktionen liefern Werte und können in Ausdrücken zusammen mit Konstanten,
+Variablen und Operatoren verwendet werden. 
+Viele der eingebauten Funktionen arbeiten mit Argumenten, das heißt es werden den
+Funktionen Werte übergeben. 
+In Kapitel 8 dieses Handbuches sind alle Funktionen ausführlich beschrieben. 
+Beispiele für #ib(3)#Funktionsaufrufe#ie(3)#: 
+  SQR (17)             Dieser Ausdruck liefert die Wurzel von 17 als REAL. 
+  RIGHT$ (text$, 5)    Dieser Ausdruck liefert die letzten fünf Textzeichen 
+#right#aus 'text$' als TEXT. 
+ 
+ 
+ 
+Benutzer-definierte Funktionen 
+ 
+Neben der Verwendung der standardmäßig verfügbaren Funktionen besteht für den
+Benutzer die Möglichkeit, selbst Funktionen innerhalb eines Programms zu definieren. 
+ 
+#on ("b")# 
+#ib(3)#Definition benutzer-definierter Funktionen#ie(3)# #off ("b")# 
+Hierzu dient die #ib(3)#DEF FN#ie(3)#-Anweisung (vergleiche Kapitel 8). 
+Die Syntax der DEF FN-Anweisung lautet: 
+ 
+DEFFN<Name>[(<Parameter>[,<Parameter>][...])]= 
+#right#<Funktionsdefinition> 
+ 
+<Name>:                   Zeichenfolge, die der Syntax für Variablennamen ent­
+                          sprechen muß. 
+                          FN<Name> bilden zusammen den Namen der neuen
+                          Funktion. 
+<#ib(3)#Parameter#ie(3)#>:              Zeichenfolge, die der Syntax für Variablennamen ent­
+                          sprechen muß. 
+<Funktionsdefinition>:    Ausdruck, der Konstanten, Variablen, die Parameter der
+                          Funktion und Aufrufe anderer Funktionen enthalten
+                          darf. 
+ 
+- Die benutzer-definierten Funktionen ("user functions") liefern, genau wie die
+  Standard-Funktionen, Werte. 
+- Das letzte Zeichen des Funktionsnamens gibt den Typ des Wertes an, den die
+  Funktion liefert. Soll die Funktion einen TEXT liefern, so muß der Name mit "$"
+  enden. Soll ein INT geliefert werden, muß der Name mit "%" enden. Für alle
+  anderen Endungen wird eine REAL-liefernde Funktion eingetragen. 
+- Die Syntax der Parameternamen entspricht der Syntax für die Namen von einfachen
+  Variablen. 
+- Die Parameter haben nur bei der Definition Gültigkeit. Hierbei 'überdecken' sie (für
+  diese Zeile) eventuell im BASIC-Programm vorhandene gleichnamige Variablen. 
+- Jeder Parameter darf in der Parameterliste nur einmal vorkommen. 
+- Bezeichnet der Funktionsname eine TEXT-liefernde Funktion, so muß auch die
+  Funktionsdefinition ein Ergebnis vom Typ TEXT liefern. Zwischen INTs und REALs
+  findet eine Typanpassung statt. 
+- Eine Funktion darf nicht in ihrer eigenen Definition erscheinen. 
+- Eine Funktion ist allein durch ihren Namen gekennzeichnet. Generische Funktionen
+  (gleicher Name, aber unterschiedliche Parameter) können somit nicht definiert wer­
+  den. 
+ 
+Beispiele für gültige Funktionsdefinitionen: 
+  DEF FNPI = 3.1415927 
+  DEF FNumfang (radius) = 2.0 * FNPI * radius    (Enthält Aufruf von FNPI) 
+  DEF FNhallo$ (dummy$) = "Hallo " + name$       (name$ kommt im 
+  #right#BASIC-Programm vor) 
+  DEF FNheavyside% (x) = ABS (SGN (x) = 1) 
+ 
+Beispiele für ungültige Funktionsdefinitionen: 
+  DEF FNfunct (a, b, a) = a ^ 2 + b  (a kommt zweimal als Parameter vor) 
+  DEF FNfr (x) = x * FNfr (x - 1)    (rekursive Definition) 
+ 
+ 
+#on ("b")# 
+#ib(3)#Aufruf benutzer-definierter Funktionen#ie(3)# #off ("b")# 
+ 
+FN<Name> [ ( <Argument> [, <Argument>] [...] ) ] 
+ 
+<#ib(3)#Argument#ie(3)#>  : Ausdruck, der für den entsprechenden Parameter bei der Evaluation
+              (Auswertung) der Funktion eingesetzt werden soll 
+ 
+- Beim Funktionsaufruf werden die Argumente in der Reihenfolge ihres Auftretens für
+  die Parameter eingesetzt. Für TEXT-Parameter müssen die Argumente ebenfalls
+  TEXTe liefern. Zwischen INTs und REALs findet eine Typanpassung statt. 
+- Die Anzahl der Argumente muß genau mit der Anzahl der Parameter übereinstim­
+  men. 
+- Für in der Funktionsdefinition vorkommende Variablen wird der zum Zeitpunkt des
+  Funktionsaufruf gültige Wert eingesetzt. 
+- Die Definition der Funktion muß dem ersten Aufruf der Funktion textuell voraus­
+  gehen. 
+- Eine Definition gilt für alle textuell folgenden Aufrufe, bis die Funktion wieder neu
+  definiert wird. 
+ 
+Beispiele für korrekte Funktionsaufrufe (bezogen auf obige Beispiel-Definitionen): 
+  PRINT FNPI / 2.0                              (Ausgabe: 1.570796) 
+  PRINT FNumfang (20)                           (Ausgabe: 125.6637) 
+  LET name$ = "Purzelbär":PRINT FNhallo$ ("")   (Ausgabe: Hallo Purzelbär) 
+  PRINT heavyside% (-17.3)                      (Ausgabe: 0) 
+ 
+Beispiele für falsche Funktionsaufrufe (bezogen auf obige Beispiel-Definitionen): 
+  PRINT FNPI (10)                    (kein Argument erwartet) 
+  PRINT FNumfang                     (Argument erwartet) 
+  PRINT FNhallo$ (zahl%)             (Falscher Typ des Arguments) 
+  PRINT FNheavyside (17.4, -12.3)    (Zu viele Argumente) 
+ 
+ 
+#page# 
+ 
+4.6. #ib(3)#Typanpassung#ie(3)# 
+ 
+ 
+In BASIC wird, im Gegensatz zu ELAN, nicht sehr streng zwischen den numerischen
+Datentypen unterschieden, sondern es finden häufig automatische Typanpassungen
+statt. Zu solchen Typanpassungen kommt es vor allem bei der Zuweisung, bei Opera­
+toren und bei Funktionen, aber auch bei einigen Anweisungen. 
+Die automatische Typanpassung hat zwei Nachteile: 
+1. Die Typkonvertierung von INT nach REAL und umgekehrt kostet Zeit während der
+   Programmausführung. 
+2. Es kann zu sehr unangenehmen Laufzeitfehlern kommen, wenn eine REAL-
+   INT-#ib(3)#Konvertierung#ie(3)# mit Fehler abbricht, weil der REAL-Wert außerhalb des
+   INT-Wertebereichs liegt. 
+ 
+Allgemein gilt also, daß sich der Programmierer auch in BASIC über die Typen der
+verwendeten Objekte im klaren sein sollte. Außerdem ist zu beachten, daß bei Konver­
+tierungen von REAL nach INT immer gerundet wird. 
+ 
+Genaueres zur Typanpassung bei der Zuweisung finden Sie in Kapitel 8 bei der
+LET-Anweisung. 
+Über Typkonvertierung bei Operatoren informiert Kapitel 4.4. 
+Informationen über die Funktionen betreffenden Typkonvertierungen befinden sich am
+Anfang von Kapitel 8 und direkt bei der Beschreibung der jeweiligen Funktionen
+(ebenfalls in Kapitel 8). 
+ 
+#page# 
+ 
+4.7. Aufruf von EUMEL-Prozeduren in
+     BASIC-Programmen
+      
+ 
+ 
+Der EUMEL-BASIC-Compiler bietet die Möglichkeit, insertierte ELAN-Prozeduren
+(und auch insertierte BASIC-Programme) in BASIC-Programmen aufzurufen. Hierzu
+werden die beiden Anweisungen #ib(3)#CALL#ie(3)# und #ib(3)#CHAIN#ie(3)# (identisch) sowie die Funktion
+#ib(3)#USR#ie(3)# zur Verfügung gestellt. 
+Mit der CALL-Anweisung (siehe auch Kapitel 8) können Prozeduren aufgerufen
+werden, die keinen Wert liefern und nur die BASIC-Datentypen INT, REAL und/oder
+TEXT als Parameter benötigen. 
+Beispiele: 
+  CALL list 
+  CALL taskstatus ("PUBLIC") 
+  CALL cursor (10, 21) 
+  CALL getcursor (x%, y%) 
+ 
+Das letzte Beispiel zeigt, daß auch #ib(3)#VAR-Parameter#ie(3)# im ELAN-Sinne übergeben
+werden können. 
+ 
+Die Funktion USR dient im Gegensatz zu CALL zum Aufruf von #ib(3)#wertliefernden Pro­
+zeduren#ie(3)#. Die Prozeduren dürfen allerdings nur einen der BASIC-Datentypen INT,
+REAL oder TEXT liefern. Es gilt auch bei USR, wie bei CALL, daß die aufgerufenen
+Prozeduren nur Parameter der Typen INT, REAL oder TEXT haben dürfen. 
+Beispiele: 
+  PRINT USR e                            (Ausgabe: 2.718282) 
+  PRINT USR compress ("   EUMEL   ")     (Ausgabe: EUMEL) 
+ 
+#on ("b")# 
+Wichtige Hinweise zu CALL, CHAIN und USR: #off ("b")# 
+1. Bei den Parametern finden keinerlei Typkonvertierungen statt (ELAN-
+   Prozeduren werden ja gerade anhand der Typen ihrer Parameter eindeutig identifi­
+   ziert). 
+2. Die Prozedurnamen nach CALL, CHAIN und USR dürfen keine Leerzeichen ent­
+   halten, weil die Prozedur sonst nicht identifiziert werden kann. 
+   Beispiel:  CALLlernsequenzauftastelegen(...)  statt
+              CALLlernsequenzauftastelegen(...) 
+3. Die Prozedurnamen können (nach BASIC-Konvention) auch Großbuchstaben
+   enthalten. 
+   Beispiel:  CALLcursor(17,4) ist äquivalent zu 
+              CALLCURSOR(17,4) 
+ 
+ 
+Wie in Kapitel 3 erläutert kann ein BASIC-Programm auch insertiert werden. Somit
+können mit der CALL-Anweisung auch andere (vorher insertierte) BASIC-
+Programme aufgerufen werden. 
+Beispiel: 
+CALL blackjack      ('blackjack' sei der Prozedurname, unter dem ein BASIC-
+                    Programm zuvor insertiert wurde.) 
+ 
+Die sonst in einigen BASIC-Dialekten vorhandene Möglichkeit, Programme oder
+#ib(3)#Programmsegmente#ie(3)# nachzuladen, kann so durch Aufrufe von insertierten Programmen
+nachgebildet werden. 
+#page# 
+#head# 
+EUMEL-BASIC-Compiler       5. Steuerung der Bildschirmausgaben      % 
+ 
+#end# 
+ 
+5. #ib(4)#Steuerung der #ib(3)#Bildschirmausgaben#ie(3)##ie(4)# 
+ 
+ 
+ 
+Die Ausgaben von BASIC-Programmen ('PRINT' und 'WRITE') werden im Paket
+'basic output' behandelt. Dieses Paket ermöglicht unter anderem, daß die Ausgabe
+auf das Terminal mit der Prozedur 
+ 
+         PROC #ib(3)#basic page#ie(3)# (BOOL CONST status) 
+ 
+gesteuert werden können. Wird dabei 'TRUE' eingestellt, so wartet die Ausgabe bei
+Erreichen der letzten Terminalzeile auf die Eingabe eines Zeichens, bevor sie fortfährt.
+Das Eingabezeichen wird nach Ausgabe von ">>" in der rechten unteren Ecke des
+Bildschirms erwartet und wie folgt interpretiert: 
+ 
+#linefeed (1.5)# 
+          Löschen des Bildschirms und Ausgabe der nächsten Bildschirmseite 
+         Ausgabe der nächsten Zeile 
+         Abbruch des Programms mit der Fehlermeldung "'halt' vom Terminal" 
+           'basic page' wird auf 'FALSE' gesetzt #linefeed (1.0)#und mit der normalen Ausgabe
+            weitergemacht 
+ 
+Alle anderen Tasten bewirken eine Ausgabe der nächste Bildschirmseite (#ib(3)#Scrolling#ie(3)#). 
+ 
+Ist 'basic page' auf 'FALSE' gesetzt, so kann durch Eingabe von  vor einem Zei­
+lenwechsel 'basic page' auf 'TRUE' gesetzt werden. 
+#page# 
+#head# 
+EUMEL-BASIC-Compiler          6. Grenzen des Compilers             % 
+ 
+#end# 
+ 
+6. #ib(3)#Grenzen des Compilers#ie(3)# 
+ 
+ 
+Es gibt verschiedene Grenzen, die bei der Benutzung des BASIC-Compilers erreicht
+werden können. 
+ 
+#on ("b")# 
+Grenzen des #ib(3)#EUMEL-Coder#ie(3)#s #off ("b")# 
+Da ein BASIC-Programm vom Compiler als eine Prozedur im Coder eingetragen
+wird, darf der Code für ein BASIC-Programm die #ib(3)#Modulgrenze#ie(3)# von 7500 Byte Code
+nicht überschreiten. 
+Sollte dies doch einmal der Fall sein (#ib(3)#Compiler Error 308#ie(3)#), so gibt es folgende
+Abhilfe-Möglichkeiten: 
+- Zerlegen des BASIC-Programms in mehrere BASIC-Programme, wobei ein
+  Programm das andere während der Ausführung aufrufen kann (vgl.4.7.). 
+  Bei dieser Methode können die Teilprogramme aber nicht mit gemeinsamen Variab­
+  len arbeiten. 
+- Auslagerung von Programmteilen (z.B. Unterprogrammen) in ELAN-Prozeduren,
+  die insertiert und vom BASIC-Programm aufgerufen werden können (vgl.4.7.). 
+  Dieses Verfahren bietet die Möglichkeit, Variablen zwischen BASIC-Programm und
+  ELAN-Prozedur über die Prozedurschnittstelle auszutauschen. 
+ 
+Neben der Begrenzung des Codes ist auch die Größe des Datenspeicherbereichs pro
+BASIC-Programm begrenzt. Insgesamt dürfen die Datenobjekte eines BASIC-
+Programms nicht mehr als 32 KByte Speicherplatz belegen. Andernfalls kommt es
+zum #ib(3)#Compiler Error 307#ie(3)#. 
+ 
+Eine weitere Grenze des EUMEL-Coders stellt die maximal zulässige Anzahl der
+#ib(3)#Labels#ie(3)# (interne Sprungadressen) dar. Es können nur höchstens 2000 Labels vom
+Coder verwaltet werden. Der BASIC-Compiler vergibt für jede gefundene Zeile mit
+Zeilennummer ein Label und benötigt auch bei Schleifen (FOR-NEXT, WHILE-
+WEND), Fallunterscheidungen (IF-Anweisung), Unterprogramm-Aufrufen (GOSUB)
+und bei der Definition von benutzer-definierten Funktionen (DEF) Labels. 
+Beim Auftreten des #ib(3)#Compiler Errors 304#ie(3)# (zu viele Label) ist Abhilfe relativ leicht
+dadurch möglich, daß Zeilennummern nur den Zeilen vergeben werden, die tatsächlich
+angesprungen werden (d.h. zu denen es GOTOs oder GOSUBs gibt). 
+ 
+#on ("b")# 
+Grenzen des BASIC-Compilers #off ("b")# 
+Die interne #ib(3)#Namenstabelle#ie(3)# des BASIC-Compilers kann etwa 4240 Einträge aufneh­
+men. Ein Eintrag in dieser Tabelle wird für jede Variable, für jedes Feld, für jede
+benutzer-definierte Funktion und für jeden Parameter einer benutzer-definierten
+Funktion sowie für jede Konstante erzeugt. Numerische Konstanten erhalten, sofern
+sie konvertiert werden müssen, sogar zwei Einträge in der Namenstabelle. 
+Bei Auftreten des seltenen Fehlers "volle Namenstabelle" kann durch eine Aufteilung
+des BASIC-Programms in Teilprogramme oder eine Auslagerung von Unterprogram­
+men in ELAN-Prozeduren Abhilfe geschaffen werden. 
+ 
+#on ("b")# 
+Sonstige EUMEL-Grenzen #off ("b")# 
+Außer den bisher genannten Begrenzungen sei nochmals auf die Begrenzung des
+#ib(3)#Codebereichs pro Task#ie(3)# hingewiesen (maximal 256 KByte Code). 
+Da der EUMEL-Coder und der BASIC-Compiler recht viel Code belegen, sollte
+"vorsichtig" insertiert werden, also nur das, was wirklich benötigt wird. 
+Auch die übrigen Grenzen des EUMEL-Systems sind zu beachten (vergleiche hierzu
+die Aufstellung der möglichen Compiler Errors im EUMEL-Benutzerhandbuch)! 
+ 
+#page# 
+#head# 
+EUMEL-BASIC-Compiler            7. Fehlerbehandlung              % 
+ 
+#end# 
+ 
+7. #ib(3)#Fehlerbehandlung#ie(3)# 
+ 
+ 
+7.1. #ib(3)#Fehler zur Übersetzungszeit#ie(3)# 
+ 
+Endeckt der BASIC-Compiler bei der Übersetzung eines BASIC-Programms Fehler,
+so werden diese auf dem Bildschirm angezeigt und ins #ib(3)#Notebook#ie(3)# eingetragen. 
+Nur (syntaktisch) fehlerfreie Programme werden zur Ausführung gebracht beziehungs­
+weise insertiert. 
+Im #ib(3)#Vordurchlauf#ie(3)# werden die Zeilennummern auf Richtigkeit überprüft. Falls bereits
+hiebei Fehler festgestellt werden, bricht der Compiler die Übersetzung nach dem
+Vordurchlauf ab. 
+Im #ib(3)#Hauptdurchlauf#ie(3)# wird das Programm Zeile für Zeile auf syntaktische Richtigkeit
+überprüft und gleichzeitig übersetzt. Wird dabei in einer Programmzeile ein Fehler
+entdeckt, so wird er angezeigt und die Übersetzung des Programms #on("i")#in der nächsten
+Programmzeile#off("i")# fortgesetzt. Eine Ausnahme von dieser Regel bildet nur die #ib(3)#DEF FN#ie(3)#-
+Anweisung, bei der bei gewissen Fehlern die Übersetzung fortgesetzt wird. (Der
+Grund hierfür liegt darin, daß die Folgefehlerzahl besonders bei der DEF FN-
+Anweisung sehr groß wäre, wenn beim Auftreten eines Fehlers die Übersetzung der
+Zeile sofort abgebrochen würde. Die Parameter würden dann nämlich nicht oder
+falsch abgelegt, und bei jedem Aufruf der Funktion würde ein Fehler gemeldet.) 
+ 
+Eine Übersicht über alle verwendeten Fehlermeldungen zur Übersetzungszeit befindet
+sich im AnhangC. 
+ 
+ 
+ 
+Interne Compilerfehler 
+ 
+Neben den "normalen" Fehlern (siehe oben) kann es in seltenen Fällen möglicher­
+weise auch zu internen Fehlern kommen. 
+Es gibt zwei verschiedene Sorten von internen Fehlern: 
+1. interne Fehler, die das Compilerprogramm selbst feststellt. 
+   Solche Fehler bewirken die Meldung "Interner Fehler !" (meist mit näherer Erläu­
+   terung) und die Fortsetzung der Übersetzung in der nächsten Programmzeile. 
+2. Fehler, die in anderen Paketen des BASIC-Systems oder des EUMELs (z.B. im
+   EUMEL-Coder) während der Übersetzungszeit ausgelöst werden (siehe auch
+   Kapitel 6: "Grenzen des Compilers"). 
+   Solche Fehler werden mit "#ib(3)#BASIC-Compiler ERROR#ie(3)#" und eventuell näheren
+   Angaben gemeldet. Beim Auftreten eines solchen Fehlers wird die Übersetzung
+   des gesamten Programms abgebrochen. 
+ 
+Sollten bei Ihrer Arbeit mit dem EUMEL-BASIC-Compiler interne Fehler auftreten,
+die nicht auf das Überschreiten von Compilergrenzen zurückzuführen sind, dann
+wären wir Ihnen für eine Meldung der Fehler dankbar. Bitte senden Sie eine Fehler­
+beschreibung an: 
+ 
+  Gesellschaft für Mathematik und Datenverarbeitung 
+  Schloß Birlinghoven 
+  Postfach 1240 
+  5205 Sankt Augustin 1 
+ 
+Die Fehlerbeschreibung sollte nach Möglichkeit folgende Informationen enthalten: 
+- verwendete Hardware 
+- Urlader-Version 
+- EUMEL-Version 
+- Programmtext des Programms, das den Fehler auftreten ließ 
+- genaue Angabe der ausgegebenen Fehlermeldung 
+ 
+ 
+#page# 
+ 
+7.2. #ib(3)#Fehler zur Laufzeit#ie(3)# 
+ 
+Treten während der Laufzeit eines BASIC-Programms Fehler auf, so wird die Ausfüh­
+rung des Programms mit einer entsprechenden Fehlermeldung abgebrochen. 
+Da die meisten Laufzeit-Fehlermeldungen durch Prozeduren des EUMEL-Systems
+(und nicht des BASIC-Systems) erzeugt werden, entsprechen sie oft nicht der
+BASIC-Terminologie. (Beispielsweise führt ein zu großer Feldindex zu der Fehlermel­
+dung "Ueberlauf bei Subskription".) 
+ 
+Die bei Laufzeitfehlern gemeldete #ib(3)#Fehlerzeile#ie(3)# bezieht sich nicht (wie bei ELAN-Pro­
+grammen) auf die Nummer der Dateizeile, sondern auf die letzte der Programmzeile
+vorangegangene BASIC-Zeilennummer. 
+ 
+Fast alle ausgelösten Laufzeitfehler erzeugen auch #ib(3)#Fehlercodes#ie(3)#. Dabei liefern Fehler
+aus EUMEL-Betriebssystem-Prozeduren die EUMEL-Standard-Fehlercodes (vgl.
+Systemhandbuch), zum Beispiel wird beim Fehler "INT-Ueberlauf" der Fehlercode 4
+geliefert. 
+Laufzeitfehler, die in Prozeduren des BASIC-Systems ausgelöst werden, liefern dage­
+gen den in Microsoft-BASIC üblichen Fehlercode plus 1000. So liefert die Meldung
+"Keine Daten mehr für READ" den Fehlercode 1004 (MS-BASIC: "Out of data",
+Fehlercode 4). 
+Es läßt sich so anhand des gelieferten Fehlercodes ermitteln, ob der Fehler im
+BASIC-System oder an einer anderen Stelle des EUMEL-Systems ausgelöst wurde. 
+ 
+Eine Übersicht über die innerhalb des BASIC-Systems erzeugten Fehlermeldungen
+enthält Anhang C. 
+
diff --git a/lang/basic/1.8.7/doc/basic handbuch.2 b/lang/basic/1.8.7/doc/basic handbuch.2
new file mode 100644
index 0000000..1379e9e
--- /dev/null
+++ b/lang/basic/1.8.7/doc/basic handbuch.2
@@ -0,0 +1,2441 @@
+#page nr ("%", 31)# 
+#head# 
+EUMEL-BASIC-Compiler    8. Übersicht über die Befehle und Funktionen    % 
+ 
+#end# 
+ 
+8. Übersicht über die Anweisungen und Funktionen 
+    
+ 
+ 
+In diesem Kapitel sind alle Anweisungen und Funktionen des vom Compiler übersetz­
+baren BASIC-Sprachumfangs in alphabetischer Reihenfolge aufgeführt. 
+Auch die Anweisungsbestandteile (z.B. ELSE und TO) sind mit einem Hinweis auf die
+zugehörige Anweisung eingeordnet. 
+Sind bei Funktionen INT- oder REAL-Ausdrücke als Argumente angegeben, so ist
+dies als Hinweis auf den Sinn der Funktion zu verstehen. Es können auch Ausdrücke
+des jeweils anderen Datentyps eingesetzt werden. Wird statt eines INT-Ausdrucks
+ein REAL-Ausdruck angegeben, so darf dessen Wert aber nur innerhalb des
+Wertebereichs für INTs liegen, da der REAL-Wert bei der Ausführung der Funktion
+in einen INT-Wert konvertiert wird. 
+ 
+ 
+ 
+Funktion : ABS 
+ 
+Zweck :        Berechnung des Betrages (Absolutwertes) einer Zahl 
+ 
+Syntax :       ABS (<num. Ausdruck>) 
+ 
+Erklärung :   Liefert den Betrag des numerischen Ausdrucks. 
+              Das Ergebnis ist vom gleichen Typ wie das Argument. 
+ 
+ 
+Beispiel :      10 a = -12.74 
+                20 PRINT ABS (a) 
+                Ausgabe: 12.74 
+ 
+Vergleiche :  SGN-Funktion 
+ 
+ 
+ 
+Operator :  AND 
+ 
+Siehe Kapitel 4.4. (Operatoren) 
+ 
+ 
+ 
+Anweisungsbestandteil : AS 
+ 
+Siehe NAME-Anweisung 
+ 
+ 
+ 
+Funktion : ASC 
+ 
+Zweck :        Ermittlung des ASCII-Codes eines Textzeichens 
+ 
+Syntax :       ASC (<TEXT-Ausdruck>) 
+ 
+Erklärung :   Die Funktion liefert den ASCII-Code des ersten Zeichens des
+              TEXT-Ausdrucks. 
+              Der Code wird als INT geliefert. 
+ 
+ 
+Beispiel :      10 a$ = "Guten Tag !" 
+                20 PRINT ASC (a$) 
+                Ausgabe:  71 
+ 
+Vergleiche :  CHR$-Funktion (Komplementärfunktion) 
+ 
+ 
+ 
+Funktion : ATN 
+ 
+Zweck :        Berechnung des Arcustangens 
+ 
+Syntax :       ATN (<num. Ausdruck>) 
+ 
+Erklärung :   Die Funktion liefert den Arcustangens des 
+              numerischen Ausdrucks in Radiant. 
+ 
+ 
+Beispiel :      10 LET x = 4 
+                20 PRINT ATN (x) 
+                Ausgabe: 1.325818 
+ 
+Vergleiche :  TAN-Funktion (Komplementärfunktion), SIN, COS 
+ 
+ 
+ 
+Anweisungsbestandteil : BASE 
+ 
+Siehe OPTION BASE-Anweisung 
+ 
+ 
+ 
+Anweisung : CALL 
+ 
+Zweck :        Aufruf einer insertierten Prozedur 
+ 
+Syntax :       CALL <Prozedurname> #right#[ (<Parameter> [, <Parameter>] [...] ) ] 
+ 
+Erklärung :   <Prozedurname>: Folge aus Zeichen, die für Prozeduren im
+              EUMEL-System zugelassen sind (also Buchstaben und  - ab der
+              zweiten Stelle -  Zahlen), aber keine Leerzeichen. 
+ 
+              <Parameter>: <CONST-Parameter> | <VAR-Parameter> 
+ 
+              <CONST-Parameter>:   Ausdruck (genau des von der Prozedur
+                                   benötigten Typs) 
+              <VAR-Parameter>:     Variable (genau des von der Prozedur benö­
+                                   tigten Typs) 
+ 
+              Die Prozedur mit dem angegebenen <Prozedurnamen> wird mit den
+              angegebenen Parametern aufgerufen. 
+              Die aufgerufene Prozedur darf keinen Wert liefern (vgl. USR-Funk­
+              tion). 
+ 
+              Mögliche Fehlerfälle: 
+              - Eine Prozedur mit dem Namen <Prozedurnamen> und den an­
+                gegebenen Parametern gibt es nicht. 
+              - Die Prozedur liefert einen Wert. 
+              - Die Prozedur benötigt Parametertypen, die in BASIC nicht bekannt
+                sind (z.B. BOOL, FILE, TASK, QUIET). 
+              - Ein Parameter ist CONST, es wird aber ein VAR-Parameter ver­
+                langt. 
+ 
+              Weitere Informationen finden Sie in Kapitel 4.7. 
+ 
+Hinweis :     1.  Bei den Parametern wird keine Typkonvertierung vorgenommen. 
+              2. Der Prozedurname muß (entgegen der ELAN-Gewohnheit) ohne
+                 Leerzeichen angegeben werden. 
+              3. Statt des Anweisungswortes CALL kann auch CHAIN geschrieben
+                 werden. CALL und CHAIN werden im EUMEL-BASIC nicht wie
+                 in Microsoft-BASIC benutzt. 
+ 
+ 
+Beispiel :      10 CALL sysout ("Meine Datei") 
+                20 PRINT "Dieser Text geht nun in die Datei" 
+                30 CALL sysout ("") 
+                40 PRINT "Wieder auf den Bildschirm" 
+                 
+ 
+Vergleiche :  USR-Funktion 
+ 
+ 
+ 
+Funktion : CDBL 
+ 
+Zweck :        Konvertierung in den Datentyp REAL 
+ 
+Syntax :       CDBL (<num. Ausdruck>) 
+ 
+Erklärung :   Das Ergebnis des numerischen Ausdrucks wird als REAL geliefert. 
+ 
+ 
+Beispiel :      10 LET a! = 17 
+                20 PRINT USR max (CDBL (a!), 152.3) 
+                30 REM max benötigt zwei REALs als Parameter 
+ 
+ 
+Vergleiche :  CINT-Funktion 
+ 
+ 
+ 
+Anweisung : CHAIN 
+ 
+Vollkommen identisch mit der CALL-Anweisung (Erklärung siehe dort !) 
+ 
+ 
+ 
+Funktion : CHR$ 
+ 
+Zweck :        Erzeugung eines Textzeichens mit einem bestimmten ASCII-Code 
+ 
+Syntax :       CHR$ (<INT-Ausdruck>) 
+ 
+Erklärung :   Die Funktion liefert das Zeichen mit dem ASCII-Code, den der
+              INT-Ausdruck angibt. 
+              Das Zeichen wird als TEXT geliefert. 
+              Die Leistung der Funktion ist nur für Werte im Bereich 0 bis 255
+              definiert. 
+ 
+ 
+Beispiel :      10 PRINT CHR$ (61) 
+                Ausgabe:  = 
+ 
+Vergleiche :  ASC-Funktion (Komplementärfunktion) 
+ 
+ 
+ 
+Funktion : CINT 
+ 
+Zweck :        Konvertierung in den Datentyp INT 
+ 
+Syntax :       CINT (<num. Ausdruck>) 
+ 
+Erklärung :   Das Ergebnis des numerischen Ausdrucks wird als INT geliefert.
+              REALs werden gerundet. Werte außerhalb des INT-Bereichs führen
+              zu einem INT-Überlauf. 
+ 
+ 
+Beispiel :      10 LET a = 17.625 
+                20 PRINT CINT (a); CINT (-a) 
+                Ausgabe:  18  -18 
+ 
+Vergleiche :  CDBL-, FIX-, INT-Funktionen 
+ 
+ 
+ 
+Anweisung : CLS 
+ 
+Zweck :        Löschen des Bildschirms 
+ 
+Syntax :       CLS 
+ 
+Erklärung :   Löscht den Bildschirm und positioniert den Cursor in die linke obere
+              Bildschirmecke (Position 1, 1). 
+ 
+ 
+Beispiel :      10 CLS 
+                20 PRINT "PROGRAMMBEGINN" 
+ 
+ 
+ 
+ 
+Funktion : COS 
+ 
+Zweck :        Berechnung des Cosinus eines Radiantwertes 
+ 
+Syntax :       COS (<Winkel>) 
+ 
+Erklärung :   <Winkel>: REAL-Ausdruck, der den Winkel in Radiant angibt. 
+              Die Funktion liefert den Cosinus des Winkels als REAL. 
+ 
+ 
+Beispiel :      10 PI = 3.141593 
+                20 PRINT COS (PI/4) 
+                Ausgabe:  .7071067 
+ 
+Vergleiche :  SIN-, TAN-Funktionen 
+ 
+ 
+ 
+Funktion : CSRLIN 
+ 
+Zweck :        Ermittlung der aktuellen Cursorzeile 
+ 
+Syntax :       CSRLIN 
+ 
+Erklärung :   Geliefert wird die Nummer der Zeile (als INT), in der sich der Cursor
+              auf dem Bildschirm befindet. Die oberste Zeile hat die Nummer 1. 
+ 
+ 
+Beispiel :      10 CLS 
+                20 PRINT 
+                30 PRINT CSRLIN 
+                Ausgabe:  2 
+ 
+Vergleiche :  POS-Funktion 
+ 
+ 
+ 
+Funktion : CVD, CVI 
+ 
+Zweck :        Decodierung von in Texten verschlüsselten Zahlenwerten 
+ 
+Syntax :       CVD (<TEXT-Ausdruck>) 
+              CVI (<TEXT-Ausdruck>) 
+ 
+Erklärung :   INTs und REALs können (mit MKI$ und MKD$) zu Texten codiert
+              werden. 
+              CVD decodiert einen in 8 TEXT-Zeichen codierten REAL-Wert. 
+              CVI decodiert einen in 2 TEXT-Zeichen codierten INT-Wert. 
+              Es wird beim ersten Zeichen des TEXT-Ausdrucks mit der Dekodie­
+              rung begonnen. 
+              Ist der TEXT zu kurz, so wird mit der Meldung "Ueberlauf bei Subs­
+              kription" abgebrochen. 
+ 
+ 
+Beispiel :      10 zahl$ = MKD$ (3.1415) 
+                20 PRINT CVD (zahl$) 
+                Ausgabe:  3.1415 
+ 
+Vergleiche :  MKD$-, MKI$- Funktionen (Komplementärfunktionen) 
+ 
+ 
+ 
+Anweisung : DATA 
+ 
+Zweck :        Ablegen von Konstanten 
+ 
+Syntax :       DATA [<string>] [, [<string>]] [...] 
+ 
+Erklärung :   <string>         : <quoted string> | <unquoted string> 
+              <quoted string>  : von Anführungszeichen umschlossene Zeichen­
+                                 folge, die alle Zeichen außer Anführungs­
+                                 zeichen enthalten darf 
+              <unquoted string>: Zeichenfolge, die alle Zeichen außer Komma
+                                 und Doppelpunkt enthalten darf 
+ 
+              Eine DATA-Anweisung stellt einen Datenspeicher dar, der mit READ
+              (s.d.) ausgelesen werden kann. 
+              In der DATA-Anweisung können "quoted strings" oder "unquo­
+              ted strings" angegeben werden. "quoted strings" können später nur
+              noch als Texte ausgelesen werden. 
+              Bei "unquoted strings" wird der Datentyp in der DATA-Anweisung
+              dagegen nicht festgelegt. Sie können also als INTs, REALs oder
+              TEXTe ausgelesen werden. Sollen "unquoted strings" Zahlenwerte
+              darstellen, so müssen sie den in BASIC üblichen Schreibregeln für
+              die numerischen Konstanten des jeweiligen Typs genügen. Es sind
+              allerdings zusätzlich noch Vorzeichen erlaubt. 
+              Wenn die <strings> nicht angegeben sind, so wird ein "nil-Datum"
+              abgelegt. Dieses bewirkt bei einem READ mit numerischer Variable
+              die Lieferung des Wertes null und bei einem READ mit TEXT-Vari­
+              able die Lieferung eines Leertextes. 
+ 
+              Die DATA-Anweisungen können an beliebiger Stelle im Programm
+              (vor oder hinter den zugehörigen READ-Anweisungen) stehen. 
+ 
+              Alle DATA-Anweisungen eines Programms bilden zusammen einen
+              großen sequentiellen Speicher, auf den mit READ der Reihe nach
+              zugegriffen wird. Intern wird ein sogenannter READ-DATA-Zeiger
+              geführt, der immer auf das nächste auszulesende Element zeigt. 
+              Die RESTORE-Anweisung (s.d.) ermöglicht es, den READ-
+              DATA-Zeiger auf das erste Element einer bestimmten DATA-Zeile
+              zu setzen. 
+ 
+ 
+Beispiel :      2020 PRINT "Stadt", "Land", "Fluß" 
+                2030 READ stadt$, land$, fluß$ 
+                2040 PRINT stadt$, land$, fluß$ 
+                . 
+                5000 DATA Paris, Frankreich, Seine 
+ 
+ 
+Vergleiche :  READ-, RESTORE-Anweisungen 
+ 
+ 
+ 
+Funktion : DATE$ 
+ 
+Zweck :        Abrufen des aktuellen Tagesdatums 
+ 
+Syntax :       DATE$ 
+ 
+Erklärung :   Das Tagesdatum wird als Text in der Form TT.MM.JJ geliefert. 
+ 
+ 
+Beispiel :      10 PRINT "Heute ist der " + DATE$ 
+                Ausgabe (z.B.):  Heute ist der 28.08.87 
+ 
+Vergleiche :  TIME$-Funktion 
+ 
+ 
+ 
+Anweisung : DEFDBL, DEFINT, DEFSNG, DEFSTR 
+ 
+Zweck :        Definition von Anfangsbuchstaben zur Kennzeichnung bestimmter
+              Variablentypen 
+ 
+Syntax :       DEFDBL <Buchstabe1> [ - <Buchstabe2>] 
+              #right#[, <Buchstabe3> [ - <Buchstabe4>] ] [...] 
+              DEFINT <Buchstabe1> [ - <Buchstabe2>] 
+              #right#[, <Buchstabe3> [ - <Buchstabe4>] ] [...] 
+              DEFSNG <Buchstabe1> [ - <Buchstabe2>] 
+              #right#[, <Buchstabe3> [ - <Buchstabe4>] ] [...] 
+              DEFSTR <Buchstabe1> [ - <Buchstabe2>] 
+              #right#[, <Buchstabe3> [ - <Buchstabe4>] ] [...] 
+ 
+ 
+Erklärung :   Mit den aufgeführten Anweisungen ist es möglich, bestimmte Buch­
+              staben festzulegen, die, wenn sie als Anfangsbuchstaben eines
+              Variablennamens verwendet werden, der Variablen einen bestimmten
+              Typ zuordnen. 
+ 
+              Die Typfestlegung durch Kennzeichnung mit den Zeichen '!', '\#', '%'
+              oder '$' hat jedoch Vorrang vor den festgelegten Anfangsbuchstaben.
+              Eine genaue Erläuterung, nach welchen Kriterien der BASIC-Compi­
+              ler den Typ einer Variablen feststellt, befindet sich in Kapitel 4.3. 
+ 
+              Die DEFINT-Anweisung legt Anfangsbuchstaben für INT-Variablen
+              fest. 
+              Mit der DEFSTR-Anweisung werden Anfangsbuchstaben von
+              TEXT-Variablen festgelegt. 
+              Die Anweisungen DEFDBL- und DEFSNG- wurden nur aus Kom­
+              patibilitätsgründen implementiert. Sie werden zwar auf syntaktische
+              Richtigkeit überprüft, aber ansonsten vom Compiler nicht beachtet. 
+ 
+              Werden bei den Anweisungen ganze Buchstabenbereiche angegeben,
+              so muß der Buchstabe vor dem Bindestrich auch im Alphabet vor
+              dem Buchstaben hinter dem Bindestrich stehen. 
+ 
+Hinweis :     1.  Die oben beschriebenen Anweisungen gelten stets erst für die im
+                 weiteren Text neu benutzten (also neu eingerichteten) Variablen. 
+              2. Die beschriebenen Anweisungen dürfen auch mehr als einmal in
+                 einem Programm vorkommen. Die Buchstaben, die in der zweiten
+                 und in den folgenden Anweisungen festgelegt werden, werden
+                 #on("izusätzlich#off("i zu den in der ersten Anweisung festgelegten Buchsta­
+                 ben als Kennzeichen für den betreffenden Datentyp vom Compiler
+                 vermerkt. 
+              3. Der Compiler überprüft nicht, ob gleiche Buchstaben als Kennzei­
+                 chen für mehr als einen Variablentyp angegeben werden (siehe
+                 Kapitel 4.3.). Der Benutzer ist also selbst dafür verantwortlich, daß
+                 solche Überschneidungen nicht vorkommen. 
+ 
+ 
+Beispiel :      10 DEFSTR s - z 
+                20 DEFINT a - h, n 
+                30 DIM tabelle (17) 'TEXT-Feld 
+                40 LET c = 4        'INT-Variable 
+                50 LET nummer = 17  'INT-Variable 
+                60 LET ueberschrift = "Willkommen" 'TEXT-Variable 
+                70 LET reellezahl = 19.563 'REAL-Variable 
+                80 LET aha\# = -1.36E17     'REAL-Variable 
+                 
+ 
+ 
+ 
+Anweisung : DEF FN 
+ 
+Zweck :        Definition einer benutzer-definierten Funktion 
+ 
+Syntax :       DEF FN<Name> [ ( <Parameter> [, <Parameter>] #right# [...] ) ] = <Funktionsdefinition> 
+ 
+Erklärung :   <Name>     :  Zeichenfolge, die der Syntax für Variablennamen
+                            entsprechen muß 
+                            FN<Name> bilden zusammen den Namen der
+                            neuen Funktion 
+              <Parameter>:  Zeichenfolge, die der Syntax für Variablennamen
+                            entsprechen muß 
+              <Funktionsdefinition>:  Ausdruck, der Konstanten, Variablen, die
+                                      Parameter der Funktion und Aufrufe
+                                      anderer Funktionen enthalten darf 
+ 
+              Mit der DEF FN-Anweisung wird eine benutzer-definierte Funktion
+              ("user function") mit dem Funktionsnamen FN<Name> definiert
+              (vergleiche hierzu auch Kapitel 4.5.). 
+              Die benutzer-definierte Funktion liefert, genau wie die standard­
+              mäßig eingebauten Funktionen, einen Wert, der sich aus der Auswer­
+              tung des unter <Funktionsdefinition> angegebenen Ausdrucks
+              ergibt. 
+              Das letzte Zeichen des Funktionsnamens gibt den Typ des Wertes
+              an, den die Funktion liefert. Soll die Funktion einen TEXT liefern, so
+              muß der Name mit "$" enden. Soll ein INT geliefert werden, muß der
+              Name mit "%" enden. Für alle anderen Endungen wird eine REAL-
+              liefernde Funktion eingetragen. 
+              Bezeichnet der Funktionsname eine TEXT-liefernde Funktion, so
+              muß auch die Funktionsdefinition ein Ergebnis vom Typ TEXT liefern.
+              Zwischen INTs und REALs findet eine Typanpassung statt. 
+ 
+              Die Parameter stehen für die beim Aufruf der Funktion übergebenen
+              Argumente. 
+              Sie haben nur bei der Definition Gültigkeit. Hierbei 'überdecken' sie
+              (für diese Zeile) eventuell im BASIC-Programm vorhandene gleich­
+              namige Variablen. 
+              Die Syntax der Parameternamen entspricht der Syntax der Namen
+              von einfachen Variablen. 
+              Jeder Parameter darf in der Parameterliste nur einmal vorkommen. 
+ 
+              In der Definition dürfen auch Aufrufe von zuvor definierten anderen
+              "user functions" erscheinen, nicht aber die zu definierende Funktion
+              selbst (rekursive Definition). 
+ 
+              Die Funktionen sind allein durch ihre Namen gekennzeichnet. Gene­
+              rische Funktionen (gleicher Name, aber unterschiedliche Parameter)
+              können somit nicht definiert werden. 
+ 
+Hinweis :     1.  Die Definition einer "user function" muß ihrem ersten Aufruf
+                 immer textuell vorausgehen. 
+              2. "user functions" können auch mehrfach definiert werden. Der
+                 Compiler gibt in einem solchen Fall aber eine Warnung aus, da
+                 die neue Definition nur für die textuell folgenden Aufrufe gültig ist. 
+ 
+ 
+Beispiel :      10 LET pi = 3.1415927 
+                20 DEF FNkreisflaeche (radius) 
+                #right#= 4.0 * pi * radius * radius 
+                1010 PRINT FNkreisflaeche (1.75) 
+                Ausgabe:  38.48451 
+ 
+ 
+ 
+Anweisung : DIM 
+ 
+Zweck :        Dimensionierung eines Feldes 
+ 
+Syntax :       DIM <Felddeklaration> [, <Felddeklaration>] [...] 
+ 
+Erklärung :   <Felddeklaration>: <Feldvariable> (<INT-Konstante> 
+                                 #right#[, <INT-Konstante>] [...] ) 
+              <Feldvariable>: Name des Feldes (Syntax wie Name von einfachen
+                              Variablen, vgl. 4.3.) 
+ 
+              Mit der DIM-Anweisung wird ein Feld dimensioniert, das heißt die
+              Anzahl seiner Dimensionen sowie der kleinste und größte Index in
+              jeder Dimension werden festgelegt und der Speicherplatz für seine
+              Elemente (siehe 4.3.) wird reserviert. 
+ 
+              Der kleinste Index in allen Dimensionen richtet sich nach der letzten
+              vorausgegangenen OPTION BASE-Anweisung. 
+              Geht der Dimensionierung die Anweisung OPTION BASE 0 textuell
+              voraus oder ist keine OPTION BASE-Anweisung vor der Dimensio­
+              nierung vorhanden, so ist der kleinste Index in allen Dimensionen
+              null. 
+              Wenn der Dimensionierung aber eine OPTION BASE 1-Anweisung
+              vorausgeht, dann ist der kleinste Index in allen Dimensionen eins. 
+ 
+              Der größte Feldindex wird für jede Dimension durch die in Klammern
+              stehenden INT-Konstanten angegeben. Die Anzahl dieser INT-Kon­
+              stanten bestimmt auch, wie viele Dimensionen das dimensionierte
+              Feld hat. 
+ 
+              Wird auf ein Element einer Feldvariablen zugegriffen, ohne daß die
+              Feldvariable vorher dimensioniert wurde, dann wird das Feld automa­
+              tisch dimensioniert, wobei die Anzahl der Dimensionen anhand der
+              Anzahl der Indizes beim Aufruf ermittelt wird. Der größte Feldindex
+              wird bei dieser automatischen Dimensionierung in jeder Dimension
+              auf zehn gesetzt. Der kleinste Index richtet sich nach den vorausge­
+              gangenen OPTION BASE-Anweisungen (siehe oben). 
+ 
+              Fehlerfälle bei der Dimensionierung: 
+              - "Das Feld ist bereits dimensioniert": 
+                Das Feld wurde bereits explizit, oder automatisch durch den Zugriff
+                auf ein Feldelement dimensioniert . 
+              - "Die Obergrenze muß >= 1 sein": 
+                Es wurde versucht, 0 als größten Index in einer Dimension festzu­
+                legen, obwohl mit OPTION BASE der kleinste Index auf eins fest­
+                gelegt wurde. 
+ 
+              Fehlerfälle beim Zugriff auf ein Feldelement: 
+              - "Dimensioniert in ... Dimensionen, gefundene Anzahl Indizes ...": 
+                Beim Zugriff wurde eine Anzahl von Indizes gefunden, die nicht mit
+                der Anzahl der Dimensionen übereinstimmt (Fehler zur Über­
+                setzungszeit). 
+              - "Ueberlauf bei Subskription" oder "Unterlauf bei Subskription": 
+                Der Index ist zu groß beziehungsweise zu klein (Fehler zur Lauf­
+                zeit). 
+ 
+ 
+Beispiel :      10 DIM a% (20, 10), text$ (30, 40) 
+                20 DIM tabelle (5, 7, 25) 
+                30 LET element = matrix (1, 7) 
+ 
+              Zeile 30 führt eine automatische Dimensionierung durch, die einem
+              DIM matrix (10, 10) entspricht. 
+ 
+ 
+ 
+Anweisungsbestandteil : ELSE 
+ 
+Siehe IF-Anweisung 
+ 
+ 
+ 
+Anweisung : END 
+ 
+Zweck :        Beenden der Programmausführung eines BASIC-Programms 
+ 
+Syntax :       END 
+ 
+Erklärung :   END beendet die Programmausführung des BASIC-Programms ohne
+              eine Meldung (im Gegensatz zu STOP, s.d.). 
+              END-Anweisungen dürfen im Programm an beliebiger Stelle stehen,
+              und es darf auch mehr als eine END-Anweisung in einem
+              Programm vorkommen. 
+              Der Compiler übersetzt ein Programm auch nach Erreichen einer
+              END-Anweisung weiter. 
+              Nach der letzten Anweisung eines Programms muß kein END stehen. 
+ 
+ 
+Beispiel :      2020 PRINT "Das war's !" 
+                2030 REM Hiernach hört's auf 
+                2040 END 
+ 
+ 
+Vergleiche :  STOP-Anweisung 
+ 
+ 
+ 
+Anweisungsbestandteil : EOF 
+ 
+Siehe INPUT-Anweisung 
+ 
+ 
+ 
+ 
+Operator : EQV 
+ 
+Siehe Kapitel 4.4. (Operatoren) 
+ 
+ 
+ 
+Funktion : ERL 
+ 
+Zweck :        Ermittlung der letzten Fehlerzeile 
+ 
+Syntax :       ERL 
+ 
+Erklärung :   Die Nummer der Zeile, in der der letzte Fehler auftrat, wird als INT
+              geliefert. 
+ 
+Hinweis :     ERL ist realisiert durch Aufruf der Prozedur 'errorline' des Betriebs­
+              systems. 
+              Da die Fehlerbehandlungs-Anweisung ON ERROR nicht zur Verfü­
+              gung steht, ist diese Funktion nicht im üblichen BASIC-Sinne
+              brauchbar. 
+ 
+Vergleiche :  ERM$, ERR-Funktionen, ERROR-Anweisung 
+ 
+ 
+ 
+Funktion : ERM$ 
+ 
+Zweck :        Ermittlung der letzten Fehlermeldung 
+ 
+Syntax :       ERM$ 
+ 
+Erklärung :   Die letzte Fehlermeldung wird als TEXT geliefert. 
+ 
+Hinweis :     ERM$ ist realisiert durch Aufruf der Prozedur 'errormessage' des
+              Betriebssystems. 
+              Da die Fehlerbehandlungs-Anweisung ON ERROR nicht zur Verfü­
+              gung steht, ist diese Funktion nicht im üblichen BASIC-Sinne
+              brauchbar. 
+ 
+Vergleiche :  ERL-, ERR-Funktionen, ERROR-Anweisung 
+ 
+ 
+ 
+Funktion : ERR 
+ 
+Zweck :        Ermittlung des letzten Fehlercodes 
+ 
+Syntax :       ERR 
+ 
+Erklärung :   Der Code des letzten aufgetretenen Fehlers wird als INT geliefert. 
+ 
+Hinweis :     ERR ist realisiert durch Aufruf der Prozedur 'errorcode' des Betriebs­
+              systems. 
+              Da die Fehlerbehandlungs-Anweisung ON ERROR nicht zur Verfü­
+              gung steht, ist diese Funktion nicht im üblichen BASIC-Sinne
+              brauchbar. 
+ 
+Vergleiche :  ERL-, ERM$-Funktionen, ERROR-Anweisung 
+ 
+ 
+ 
+Anweisung : ERROR 
+ 
+Zweck :        Auslösen eines Fehlers mit bestimmtem Fehlercode 
+ 
+Syntax :       ERROR <INT-Ausdruck> 
+ 
+Erklärung :   Es wird ein Fehler mit dem durch den INT-Ausdruck bestimmten
+              Fehlercode ausgelöst. 
+ 
+Hinweis :     ERROR ist realisiert durch Aufruf der Prozedur 'errorstop' des Be­
+              triebssystems. 
+              Da die Fehlerbehandlungs-Anweisung ON ERROR nicht zur Verfü­
+              gung steht, ist diese Anweisung nicht im üblichen BASIC-Sinne
+              brauchbar. 
+ 
+Vergleiche :  ERL-, ERM$-, ERR-Funktionen 
+ 
+ 
+ 
+Funktion : EXP 
+ 
+Zweck :        Berechnung einer Potenz der Eulerschen Zahl 
+ 
+Syntax :       EXP (<REAL-Ausdruck>) 
+ 
+Erklärung :   Die Funktion liefert e (die Basis des natürlichen Logarithmus) poten­
+              ziert mit dem Wert des REAL-Ausdrucks. 
+              Bei zu großen Werten kommt es zum Fehler 'REAL-Ueberlauf'. 
+              Das Ergebnis der Funktion wird als REAL geliefert. 
+ 
+ 
+Beispiel :      10 PRINT EXP (10.0) 
+                Ausgabe:  22026.47 
+ 
+Vergleiche :  LOG-Funktion (Komplementärfunktion) 
+ 
+ 
+ 
+Funktion : FIX 
+ 
+Zweck :        Ermittlung der Vorkommastellen einer REAL-Zahl 
+ 
+Syntax :       FIX (<REAL-Ausdruck>) 
+ 
+Erklärung :   Die Funktion schneidet die Nachkommastellen ab und liefert nur die
+              Vorkommastellen des REAL-Ausdrucks. 
+              Die Vorkommastellen werden ebenfalls als REALs geliefert. 
+ 
+ 
+Beispiel :      10 zahl = 1.2345E2 
+                20 PRINT FIX (zahl) 
+                Ausgabe:  123 
+ 
+Vergleiche :  CINT-, INT-Funktionen 
+ 
+ 
+ 
+Anweisung : FOR 
+ 
+Zweck :        Beginn einer Zählschleife 
+ 
+Syntax :       FOR <num. Variable> = <Anfangswert> #ib(3)#TO#ie(3)# <Endwert> 
+              #right#[ #ib(3)#STEP#ie(3)# <Schrittweite> ] 
+              <Schleifenrumpf> 
+ 
+ 
+Erklärung :   <num. Variable> : INT- oder REAL-Variable 
+              <Anfangswert>   : numerischer Ausdruck 
+              <Endwert>       : numerischer Ausdruck 
+              <Schrittweite>  : numerischer Ausdruck 
+              <Schleifenrumpf>: Folge von Programmzeilen 
+ 
+              Die FOR-Anweisung erlaubt die komfortable Programmierung von
+              automatischen Zählschleifen (sogenannten FOR-NEXT-Schleifen).
+              Gelangt das Programm während der Ausführung an eine FOR-An­
+              weisung, so werden zunächst die Ausdrücke <Anfangswert>,
+              <Endwert> sowie gegebenenfalls <Schrittweite> ausgewertet. Der
+              Anfangswert wird dann der Variablen zugewiesen. 
+              Wenn der Wert der Variablen größer ist als der Endwert (bzw. kleiner
+              als der Endwert bei negativer Schrittweite), dann wird das Programm
+              mit der nach dem korrespondierenden NEXT (s.d.) folgenden
+              Anweisung fortgesetzt. 
+              Ist dies jedoch nicht der Fall, werden die Anweisungen des <Schlei­
+              fenrumpfs> ausgeführt. Erreicht das Programm nun die zum FOR
+              gehörige NEXT-Anweisung (gleiche Variable), so wird der Wert der
+              Variablen um die Schrittweite erhöht beziehungsweise erniedrigt (je
+              nach Vorzeichen), und wieder an den Anfang der Schleife verzweigt.
+              Hier findet dann wieder der Vergleich des Variableninhalts mit dem
+              Endwert statt (siehe oben). 
+ 
+              Die Laufvariable darf innerhalb der Schleife in Ausdrücken vorkom­
+              men. Sie darf sogar verändert werden (, was aber zu unübersichtli­
+              chen Effekten führen kann). Auch eine Schachtelung mehrerer
+              Schleifen mit der gleichen Laufvariable ist syntaktisch möglich, sollte
+              aber #on("iunter allen Umständen#off("i vermieden werden. 
+ 
+              FOR-NEXT-Schleifen dürfen (auch mit WHILE-WEND-Schleifen,
+              s.d.) geschachtelt werden. Überschneidungen von FOR-NEXT-
+              Schleifen und WHILE-WEND-Schleifen sind aber nicht zulässig. 
+ 
+ 
+Beispiel :      10 DIM name$ (5) 
+                20 FOR i = 1 TO 5 
+                30 PRINT "Bitte geben Sie den " + STR$ (i) 
+                #right#+ ". Namen ein:"; 
+                40 INPUT name$ (i) 
+                50 NEXT i 
+ 
+ 
+              Es werden die fünf Elemente des Feldes 'name$' eingelesen. 
+ 
+Vergleiche :  NEXT-, WHILE-, IF-Anweisungen 
+ 
+ 
+ 
+Funktion : FRE 
+ 
+Zweck :        Ermittlung des verfügbaren Speicherplatzes 
+ 
+Syntax :       FRE (<num. Ausdruck>) 
+              FRE (<TEXT-Ausdruck>) 
+ 
+Erklärung :   Die Funktion liefert die Anzahl der freien Bytes. 
+              FRE veranlaßt außerdem ein 'collect heap garbage' (EUMEL-
+              Systemprozedur). 
+ 
+              Das Ergebnis der Funktion wird als REAL geliefert. 
+              Der Argument-Ausdruck ist ein Dummy-Argument (hat keinen
+              Einfluß auf den gelieferten Wert). 
+ 
+Hinweis :     Bei der EUMEL M+ Version wird ein korrektes Ergebnis geliefert
+              (vgl.'storage info'). 
+ 
+ 
+Beispiel :      10 PRINT FRE (0) 
+                Ausgabe (z.B.):  5324800 
+ 
+ 
+ 
+Anweisungsbestandteil : GO 
+ 
+Siehe GOSUB und GOTO 
+ 
+ 
+ 
+Anweisung : GOSUB 
+ 
+Zweck :        Unterprogramm-Aufruf 
+ 
+Syntax :       GOSUB <Zeilennummer> 
+ 
+Erklärung :   <Zeilennummer>: INT-Konstante 
+              Statt GOSUB darf auch GO #ib(3)#SUB#ie(3)# geschrieben werden. 
+ 
+              Die Programmausführung wird in der Zeile mit der angegebenen
+              Zeilennummer fortgesetzt. Die Zeile mit der Zeilennummer muß im
+              Programm existieren. 
+              Wird im weiteren Programmablauf die Anweisung RETURN gefunden,
+              so wird hinter dem letzten abgearbeiteten GOSUB die Programm­
+              ausführung fortgesetzt. 
+              GOSUB dient zum Aufruf von #on("iUnterprogrammen#off("i, die von mehr als
+              einer Stelle im Programm (und auch in anderen Unterprogrammen)
+              aufgerufen werden können. 
+ 
+Hinweis :     Es wird empfohlen, Unterprogramme im Programm deutlich als solche
+              zu kennzeichnen und (durch END, STOP oder GOTO) sicherzustel­
+              len, daß nur mit GOSUB zu ihnen verzweigt wird, da es sonst leicht
+              zu der (Laufzeit-) Fehlermeldung "RETURN ohne GOSUB" kommen
+              kann. 
+ 
+ 
+Beispiel :      140 GOSUB 10000  'Zeige Uhrzeit 
+                . 
+                . 
+                370 GOSUB 10000  'Zeige Uhrzeit 
+                9990 END 
+                10000 REM Unterprogramm Zeige Uhrzeit 
+                10010 PRINT "Es ist " + TIME$ + " Uhr" 
+                10020 RETURN 
+ 
+ 
+Vergleiche :  RETURN-, ON-, GOTO- Anweisungen 
+ 
+ 
+ 
+Anweisung : GOTO 
+ 
+Zweck :        Sprung zu einer angegebenen Zeile 
+ 
+Syntax :       GOTO <Zeilennummer> 
+ 
+Erklärung :   <Zeilennummer>: INT-Konstante 
+              Statt GOTO darf auch GO #ib(3)#TO#ie(3)# geschrieben werden. 
+ 
+              Die Programmausführung wird in der Zeile mit der angegebenen
+              Zeilennummer fortgesetzt. Die Zeile mit der Zeilennummer muß im
+              Programm existieren. 
+ 
+ 
+Beispiel :      10 INPUT "Monat (1-12)", monat% 
+                20 IF monat% < 1 OR monat% > 12 THEN GOTO 10 
+ 
+ 
+Vergleiche :  ON-, IF-, GOSUB- Anweisungen 
+ 
+ 
+ 
+Funktion : HEX$ 
+ 
+Zweck :        Erzeugung der hexadezimalen Darstellung einer Zahl als Text 
+ 
+Syntax :       HEX$ (<INT-Ausdruck>) 
+ 
+Erklärung :   Die Funktion liefert die hexadezimale (Zweierkomplement-) Darstel­
+              lung der Zahl, die sich aus dem INT-Ausdruck ergibt. 
+ 
+ 
+Beispiel :      10 PRINT HEX$ (10000) 
+                Ausgabe:  2710 
+ 
+Vergleiche :  OCT$-Funktion 
+ 
+ 
+ 
+Anweisung : IF 
+ 
+Zweck :        Sprung zu einer angegebenen Zeile 
+ 
+Syntax :       IF <Bedingung> 
+              #right#[,] #ib(3)#THEN#ie(3)# <Anweisung(en)>|<Zeilennummer> 
+              #right#[ [,] #ib(3)#ELSE#ie(3)# <Anweisung(en)>|<Zeilennummer>] 
+              IF <Bedingung> [,] GOTO <Zeilennummer> 
+              #right#[ [,] ELSE <Anweisung(en)>|<Zeilennummer>] 
+ 
+Erklärung :   <Bedingung>    : numerischer Ausdruck 
+              <Anweisung(en)>: Eine oder mehrere BASIC-Anweisungen, wobei
+                               mehrere wie gewohnt durch ':' zu trennen sind 
+              <Zeilennummer> : INT-Konstante 
+              Statt GOTO darf auch GO TO geschrieben werden. 
+ 
+              Anhand der Bedingung wird entschieden, ob die Abarbeitung des
+              Programms mit dem THEN- oder ELSE-Zweig fortgesetzt werden
+              soll. Mit dem THEN-Zweig wird das Programm fortgesetzt, wenn die
+              Bedingung erfüllt ist (, d.h. der numerische Ausdruck ungleich null
+              ist). Im anderen Fall (Bedingung nicht erfüllt, numerischer Ausdruck
+              gleich null) wird das Programm mit dem ELSE-Teil fortgesetzt. Ist
+              kein ELSE-Teil angegeben, so wird die Abarbeitung des
+              Programmes in der folgenden #on("iZeile#off("i (nicht nach ':') fortgesetzt. 
+ 
+              Sind statt Anweisungen Zeilennummern nach THEN oder ELSE
+              angegeben, so entspricht dies einem GOTO (s.d.) zu diesen Zeilen­
+              nummern. 
+ 
+ 
+Hinweis :     Auch eine IF-Anweisung muß in #on("ieiner#off("i Programmzeile stehen. 
+ 
+ 
+Beispiel :      10 IF a >= b THEN IF a > b THEN 
+                #right#PRINT "a größer b" ELSE PRINT "a gleich b" 
+                #right#ELSE PRINT "a kleiner b" 
+ 
+ 
+              Das Beispiel zeigt, daß bei geschachtelten IF-Anweisungen die
+              ELSE-Teile immer auf das letzte vorhergehende IF bezogen werden,
+              für das noch kein ELSE-Teil gefunden wurde. 
+ 
+ 
+ 
+Vergleiche :  GOTO-, GOSUB-, ON-Anweisungen 
+ 
+ 
+ 
+Operator : IMP 
+ 
+Siehe Kapitel 4.4. (Operatoren) 
+ 
+ 
+ 
+Funktion : INKEY$ 
+ 
+Zweck :        Holen eines Zeichens von der Tastatur 
+ 
+Syntax :       INKEY$ 
+ 
+Erklärung :   Die Funktion liefert ein Textzeichen aus dem Tastaturzeichenpuffer.
+              Wurde kein Zeichen eingegeben, so wird ein Leertext (niltext) gelie­
+              fert. 
+              Die gelieferten Zeichen erscheinen nicht auf dem Bildschirm. 
+ 
+ 
+Beispiel :      10 REM Schreibmaschine 
+                20 LET a$ = INKEY$ 
+                30 IF ASC (a$) = 27 THEN STOP 
+                40 PRINT a$; 
+                50 GOTO 20 
+ 
+ 
+              Die eingegebenen Zeichen werden ausgegeben. Abbruch mit ESC. 
+ 
+Vergleiche :  INPUT$-Funktion, INPUT-Anweisung 
+ 
+ 
+ 
+Anweisung : INPUT 
+ 
+Zweck :        Einlesen von Daten von der Tastatur 
+ 
+Syntax :       INPUT [;] [<Eingabeaufforderung> ,|; ][ #ib(3)#EOF#ie(3)#
+        <Zeilennummer>] 
+              #right#<Variable> [, <Variable> ] [...]  
+ 
+Erklärung :   <Eingabeaufforderung>:  TEXT-Konstante 
+              <Zeilennummer>:         INT-Konstante 
+              <Variable>:             Variable, der der eingelesene Werte
+                                      zugewiesen werden soll 
+ 
+              Mit der INPUT-Anweisung werden Daten zur Laufzeit des
+              Programms von der Tastatur in Variablen eingelesen. 
+ 
+              Folgt dem INPUT-Statement ein Semikolon, so wird nach
+              Beendigung der Eingabe kein Zeilenwechsel vorgenommen. 
+ 
+              Fehlt die <Eingabeaufforderung>, so wird "? " als Eingabe­
+              aufforderung ausgegeben. 
+              Folgt der  ein Semikolon, so wird "? " noch zusätzlich ausge­
+              geben. Bei einem Komma wird dieser Standard-Prompt unter­
+              drückt. 
+ 
+              Folgt der <Eingabeaufforderung> die Zeichenfolge 'EOF', so wird
+              bei Eingabe eines Leertextes zu der nach 'EOF' angegebenen
+              Zeilennumer verzweigt. 
+ 
+              Sollen mehrere Variablen eingelesen werden, so muß der Benutzer
+              auch entsprechend viele Daten (durch Kommata getrennt) zur Verfü­
+              gung stellen. 
+ 
+              Wird nichts eingegeben beziehungsweise nur die richtige Anzahl von
+              Kommata, so wird den entsprechenden Variablen 0, 0.0 bzw. 'niltext'
+              zugewiesen. 
+ 
+              Bei der Eingabe für eine Textvariable können alle Zeichen (außer
+              Steuerzeichen) eingegeben werden. Beginnt eine Eingabe mit dem
+              Anführungszeichen oder endet sie damit, dann muß sie auch damit
+              enden beziehungsweise beginnen. Diese beiden Anführungszeichen
+              werden nicht mit zugewiesen. Innerhalb dieser Texteingabe dürfen
+              Anführungszeichen stehen, aber keine Kommata. 
+ 
+              Eingaben für numerische Variablen müssen in der für Konstanten
+              üblichen Schreibweise erfolgen. Vorzeichen sind allerdings zusätzlich
+              erlaubt. 
+ 
+              Vor Zuweisung der eingegebenen Werte an die Variablen werden
+              Anzahl und Typ(en)  und die Anzahl überprüft. 
+              Dabei können folgende Fehlerfälle auftreten: 
+              - "falscher Typ": 
+                Es wurde ein Text statt einer Zahl eingegeben, es wurde ein REAL
+                statt eines INTs eingegeben oder eine Texteingabe ist fehlerhaft. 
+              - "zu wenig Daten" 
+              - "zu viele Daten" 
+              - "Überlauf": 
+                Es wurde eine zu große (oder zu kleine) Zahl eingegeben. 
+ 
+              Kommt es zu einem Fehler, dann wird nach der Meldung "?Eingabe
+              wiederholen !  (<Fehlerbeschreibung>)" die Eingabe zum Editieren
+              angeboten. 
+ 
+Hinweis :     Bei Eingabe von 'ESC k' kann die letzte Eingabezeile zum Editieren
+              zurückgeholt werden. 
+ 
+              Die Eingabe kann mit der Systemprozedur 'sysin' aus einer Datei
+              erfolgen. Aus der Eingabedatei wird für jedes INPUT-Statement eine
+              Zeile eingelesen. Die Ausgabe der Eingabeaufforderung und der
+              Zeilenwechsel nach der Eingabe werden unterdrückt. Sind die
+              Eingabedaten fehlerhaft, so wird das Programm mit 'errorstop'
+              abgebrochen. 
+ 
+              Wird die Ausgabe mit 'sysout' umgeleitet, so werden die Eingabe­
+              aufforderung, die Eingabezeichenfolge und der Zeilenwechsel nach
+              der Eingabe auf den Bildschirm und in die Ausgabedatei ausgegeben,
+              auch dann, wenn der Text der Eingabe aus einer Datei eingelesen
+              wurde. 
+ 
+ 
+Beispiel :      1990 INPUT "Name, Vorname, Alter"; 
+                #right#name$, vorname$, alter% 
+ 
+ 
+Vergleiche :  INKEY$-, INPUT$-Funktionen 
+ 
+ 
+ 
+Funktion : INPUT$ 
+ 
+Zweck :        Holen einer Zeichenfolge von der Tastatur 
+ 
+Syntax :       INPUT$ (<Anzahl Zeichen>) 
+ 
+Erklärung :   <Anzahl Zeichen>: INT-Ausdruck 
+ 
+              Die Funktion liefert eine Folge von <Anzahl Zeichen> Textzeichen
+              aus dem Tastaturzeichenpuffer. Enthält der Puffer nicht alle ge­
+              wünschten Zeichen, so wird auf weitere Zeichen von der Tastatur
+              gewartet. 
+              Die gelieferten Zeichen erscheinen nicht auf dem Bildschirm. 
+ 
+ 
+Beispiel :      10 PRINT "Bitte drei Zeichen eingeben !" 
+                20 LET a$ = INPUT$ (3) 
+                30 PRINT "Danke schön !" 
+ 
+ 
+Vergleiche :  INKEY$-Funktion, INPUT-Anweisung 
+ 
+ 
+ 
+Funktion : INSTR 
+ 
+Zweck :        Suchen einer Zeichenfolge in einer anderen 
+ 
+Syntax :       INSTR ( [<Startposition>,] <TEXT-Ausdruck1>, 
+              #right#<TEXT-Ausdruck 2>) 
+ 
+Erklärung :   <Startposition>: INT-Ausdruck 
+ 
+              Die Funktion liefert die Position, ab der der TEXT-Ausdruck 2 das
+              erste Mal im TEXT-Ausdruck 1 vorkommt. 
+              Die Position wird als INT geliefert. 
+ 
+ 
+Beispiel :      10 LET a$ = "hallihallo" 
+                20 LET b$ = "all" 
+                30 PRINT INSTR (a$, b$); INSTR (5, a$, b$) 
+                Ausgabe:   2  7 
+ 
+ 
+ 
+Funktion : INT 
+ 
+Zweck :        Ermittlung der nächstkleineren ganzen Zahl 
+ 
+Syntax :       INT (<REAL-Ausdruck>) 
+ 
+Erklärung :   Die Funktion liefert die größte ganze Zahl, für die gilt: 
+              n kleiner gleich <REAL-Ausdruck>. 
+              Bei positiven Werten bedeutet das, daß die Nachkommastellen abge­
+              schnitten werden. 
+              Das Ergebnis wird als REAL geliefert. 
+ 
+ 
+Beispiel :      10 PRINT INT (11.74); INT (-11.74) 
+                Ausgabe:  11  -12 
+ 
+Vergleiche :  CINT-, FIX-Funktionen 
+ 
+ 
+ 
+Anweisung : KILL 
+ 
+Zweck :        Löschen einer Datei in der Task 
+ 
+Syntax :       KILL <Dateiname> 
+ 
+Erklärung :   <Dateiname>: TEXT-Ausdruck 
+              Die Datei <Dateiname> wird (ohne Nachfrage) gelöscht. 
+ 
+ 
+Beispiel :      2110 KILL "Scratchdatei" 
+ 
+ 
+ 
+ 
+Funktion : LEFT$ 
+ 
+Zweck :        Erzeugung eines Teiltextes aus einem anderen Text 
+ 
+Syntax :       LEFT$ (<TEXT-Ausdruck>, <Anzahl Zeichen>) 
+ 
+Erklärung :   <Anzahl Zeichen>: INT-Ausdruck 
+ 
+              Die Funktion liefert die ersten <Anzahl Zeichen> Textzeichen des
+              TEXT-Ausdrucks. 
+ 
+ 
+Beispiel :      10 LET a$ = "hallihallo" 
+                20 PRINT LEFT$ (a$, 4) 
+                Ausgabe:   hall 
+ 
+Vergleiche :  MID$-, RIGHT$-Funktionen, LSET-, MID$-, RSET-
+              Anweisungen 
+ 
+ 
+ 
+Funktion : LEN 
+ 
+Zweck :        Ermittlung der Länge eines Textes 
+ 
+Syntax :       LEN (<TEXT-Ausdruck>) 
+ 
+Erklärung :   Die Funktion liefert die Anzahl der im TEXT-Ausdruck enthaltenen
+              Zeichen (also die Länge des Textes). Die Länge wird als INT
+              geliefert. 
+              Ein Leertext (niltext, "") hat die Länge null. 
+ 
+ 
+Beispiel :      10 LET a$ = "hallihallo" 
+                20 PRINT LEN (a$) 
+                Ausgabe:   10 
+ 
+ 
+ 
+Anweisung : LET 
+ 
+Zweck :        Zuweisung eines Wertes an eine Variable 
+ 
+Syntax :       [LET] <Variable> = <Ausdruck> 
+ 
+Erklärung :   Die LET-Anweisung ermöglicht das Zuweisen von Werten an Variab­
+              len (dazu gehören auch die Elemente von Feldern). 
+ 
+              Das Schlüsselwort LET ist optional, d.h. eine Zuweisung wird auch
+              ohne dieses Schlüsselwort erkannt. 
+ 
+              #on("iZuweisung an TEXT-Variablen:#off("i 
+                LET <TEXT-Variable> = <TEXT-Ausdruck> oder <num.
+                Konstante> 
+              Die numerische Konstante wird automatisch in einen TEXT umge­
+              wandelt (vgl. STR$-Funktion) 
+ 
+              #on("iZuweisung an INT-Variablen:#off("i 
+                LET <INT-Variable> = <num. Ausdruck> 
+              Ist der numerische Ausdruck ein REAL-Ausdruck, so wird automa­
+              tisch nach INT konvertiert (vgl. CINT-Funktion). 
+ 
+              #on("iZuweisung an REAL-Variablen:#off("i 
+                LET <REAL-Variable> = <num. Ausdruck> 
+              Ist der numerische Ausdruck ein INT-Ausdruck, so wird automatisch
+              nach REAL konvertiert (vgl. CDBL-Funktion). 
+ 
+ 
+Beispiel :      10 LET t$ = "murmel marmel" 
+                20 LET t$ = 1245.3 'wie "1245.3" 
+                30 LET i% = 852 
+                40 LET i% = 12.73  'aufgerundet: 13 
+                50 LET r = 564     'wie 564. 
+                60 LET r = 157.36 
+ 
+ 
+ 
+ 
+Anweisung : LINE INPUT 
+ 
+Zweck :        Einlesen einer Eingabe von der Tastatur in eine TEXT-Variable 
+ 
+Syntax :       LINE INPUT [;] [<Eingabeaufforderung>;] 
+              #right#<TEXT-Variable> 
+ 
+Erklärung :   Die LINE INPUT-Anweisung ermöglicht das Einlesen von Eingaben
+              in TEXT-Variablen, aber im Gegensatz zu INPUT ohne Beachtung
+              von Trennzeichen (z.B. ","). 
+ 
+              Steht direkt nach LINE INPUT ein Semikolon, so wird nach Beendi­
+              gung der Eingabe der Zeilenwechsel unterdrückt. 
+ 
+              Der eingegebene Text wird (bis auf das CR-Zeichen) der TEXT-
+              Variablen zugewiesen. 
+ 
+ 
+Beispiel :      2110 LINE INPUT "Name: ";name$ 
+ 
+ 
+              Der Benutzer könnte nun auch folgendes eingeben: 
+              Neumann, Alfred E. 
+ 
+Vergleiche :  INPUT-Anweisung 
+ 
+ 
+ 
+Funktion : LOG 
+ 
+Zweck :        Berechnung des natürlichen Logarithmus einer Zahl 
+ 
+Syntax :       LOG (<REAL-Ausdruck>) 
+ 
+Erklärung :   Die Funktion liefert den natürlichen Logarithmus des Wertes des
+              REAL-Ausdrucks. 
+              Bei nicht-positiven Werten kommt es zu einem Fehler in der
+              EUMEL-Prozedur 'log2'. 
+              Das Ergebnis der Funktion wird als REAL geliefert. 
+ 
+ 
+Beispiel :      10 PRINT LOG (10.0) 
+                Ausgabe:  2.302585 
+ 
+Vergleiche :  EXP-Funktion (Komplementärfunktion) 
+ 
+ 
+ 
+Funktion : LPOS 
+ 
+Zweck :        Ermittlung der aktuellen Druckspalte 
+ 
+Syntax :       LPOS (<num. Ausdruck>) 
+ 
+Erklärung :   Geliefert wird die Nummer der Spalte (als INT), in die das nächste
+              nächste Zeichen mit LPRINT ausgegeben wird. Die Spalte ganz links
+              hat die Nummer 1. 
+              Der Argument-Ausdruck ist ein Dummy-Argument (hat keinen
+              Einfluß auf den gelieferten Wert). 
+ 
+ 
+Beispiel :      3010 IF LPOS (0) > 65 THEN LPRINT 
+                3020 LPRINT name$ 
+ 
+ 
+              Falls die Druckposition hinter Spalte 65 liegt, wird eine neue Druck­
+              zeile begonnen. 
+ 
+Vergleiche :  LPRINT-Anweisung, TAB-, POS-Funktion 
+ 
+ 
+ 
+Anweisung : LPRINT 
+ 
+Zweck :        Ausgabe in eine Druckdatei 
+ 
+Syntax :       LPRINT [#ib(3)#USING#ie(3)# <Format> ;] 
+              #right#[ #ib(3)#TAB#ie(3)# (<Spalte>) | , | ; | <Ausdruck> ] [...] 
+ 
+Erklärung :   <Format>  : TEXT-Ausdruck für USING (vgl. PRINT) 
+              <Spalte>  : INT-Ausdruck (vgl. PRINT) 
+              <Ausdruck>: TEXT-Ausdruck oder numerischer Ausdruck 
+ 
+              Die LPRINT-Anweisung arbeitet wie PRINT (siehe dort), mit dem
+              Unterschied, daß LPRINT die Zeichen nicht auf den Bildschirm, son­
+              dern in eine Datei mit dem Namen "BASIC LPRINT OUTPUT"
+              ausgibt. Diese Datei wird automatisch eingerichtet, falls sie noch
+              nicht existiert. Ist sie schon vorhanden, so werden die auszugeben­
+              den Zeichen am Ende der Datei angefügt. 
+              Nach oder bei Ablauf des Programms kann die Datei (evtl. nach
+              vorheriger Aufbereitung durch Textverarbeitungsprogramme) mit
+              'print', wie im EUMEL-System üblich, an den Drucker geschickt
+              werden. Der Benutzer ist selbst dafür verantwortlich, daß er die
+              Druckdatei, sofern die Daten nicht mehr benötigt werden, vor einem
+              neuen Programmlauf leert oder löscht. Versäumt er dies, so bleiben
+              die alten Daten in der Druckdatei, und die neuen Ausgaben werden
+              hinten angefügt. Das Löschen der Druckdatei kann zum Beispiel
+              durch das BASIC-Programm mit der KILL-Anweisung erreicht
+              werden. 
+ 
+              Die Art der Ausgabe und die Syntax ist sonst analog zur PRINT-
+              Anweisung (siehe Erläuterungen dort). 
+ 
+ 
+Beispiel :      2110 LPRINT "Dieser Text geht in die Druckdatei" 
+                2120 LPRINT TAB (12); "Datum: " DATE$ 
+                2130 LPRINT 1, 2, 3 
+ 
+ 
+Vergleiche :  PRINT-Anweisung, LPOS-Funktion 
+ 
+ 
+ 
+Anweisung : LSET 
+ 
+Zweck :        Ersetzen von Zeichen eines Textes von links her 
+ 
+Syntax :       LSET <TEXT-Variable> = <TEXT-Ausdruck> 
+ 
+Erklärung :   Das Ergebnis des TEXT-Ausdrucks wird, links beginnend, in der
+              TEXT-Variablen eingesetzt. Es werden höchstens so viele Zeichen
+              ersetzt, wie bisher schon in der Variablen vorhanden waren, das heißt
+              die Länge des Textes in der Variablen ändert sich nicht. 
+ 
+ 
+Beispiel :      210 LET a$ = "12345" 
+                220 LSET a$ = "ABCDEFG" 
+                230 PRINT a$, 
+                240 LSET a$ = "abc" 
+                250 PRINT a$ 
+                Ausgabe:    ABCDE         abcDE 
+ 
+Vergleiche :  MID$-, RSET-Anweisungen, LEFT$-, MID$-, RIGHT$-Funk­
+              tionen 
+ 
+ 
+ 
+Anweisung : MID$ 
+ 
+Zweck :        Ersetzen von Zeichen innnerhalb eines Textes 
+ 
+Syntax :       MID$ (<TEXT-Variable>, <Startposition> 
+              #right#[, <Anzahl Zeichen>] ) = <TEXT-Ausdruck> 
+ 
+Erklärung :   <Startposition> : INT-Ausdruck 
+              <Anzahl Zeichen>: INT-Ausdruck 
+ 
+              Das Ergebnis des TEXT-Ausdrucks wird, bei <Startposition>
+              beginnend, in der TEXT-Variablen eingesetzt. Es werden höch­
+              stens LEN <TEXT-Variable> Textzeichen ersetzt. Ist keine
+              <Anzahl Zeichen> angegeben, so werden so viele Zeichen des
+              TEXT-Ausdrucks wie möglich in der TEXT-Variablen eingetragen. 
+              Außerdem gilt: Es wird nicht über das bisherige Ende des Variablen­
+              inhalts ersetzt, das heißt die Länge des Textes in der Variablen
+              ändert sich nicht. 
+ 
+ 
+Beispiel :      210 LET a$ = "12345" 
+                220 MID$ (a$, 3) = "ABCDEFG" 
+                230 PRINT a$, 
+                240 MID$ (a$, 2, 1) = "abc" 
+                250 PRINT a$ 
+                Ausgabe:    12ABC           1aABC 
+ 
+Vergleiche :  LEFT$-, MID$-, RIGHT$-Funktionen, LSET-, RSET-
+              Anweisungen 
+ 
+ 
+ 
+Funktion : MID$ 
+ 
+Zweck :        Erzeugung eines Teiltextes aus einem anderen Text 
+ 
+Syntax :       MID$ (<TEXT-Ausdruck>, 
+              #right#<Startposition> [, <Anzahl Zeichen>]) 
+ 
+Erklärung :   <Startposition> : INT-Ausdruck 
+              <Anzahl Zeichen>: INT-Ausdruck 
+ 
+              Die Funktion liefert höchstens <Anzahl Zeichen> Textzeichen des
+              TEXT-Ausdrucks von Position <Startposition> an. 
+              Wird <Anzahl Zeichen> nicht angegeben, so werden alle Zeichen
+              ab Startposition geliefert. 
+              Werden rechts von <Startposition> keine Zeichen mehr gefunden
+              oder ist <Anzahl Zeichen> gleich null, so wird ein Leertext geliefert. 
+ 
+ 
+Beispiel :      10 LET a$ = "hallihallo" 
+                20 PRINT MID$ (a$, 4, 4), 
+                30 PRINT MID$ (a$, 6) 
+                Ausgabe:   liha           hallo 
+ 
+Vergleiche :  LEFT$-, RIGHT$-Funktionen, LSET-, MID$-, RSET-
+              Anweisungen 
+ 
+ 
+ 
+Funktion : MKD$, MKI$ 
+ 
+Zweck :        Codierung von Zahlenwerten in Texte 
+ 
+Syntax :       MKD$ (<REAL-Ausdruck>) 
+              MKI$ (<INT-Ausdruck>) 
+ 
+Erklärung :   Mit MKD$ und MKI$ können INTs und REALs zu Texten codiert
+              werden. 
+ 
+              Die Funktion MKD$ liefert einen 8 Zeichen langen TEXT, der den
+              Wert des REAL-Ausdrucks codiert enthält. 
+              Vergleichbar arbeitet MKI$, das einen 2 Zeichen langen TEXT liefert,
+              der den Wert des INT-Ausdrucks darstellt. 
+ 
+              Mit MKD$ und MKI$ codierte Werte können mit CVD und CVI (s.d.)
+              wieder decodiert werden. 
+ 
+ 
+Beispiel :      10 zahl$ = MKD$ (3.1415) 
+                20 PRINT CVD (zahl$) 
+                Ausgabe:  3.1415 
+ 
+Vergleiche :  CVD-, CVI-Funktionen 
+ 
+ 
+ 
+Operator : MOD 
+ 
+Siehe Kapitel 4.4. (Operatoren) 
+ 
+ 
+ 
+Anweisung : NAME 
+ 
+Zweck :        Umbenennen einer Datei 
+ 
+Syntax :       NAME <alter Name> AS <neuer Name> 
+ 
+Erklärung :   <alter Name>: TEXT-Ausdruck 
+              <alter Name>: TEXT-Ausdruck 
+ 
+              NAME benennt die Datei <alter Name> in <neuer Name> um. 
+ 
+ 
+Beispiel :      10 NAME "Käufer" AS "Kunden" 
+ 
+ 
+ 
+ 
+Anweisung : NEXT 
+ 
+Zweck :        Markierung des Endes einer FOR-Schleife 
+ 
+Syntax :       NEXT [<num. Variable>] [, <num. Variable>] [...] 
+ 
+Erklärung :   NEXT markiert das Ende einer FOR-Schleife (vergleiche FOR-
+              Anweisung). 
+ 
+              Wird keine Variable angegeben, so bezieht sich das NEXT auf das
+              letzte textuell vorhergehende FOR. 
+              Wird eine Laufvariable angegeben, so muß sie mit der im letzten
+              FOR verwendeten Laufvariable übereinstimmen. 
+              Werden mehrere Variablen angegeben, so werden durch die
+              NEXT-Anweisung mehrere FOR-Schleifen abgeschlossen. 
+              Beachten Sie, daß FOR-Schleifen sich nicht überschneiden dürfen,
+              sondern nur Schachtelungen zulässig sind. Es kommt daher auf die
+              Reihenfolge der Variablen bei den NEXT-Anweisungen an. Die
+              letzte (innerste) FOR-Schleife muß als erste wieder mit dem zuge­
+              hörigen NEXT abgeschlossen werden. 
+ 
+Vergleiche :  FOR-, WHILE-Anweisungen 
+ 
+ 
+ 
+Operator : NOT 
+ 
+Siehe Kapitel 4.4. (Operatoren) 
+ 
+ 
+ 
+Funktion : OCT$ 
+ 
+Zweck :        Erzeugung der oktalen Darstellung einer Zahl als Text 
+ 
+Syntax :       OCT$ (<INT-Ausdruck>) 
+ 
+Erklärung :   Die Funktion liefert die oktale (Zweierkomplement-) Darstellung der
+              Zahl, die sich aus dem INT-Ausdruck ergibt. 
+ 
+ 
+Beispiel :      10 PRINT OCT$ (10000) 
+                Ausgabe:  23420 
+ 
+Vergleiche :  OCT$-Funktion 
+ 
+ 
+ 
+Anweisung : ON 
+ 
+Zweck :        Ausführung eines "berechneten" Sprungs oder Unterprogramm-
+              Aufrufs 
+ 
+Syntax :       ON <Sprungziel Nr.> GOTO | GOSUB 
+              #right#<Zeilennummer> [, <Zeilennummer>] [...] 
+ 
+Erklärung :   <Sprungziel Nr.>: INT-Ausdruck 
+              <Zeilennummer>   : INT-Konstante 
+ 
+              ON ermöglicht die Verzweigung des Programms an eine von mehre­
+              ren Stellen abhängig vom Ergebnis eines INT-Ausdrucks. 
+              Gelangt das Programm an eine ON-Anweisung, dann wird zunächst
+              der Wert des INT-Ausdrucks berechnet. Dieses Ergebnis bildet dann
+              die Nummer n des Sprungziels. Danach wird zur n-ten Zeilen­
+              nummer, die nach GOTO beziehungsweise GOSUB steht, verzweigt. 
+              Die maximale Anzahl von Zeilennummern, die nach GOTO oder
+              GOSUB angegeben werden dürfen, ist 512. 
+              Nimmt <Sprungziel Nr.> einen Wert an, zu dem keine Zeile in der
+              Liste gefunden wird (z.B. Werte kleiner gleich null oder Werte größer
+              als die Anzahl der angegebenen Zeilennummern), so wird das Pro­
+              gramm mit der der ON-Anweisung folgenden Programmzeile fortge­
+              setzt. 
+ 
+              Statt GOTO und GOSUB darf auch GO TO beziehungsweise
+              GO SUB geschrieben werden. 
+ 
+Hinweis :     Die ON-Anweisung muß in #on("ieiner#off("i Programmzeile stehen. 
+ 
+ 
+Beispiel :      260 INPUT "Menüpunkt 1, 2 oder 3", a 
+                270 ON VAL (a) GOTO 300, 400, 500 
+                280 GOTO 260 
+                300 PRINT "Menüpunkt 1" 
+                . 
+                . 
+                400 PRINT "Menüpunkt 2" 
+                . 
+                . 
+                500 PRINT "Menüpunkt 3" 
+ 
+ 
+              Entsprechend der Eingabe wird nach 300, 400 oder 500 verzweigt.
+              Bei Fehleingaben wird Zeile 280 ausgeführt. 
+ 
+Vergleiche :  GOSUB-, GOTO-, IF-Anweisungen 
+ 
+ 
+ 
+Anweisung : OPTION BASE 
+ 
+Zweck :        Festlegung des kleinsten Wertes für Feldindizes 
+ 
+Syntax :       OPTION BASE 0|1 
+ 
+Erklärung :   OPTION BASE legt fest, ob die nachfolgend dimensionierten Felder
+              Elemente mit dem Index 0 erhalten, oder ob der niedrigste Index 1
+              ist. Voreingestellt ist OPTION BASE 0. 
+ 
+Hinweis :     Der niedrigste Feldindex kann für jedes Feld individuell eingestellt
+              werden. Die OPTION BASE-Anweisung gilt für alle Felder, deren
+              Dimensionierung ihr textuell nachfolgen. Eine erneute OPTION
+              BASE-Anweisung kann dann die Untergrenze für die #on("iihr#off("i folgenden
+              Dimensionierungen festlegen. 
+ 
+ 
+Beispiel :      10 DIM a (100)       'Indizes 0-100 
+                20 OPTION BASE 1 
+                30 b$ (3) = "hallo"  'Indizes 1-10 
+                40 DIM a% (5)        'Indizes 1-5 
+                50 OPTION BASE 0 
+                60 DIM c% (9)        'Indizes 0-9 
+                70 LET d (4) = 12.3  'Indizes 0-10 
+ 
+ 
+Vergleiche :  DIM-Anweisung 
+ 
+ 
+ 
+Operator : OR 
+ 
+Siehe Kapitel 4.4. (Operatoren) 
+ 
+ 
+ 
+Funktion : POS 
+ 
+Zweck :        Ermittlung der aktuellen Cursorspalte 
+ 
+Syntax :       POS (<num. Ausdruck>) 
+ 
+Erklärung :   Geliefert wird die Nummer der Spalte (als INT), in der sich der Cursor
+              auf dem Bildschirm befindet. Die Spalte ganz links hat die Num­
+              mer 1. 
+              Der Argument-Ausdruck ist ein Dummy-Argument (hat keinen
+              Einfluß auf den gelieferten Wert). 
+ 
+ 
+Beispiel :      10 CLS 
+                20 PRINT "testtext"; 
+                30 PRINT POS (0) 
+                Ausgabe:  testtext 9 
+ 
+ 
+Vergleiche :  CSRLIN-, LPOS-Funktionen 
+ 
+ 
+ 
+Anweisung : PRINT 
+ 
+Zweck :        Ausgabe auf den Bildschirm 
+ 
+Syntax :       PRINT [#ib(3)#USING#ie(3)# <Format> ;] 
+              #right#[ #ib(3)#TAB#ie(3)# (<Spalte>) | , | ; | <Ausdruck> ] [...] 
+ 
+Erklärung :   <Format>  : TEXT-Ausdruck für USING (s. u.) 
+              <Spalte>  : INT-Ausdruck (s. u.) 
+              <Ausdruck>: TEXT-Ausdruck oder numerischer Ausdruck, der
+                          ausgegeben werden soll. 
+ 
+               PRINT dient der Ausgabe von Zeichen auf dem Bildschirm. 
+               Numerische Werte werden mit sieben signifikanten Ziffer ausgege­
+               ben. Bei Exponentendarstellung werden für den Exponent maximal 3
+               Ziffern ausgegeben. Hinter allen numerischen Werten und vor posi­
+               tiven numerischen Werten wird jeweils ein Leerzeichen ausgegeben. 
+ 
+               TAB bewirkt eine Positionierung des Cursors auf die angegebene
+               Spalte (die Spalte ganz links hat die Nummer 1). Ist die Spaltenzahl
+               größer als die mit WIDTH eingestellte Ausgabebreite, so wird auf die
+               Spalte mit der Nummer Spalte MODULO Ausgabebreite positioniert.
+               Eine Spaltennummer kleiner gleich null bewirkt eine entsprechende
+               Warnung. 
+               Ist die Spalte mit der angegebenen Nummer in der aktuellen Zeile
+               bereits überschritten, dann wird auf die nächste Zeile positioniert. 
+ 
+               Ein Semikolon bewirkt, daß der Cursor an der gerade erreichten
+               Position bleibt. 
+ 
+               Ein Komma bewirkt die Positionierung auf die nächste gültige Spal­
+               te, für deren Nummer gilt: Nummer MODULO 16 ist 1. 
+               Das Komma dient also der Ausgabe in 16 Zeichen breiten Zonen. 
+ 
+               Endet die PRINT-Anweisung mit TAB (<Spalte>), einem Komma
+               oder einem Semikolon, dann wird kein Zeilenvorschub ausgelöst. 
+ 
+               #onbold#USING 
+               Der EUMEL-BASIC-Compiler unterstützt auch die PRINT
+               USING-Anweisung für formatierte Ausgaben. 
+               Der nach dem Wort USING angegebene TEXT-Ausdruck spezifi­
+               ziert das Ausgabeformat für eine PRINT USING-Anweisung. 
+ 
+               Formatierung von Texten: 
+               "!": Nur das erste Zeichen einer Zeichenfolge wird ausgegeben 
+               "\n Leerzeichen\": Es werden die 2 + n ersten Zeichen einer
+                    Zeichenfolge ausgegeben 
+               "&": Alle Zeichen einer Zeichenfolge werden ausgegeben 
+ 
+               Formatierung von Zahlen: 
+               "\#": bezeichnet eine Ziffernposition 
+               ".": Position des Dezimalpunkts 
+               "+": (vor oder nach Zahlen) Ausgabe des Vorzeichens 
+               "-": (nach Zahlen) gegebenenfalls Ausgabe von "-" hinter der
+                    Zahl 
+               "**": Führende Leerstellen werden mit Sternchen aufgefüllt; wirkt
+                     außerdem wie "\#\#". 
+               "$$": Es wird ein Dollarzeichen links vor der formatierten Zahl ausgegeben;
+                     wirkt außerdem wie "\#\#". 
+               "**$": Führende Leerstellen werden mit Sternchen ausgefüllt und direkt vor
+                      der formatierten Zahl wird ein Dollarzeichen ausgegeben; wirkt
+                      außerdem wie "\#\#\#". 
+               ",": (vor Dezimalpunkt) Unterteilung der Vorkommastellen in Dreier­
+                    gruppen mittels Komma 
+               "^^^^": Position des Exponenten 
+               "_": Ein Zeichen, das einem Unterstreichungsstrich folgt, wird unverändert
+                    ausgegeben 
+ 
+               Ist der Format-Ausdruck fehlerhaft, so kommt es zum Fehler "USING-
+               Format fehlerhaft". 
+               Überschreitet eine auszugebende Zahl in irgendeiner Hinsicht die im
+               Format-Ausdruck für sie vorgesehene Stellenzahl, so wird das Zeichen "%"
+               ausgegeben, um den Fehler anzuzeigen. 
+ 
+ 
+Hinweis :      1.  PRINT (und PRINT USING) richtet sich bei allen Ausgaben nach
+                  der mit WIDTH eingestellten Ausgabebreite. 
+               2. Alle Ausgaben von PRINT können mit der Systemprozedur
+                  'sysout' in eine Datei umgeleitet werden. Dann wird nichts auf
+                  das Terminal ausgegeben. 
+               3. Das Verhalten beim Erreichen der letzten Bildschirmzeile kann
+                  mit der Prozedur 'basic page' gesteuert werden. Vergleiche
+                  hierzu Kapitel 5, "Steuerung der Bildschirmausgabe". 
+ 
+ 
+Beispiel :      10 PRINT "hallo", 2 ^ 32 TAB (33) "Ende"; 
+ 
+               Ausgabe:  hallo            4.294967E+09   Ende 
+               Position: 1234567890123456789012345678901234567890 
+ 
+ 
+Vergleiche :   WRITE-, LPRINT-Anweisungen, POS-, CSRLIN-, SPC-
+               Funktionen 
+ 
+ 
+ 
+Anweisung : RANDOMIZE 
+ 
+Zweck :        Festlegung eines Anfangswertes für den Zufallszahlengenerator 
+ 
+Syntax :       RANDOMIZE [<num. Ausdruck>] 
+ 
+Erklärung :   Mit RANDOMIZE erhält der Zufallszahlengenerator einen bestimmten
+              Startwert. 
+              Ist kein numerischer Ausdruck angegeben, so wird während des
+              Programmlaufs die Meldung "Startwert des Zufallszahlen­
+              generators ?" ausgegeben und ein Startwert eingelesen. 
+ 
+              Wird der Zufallszahlengenerator immer mit dem gleichen Wert gestar­
+              tet, so liefert er auch immer die gleichen Zufallszahlen. Soll er immer
+              verschiedene Werte liefern, so kann er zum Beispiel mit der System­
+              uhr auf zufällige Startwerte gesetzt werden (RANDOMIZE TIMER). 
+ 
+ 
+Beispiel :      10 RANDOMIZE 4711 
+                20 FOR i = 1 TO 5 
+                30 PRINT INT (RND * 10); 
+                40 NEXT i 
+                Ausgabe:   5  6  2  9  6 
+ 
+Vergleiche :  RND-Funktion 
+ 
+ 
+ 
+Anweisung : READ 
+ 
+Zweck :        Auslesen von Daten aus DATA-Anweisungen 
+ 
+Syntax :       READ <Variable> [, <Variable>] [...] 
+ 
+Erklärung :   <Variable>: numerische Variable oder TEXT-Variable 
+ 
+              Die READ-Anweisung liest die nächsten Elemente aus der aktuellen
+              DATA-Anweisung (s.d.) in die angegebenen Variablen ein. 
+ 
+              In TEXT-Variablen können sowohl "quoted strings" als auch "un­
+              quoted strings" (vgl. DATA-Anweisung) eingelesen werden. 
+              In numerische Variablen können dagegen nur "unquoted strings"
+              eingelesen werden. Außerdem müssen die Zeichen des "unquoted
+              string" eine gültige Darstellung einer numerischen Konstanten (even­
+              tuell mit Vorzeichen) sein. Sind diese Bedingungen nicht erfüllt, so
+              kommt es bei der Ausführung des Programms zu entsprechenden
+              Fehlern. 
+ 
+              Eine READ-Anweisung kann Daten aus vorangehenden und nach­
+              folgenden DATA-Anweisungen lesen. 
+              Alle DATA-Anweisungen eines Programms bilden zusammen einen
+              großen sequentiellen Speicher, auf den mit READ der Reihe nach
+              zugegriffen wird. Intern wird ein sogenannter READ-DATA-Zeiger
+              geführt, der immer auf das nächste auszulesende Element zeigt. 
+ 
+              Die RESTORE-Anweisung (s.d.) ermöglicht es, den READ-DATA-
+              Zeiger auf das erste Element einer bestimmten DATA-Zeile zu
+              setzen. 
+ 
+              Sind keine Daten mehr für READ vorhanden, so wird die Ausführung
+              des Programms mit der Fehlermeldung "Keine Daten mehr für
+              READ" abgebrochen. 
+ 
+ 
+Beispiel :      2020 PRINT "Stadt", "Land", "Fluß" 
+                2030 READ stadt$, land$, fluß$ 
+                2040 PRINT stadt$, land$, fluß$ 
+                . 
+                5000 DATA Köln, Bundesrepublik Deutschland, Rhein 
+ 
+ 
+Vergleiche :  DATA-, RESTORE-Anweisungen 
+ 
+ 
+ 
+Anweisung : REM 
+ 
+Zweck :        Ermöglicht das Einfügen von Kommentaren in ein Programm 
+ 
+Syntax :       REM <Zeichenfolge> 
+ 
+Erklärung :   <Zeichenfolge>: Beliebige Folge von Zeichen 
+ 
+              Wird eine REM-Anweisung gefunden, so wird der Rest der Pro­
+              grammzeile nicht weiter beachtet. Die Compilierung wird in der fol­
+              genden Zeile fortgesetzt. 
+              Es empfielt sich, von Kommentarzeilen möglichst oft Gebrauch zu
+              machen, weil sie den Programmtext dokumentieren und strukturieren. 
+ 
+Hinweis :     Nach REM können keine weiteren Anweisungen mehr in einer Pro­
+              grammzeile stehen, da sie nicht übersetzt werden. Auch der Doppel­
+              punkt wird nach REM nicht beachtet. 
+ 
+ 
+Beispiel :      1000 REM Ausgabe des Feldes 
+                1010 FOR i = 1 TO feldgroesse% 
+                1020 PRINT "Eintrag"; i; feld (i) 
+                1030 NEXT i 
+ 
+ 
+ 
+Anweisung : RESTORE 
+ 
+Zweck :        Setzen des READ-DATA-Zeigers auf den Anfang einer angegebe­
+              nen Zeile 
+ 
+Syntax :       RESTORE [<Zeilennummer>] 
+ 
+Erklärung :   <Zeilennummer>: INT-Konstante 
+ 
+              Der READ-DATA-Zeiger (vgl. DATA-Anweisung) wird auf die Zeile
+              <Zeilennummer> gesetzt. 
+              Wird keine Zeilennummer angegeben, so wird für <Zeilennummer>
+              1 eingesetzt. 
+ 
+              Existiert die Programmzeile <Zeilennummer> nicht oder ist in ihr
+              keine DATA-Anweisung vorhanden, so wird der Zeiger auf die
+              nächste textuell folgende DATA-Anweisung gesetzt. 
+              Folgt der angegebenen Zeilennummer im Programm keine DATA-
+              Anweisung mehr, kommt es zu der Fehlermeldung "RESTORE: Keine
+              DATA-Anweisung in oder nach Zeile <Zeilennummer> gefunden !" 
+ 
+ 
+Beispiel :      10 READ a, b, c 
+                20 RESTORE 
+                30 READ d, e, f 
+                40 DATA 2, 3, 5 
+                50 PRINT a; b; c; d; e; f 
+                Ausgabe:   2  3  5  2  3  5 
+ 
+Vergleiche :  DATA-, READ-Anweisungen 
+ 
+ 
+ 
+Anweisung : RETURN 
+ 
+Zweck :        Rücksprung aus einem Unterprogramm 
+ 
+Syntax :       RETURN 
+ 
+Erklärung :   RETURN bewirkt einen Rücksprung aus dem Unterprogramm hinter
+              die aufrufende GOSUB-Anweisung. 
+ 
+              Es dürfen auch mehrere RETURN-Anweisungen in einem Unterpro­
+              gramm vorkommen, um es an verschiedenen Stellen zu verlassen. 
+ 
+              Wird ein RETURN gefunden, ohne daß ein GOSUB durchlaufen
+              wurde, so wird mit der Fehlermeldung "RETURN ohne GOSUB"
+              abgebrochen. 
+ 
+ 
+Beispiel :      140 GOSUB 10000  'Zeige Uhrzeit 
+                . 
+                . 
+                370 GOSUB 10000  'Zeige Uhrzeit 
+                9990 END 
+                10000 REM Unterprogramm Zeige Uhrzeit 
+                10010 PRINT "Es ist " + TIME$ + " Uhr" 
+                10020 RETURN 
+ 
+ 
+Vergleiche :  GOSUB-, ON-Anweisungen 
+ 
+ 
+ 
+Funktion : RIGHT$ 
+ 
+Zweck :        Erzeugung eines Teiltextes aus einem anderen Text 
+ 
+Syntax :       RIGHT$ (<TEXT-Ausdruck>, <Anzahl Zeichen>) 
+Erklärung :   <Anzahl Zeichen>: INT-Ausdruck 
+ 
+              Die Funktion liefert die letzten <Anzahl Zeichen> Textzeichen des
+              TEXT-Ausdrucks. 
+              Ist <Anzahl Zeichen> größer gleich der Länge des TEXT-
+              Ausdrucks, so wird der gesamte Ausdruck geliefert. 
+ 
+ 
+Beispiel :      10 LET a$ = "hallihallo" 
+                20 PRINT RIGHT$ (a$, 5) 
+                Ausgabe:   hallo 
+ 
+Vergleiche :  LEFT$-, MID$-Funktionen, LSET-, MID$-, RSET-Anweisungen 
+ 
+ 
+ 
+Funktion : RND 
+ 
+Zweck :        Erzeugung von Zufallszahlen 
+ 
+Syntax :       RND [<num. Ausdruck>] 
+ 
+Erklärung :   Wird kein Argument angegeben, so wird ein Wert größer null für den
+              Ausdruck angenommen. 
+ 
+              RND (x) liefert 
+ 
+              für x > 0: 
+              eine neue Zufallszahl. Es gilt immer: 0 <= RND < 1. Der Betrag
+              des Arguments hat keinen Einfluß auf das Ergebnis. 
+ 
+              für x = 0: 
+              die letzte gelieferte Zufallszahl noch einmal. 
+ 
+              für x < 0: 
+              eine neue Zufallszahl. Vorher wird aber RANDOMIZE x (s.d.) ausge­
+              führt. 
+ 
+              Die Zufallszahlen werden als REALs geliefert. 
+              Der Zufallszahlengenerator kann mit der RANDOMIZE-Anweisung
+              auf bestimmte Startwerte eingestellt werden. 
+ 
+ 
+Beispiel :      10 FOR i = 1 TO 5 
+                20 PRINT INT (RND * 10) 
+                30 NEXT i 
+                Ausgabe (z.B.):   7  9  9  5  0 
+ 
+Vergleiche :  RANDOMIZE-Anweisung 
+ 
+ 
+ 
+Anweisung : RSET 
+ 
+Zweck :        Ersetzen von Zeichen eines Textes von rechts her 
+ 
+Syntax :       RSET <TEXT-Variable> = <TEXT-Ausdruck> 
+ 
+Erklärung :   Das Ergebnis des TEXT-Ausdrucks wird, rechts beginnend, in der
+              TEXT-Variablen eingesetzt. Es werden höchstens so viele Zeichen
+              ersetzt, wie bisher schon in der Variablen vorhanden waren, das heißt
+              die Länge des Textes in der Variablen ändert sich nicht. 
+              Soll ein Text eingesetzt werden, der länger ist als der Text in der
+              Variablen, so wird die Variable nicht verändert. 
+ 
+ 
+Beispiel :      210 LET a$ = "ABCDEFG" 
+                220 RSET a$ = "12345" 
+                230 PRINT a$, 
+                240 RSET a$ = "abc" 
+                250 PRINT a$ 
+                Ausgabe:    AB12345           AB12abc 
+ 
+Vergleiche :  LSET-, MID$-Anweisungen, LEFT$-, MID$-, RIGHT$-Funk­
+              tionen 
+ 
+ 
+ 
+Funktion : SGN 
+ 
+Zweck :        Ermittlung des Vorzeichens einer Zahl 
+ 
+Syntax :       SGN (<num. Ausdruck>) 
+ 
+Erklärung :   SGN (x) liefert 
+              für x > 0:   1 
+              für x = 0:   0 
+              für x < 0:  -1 . 
+ 
+ 
+Beispiel :      10 a = -12.74 
+                20 PRINT SGN (a); SGN (-a); SGN (0 * a) 
+                Ausgabe:  -1  1  0 
+ 
+Vergleiche :  ABS-Funktion 
+ 
+ 
+ 
+Funktion : SIN 
+ 
+Zweck :        Berechnung des Sinus eines Radiantwertes 
+ 
+Syntax :       SIN (<Winkel>) 
+ 
+Erklärung :   <Winkel>: REAL-Ausdruck, der den Winkel in Radiant angibt. 
+              Die Funktion liefert den Sinus des Winkels als REAL. 
+ 
+ 
+Beispiel :      10 PI = 3.141593 
+                20 PRINT SIN (PI/4) 
+                Ausgabe:  .7071068 
+ 
+Vergleiche :  COS-, TAN-Funktionen 
+ 
+ 
+ 
+Funktion : SPACE$ 
+ 
+Zweck :        Erzeugung einer bestimmten Anzahl von Leerzeichen 
+ 
+Syntax :       SPACE$ (<INT-Ausdruck>) 
+ 
+Erklärung :   Die SPACE$-Funktion liefert einen TEXT, der aus so vielen Leerzei­
+              chen (Code 32) besteht, wie der Wert des INT-Ausdrucks angibt. 
+ 
+ 
+Beispiel :      10 PRINT "123456789" 
+                20 PRINT "^" + SPACE$ (7) + "^" 
+ 
+              Ausgabe:  123456789 
+                        ^       ^ 
+ 
+ 
+Vergleiche :  STRING$-Funktion 
+ 
+ 
+ 
+Funktion : SPC 
+ 
+Diese Funktion entspricht exakt der SPACE$-Funktion und wurde nur aus Kompatibi­
+litätsgründen implementiert. 
+ 
+ 
+ 
+Funktion : SQR 
+ 
+Zweck :        Berechnung der Quadratwurzel einer Zahl 
+ 
+Syntax :       SQR (<num. Ausdruck>) 
+ 
+Erklärung :   SQR (x) liefert die Quadratwurzel des durch den numerischen Aus­
+              druck angegebenen Wertes. 
+              Das Ergebnis wird als REAL geliefert. 
+ 
+ 
+Beispiel :      10 PRINT SQR (100); 
+                20 PRINT SQR (2); 
+                30 PRINT SQR (17.453) 
+                Ausgabe:  10  1.414214  4.177679 
+ 
+ 
+ 
+Anweisungsbestandteil : STEP 
+ 
+Siehe FOR-Anweisung 
+ 
+ 
+ 
+Anweisung : STOP 
+ 
+Zweck :        Beenden der Programmausführung eines BASIC-Programms mit
+              Meldung 
+ 
+Syntax :       STOP 
+ 
+Erklärung :   STOP beendet die Programmausführung des BASIC-Programms. 
+              Im Gegensatz zu END (s.d.) erzeugt STOP dabei die Meldung "STOP
+              beendet das Programm in Zeile ...". 
+ 
+              STOP-Anweisungen dürfen im Programm an beliebiger Stelle
+              stehen, und es darf auch mehr als eine STOP-Anweisung in einem
+              Programm vorkommen. 
+              Der Compiler übersetzt ein Programm auch nach Erreichen einer
+              STOP-Anweisung weiter. 
+ 
+ 
+Beispiel :      3220 IF eingabe$ = "Ende" THEN STOP 
+ 
+ 
+Vergleiche :  END-Anweisung 
+ 
+ 
+ 
+Funktion : STR$ 
+ 
+Zweck :        Konvertierung einer Zahl in einen Text 
+ 
+Syntax :       STR$ (<num. Ausdruck>) 
+ 
+Erklärung :   Die Funktion liefert die Darstellung des Wertes des numerischen
+              Ausdrucks als TEXT. 
+              Die Zahlen werden so als Text geliefert, wie sie bei einer PRINT-
+              Anweisung auf dem Bildschirm erscheinen würden. 
+ 
+ 
+Beispiel :      10 LET zahl$ = STR$ (1e6) 
+                20 PRINT zahl$; LEN (zahl$) 
+                Ausgabe:   1000000  7 
+ 
+Vergleiche :  VAL-Funktion (Komplementärfunktion) 
+ 
+ 
+ 
+Funktion : STRING$ 
+ 
+Zweck :        Erzeugung eines Textes mit mehreren gleichen Zeichen 
+ 
+Syntax :       STRING$ (<Anzahl>, <Code>|<TEXT-Ausdruck>) 
+ 
+Erklärung :   <Anzahl>: INT-Ausdruck 
+              <Code>  : INT-Ausdruck  (Wert im Bereich 0 bis 255) 
+ 
+              Die Funktion liefert <Anzahl> mal das Zeichen, 
+              - das den ASCII-Code <Code> hat oder 
+              - das am Anfang vom Ergebnis des TEXT-Ausdrucks steht. 
+ 
+ 
+Beispiel :      10 LET pfeil$ = STRING$ (10, "=") + ">" 
+                20 PRINT pfeil$;" ";STRING$ (5, 35) '35 entspr. \# 
+                Ausgabe:   ==========> \#\#\#\#\# 
+ 
+Vergleiche :  SPACE$-Funktion 
+ 
+ 
+ 
+Anweisungsbestandteil : SUB 
+ 
+Siehe GOSUB-Anweisung 
+ 
+ 
+ 
+Anweisung : SWAP 
+ 
+Zweck :        Tauschen der Inhalte zweier Variablen 
+ 
+Syntax :       SWAP <Variable1>, <Variable2> 
+ 
+Erklärung :   SWAP tauscht die Inhalte der beiden Variablen. 
+ 
+              Die beiden Variablen müssen vom gleichen Typ sein. 
+ 
+ 
+Beispiel :      3220 LET a = 10 
+                3230 LET b = 20 
+                3240 SWAP a, b 
+                3250 PRINT a; b 
+                Ausgabe:  20  10 
+ 
+ 
+ 
+Anweisungsbestandteil : TAB 
+ 
+Siehe PRINT- und LPRINT-Anweisung 
+ 
+ 
+ 
+Funktion : TAN 
+ 
+Zweck :        Berechnung des Tangens eines Radiantwertes 
+ 
+Syntax :       TAN (<Winkel>) 
+ 
+Erklärung :   <Winkel>: REAL-Ausdruck, der den Winkel in Radiant angibt. 
+              Die Funktion liefert den Tangens des Winkels als REAL. 
+ 
+ 
+Beispiel :      10 PI = 3.141593 
+                20 PRINT TAN (PI/4) 
+                Ausgabe:  1 
+ 
+Vergleiche :  COS-, SIN-Funktionen 
+ 
+ 
+ 
+Anweisungsbestandteil : THEN 
+ 
+Siehe IF-Anweisung 
+ 
+ 
+ 
+Funktion : TIMER 
+ 
+Zweck :        Lesen der Systemuhr (CPU-Zeit der Task) 
+ 
+Syntax :       TIMER 
+ 
+Erklärung :   Die bisher von der Task verbrauchte CPU-Zeit (in Sekunden) wird
+              als REAL geliefert. 
+ 
+              TIMER eignet sich auch zum Starten des Zufallszahlengenerators
+              (vgl. RANDOMIZE-Anweisung). 
+ 
+ 
+Beispiel :      2010 LET starttime = TIMER 
+                . 
+                . 
+                2620 PRINT "Verbrauchte CPU-Zeit:"; 
+                2630 PRINT TIMER - starttime; "Sekunden" 
+ 
+ 
+Vergleiche :  TIME$-Funktion 
+ 
+ 
+ 
+Funktion : TIME$ 
+ 
+Zweck :        Abrufen der aktuellen Tageszeit 
+ 
+Syntax :       TIME$ 
+ 
+Erklärung :   Die Tageszeit wird als Text in der Form HH.MM.SS geliefert. 
+ 
+ 
+Beispiel :      10 PRINT "Es ist jetzt "; TIME$; " Uhr" 
+                Ausgabe (z.B.):  Es ist jetzt 10:51:17 Uhr 
+ 
+Vergleiche :  DATE$-, TIMER-Funktionen 
+ 
+ 
+ 
+Anweisungsbestandteil : TO 
+ 
+Siehe FOR- und GOTO-Anweisungen 
+ 
+ 
+ 
+Anweisung : TRON / TROFF 
+ 
+Zweck :        Ein- und Ausschalten der TRACE-Funktion 
+ 
+Syntax :       TRON 
+              TROFF 
+ 
+Erklärung :   Der TRACE-Modus dient der Suche nach logischen Fehlern bei der
+              Entwicklung von BASIC-Programmen. 
+ 
+              TRON schaltet den TRACE-Modus für die nachfolgend übersetzten
+              Programmzeilen ein. 
+ 
+              Ist der TRACE-Modus eingeschaltet, so wird für jede gefundene
+              Zeilennummer die Ausgabe dieser Zeilennummer in eckigen
+              Klammern mit in den erzeugten Code aufgenommen. Dies hat dann
+              während des Laufens den Effekt, daß immer bei Abarbeitung der im
+              TRACE-Modus übersetzten Zeilen die aktuelle Zeilennummer aus­
+              gegeben wird. Es ist so leicht zu verfolgen, in welcher Reihenfolge
+              die Zeilen des Programms ausgeführt werden. 
+ 
+              TROFF schaltet den TRACE-Modus für die textuell folgenden Pro­
+              grammzeilen wieder aus. 
+ 
+ 
+Beispiel :      5220 TRON 
+                5230 REM hier beginnt die kritische 
+                5240 REM Programmstelle 
+                . 
+                . 
+                . 
+                5970 TROFF 
+ 
+ 
+              Die Zeilen 5230 bis 5970 werden im TRACE-Modus übersetzt. 
+ 
+ 
+ 
+Anweisungsbestandteil : USING 
+ 
+Siehe PRINT-Anweisung 
+ 
+ 
+ 
+Funktion : USR 
+ 
+Zweck :        Aufruf einer wertliefernden insertierten Prozedur 
+ 
+Syntax :       USR <Prozedurname> 
+              #right#[ (<Parameter> [, <Parameter>] [...] ) ] 
+ 
+Erklärung :   <Prozedurname>: Folge aus Zeichen, die für Prozeduren im
+              EUMEL-System zugelassen sind (also Buchstaben und  - ab der
+              zweiten Stelle -  Zahlen), jedoch keine Leerzeichen. 
+ 
+              <Parameter>: <CONST-Parameter> | <VAR-Parameter> 
+ 
+              <CONST-Parameter>:   Ausdruck (genau des von der Prozedur
+                                   benötigten Typs) 
+              <VAR-Parameter>:     Variable (genau des von der Prozedur benö­
+                                   tigten Typs) 
+ 
+              Die Prozedur mit dem angegebenen <Prozedurnamen> und den
+              angegebenen Parametern wird aufgerufen. 
+              Die USR-Funktion liefert nach Ausführung der Prozedur das von der
+              Prozedur übergebene Ergebnis (Typ INT, REAL oder TEXT). 
+ 
+              Mögliche Fehlerfälle: 
+              - Eine Prozedur mit dem Namen <Prozedurnamen> und den ange­
+                gebenen Parametern gibt es nicht. 
+              - Die Prozedur liefert keinen Wert. 
+              - Die Prozedur liefert einen Typ, der in BASIC unbekannt ist (zum
+                Beispiel BOOL). 
+              - Die Prozedur benötigt Parametertypen, die in BASIC nicht bekannt
+                sind (z.B. BOOL, FILE, TASK, QUIET). 
+              - Ein Parameter ist CONST, es wird aber ein VAR-Parameter ver­
+                langt. 
+ 
+              Weitere Informationen finden Sie in Kapitel 4.7. 
+ 
+Hinweis :     1.  Bei den Parametern wird keine Typkonvertierung vorgenommen. 
+              2. Der Prozedurname muß (entgegen der ELAN-Gewohnheit) ohne
+                 Leerzeichen angegeben werden. 
+              3. USR ist die einzige Funktion, bei der das Argument (nämlich der
+                 Prozeduraufruf) nicht in Klammern stehen darf. 
+ 
+ 
+Beispiel :      10 LET euler = USR e 
+                20 PRINT euler 
+                Ausgabe:  2.718282 
+ 
+Vergleiche :  CALL-, CHAIN-Anweisungen 
+ 
+ 
+ 
+Funktion : VAL 
+ 
+Zweck :        Konvertierung eines Texts in eine Zahl 
+ 
+Syntax :       VAL (<TEXT-Ausdruck>) 
+ 
+Erklärung :   Die Funktion liefert den Wert der Zahl, deren Darstellung in dem
+              übergebenen TEXT-Ausdruck enthalten ist. Führende Leerstellen
+              werden dabei überlesen. 
+              Sobald ein nicht wandelbares Zeichen festgestellt wird, wird der bis
+              dahin ermittelte Wert (am Anfang null) geliefert. 
+ 
+ 
+Beispiel :      10 LET zahl$ = "-1.256E-63" 
+                20 PRINT VAL (zahl$) 
+                Ausgabe:   -1.256E-63 
+ 
+Vergleiche :  STR$-Funktion (Komplementärfunktion) 
+ 
+ 
+ 
+Anweisung : WEND 
+ 
+Zweck :        Markierung des Endes einer WHILE-Schleife 
+ 
+Syntax :       WEND 
+ 
+Erklärung :   WEND markiert das Ende einer WHILE-Schleife (vergleiche
+              WHILE-Anweisung). 
+ 
+Vergleiche :  WHILE-, FOR-Anweisungen 
+ 
+ 
+ 
+Anweisung : WHILE 
+ 
+Zweck :        Beginn einer abweisenden Schleife 
+ 
+Syntax :       WHILE <Bedingung> 
+              <Schleifenrumpf> 
+ 
+Erklärung :   <Bedingung>     : numerischer Ausdruck 
+              <Schleifenrumpf>: Folge von Programmzeilen 
+ 
+              Die WHILE-Anweisung erlaubt die komfortable Programmierung von
+              abweisenden Schleifen (sogenannten WHILE-WEND-Schleifen) in
+              BASIC. 
+              Gelangt das Programm während der Ausführung an eine WHILE-
+              Anweisung, so wird zunächst der Bedingungs-Ausdruck ausge­
+              wertet. Ist die Bedingung nicht erfüllt (falsch, Wert gleich null), so
+              wird das Programm mit der nächsten Anweisung hinter der korres­
+              pondierenden WEND-Anweisung fortgesetzt. 
+              Ist die Bedingung dagegen erfüllt (wahr, Wert ungleich null), so
+              werden die Anweisungen des Schleifenrumpfs abgearbeitet. Beim
+              Erreichen der WEND-Anweisung springt das Programm wieder zur
+              WHILE-Anweisung zurück, die Bedingung wird erneut überprüft und,
+              je nach Ergebnis, wird der Schleifenrumpf oder die Anweisung nach
+              WEND ausgeführt. 
+ 
+              WHILE-WEND-Schleifen dürfen (auch mit FOR-NEXT-Schleifen,
+              s.d.) geschachtelt werden. Überschneidungen von WHILE-WEND-
+              Schleifen und FOR-NEXT-Schleifen sind jedoch nicht zulässig. 
+ 
+ 
+Beispiel :      10 LET weiter$ = "j" 
+                20 WHILE LEFT$ (weiter$, 1) = "j" 
+                30 REM Hier beginnt das eigentliche Programm 
+                . 
+                . 
+                1650 INPUT "Weiter ? (j/n)", weiter$ 
+                1660 WEND 
+ 
+ 
+              Das eigentliche Programm wird so lange ausgeführt, bis der Benutzer
+              etwas anderes als "j" an der ersten Stelle von 'weiter$' eingibt. 
+ 
+Vergleiche :  FOR-, IF-Anweisungen 
+ 
+ 
+ 
+Anweisung : WIDTH 
+ 
+Zweck :        Einstellung der Bildschirmbreite 
+ 
+Syntax :       WIDTH <Zeichen pro Zeile> 
+ 
+Erklärung :   <Zeichen pro Zeile>     : INT-Ausdruck 
+ 
+              Mit der WIDTH-Anweisung wird festgelegt, wie viele Zeichen pro
+              Zeile bei Ausgaben auf den Bildschirm oder in Dateien pro Zeile
+              ausgegeben werden sollen. 
+              Soll für die Druckdatei eine andere Anzahl von Zeichen pro Zeile
+              gelten als für den Bildschirm, dann muß vor jeder Sequenz von
+              LPRINT-Anweisungen die gewünschte Anzahl mit WIDTH einge­
+              stellt werden. 
+              WIDTH gilt auch für Ausgaben in 'sysout'-Dateien. 
+              Insbesondere bei der Ausgabe in Dateien kann ein Wert von mehr als
+              80 Zeichen pro Zeile sinnvoll sein. 
+ 
+ 
+Beispiel :      10 REM es sollen nur 45 Zeichen pro Zeile 
+                20 REM ausgegeben werden 
+                30 WIDTH 45 
+                 
+ 
+Vergleiche :  PRINT-, LPRINT-, WRITE-Anweisungen 
+ 
+ 
+ 
+Anweisung : WRITE 
+ 
+Zweck :        Ausgabe von Zahlen und Texten auf dem Bildschirm 
+ 
+Syntax :       WRITE [<Ausdruck>] [, <Ausdruck>] [...] 
+ 
+Erklärung :   <Ausdruck>: numerischer Ausdruck oder TEXT-Ausdruck 
+ 
+              Die WRITE-Anweisung erlaubt die Ausgabe von Daten auf dem
+              Bildschirm. Die angegebenen Ausdrücke werden ausgewertet und
+              ausgegeben. Dabei werden numerische Werte im gleichen Format
+              wie bei der PRINT-Anweisung (s.d.) ausgegeben, mit der Einschrän­
+              kung, daß den Zahlen keine Leerstelle folgt. 
+              Die Ergebnisse von Text-Ausdrücken werden von Anführungszei­
+              chen umschlossen ausgegeben. 
+              Alle Einzelausgaben werden durch Kommata voneinander getrennt. 
+ 
+              Nach Ausgabe aller angegebenen Ausdrücke wird der Cursor an den
+              Anfang der nächsten Zeile positioniert. 
+ 
+ 
+Beispiel :      10 LET a = 10.7: b = 20 
+                20 LET c$ = "Testtext" 
+                30 WRITE a, b, c$ 
+                Ausgabe:  10.7, 20,"Testtext" 
+ 
+Vergleiche :  PRINT-, LPRINT-, WIDTH-Anweisungen 
+ 
+ 
+ 
+Operator : XOR 
+ 
+Siehe Kapitel 4.4. (Operatoren) 
+
diff --git a/lang/basic/1.8.7/doc/basic handbuch.3 b/lang/basic/1.8.7/doc/basic handbuch.3
new file mode 100644
index 0000000..14cb499
--- /dev/null
+++ b/lang/basic/1.8.7/doc/basic handbuch.3
@@ -0,0 +1,698 @@
+#page nr ("%",97)# 
+#head# 
+EUMEL-BASIC-Compiler    9. Anpassung von Programmen an den EUMEL-BASIC-Compiler    % 
+ 
+#end# 
+ 
+9. Anpassung von Programmen an den EUMEL-BASIC-Compiler 
+   
+ 
+9.1. Unterschiede zwischen BASIC-Inter­
+     pretern und dem EUMEL-BASIC-
+     Compiler 
+ 
+Bei der Anpassung von Programmen für BASIC-Interpreter an den EUMEL-
+BASIC-Compiler gibt es einige Besonderheiten zu beachten, die auf den unterschied­
+lichen Arbeitsweisen von Compilern gegenüber Interpretern beruhen. 
+Bei Interpretern fällt die Übersetzung und Ausführung des Quellprogramms zeitlich
+zusammen (genau genommen gibt es ja gar keine Übersetzung, sondern das Quell­
+programm wird #on("i")#interpretiert#off("i")#). Dies hat zur Folge, daß auch nicht zur Ausführung
+bestimmte Anweisungen (z.B. Dimensionierungen, Typfestlegungen etc.) erst während
+der Ausführung des Programms erkannt und ausgewertet werden. 
+Bei Compilern hingegen muß deutlich zwischen der Übersetzungszeit (Compiletime)
+und der Laufzeit (Runtime) eines Programms unterschieden werden. 
+Der wesentliche Unterschied zwischen Compilern und Interpretern liegt nun in der
+Reihenfolge der Kenntnisnahme von den Anweisungen. Während der Interpreter von
+den Anweisungen in der Reihenfolge ihres Auftretens entlang des Programmablaufs
+Kenntnis nimmt, werden die Anweisungen vom Compiler in der Reihenfolge ihres
+textuellen Auftretens zur Kenntnis genommen. 
+Da es sich bei dem EUMEL-BASIC-Compiler um einen One-Pass-Compiler
+handelt, ist es zwingend notwendig, daß 
+- DIM-Anweisungen vor dem ersten Zugriff auf das zu dimensionierende Feld
+  stehen. 
+- OPTION BASE-Anweisungen vor den betreffenden Dimensionierungen stehen. 
+- DEF FN-Anweisungen vor dem ersten Aufruf der zu definierenden Funktion ste­
+  hen. 
+- DEFINT- beziehungsweise DEFSTR-Anweisungen vor der ersten Verwendung der
+  betreffenden Variablen erscheinen. 
+ 
+Einige Interpreter lassen sogar den Abschluß von FOR-NEXT- und WHILE-
+WEND-Schleifen an mehreren Stellen im Programm zu (z.B. mehrere NEXT-
+Anweisungen zu einer FOR-Anweisung). Auch solche "Kunstgriffe" gestattet der
+EUMEL-BASIC-Compiler (aus den oben geschilderten Gründen) nicht. 
+ 
+ 
+ 
+ 
+9.2. Abweichungen von ISO 6373-1984
+     (Minimal-BASIC)
+     
+ 
+ 
+Der EUMEL-BASIC-Compiler weicht in folgenden Punkten von der ISO-Norm
+6373-1984 für Minimal-BASIC ab: 
+- Treten bei der Auswertung von numerischen Ausdrücken Überläufe auf, so wird
+  nicht, wie im Standard vorgesehen, eine Warnung ausgegeben und mit bestimmten
+  Höchstwerten weitergerechnet, sondern die Ausführung des BASIC-Programms
+  wird mit einer entsprechenden Fehlermeldung abgebrochen. 
+- Nimmt die Sprungziel-Nummer bei der ON-Anweisung einen fehlerhaften Wert an
+  (Nummer < 1 oder Nummer > Anzahl Sprungziele), dann wird nicht, wie im
+  Standard empfohlen, mit einer Fehlermeldung abgebrochen, sondern es wird (wie
+  auch in Microsoft-BASIC üblich) das Programm mit der der ON-Anweisung fol­
+  genden Anweisung fortgesetzt. 
+- Bei der DATA-Anweisung müssen nicht unbedingt Zeichenfolgen angegeben
+  werden. Werden sie weggelassen, dann wird bei Ausführung der READ-
+  Anweisung null beziehungsweise Leertext geliefert (vergleiche Kapitel 8, DATA-
+  Anweisung). 
+- Bei den Eingaben für eine INPUT-Anweisung können ebenfalls die Daten wegge­
+  lassen werden. Auch hier wird null beziehungsweise Leertext geliefert (vergleiche
+  Kapitel 8, INPUT-Anweisung) 
+ 
+ 
+Die Erweiterungen gegenüber ISO 6373 sollen hier nicht im einzelnen aufgeführt
+werden. Bitte vergleichen Sie in Zweifelsfällen die Normungsschrift mit dieser Doku­
+mentation! 
+ 
+ 
+ 
+ 
+9.3. Anpassung von Microsoft-BASIC Pro­
+     grammen an den EUMEL-BASIC-
+     Compiler
+     
+ 
+ 
+Bei der Entwicklung des EUMEL-BASIC-Compilers wurde zwar auf Übereinstim­
+mung mit Microsoft-BASIC Wert gelegt, von einer echten Kompatibilität kann aber
+aufgrund einer ganzen Reihe fehlender Anweisungen und Funktionen nicht gespro­
+chen werden. 
+Gegenüber Microsoft-BASIC fehlen vor allem: 
+- alle "Direkt-Kommandos" (RUN, LIST, LOAD, SAVE, MERGE usw.). Die Aufgaben
+  dieser Anweisungen werden von den Prozeduren des EUMEL-Systems über­
+  nommen. 
+- im weiteren Sinne "hardware-nahe" oder an Maschinensprache orientierte Anwei­
+  sungen und Funktionen (CALL, PEEK, POKE, USR, WAIT usw.) 
+- die ERROR-Handling Anweisungen (ON ERROR, RESUME) 
+- die Dateiverarbeitungs-Anweisungen und -Funktion (INPUT\#, PRINT\# u.a.; die 
+  INPUT- und PRINT-Anweisungen wurden aber auf Zusammenarbeit mit 'sysin'
+  und 'sysout' abgestimmt.) 
+- die Single-Precision-Variablen (Single- und Double-Precision-Variablen wer­
+  den beide auf den Datentyp REAL abgebildet.) 
+- die hexadezimalen und oktalen Konstanten 
+ 
+Anweisungen und Funktionen, die sich abweichend vom Microsoft-Standard verhal­
+ten, sind vor allem: 
+- CALL, CHAIN, USR 
+- ERROR, ERR, ERL 
+- LSET, RSET 
+ 
+Wichtige Erweiterungen gegenüber Microsoft-BASIC sind: 
+- Möglichkeit des Aufrufs von ELAN-Prozeduren 
+- Maximale Anzahl von Zeichen pro Zeile: 32000 
+- Maximale Anzahl von Zeichen pro TEXT-Objekt: 32000 
+- OPTION BASE wirkt auf einzelne Felder (und nicht unbedingt auf ein ganzes
+  Programm) 
+ 
+#on ("b")# 
+Hinweis zur Verwendung von MS-BASIC-Programmen im EUMEL-System#off ("b")# 
+Sollen Microsoft-BASIC-Programme in das EUMEL-Systemm übernommen wer­
+den, so ist dabei so vorzugehen: 
+1. Speichern Sie das Programm von MS-BASIC aus mit der ASCII-SAVE-Option
+   ab. 
+   Beispiel: SAVE "PROGRAMM.BAS",A 
+2. Lesen Sie das Programm mittels "DOSDAT" (Programm zum Lesen von MS-
+   DOS-Dateien) im "file ascii"-Modus ein: 
+ 
+   reserve ("file ascii", /"DOS"); fetch ("PROGRAMM.BAS", /"DOS") 
+ 
+Danach steht ihnen das BASIC-Program in der EUMEL-Textdatei
+"PROGRAMM.BAS" zur Verfügung. 
+ 
+#page# 
+#head# 
+EUMEL-BASIC-Compiler        Anhang A: Reservierte Wörter          % 
+ 
+#end# 
+ 
+Anhang A: #ib(4)#Reservierte Wörter#ie(4)# 
+Dieser Anhang enthält eine Übersicht über alle vom EUMEL-BASIC-Compiler
+erkannten reservierten Wörter. 
+ 
+ABS                Funktion 
+AND                Operator 
+AS                 Anweisungsbestandteil 
+ASC                Funktion 
+ATN                Funktion 
+BASE               Anweisungsbestandteil 
+CALL               Anweisung 
+CDBL               Funktion 
+CHAIN              Anweisung 
+CHR$               Funktion 
+CINT               Funktion 
+CLEAR              nicht implementiert 
+CLOSE              nicht implementiert 
+CLS                Anweisung 
+COMMON             nicht implementiert 
+FIELD              nicht implementiert 
+COS                Funktion 
+CSRLIN             Funktion 
+CVD                Funktion 
+CVI                Funktion 
+DATA               Anweisung 
+DATE$              Funktion 
+DEF                Anweisung 
+DEFDBL             Anweisung 
+DEFINT             Anweisung 
+DEFSNG             Anweisung 
+DEFSTR             Anweisung 
+DIM                Anweisung 
+ELSE               Anweisungsbestandteil 
+END                Anweisung 
+EOF                Anweisungsbestandteil 
+EQV                Operator 
+ERL                Funktion 
+ERM$               Funktion 
+ERR                Funktion 
+ERROR              Anweisung 
+EXP                Funktion 
+FIX                Funktion 
+FOR                Anweisung 
+FRE                Funktion 
+GET                nicht implementiert 
+GO                 Anweisungsbestandteil 
+GOSUB              Anweisung 
+GOTO               Anweisung 
+HEX$               Funktion 
+IF                 Anweisung 
+IMP                Operator 
+INKEY$             Funktion 
+INPUT              Anweisung 
+INPUT$             Funktion 
+INSTR              Funktion 
+INT                Funktion 
+KILL               Anweisung 
+LEFT$              Funktion 
+LEN                Funktion 
+LET                Anweisung 
+LINE               Anweisungsbestandteil 
+LOC                nicht implementiert 
+LOG                Funktion 
+LPOS               Funktion 
+LPRINT             Anweisung 
+LSET               Anweisung 
+MID$               Anweisung/Funktion 
+MKD$               Funktion 
+MKI$               Funktion 
+MOD                Operator 
+NAME               Anweisung 
+NEXT               Anweisung 
+NOT                Operator 
+OCT$               Funktion 
+ON                 Anweisung 
+OPEN               nicht implementiert 
+OPTION             Anweisung 
+OR                 Operator 
+OUT                nicht implementiert 
+POS                Funktion 
+PRINT              Anweisung 
+PUT                nicht implementiert 
+RANDOMIZE          Anweisung 
+READ               Anweisung 
+REM                Anweisung 
+RESTORE            Anweisung 
+RESUME             nicht implementiert 
+RETURN             Anweisung 
+RIGHT$             Funktion 
+RND                Funktion 
+RSET               Anweisung 
+SGN                Funktion 
+SIN                Funktion 
+SPACE$             Funktion 
+SPC                Funktion 
+SQR                Funktion 
+STEP               Anweisungsbestandteil 
+STOP               Anweisung 
+STR$               Funktion 
+STRING$            Funktion 
+SUB                Anweisungsbestandteil 
+SWAP               Anweisung 
+TAB                Anweisungsbestandteil 
+TAN                Funktion 
+THEN               Anweisungsbestandteil 
+TIME$              Funktion 
+TIMER              Funktion 
+TO                 Anweisungsbestandteil 
+TROFF              Anweisung 
+TRON               Anweisung 
+USING              Anweisungsbestandteil 
+USR                Funktion 
+VAL                Funktion 
+WAIT               nicht implementiert 
+WEND               Anweisung 
+WHILE              Anweisung 
+WIDTH              Anweisung 
+WRITE              Anweisung 
+XOR                Operator 
+#page# 
+#head# 
+EUMEL-BASIC-Compiler       Anhang B: Vom Scanner erkannte Symboltypen    % 
+ 
+#end# 
+ 
+Anhang B: Vom #ib(3)#Scanner#ie(3)# erkannte #ib(3)#Symbol­
+typen#ie(3)#
+ 
+ Der Scanner (ein Paket des EUMEL-BASIC-Systems) hat die Aufgabe, den Pro­
+grammtext Zeichen für Zeichen durchzugehen und auszulesen ('scannen'). Dabei
+werden die Zeichen immer zu logischen Gruppen, sogenannten #on("i")#Symbolen#off("i")# zusammen­
+gefaßt. Diese Symbole werden dann dem eigentlichen Compilerprogramm geliefert. 
+Der Scanner entscheidet nach recht komplizierten Regeln, welche Zeichen aus der
+Quelldatei zu einem Symbol zusammengefaßt werden. Dennoch soll in diesem An­
+hang der Begriff des Symbols etwas näher erklärt werden, da der Anwender (vor allem
+bei den Fehlermeldungen) mit Symboltypen konfrontiert wird. 
+ 
+ 
+ 
+Reservierte Wörter 
+#on ("b")# 
+Anfangszeichen:#off ("b")#  Buchstaben 
+#on ("b")# 
+Folgezeichen:#off ("b")#    Buchstaben 
+#on ("b")# 
+Beispiele:#off ("b")#       PRINT, VAL, TAB, SUB, TO 
+#on ("b")# 
+Vergleiche:#off ("b")#      Anhang A 
+ 
+ 
+ 
+Operatoren 
++  -  *  /  \  ^  MOD 
+NOT  AND  OR  XOR  EQV  IMP 
+<  >  =   <=   >=   <> 
+ 
+#on ("b")# 
+Vergleiche:#off ("b")#      Kapitel 4.4. 
+ 
+ 
+ 
+numerische Konstanten 
+#on ("b")# 
+Anfangszeichen:#off ("b")#  Ziffern 0 bis 9, Dezimalpunkt '.' 
+#on ("b")# 
+Folgezeichen:#off ("b")#    zusätzlich: 'd', 'D', 'e' oder 'E', am Schluß auch '%', '!' oder '\#' 
+#on ("b")# 
+Beispiele:#off ("b")#       1.0, 1.256d123, 12! 
+#on ("b")# 
+Vergleiche:#off ("b")#      Kapitel 4.2. 
+ 
+ 
+ 
+TEXT-Konstanten 
+#on ("b")# 
+Anfangszeichen:#off ("b")#  Anführungszeichen 
+#on ("b")# 
+Folgezeichen:#off ("b")#    Alle Zeichen, sogar Doppelpunkte, Apostrophe und Steuerzei­
+                             chen. Anführungszeichen dürfen #on("i")#innerhalb#off("i")# von
+                             TEXT-Konstanten nicht vorkommen. Eine
+                             TEXT-Konstante #on("i")#muß#off("i")# aber mit einem Anfüh­
+                             rungszeichen enden. 
+#on ("b")# 
+Beispiele:#off ("b")#       "tadellos", "!?': alles mögliche" 
+#on ("b")# 
+Vergleiche:#off ("b")#      Kapitel 4.2. 
+ 
+ 
+ 
+Variablen 
+#on ("b")# 
+Anfangszeichen:#off ("b")#  Buchstaben 
+#on ("b")# 
+Folgezeichen:#off ("b")#    zusätzlich: Punkt '.', Ziffern 0 bis 9, Zeichen '$', '%', '!' und '\#' 
+#on ("b")# 
+Beispiele:#off ("b")#       zeiger, A$, Zahl!, n%, var\#4.3% 
+#on ("b")# 
+Vergleiche:#off ("b")#      Kapitel 4.3. 
+ 
+ 
+ 
+Felder/Feldelemente 
+wie Variablen, jedoch gefolgt von '(', den Indexangaben und ')' 
+#on ("b")# 
+Beispiele:#off ("b")#       zeiger (3), A$ (pointer), Zahl! (7), n%  (a, b, c + d) 
+#on ("b")# 
+Vergleiche:#off ("b")#      Kapitel 4.3. 
+ 
+ 
+ 
+Benutzer-definierte Funktionen 
+#on ("b")# 
+Anfangszeichen:#off ("b")#  FN 
+#on ("b")# 
+Folgezeichen:#off ("b")#    Buchstaben, Punkt '.', Ziffern 0 bis 9, 
+                             Zeichen '$', '%', '!' und '\#' 
+#on ("b")# 
+Beispiele:#off ("b")#       FNfunct, FNgauss%, FNf!4.5.6d\# 
+#on ("b")# 
+Vergleiche:#off ("b")#      Kapitel 4.5. 
+ 
+ 
+ 
+EOS (End of Statement, Anweisungsende) 
+Doppelpunkt ':' 
+ 
+#on ("b")# 
+Vergleiche:#off ("b")#      Kapitel 4.1. 
+ 
+ 
+ 
+EOL (End of Line, Zeilenende) 
+Apostrophzeichen ' oder Ende der Dateizeile 
+EOL bedeutet gleichzeitig auch EOS 
+ 
+#on ("b")# 
+Vergleiche:#off ("b")#      Kapitel 4.1. 
+ 
+ 
+ 
+EOF (End of File, Dateiende) 
+Ende der Quelldatei 
+EOF bedeutet gleichzeitig auch EOL (und somit auch EOS) 
+ 
+#on ("b")# 
+Vergleiche:#off ("b")#      Kapitel 4.1. 
+ 
+ 
+ 
+Trennzeichen 
+Alle bisher nicht genannten Zeichen werden vom Scanner als Trennzeichen behan­
+delt. In BASIC benötigte Trennzeichen sind das Komma (','), das Semikolon (';') sowie
+die beiden runden Klammern '(' und ')'. 
+Zeichen mit Codes kleiner als 32 (Steuerzeichen) werden vom Scanner überlesen. 
+#page# 
+#head# 
+EUMEL-BASIC-Compiler     Anhang C: Übersicht über die Fehlermeldungen     % 
+ 
+#end# 
+ 
+Anhang C: Übersicht über die Fehlermeldungen 
+ 
+ 
+Übersicht über die verwendeten Fehlermeldungen zur
+Übersetzungszeit
+Diese Übersicht enthält alle zur Übersetzungszeit möglichen Fehler, mit Ausnahme
+der internen Fehler. 
+Die Erläuterungen geben die üblichen Ursachen für die Fehlermeldung an. Es wird
+empfohlen, sich im Falle eines Fehlers außerdem in Kapitel 8 über die genaue Syntax
+der betreffenden Anweisung beziehungsweise Funktion zu informieren. 
+ 
+ 
+#on ("b")#AS ohne NAME#off ("b")# 
+AS darf nur in NAME-Anweisungen vorkommen. 
+ 
+#on ("b")#Accessrecht VAR erwartet, CONST gefunden#off ("b")# 
+Beim Aufruf einer ELAN-Prozedur (CALL, CHAIN oder USR) wurde ein VAR-Para­
+meter verlangt. Angegeben wurde aber ein CONST-Parameter (zum Beispiel ein
+Ausdruck). 
+ 
+#on ("b")#Ausdruck erwartet#off ("b")# 
+Es wurde ein numerischer oder TEXT-Ausdruck erwartet. Diese Fehlermeldung
+erscheint zum Beispiel, wenn nach einem Operator kein Ausdruck mehr gefunden
+wird. 
+ 
+#on ("b")#BASE ohne OPTION#off ("b")# 
+BASE darf nur in OPTION BASE-Anweisungen vorkommen. 
+ 
+#on ("b")#Bei SWAP nur gleiche Variablentypen erlaubt#off ("b")# 
+Mit SWAP können nur Variablen von genau dem gleichen Typ bearbeitet werden. 
+ 
+#on ("b")#Das Feld ist bereits dimensioniert#off ("b")# 
+Diese Fehlermeldung erscheint bei DIM-Anweisungen, wenn das Feld vorher schon
+explizit oder automatisch dimensioniert wurde. 
+ 
+#on ("b")#ELSE ohne IF#off ("b")# 
+ELSE darf nur in IF-Anweisungen vorkommen. ELSE muß in der gleichen Zeile
+stehen wie die zugehörige IF-Anweisung. 
+ 
+#on ("b")#Falsche Felddimension: 
+Dimensioniert in ... Dimensionen, gefundene Anzahl Indizes: ...#off ("b")# 
+Beim Zugriff auf ein Feldelement wurden zu viele oder zu wenig Indizes angegeben. 
+ 
+#on ("b")#FOR ohne NEXT#off ("b")# 
+Diese Fehlermeldung erscheint, wenn am Programmende für eine FOR-Anweisung
+kein korrespondierendes NEXT gefunden wurde. 
+ 
+#on ("b")#Falsche Reihenfolge der Zeilennummern#off ("b")# 
+Die Zeilennummern wurden nicht in aufsteigender Reihenfolge angegeben. 
+ 
+#on ("b")#Falscher Typ#off ("b")# 
+Es wurde ein anderer Datentyp erwartet als angegeben, und es konnte keine automa­
+tische Konvertierung vorgenommen werden. 
+ 
+#on ("b")#Falscher Typ der Operanden#off ("b")# 
+Bei einem dyadischen Operator wurden Operanden angegeben, für deren Typen
+dieser Operator nicht definiert ist (vergleiche Kapitel 4.4.). 
+ 
+#on ("b")#Falscher Typ des Operanden#off ("b")# 
+Bei einem monadischen Operator wurde ein Operand angegeben, für dessen Typ
+dieser Operator nicht definiert ist (vergleiche Kapitel 4.4.). 
+ 
+#on ("b")#Fehlerhafte Bereichsangabe#off ("b")# 
+Diese Fehlermeldung kann bei den Anweisungen DEFDBL, DEFINT, DEFSNG und
+DEFSTR auftreten, wenn bei einer Bereichsangabe der Buchstabe vor dem Binde­
+strich im Alphabet nach dem Buchstaben hinter dem Bindestrich steht. 
+ 
+#on ("b")#Fehlerhafte Dimensionierung:   Die Obergrenze muß >= 1 sein#off ("b")# 
+Es wurde versucht, ein Feld mit dem größten Index null in einer Dimension zu
+dimensionieren, obwohl die Index-Untergrenze mit OPTION BASE auf eins einge­
+stellt war. 
+ 
+#on ("b")#Fehlerhafte Laufvariable#off ("b")# 
+Nach einer NEXT-Anweisung wurde eine Laufvariable gefunden, die nicht zur letzten
+anhängigen FOR-Anweisung gehört. Der Fehler tritt auf, wenn Schleifen geschachtelt
+wurden. 
+ 
+#on ("b")#Fehlerhafte Zeilennummer#off ("b")# 
+Die Zeilennumer entspricht nicht der Syntax für Zeilennumern. 
+ 
+#on ("b")#Fehlerhafter Funktionsaufruf#off ("b")# 
+- Die Prozedur liefert keinen Wert 
+  Es wurde versucht, eine Prozedur mit USR aufzurufen, die keinen Wert liefert. 
+- Der Typ des Resultats ist nicht erlaubt, gefunden: ... 
+  Es wurde versucht, eine Prozedur mit USR aufzurufen, die ein Objekt liefert,
+  dessen Datentyp in BASIC nicht bekannt ist. 
+- Kein Argument erwartet 
+  Es wurde versucht, eine benutzer-definierte Funktion, die ohne Parameter definiert
+  wurde, mit Argument(en) aufzurufen. 
+- ... Argument(e) erwartet 
+  Die Anzahl der angegebenen Argumente ist kleiner als die Anzahl der bei der
+  Funktionsdefinition angegebenen Parameter. 
+- Nur ... Argument(e) erwartet 
+  Die Anzahl der angegebenen Argumente ist größer als die Anzahl der bei der Funk­
+  tionsdefinition angegebenen Parameter. 
+- Kein Resultat erlaubt  (gefunden: ...) 
+  Bei CALL oder CHAIN wurde versucht, eine wertliefernde Prozedur aufzurufen. 
+ 
+#on ("b")#Funktionsaufruf ohne Zusammenhang#off ("b")# 
+Es wurde ein Funktionsaufruf angegeben, wo eine Anweisung erwartet wurde. 
+ 
+#on ("b")#GO ohne TO oder SUB#off ("b")# 
+Das reservierte Wort GO kann nur in GO SUB oder GO TO auftreten. 
+ 
+#on ("b")#Interner Fehler#off ("b")# 
+Bei der Übersetzung wurde innerhalb des Compilerprogramms ein interner Fehler
+ausgelöst. (vergleiche Kapitel 7.1.) 
+ 
+#on ("b")#Nach OPTION BASE ist nur 0 oder 1 erlaubt#off ("b")# 
+Es wurde versucht, eine Zahl > 1 nach OPTION BASE anzugeben. 
+ 
+#on ("b")#NEXT ohne FOR#off ("b")# 
+Es wurde eine NEXT-Anweisung gefunden, die keiner FOR-Anweisung zuzuordnen
+ist, da keine "offenen" FOR-Schleifen mehr anhängig sind. 
+ 
+#on ("b")#Nicht implementiert#off ("b")# 
+Einige reservierte Wörter werden vom BASIC-Compiler erkannt, obwohl die zugehö­
+rigen Anweisungen oder Funktionen nicht implementiert sind (vgl. Anhang A). 
+ 
+#on ("b")#Parametervariable kommt mehrmals vor#off ("b")# 
+Bei der Definition einer "user function" kommt ein Parameter in der Parameterliste
+mehr als einmal vor. 
+ 
+#on ("b")#Rekursive Funktionsdefinition#off ("b")# 
+Es wurde versucht, in der Definition einer "user function" die zu definierende Funk­
+tion aufzurufen. 
+ 
+#on ("b")#STEP ohne FOR#off ("b")# 
+STEP darf nur in FOR-Anweisungen vorkommen. 
+ 
+#on ("b")#SUB ohne GO#off ("b")# 
+SUB darf nur in GOSUB vorkommen. 
+ 
+#on ("b")#Syntaxfehler:    <nähere Fehlerangabe>#off ("b")# 
+Wenn dieser Fehler erscheint, wurde vom Compiler eine Angabe gefunden, die nach
+den Syntaxregeln dort nicht erwartet wurde oder fehlerhaft ist. 
+ 
+#on ("b")#TAB ohne (L)PRINT#off ("b")# 
+TAB darf nur in PRINT- und LPRINT-Anweisungen vorkommen. 
+ 
+#on ("b")#THEN ohne IF#off ("b")# 
+THEN darf nur in IF-Anweisungen vorkommen. THEN muß in der gleichen Zeile
+stehen wie die zugehörige IF-Anweisung. 
+ 
+#on ("b")#TO ohne Zusammenhang#off ("b")# 
+TO darf nur in FOR-Anweisungen oder in GO TO vorkommen. 
+ 
+#on ("b")#Text zu lang#off ("b")# 
+Dieser Fehler erscheint, wenn ein Anführungszeichen fehlt beziehungsweise ein
+Anführungszeichen zu viel gefunden wird. 
+ 
+#on ("b")#Unbekannte Funktion, Argument(e) angegeben: ...#off ("b")# 
+Es wurde versucht, eine Funktion mit einem Argument aufzurufen, für dessen Typ die
+Funktion nicht definiert ist. 
+ 
+#on ("b")#Unbekannte Prozedur, Parameter angegeben: ...#off ("b")# 
+Die angegebene Prozedur konnte mit den angegebenen Parametertypen nicht gefun­
+den werden. 
+ 
+#on ("b")#Undefinierte 'user function'#off ("b")# 
+Es wurde versucht, eine benutzer-definierte Funktion aufzurufen, die (noch) nicht
+definiert wurde. 
+ 
+#on ("b")#USING ohne (L)PRINT#off ("b")# 
+USING darf nur in PRINT- und LPRINT-Anweisungen vorkommen. 
+ 
+#on ("b")#WEND ohne WHILE#off ("b")# 
+Es wurde eine WEND-Anweisung gefunden, die keiner WHILE-Anweisung zuzuord­
+nen ist, da keine "offenen" WHILE-Schleifen mehr anhängig sind. 
+ 
+#on ("b")#WHILE ohne WEND#off ("b")# 
+Diese Fehlermeldung erscheint, wenn am Programmende für eine WHILE-Anweisung
+kein korrespondierendes WEND gefunden wurde. 
+ 
+#on ("b")#Zeile mit dieser Nummer existiert nicht#off ("b")# 
+Es wurde versucht, mit GOTO oder GOSUB zu einer Zeilennumer zu verzweigen, die
+im Programm nicht angegeben wurde. 
+ 
+ 
+ 
+ 
+Übersicht über die innerhalb des BASIC-Systems
+ausgelösten Laufzeitfehler
+Die meisten Laufzeitfehler werden auch bei BASIC-Programmen im EUMEL-System
+erzeugt (vergleiche Kapitel 7.2.). Einige werden aber innerhalb des BASIC-Systems
+erzeugt. Die nachfolgende Übersicht enthält die innerhalb des BASIC-Systems aus­
+gelösten Fehler mit Angabe des gelieferten Fehlercodes und der Fehlermeldung. 
+ 
+#on ("b")#Fehlercode:#off ("b")#     1003 
+#on ("b")#Fehlermeldung:#off ("b")#  RETURN ohne GOSUB 
+Eine RETURN-Anweisung wurde gefunden, obwohl keine GOSUB-Anweisung mehr
+anhängig war. 
+ 
+ 
+#on ("b")#Fehlercode:#off ("b")#     1004 
+#on ("b")#Fehlermeldung:#off ("b")#  RESTORE: Keine DATA-Anweisung in oder nach 
+#right#Zeile ... gefunden 
+Eine RESTORE-Anweisung konnte nicht ausgeführt werden, weil in oder nach der in
+der Anweisung angegebenen Zeilennummer keine DATA-Anweisung mehr steht. 
+ 
+ 
+#on ("b")#Fehlercode:#off ("b")#     1005 
+#on ("b")#Fehlermeldung:#off ("b")#  bei ^: negative Basis, gebrochener Exponent: ... 
+Es wurde versucht, eine negative Zahl mit einer gebrochenen Zahl zu potenzieren. 
+ 
+ 
+#on ("b")#Fehlercode:#off ("b")#     1005 
+#on ("b")#Fehlermeldung:#off ("b")#  USING: kein Format gefunden 
+Bei einer PRINT USING-Anweisung wurde kein Format für die Ausgabe angegeben
+oder die Formatzeichenkette enthält keine Formatzeichen. 
+ 
+ 
+#on ("b")#Fehlercode:#off ("b")#     1005 
+#on ("b")#Fehlermeldung:#off ("b")#  USING-Format fehlerhaft: ... 
+Bei einer PRINT USING-Anweisung wurde ein fehlerhaftes Format angegeben. 
+ 
+ 
+#on ("b")#Fehlercode:#off ("b")#     1004 
+#on ("b")#Fehlermeldung:#off ("b")#  Keine Daten mehr für READ 
+Es stehen keine Daten mehr für die READ-Anweisung zur Verfügung; der READ-
+DATA-Zeiger zeigt hinter das Ende der letzten DATA-Anweisung. 
+ 
+ 
+#on ("b")#Fehlercode:#off ("b")#     1005 
+#on ("b")#Fehlermeldung:#off ("b")#  WIDTH: negative Angabe: ... 
+Nach WIDTH wurde eine negative Zahl gefunden. 
+ 
+ 
+#on ("b")#Fehlercode:#off ("b")#     1013 
+#on ("b")#Fehlermeldung:#off ("b")#  READ: Falscher Datentyp, ... ist kein INT 
+Einer INT-Variablen konnte kein Wert zugewiesen werden, da das aktuelle Objekt
+aus der DATA-Liste keine gültige Darstellung eines INT-Wertes war oder ein
+"quoted string" gefunden wurde. 
+ 
+ 
+#on ("b")#Fehlercode:#off ("b")#     1013 
+#on ("b")#Fehlermeldung:#off ("b")#  READ: Falscher Datentyp, ... ist kein REAL 
+Einer REAL-Variablen konnte kein Wert zugewiesen werden, da das aktuelle Objekt
+aus der DATA-Liste keine gültige Darstellung eines REAL-Wertes war oder ein
+"quoted string" gefunden wurde. 
+ 
+ 
+#on ("b")#Fehlercode:#off ("b")#     1051 (interner Fehler) 
+#on ("b")#Fehlermeldung:#off ("b")#  variierend 
+Bei der Ausführung des Programms trat in einer Prozedur des BASIC-Systems ein
+interner Fehler auf. (Vergleiche Kapitel 7.) 
+ 
+ 
+#on ("b")#Fehlercode:#off ("b")#     1080 
+#on ("b")#Fehlermeldung:#off ("b")#  INPUT-Fehler ( Fehlerart ) : > Eingabezeile < 
+Bei einer INPUT-Anweisung, die auf eine mit 'sysin' eingestellte Datei wirken sollte,
+kam es zu einem Fehler der angegebenen Fehlerart. Nach dem Doppelpunkt wird die
+Eingabezeile aus der Eingabedatei ausgegeben. 
+#page# 
+#head# 
+EUMEL-BASIC-Compiler      Anhang D: ELAN-Prozeduren des Compilers       % 
+ 
+#end# 
+ 
+Anhang D: ELAN-Prozeduren des Compilers 
+ 
+   #on ("b")#PROC #ib(3)#basic#ie(3)# (TEXT CONST dateiname)#off ("b")# 
+   Das in der Datei 'dateiname' enthaltene BASIC-Programm wird dem BASIC-
+   Compiler zur Übersetzung übergeben. Werden keine Fehler gefunden, so wird das
+   Programm direkt nach der Übersetzung ausgeführt. 
+   Beispiel: 
+ 
+       basic ("Mein liebstes BASIC-Programm")#off ("b")# 
+ 
+ 
+   #on ("b")#PROC basic (TEXT CONST dateiname, prozedurname)#off ("b")# 
+   Das in der Datei 'dateiname' enthaltene BASIC-Programm wird dem BASIC-
+   Compiler zur Übersetzung übergeben. Werden keine Fehler gefunden, dann wird
+   das Programm unter dem Namen 'prozedurname' dauerhaft eingetragen (inser­
+   tiert). 
+   Das Programm wird nicht ausgeführt. Beachten Sie, daß der Prozedurname den
+   Vorschriften für ELAN-Prozedurnamen entsprechen muß und außerdem #on ("b")#keine
+   Leerzeichen#off ("b")# enthalten darf. (Zur Namenswahl siehe auch Kapitel 3.) 
+   Beispiel: 
+ 
+       basic ("Mein liebstes BASIC-Programm", "liebstesprogramm")#off ("b")# 
+ 
+ 
+ 
+   #on ("b")#PROC #ib(3)#basic list#ie(3)# (BOOL CONST status)#off ("b")# 
+   Mit der Prozedur 'basic list' kann eingestellt werden, ob die gerade vom Compiler
+   übersetzten Programmzeilen angezeigt werden sollen oder nicht (vergleiche Kapitel
+   3.). 
+ 
+   basic list (TRUE)#off ("b")#:  Die übersetzten Zeile werden angezeigt 
+   basic list (FALSE)#off ("b")#: Die übersetzten Zeile werden nicht angezeigt 
+ 
+ 
+   #on ("b")#PROC #ib(3)#basic page#ie(3)# (BOOL CONST status)#off ("b")# 
+   Mit der Prozedur 'basic page' kann eingestellt werden, wie die Ausgaben von
+   BASIC-Programmen behandelt werden, wenn der Bildschirm voll ist (vergleiche
+   Kapitel 5, Steuerung der Bildschirmausgaben). 
+ 
+   basic page (TRUE):  Beim Erreichen des Bildschirmendes wird auf einen
+                                           Tastendruck gewartet (vgl. Kap. 5.) 
+   basic page (FALSE): Beim Erreichen des Bildschirmendes wird 'gescrollt'. 
+
diff --git a/lang/basic/1.8.7/doc/basic handbuch.index b/lang/basic/1.8.7/doc/basic handbuch.index
new file mode 100644
index 0000000..4ac7e16
--- /dev/null
+++ b/lang/basic/1.8.7/doc/basic handbuch.index
@@ -0,0 +1,232 @@
+#page nr ("%",115)# 
+#head# 
+EUMEL-BASIC-Compiler             Stichwortverzeichnis       % 
+ 
+#end# 
+ 
+Stichwortverzeichnis 
+ 
+>=                                                  15 
+\                                                   14 
+-                                                   14 
++                                                   14 
++                                                   15 
+<=                                                  15 
+*                                                   14 
+/                                                   14 
+=                                                   15 
+>                                                   15 
+<                                                   15 
+<>                                                  15 
+^                                                   14 
+ABS                                                 31 
+AND                                                 16 
+Anführungszeichen                                   10 
+Argument                                            21 
+Arithmetische Operatoren                            14 
+Arrays                                              13 
+ASC                                                 32 
+ATN                                                 32 
+Äquivalenz-Verknüpfung                              17 
+Aufruf benutzer-definierter Funktionen              21 
+Aufruf und Steuerung des BASIC-Compilers            5 
+basic                                               5, 113 
+BASIC-Compiler ERROR                                28 
+basic list                                          6, 113 
+basic page                                          25, 114 
+benutzer-definierte Funktionen                      19, 104 
+Bildschirmausgaben                                  25 
+CALL                                                23, 33 
+CDBL                                                35 
+CHAIN                                               23, 35 
+CHR$                                                35 
+CINT                                                36 
+CLS                                                 36 
+Codebereichs pro Task                               27 
+Compiler Error 304                                  26 
+Compiler Error 307                                  26 
+Compiler Error 308                                  26 
+COS                                                 37 
+CSRLIN                                              37 
+CVD, CVI                                            38 
+DATA                                                38 
+DATE$                                               40 
+Datentypen                                          10 
+Datentyp INT                                        10 
+Datentyp REAL                                       10 
+Datentyp TEXT                                       10 
+Debugging                                           6 
+DEFDBL, DEFINT, DEFSNG, DEFSTR                      40 
+DEF FN                                              19, 28, 42 
+Definition benutzer-definierter Funktionen          19 
+DEFINT                                              12 
+DEFSTR                                              12 
+DIM                                                 13, 43 
+Dimensionen                                         13 
+Doppelpunkt                                         8 
+ELSE                                                54 
+END                                                 45 
+EOF                                                 56 
+EOF (End of File, Dateiende)                        7, 105 
+EOL (End of Line, Zeilenende)                       8, 105 
+EOS (End of Statement, Anweisungsende)              8, 105 
+EQV                                                 17 
+ERL                                                 46 
+ERM$                                                47 
+ERR                                                 47 
+ERROR                                               48 
+EUMEL-Coder                                         26 
+EUMEL-Textdatei                                     7 
+Exklusiv-ODER-Verknüpfung                           17 
+EXP                                                 49 
+Exponent                                            10 
+Fehlerbehandlung                                    28 
+Fehlercodes                                         30 
+Fehlerzeile                                         30 
+Fehler zur Laufzeit                                 30, 111 
+Fehler zur Übersetzungszeit                         28, 106 
+Felder (Arrays)                                     13 
+Felder/Feldelemente                                 104 
+Feldnamen                                           13 
+FIX                                                 49 
+FOR                                                 50 
+FRE                                                 51 
+Funktionen                                          19 
+Funktionsaufrufe                                    19 
+Ganzzahlen                                          10 
+Generatorprogramm                                   4 
+Gleitkommazahlen                                    10 
+GOSUB                                               52 
+GOTO                                                53 
+Grenzen des Compilers                               26 
+Groß-/Kleinschreibung                               9 
+Hauptdurchlauf                                      28 
+HEX$                                                54 
+Hochkomma                                           8 
+IF                                                  54 
+IMP                                                 17 
+Implikations-Verknüpfung                            17 
+Indizes                                             13 
+INKEY$                                              56 
+INPUT$                                              58 
+INPUT                                               56 
+Insertieren von BASIC-Programmen                    5 
+Installation des BASIC-Compilers                    4 
+INSTR                                               59 
+INT                                                 59 
+Interne Compilerfehler                              28 
+INTs                                                10 
+INT-Überlauf                                        15 
+KILL                                                60 
+Konstanten                                          10 
+Konvertierung                                       15, 22 
+Kriterien für den Typ einer Variablen               12 
+Labels                                              26 
+Leerzeichen                                         9 
+LEFT$                                               60 
+LEN                                                 61 
+LET                                                 61 
+LINE INPUT                                          62 
+LOG                                                 63 
+Logische Operatoren                                 16 
+LPOS                                                63 
+LPRINT                                              64 
+LSET                                                65 
+Mantisse                                            11 
+MID$                                                65, 66 
+MKD$, MKI$                                          67 
+MOD                                                 14 
+Modulgrenze                                         26 
+NAME                                                68 
+Namenstabelle                                       27 
+Negation                                            16 
+negative Zahlenwerte                                11 
+NEXT                                                50, 68 
+NOT                                                 16 
+Notation                                            3 
+Notebook                                            28 
+numerische Konstanten                               103 
+OCT$                                                69 
+ODER-Verknüpfung                                    17 
+ON                                                  69 
+Operatoren                                          103 
+Operatoren, arithmetische                           14 
+Operatoren, logische                                16 
+Operatoren, Text-                                   15 
+Operatoren, Vergleichs-                             15 
+Operator, Zuweisungs-                               18 
+OPTION BASE                                         13, 71 
+OR                                                  17 
+Parameter                                           19 
+POS                                                 72 
+PRINT                                               72 
+Prioritäten der Operanden                           18 
+Programmdatei                                       7 
+Programmsegmente                                    24 
+Programmzeile                                       7 
+RANDOMIZE                                           75 
+READ                                                75 
+REM                                                 77 
+Reservierte Wörter                                  9, 12, 100, 103 
+RESTORE                                             77 
+RETURN                                              78 
+RIGHT$                                              79 
+RND                                                 80 
+RSET                                                81 
+Scanner                                             9, 103 
+Schlüsselwörter                                     9 
+Scrolling                                           25 
+SGN                                                 81 
+SIN                                                 82 
+SPACE$                                              82 
+SPC                                                 83 
+SQR                                                 83 
+Standard-Funktionen                                 19 
+STEP                                                50 
+Steuerung der Bildschirmausgaben                    25 
+Steuerung des BASIC-Compilers                       5 
+STOP                                                84 
+STR$                                                84 
+STRING$                                             85 
+SUB                                                 52 
+SWAP                                                86 
+Symbol                                              9 
+Symboltypen                                         103 
+Syntax                                              7 
+sysout                                              6 
+TAB                                                 64, 72 
+TAN                                                 86 
+Texte                                               10 
+TEXT-Konstanten                                     104 
+Text-Operator +                                     15 
+THEN                                                54 
+TIME$                                               88 
+TIMER                                               87 
+TO                                                  50, 53 
+Trennzeichen                                        105 
+TRON / TROFF                                        88 
+Typanpassung                                        22 
+UND-Verknüpfung                                     16 
+USING                                               64, 72 
+USR                                                 23, 90 
+Übersetzen von BASIC-Programmen                     5 
+Übersichtlichkeit von BASIC-Programmen              7 
+VAL                                                 91 
+Variablen                                           12, 104 
+Variablennamen                                      9, 12 
+VAR-Parameter                                       23 
+Vergleichsoperatoren                                15 
+Vordurchlauf                                        28 
+Vorzeichen                                          11 
+Wahrheitswerte                                      16 
+Weitere Schreibregeln                               9 
+WEND                                                92 
+wertliefernden Prozeduren                           23 
+WHILE                                               92 
+WIDTH                                               93 
+WRITE                                               94 
+XOR                                                 17 
+Zahlen                                              10 
+Zeilennummer                                        7 
+Zuweisungsoperator                                  18 
+