summaryrefslogtreecommitdiff
path: root/lang/basic/1.8.7/doc/basic handbuch.1
diff options
context:
space:
mode:
Diffstat (limited to 'lang/basic/1.8.7/doc/basic handbuch.1')
-rw-r--r--lang/basic/1.8.7/doc/basic handbuch.11075
1 files changed, 1075 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.
+