
BASIC 64
Der BASIC-Compiler fr den
COMMODORE 64
EIN DATA BECKER PROGRAMM

***
Wichtiger Hinweis	

Das vorliegende Handbuch und das dazugehrige Programm wurden vom Autor mit grter Sorgfalt erarbeitet und unter Einschaltung wirksamer Kontrollmanahmen reproduziert. Trotzdem sind Fehler nicht ganz auszuschlieen. DATA BECKER sieht sich deshalb gezwungen, darauf hinzuweisen, da weder eine Garantie noch die juristische Verantwortung oder irgendeine Haftung fr Folgen, die auf Programmfehler oder fehlerhafte Angaben im Handbuch zurckgehen, bernommen werden kann. Fr die schriftliche, Mitteilung eventueller Fehler sind wir jederzeit dankbar.

Copyright (C) 1984 DATA BECKER
Merowinger Str. 30 4000 Dsseldorf

Alle Rechte vorbehalten. Kein Teil des Handbuches und des dazugehrigen Programms darf in irgendeiner Form (Druck, Fotokopie oder einem anderen Verfahren) ohne schriftliche Genehmigung der DATA BECKER GmbH reproduziert oder unter Verwendung elektronischer Systeme verarbeitet, vervielfltigt oder verbreitet werden.

ISBN-Nr.: 3-89011-534-9

***
DATA BECKER INFORMIERT :

1)LADESCHWIERIGKEITEN

Bei der Vervielfltigung unserer Software verwenden wir ausschlielich qualitativ hochwertige Disketten, die whrend des Dupliziervorgangs auf 100%ige Lesefhigkeit geprft werden. Schon bei der kleinsten Unstimmigkeit weist unser Dupliziercomputer den Datentrger zurck. Eine derart berprfte Programmdiskette mte von jedem 1541-Laufwerk von Commodore problemlos gelesen werden knnen. Haben Sie trotz alledem Leseschwierigkeiten bei DATA BECKER Software, so ist der Fehler in den meisten Fllen bei Ihrer Diskettenstation zu suchen. Eine Floppy kann schon nach wenigen Bestriebsstunden "dejustiert" sein, d.h. der Schreib-Lesekopf wird nicht mehr 100% richtig positioniert, Bei herkmmlicher Software (z.B. eigenen Programmen) tritt kein Lesefehler auf, da diese Programme ja auch mit einem schlecht justierten Laufwerk gespeichert wurden. Unsere Programmdisketten stellen jedoch hhere Ansprche an die Justage der Diskettenstation.
berprfen Sie deshalb bitte, ob diese Diskette sich bei einem Freund oder Ihrem DATA BECKER Hndler in den C-64 laden lt. Ist dies der Fall, so mten Sie Ihre Floppy justieren lassen.
Ergeben sich auf anderen Floppys dieselben Probleme, so kann es sein, da die Diskette z.B. auf dem Postwege (durch magnetische Aussonderungsverfahren) Schaden genommen hat. In diesem Fall wird Ihre Diskette natrlich problem- und kostenlos umgetauscht.

2)UMTAUSCH DEFEKTE DISKETTEN

Sollte aus irgendeinem anderen Grund Ihre Diskette beschdigt oder gar zerstrt werden (z.B. mechanische Schden durch Anwenderverschulden), so senden Sie uns bitte Ihre Originaldiskette mit einem Verrechnungsscheck ber DM 10.- zurck. Sie erhalten dann umgehend eine neue Programmdiskette.

3)KOPIERVERSUCHE KNNEN DIE DISKETTE ZERSTREN

Unsere Programmdisketten sind ausnahmslos gegen Kopieren geschtzt Natrlich ist kein Kopierschutz absolut sicher, aber wir werden mit allen uns zur Verfgung stehenden rechtlichen Mitteln versuchen, den Schwarzkopierern das Handwerk zu legen.

***
Inhaltsverzeichnis

Vorwort ...............................................  1


1. Kapitel

1.1 Bedienung von BASIC 64 ............................  2
1.2 BASIC 64 und Floppy-Express .......................  3


2. Kapitel

2.1 Auswahlmglichkeiten ..............................  4
2.2 Das erweiterte Entwicklungspaket ..................  4
2.3 Compileranweisungen ...............................  5
2.4 Ein Beispiel fr eine Programmentwicklung .........  5


3. Kapitel

3.1 Allgemeine Wirkungsweise des Compilierens .........  7
3.2 Optimierungen bei Formeln .........................  9
3.3 Verarbeitung von Zeichenketten .................... 10
3.4 Integer-Optimierung ............................... 11
3.5 Der Maschinensprache-Generator .................... 13


4. Kapitel

4.1 Arbeitsweise des Compilers ........................ 15
4.2 Fehlermeldungen ................................... 16
4.3 Die Zeilenliste ................................... 18
4.4 Gleitkommaberechnungen ............................ 19
4.5 Felddimensionierung ............................... 19
4.6 Direktmodusbefehle ................................ 20
4.7 Integer-Schleifen ................................. 21


5. Kapitel

5.1 Compilierbarkeit von Erweiterungen ................ 23
5.2 Supergrafik 64 und Supergrafik 64 Plus ............ 24
5.3 Simons' Basic ..................................... 25
5.4 Basic 4.0 (Diskomat, Master 64) ................... 28
5.5 Anwendung von Erweiterungen ....................... 29
5.6 Arbeitsweise von compilierten Befehlen
    einer Erweiterung ................................. 30
5.7 Andere Erweiterungen .............................. 31
5.8 Verschiedene Versionen von Basic-Erweiterungen .... 32


6. Kapitel

6.1 Compilieren von Overlay-Paketen ................... 34
6.2 Fehlerbehandlung .................................. 36
6.3 Das Runtimemodul .................................. 37


6.4 Code-Start ........................................ 37
6.5 Unterbrechen von compilierten Programmen .......... 39


7. Kapitel

7.1 Die Optimierungsstufen ............................ 39
7.2 P-Code (Speedcode) und Maschinensprache ........... 41
7.3 Integer-Wertebereich beim Poke-Befehl ............. 42


8. Kapitel

8.1 Speicherbelegung .................................. 44
8.2 Speicheradressen .................................. 44
8.3 Spezielle Befehle ................................. 46
8.4 Symbol-Tabellen als Schnittstelle zu Profimat ..... 47
8.5 Zugriff auf Speicherbnke ......................... 48


9.Kapitel

9.1 bersicht ber die Mglichkeiten von BASIC 64
    und deren Anwendungen ............................. 50


10. Kapitel

10.1 Ein-Ausgabe ...................................... 59
10.2 Gleitkommafunktionen ............................. 59
10.3 Grafik ........................................... 60


Hinweise zum Handbuch ................................. 62

***
Vorwort

BASIC 64 ist ein optimierender Basic-Compiler fr den Commodore 64, der Ihre in Basic geschriebenen Programme schneller und leistungsfhiger macht. Dabei knnen Sie whlen, ob BASIC 64 Ihre Programme in einen P-Code oder direkt in Maschinensprache bersetzen soll. Das bersetzte Programm wird dadurch bis zu 6mal schneller als das Original-Programm.

In vielen Fllen, besonders beim Einsatz von Integer-Variablen, wird durch den in BASIC 64 enthaltenen Programmoptimierer Ihr Basic-Programm sogar 6-10mal schneller als das Original. Dies gilt ebenfalls fr die Verarbeitung von Zeichenketten, auerdem ist die gefrchtete Garbage Collection bei compilierten Programmen wesentlich schneller als die des Interpreters (max. 1 Sekunde statt mehrere Minuten), was die Anwendung von Basic fr anspruchsvollere Programme erst mglich macht.

Obwohl zu jedem compilierten Basic-Programm noch ein Runtimemodul mit einer Lnge von 5K hinzukommt, werden besonders grere Basic-Programme durch das Compilieren krzer (um ca. 25%). Auerdem stehen dem compilierten Programm 62K fr Programm und Daten zur Verfgung und nicht nur 38K, wie bei Verwendung des Basic-Interpreters.

BASIC 64 kann aus Ihren Basic-Programmen aber auch direkt Maschinenspracheprogramme erzeugen, welche zwar ca. doppelt so lang sind wie das Original, aber nochmals um einiges schneller als ein P-Code-Programm. Mit BASIC 64 compilierte Programme werden dadurch in vielen Fllen 10-20fach schneller als ein Basic-Programm. Ein Mischen von kurzem P-Code und extrem schneller Maschinensprache ist ebenfalls mglich.

Selbstverstndlich compiliert BASIC 64 Programme beliebiger Gre und auch Overlay-Pakete, wobei die Compiliergeschwindigkeit ca. 1K Byte pro Minute betrgt. Ebenfalls untersttzt werden die meisten Befehle folgender Basic-Erweiterungen: Supergrafik. 64, Simons' Basic, Exbasic Level II, Basic 4.0 (enthalten in Diskomat und Master 64) und andere.

BASIC 64 bietet Ihnen viele weitere Mglichkeiten, wie z.B.: Zwei Optimierungsstufen, variabler Codestart, variable Speicherbenutzung, Umdefinieren von Datentypen von Variablen, Berechnung von konstanten Ausdrcken und Zeichenketten whrend der Compilierung, Optimieren und Umstellen von Formeln, Syntaxprfung von Programmen, Erstellen einer Zeilenadressenliste, Start von Unterprogrammen bei Laufzeitfehlern, IF .. THEN .. ELSE, Datenschnittstelle zum Assembler Profi-Ass, etc.

BASIC 64 ist kompatibel zum eingebauten Basic-Interpreter des Commodore 64 und bildet zusammen mit diesem ein ideales Programmentwicklungssystem, mit dem schnelle und leistungsfhige Programme geschrieben werden knnen, fr die bisher das Programmieren in Maschinensprache ntig war.

*** Seite 1


1. Kapitel


1.1 Bedienung von BASIC 64

Die Bedienung des BASIC 64 Compilers ist denkbar einfach:

- Speichern Sie Ihr Basic-Programm auf einer Diskette ab. Diese mu nicht unbedingt leer sein, sollte aber gengend freie Speicherkapazitt haben (bei groeeren Programmen bis zu 300 Diskettenblcke). Sie brauchen sich von Ihrem Programm nicht unbedingt eine Sicherheitskopie erstellen, da BASIC 64 das Programm nur einliest und nicht lscht.

- Legen Sie nun die Diskette mit BASIC 64 in das Laufwerk, laden Sie den Compiler mit LDAD"BASIC 64",8 und starten Sie ihn mit RUN.

- Nachdem der Compiler sich mit "BASIC 64 Compiler" und der Versionsnummer gemeldet hat, erscheinen auf dem Bildschirm die Auswahlmglichkeiten des Compilers. Nehmen Sie nun die BASIC 64-Diskette aus dem Laufwerk und legen Sie die Diskette mit dem zu compilierenden Programm ein.

- Drcken Sie die "Return"-Taste. Sie haben dadurch die Mglichkeit Nr. 1 ausgewhlt, was Sie auch mit Hilfe der Taste "1" erreicht htten.

- Der Compiler fragt Sie nun nach dem Namen Ihres Programms, geben Sie diesen ein und drcken Sie "Return".

- Der Compiler bersetzt Ihr Programm nun in ein P-Code Programm. Auf dem Bildschirm wird die gerade bearbeitete Zeilennummer angezeigt, danach gibt der Compiler einige Angaben ber das generierte Programm aus. Sind in Ihrem Programm Fehler enthalten, so meldet der Compiler diese mit den entsprechenden Fehlermeldungen. Der Compiler bricht dabei nicht ab, sondern setzt seine Arbeit fort, um evtl. weitere Fehler zu finden.

- Nachdem der Compiler seine Arbeit beendet hat, meldet er sich mit "READY". Drcken Sie nun die Taste "N", um dem Compiler mitzuteilen, da Sie keine weiteren Programme compilieren wollen. Durch Drcken einer anderen Taste knnen Sie den Compiler neu starten.

- Waren in Ihrem Programm Fehler enthalten, so mssen diese verbessert werden und anschlieend das Programm nochmals compiliert werden.

- Das compilierte Programm steht nun auf der Diskette. Um es von dem Basic-Programm zu unterscheiden, hat der Compiler vor den Programmnamen ein "P-" gehngt. Laden Sie das Programm mit LOAD"P-Programmname" und starten Sie es mit RUN.

- Dieses Programm luft nun wesentlich schneller als ein Basic-Programm.

- Evtl. noch auftretende Fehler werden genauso gemeldet, wie

*** Seite 2


bei einem Basic-Programm. Allerdings wird keine Zeilennummer, sondern die Speicherstelle, an welcher der Fehler auftrat, genannt. Mit Hilfe einer Zeilenliste knnen Sie die fehlerhafte Stelle im Original-Programm feststellen. Eine Zeilenliste wird vom Compiler auf Wunsch ebenfalls erzeugt.

- Sollte Ihnen die Geschwindigkeit des Programmes immer noch nicht ausreichen, so gibt es gengend Mglichkeiten, dies zu ndern (Optimierungsstufe 2, Generieren eines Maschinenprogrammen, Verwendung von Integer-Variablen, etc.). Dieses wird in den entsprechenden Kapiteln erlutert.

Achtung:

Zum vollstndigen Verstndnis des Compilers sollten Sie unbedingt aufmerksam das Handbuch lesen.


1.2 BASIC 64 und Floppy-Express

Soweit Sie den Data Becker Floppy-Express besitzen, koennen Sie BASIC 64 auch mit LOAD"FLADER",8 laden und mit RUN starten. Der Compiler arbeitet dann schneller.

Compilierte Programme knnen ebenfalls den Floppy-Express benutzen. Dieses geschieht wie folgt:

- Drcken Sie nach dem Laden des Compilers die Taste "3" und danach "E".

- Geben Sie die Zahl 52224 (entspricht $CC00) ein und drcken Sie zweimal "Return".

- Compilieren Sie das Programm, indem Sie die entsprechende Diskette einlegen, "Return" drcken und den Programmnamen eingeben.

Vor dem Laden des auf diese Art compilierien Programmes kann nun die Floppy-Express-Version 10 aktiviert werden.

*** Seite 3


2. Kapitel


2.1 Auswahlmglichkeiten

Nachdem Sie BASIC 64 gestartet haben, erscheint auf dem Bildschirm das Hauptmen. Die vier Wahlmglichkeiten dieses Mens sind entsprechend durchnumeriert und lassen sich durch Drcken der entsprechenden Zahlentaste starten. Der wichtigste Punkt dieses Mens ist der Punkt 1, welcher das Compilieren eines Programmen startet. Aus diesem Grund kann man diesen Punkt nicht nur mit der Taste "1" anwhlen, sondern auch mit der "Return"-Taste. Punkt 2 startet ebenfalls den Compiler, allerdings mit einer anderen Optimierungsstufe. Der Unterschied zwischen den beiden Optimierungsstufen wird in Kapitel 7 beschrieben. Zum Compilieren von Overlaypaketen dient der Menpunkt 4. Dies wird in Kapitel 6 beschrieben. Durch Anwahl des Menpunktes 3 gelangen Sie in ein weiteres Men.


2.2 Das erweiterte Entwicklungspaket

Zur Entwickelung von Programmen mit speziellen Anwendungen verfgt BASIC 64 ber die Mglichkeit, einige Eigenschaften des zu generierenden Programmes zu verndern. Whlen Sie dazu im Hauptmen den Menpunkt 3 an. Auf dem Bildschirm erscheinen nun alle vernderbaren Werte. Alle Menpunkte sind in alphabetischer Reihenfolge mit Buchstaben bezeichnet. Durch Drcken der entsprechenden Buchstabentaste knnen Sie nun die gewnschte Einstellung erreichen. Eine genaue Beschreibung der einzelnen Punkte dieses Mens finden Sie in Kapitel 9. Ein einfaches Beispiel fr die Benutzung des Entwicklungspaketes ist das Compilieren eines Programmen mit Befehlen einer Basic-Erweiterung:

Nachdem Sie Punkt 3 im Hauptmen ausgewhlt haben, erscheint die Art der verwendeten Basic-Erweiterung unter Menpunkt H. Nach Start des Compilers ist noch keine bestimmte Basic-Erweiterung eingestellt. Durch mehrmaliges Drcken der Taste "H" knnen Sie nun die von Ihnen verwendete Basic-Erweiterung einstellen und mit "Return" wieder in das Hauptmen gelangen. Durch nochmaliges Drcken der "Return"-Taste starten Sie wie gewohnt den Compiliervorgang. Andere nderungen der voreingestellten Werte knnen genauso einfach vorgenommen werden. Natrlich knnen auch mehrere Werte verstellt werden. Der Einfachheit halber werden die Wahlmglichkeiten des Entwicklungspaketes in den folgenden Kapiteln nur noch mit Punkt A bis Punkt M bezeichnet. Die Wahlmglichkeiten des Hauptmens dagegen mit Punkt 1 bis Punkt 4. Beachten Sie, da nur die jeweils auf dem Bildschirm erscheinenden Punkte angewhlt werden knnen.

*** Seite 4


2.3 Compileranweisungen

Alle Auswahlmglichkeiten knnen nur vor dem eigentlichen Compilieren benutzt werden. In vielen Fllen ist es ntig, whrend des Compilierens Anweisungen an den Compiler zu geben. Diese Anweisungen mssen dann innerhalb des Programmas notiert werden. Damit der Basic-Interpreter diese Anweisungen berspringt, mssen sie nach einem REM-Befehl folgen. Das Symbol zur Kennzeichnung dieser Anweisungen ist der Klammeraffe "@". Das Format fr eine Compileranweisung ist somit folgendes:

REM@ Anweisung

Eine Liste aller mglichen Compileranweisungen finden Sie in Kapitel 9. Die wichtigste Compileranweisung ist folgendes

REM@ I=Variablenname,Variablenname...

Diese Anweisung bewirkt, da alle in der Anweisung genannten Variablen vom Compiler als ganzzahlige Variablen angesehen werden (Integer-Variablen). Der Anwendungsbereich dieser Compileranweisung liegt in der Entwicklung von besonders schnellen Programmen.


2.4 Ein Beispiel fr eine Programmentwicklung

Ein einfaches Beispiel fr ein Programm, das mglichst schnell ablaufen soll, ist eine Primzahlberechnung. Folgendes Programm wird deswegen hufig als Benchmarktest fr die Geschwindigkeit von Computern, Programmiersprachen und Compilern benutzt:

10 REM SIEB DES ERATHOSTENES
20 DIM Z%(10000)
30 FOR I=1 TO 10000
40 Z%(I)=l
50 NEXT
60 PRINT 2
70 FOR I-1 TO 10000
90 IF Z%(I)=0 THEN 150
90 PRINT I*2+1
100 K=1
110 IF I+K*(I*2+1)>10000 THEN 150
120 Z%(I+K*(I*2+1))=0
130 K=K+l
140 GOTO110
150 NEXT

Wrden Sie nun die Zeit messen, die dieses Programm zur Ausfhrung bentigt, so wrden Sie hauptschlich die Zeit messen, die zur Ausgabe der Primzahlen auf dem Bildschirm bentigt wird. Um das Programm zum Vergleich von Rechengeschwindigkeiten benutzen zu knnen, wird blicherweise folgende nderung vorgenommen:

90 Q=I*2+1

*** Seite 5


Trotz dieser nderung bentigt das Programm noch eine ziemlich lange Rechenzeit. Das Programm wird ca. 3mal schneller, wenn Sie es wie in Kapitel 1 beschrieben compilieren. In Kapitel l wurde bereits erwhnt, da die erreichte Geschwindigkeit sich noch weiter steigern lt. Bei diesem Programm gibt es mehrere Mglichkeiten:

- Schreiben Sie das Programm so um, da nur noch ganzzahlige Variablen benutzt werden. Dies geschieht durch das Anhngen eines "%"-Zeichens hinter jeden Variablennamen. Das Programm wird dadurch schneller und der P-Code sogar krzer. Beachten Sie, da der Basic-Interpreter keine ganzzahligen Variablen in FOR-NEXT-Schleifen zulsst, das Programm mte also umgeschrieben werden.

- Diese Mhe knnen Sie sich ersparen, indem Sie folgende Compileranweisung benutzen:

5 REM@ I=I,K,Q

Besonders fr die Schleifenvariable I ist dies sehr sinnvoll, da Sie dieses Programm dann auch mit dem Basic-Interpreter ausprobieren knnen, ohne es umzuschreiben.

- Auch die Compileranweisung ist in diesem speziellen Fall unntig, da das Programm ausschlielich mit ganzen Zahlen rechnet. Anstatt den Compiler mit dem Menpunkt 1 zu starten, starten Sie ihn einfach mit 2.

- Zustzlich knnen Sie bei jedem Programm den Compiler anweisen, Maschinensprachencode zu erzeugen, dies geschieht durch Menpunkt A (im Entwicklungspaket).

Nachdem Sie das Generieren von Maschinensprache gewhlt und das Programm mit Menpunkt 2 compiliert haben, luft es ca. 15mal schneller als das Basic-Programm. Die Beachtung von einigen Regeln beim Programmieren und Compilieren lohnt sich also sehr.

*** Seite 6


3. Kapitel


Der Programmoptimierer

Beim Erstellen von Programmen, die mit maximaler Geschwindigkeit laufen sollen, ist es ntzlich, wenn Sie die Wirkungsweise des Compilers kennen und zeitkritische Teile innerhalb Ihres Programmes entsprechend anpassen. Bei Programmen, bei denen dies versumt wurde oder die nicht zum Compilieren gedacht waren, kann dies mit der Optimierungsstufe 2 nachgeholt werden. Dies wird in Kapitel 7 beschrieben. Andererseits kommt es oft vor, da Anpassungen, die ein Programm fr den Interpreter schneller machen, unntig sind, da der Compiler sie nicht bentigt oder automatisch ausfhrt. Auch derartige Flle sollte man kennen, da dadurch Arbeit gespart werden kann.


3.1 Allgemeine Wirkungsweise des Compilierens

Bei lngerer Arbeit mit dem Basic-Interpreter macht man folgende Erfahrungen bezglich der Geschwindigkeit von Programmen:

- Ein GOTO/GOSUB arbeitet langsamer, als ein RETURN, obwohl beides eigentlich einen Sprung innerhalb des Programmes bedeutet.

- Eine Schleife, die mit Hilfe einer IF-THEN-Konstruktion programmiert wird, arbeitet langsamer als eine FOR-NEXT-Schleife.

- Formeln, in denen Konstanten benutzt werden, werden langsamer berechnet, als Formeln mit Variablen, dies gilt fr Zahlen und meistens auch fr Zeichenketten.

- Variablen, die im Programm erst spter benutzt werden, arbeiten langsamer als andere.

- Die Geschwindigkeit der Sprnge GOTO und GOSUB ist bei Vorwrtssprngen abhngig von der Sprungweite, bei Rckwrtssprngen von der Entfernung des Sprungzieles zum Programmanfang.

- Integervariablen werden langsamer	verarbeitet als Gleitkommavariablen. Eine Speicherersparnis von Integervariablen ist nur bei Feldern vorhanden.

- Bei greren Programmen werden die Sprnge GOTO/GOSUB und die Verarbeitung von Variablen um ein Vielfaches langsamer.

- Durch das Einfgen von Leerzeichen werden Programme zwar bersichtlicher, aber wesentlich langsamer.

- Strukturierte Programme sind meistens langsamer als Spaghetti-Programme.

*** Seite 7


Alle diese Punkte und einige weitere treten bei compilierten Programmen nicht mehr auf. Es ist somit nicht ntig, Programme an den Basic-Interpreter anzupassen, wenn diese sowieso compiliert werden sollen. Natrlich gibt es auch bei compilierten Programmen Operationen, die schneller arbeiten als andere. Es ist oft ntzlich, diese zu kennen und zu benutzen. Dies fhrt zu der Frage, warum und wann compilierte Programme schneller arbeiten, als nichtcompilierte. Die wichtigsten Punkte sind:

- Die Arbeit des Interpretierens von Basic-Programmen wird verlagert auf das Interpretieren von einer Art Pseudo-Maschinensprache (P-Code), was wesentlich schneller ist. BASIC 64 verfgt zustzlich ber die Mglichkeit, echte Maschinensprache zu erzeugen und die Interpretation ganz zu sparen.

- Das Interpretieren von Formeln wird vom Compiler bernommen. Das compilierte Programm berechnet Formeln nach einem schnelleren Verfahren.

- Beim Verarbeiten einer Variablen mu diese nicht mehr in einer Tabelle gesucht werden, sondern es kann direkt darauf zugegriffen werden.

- Zur Auffindung des Zieles eines GOTO-GOSUB-Sprunges ist es nicht ntig, das gesamte Programm zu durchsuchen, der Sprung erfolgt direkt. Beispiel: Ein GOTO in einem Maschinenprogramm dauert 3 Mikrosekunden, bei lngeren Basic-Programmen dagegen bis zu einer zehntel Sekunde.

- Konstanten mssen vom Interpreter erst in die binre Form gebracht werden, da sie im Programm in dezimaler Form gespeichert sind, hnliches gilt fr die Zeilennummern von GOTO/GOSUB, im compilierten Programm sind Konstanten dagegen binr gespeichert.

Hieraus ergeben sich einige wichtige Konsequenzen. Das folgende Beispiel belegt dies:

10 FOR I=1 TO 1000:NEXT
20 PRINT"FERTIG MIT FOR-SCHLEIFE"
30 I=1
40 I=I+1:IF I<=1000 THEN40
50 PRINT"FERTIG MIT IF-THEN-SCHLEIFE"

Startet man dieses Programm, so ist die erste Schleife wesentlich schneller beendet als die zweite Schleife. Nach dem Compilieren laufen beide Schleifen dagegen ungefhr gleich schnell. Die Geschwindigkeit von compilierten Programmen ist nicht abhngig von der Anzahl der verwendeten Befehle oder von der Struktur des Programmen, sondern lediglich von den ausgefhrten Operationen selbst. Computerintern werden beide Schleifen nmlich mit fast der gleichen Methode ausgefhrt (der Verwaltungsaufwand der FOR-NEXT-Schleife ist etwas hher, da sie flexibler einsetzbar ist).

Bei den bisher erwhnten Ergebnissen des Compilierens handelt

*** Seite 8


es sich um Methoden, die von den meisten Basic-Compilern angewandt werden. BASIC 64 benutzt dagegen weitere Verfahren, um ein Programm zu beschleunigen. Dabei handelt es sich um das Optimieren von Formeln, die Verwendung von Integer-Operationen, eine schnelle Zeichenkettenverarbeitung und das wahlweise Generieren von Maschinensprache.


3.2 Optimierungen bei Formeln

Zur Berechnung grerer Formeln entstehen Zwischenergebnisse, die der Computer auf einem Stapel (Stack) abspeichert. Der Compiler stellt Formeln um, mit dem Ziel, sowenig Zwischenergebnisse wie mglich zu erzielen. Dadurch wird nicht nur das compilierte Programm krzer, sondern es kann auch schneller ausgefhrt werden. Sie brauchen bei der Benutzung grerer Formeln somit nicht mehr darauf zu achten, da diese mglichst schnell interpretiert werden knnen. Der Compiler ndert sogar teilweise Formeln, um eine schnellere Berechnung zu ermglichen. So ist z.B. die Multiplikation zweier Gleitkommazahlen schneller als die Division. In vielen Fllen ist es mglich, Gleitkommadivision durch Multiplikation zu ersetzen (Kehrwert). Der Compiler wendet derartige Verfahren natrlich nur an, wenn dabei das Ergebnis der Formel erhalten bleibt.

Eine wesentliche Arbeitserleichterung bei der Programmierung von mathematischen Programmen ist die Fhigkeit von BASIC 64, Formeln, in denen viele Konstanten enthalten sind, bereits whrend des Compilierens teilweise oder vollstndig zu berechnen. Das folgende Beispiel belegt dies:

10 S=1.414

Diese Zuweisung ist zwar sehr ungenau, wird vom Interpreter aber schneller bearbeitet als:

10 S=SQR(2)

Nach dem Compilieren arbeiten beide Versionen gleich schnell, die zweite Version ist aber genauer und leichter zu programmieren. Die Berechnung von konstanten Operationen fhrt der Compiler natrlich auch dann aus, wenn diese in greren Formeln enthalten sind. Oft werden durch das Umstellen von Formeln auch versteckte Konstantenoperationen entdeckt und berechnet.
Ein Fall, bei dem eine Berechnung der Konstante vor dem Compilieren nicht mglich ist, sind die Zeichenketten. Nicht alle 256 mglichen Zeichencodes lassen sich innerhalb von Anfhrungszeichen darstellen. Diese Codes werden trotzdem sehr oft bentigt, z.B. bei der Arbeit mit der Floppy.

Der Zugriff auf einen bestimmten Datensatz einer relativen Datei knnte z.B. so lauten:

PRINT#2,"P"+CHR$(2)+CHR$(10)+CHR$(1)+CHR$(5)

Die Berechnung dieser Zeichenkette ist nicht nur sehr lang, sondern auch langsam. Im compilierten Programm belegt sie

*** Seite 9


dagegen nur die notwendigen 5 Bytes und braucht nicht mehr berechnet zu werden, da dies bereits der Compiler getan hat.


3.3 Verarbeitung von Zeichenketten

Ist es Ihnen schon einmal passiert, da ein Programm pltzlich anhlt, minuten- oder stundenlang nichts geschieht und das Programm dann weiterarbeitet, als sei nichts gewesen? Wenn nicht, dann starten Sie einmal folgendes Programm (ohne Compiler):

10 DIM A$(9000):A$=CHR$(64):B$=CHR$(65)
20 FOR I=0 TO 9000
30 A$(I)=A$
40 NEXT
50 FOR I=0 TO 9000
60 A$(I)=B$:PRINT A$(I);
70 NEXT

Der erste Programmteil luft relativ schnell ab, das Programm beginnt mit dem Ausdrucken der Zeichenketten und stoppt pltzlich. Ein Drcken der STOP-Taste bleibt wirkungslos. Nach mehr als einer Stunde setzt das Programm seine Arbeit fort und beendet sie dann wie vorgesehen.

Der Grund fr dieses merkwrdige Verhalten liegt in der Speicherverwaltung des Basic-Interpreters. Bei jeder Zuordnung einer Zeichenkette an eine Variable wird der vorherige Inhalt der Variablen nicht gelscht, sondern bleibt im Speicher liegen. Diese Speicherverschwendung hat zur Folge, da irgendwann der Speicher unvermeidbar voll ist. Damit das Programm seine Arbeit fortsetzen kann, wird eine Routine gestartet, die alle nicht mehr bentigten Zeichenketten sucht und sie aus dem Speicher enfernt (Garbage Collection). Diese Routine bentigt natrlich um so mehr Zeit, je grer die Anzahl der benutzten Zeichenketten ist. Die bentigte Zeit ist allerdings nicht proportional zur Anzahl der Zeichenketten, sondern steigt quadratisch an. Fr Programme, die viele Zeichenketten verarbeiten, ist die Programmiersprache BASIC somit nicht geeignet. Dies ist ein wesentlicher Grund, wieso anspruchsvollere Programme (Textverarbeitung, Dateiverwaltung) meistens in Maschinensprache geschrieben sind. Es gibt allerdings eine Lsung fr dieses Problem. Sie brauchen Ihre Programme nur mit BASIC 64 zu compilieren. Bei obigem Beispiel wird nach dem compilieren aus der mehrstndigen Pause ein kurzes Stocken des Programmen. Auch in den extremsten Fllen ist die Garbage Collection eines compilierten Programmes nach maximal einer Sekunde beendet. Sollte Ihnen dies immer noch zu lange dauern, so gibt es die Mglichkeit, das Auslsen einer Garbage Collection vom Programm zu steuern und an weniger zeitkritischen Stellen des Programmen ausfhren zu lassen. Dies geschieht durch Benutzung der FRE-Funktion.

BASIC 64 fhrt noch weitere Optimierungen bezglich der schnelleren Ausfhrung von Zeichenkettenoperationen aus. Besonders bei komplexeren Zeichenkettenformeln sind diese sehr wirkungsvoll, wie z.B. bei:

*** Seite 10


A$=LEFT$(A$,X%-1)+B$+MID$(A$,X%)

Die Zeichenkette B$ wird in die Kette A$ an der Stelle X% eingefgt. Der Basic-Interpreter wrde zuerst mehrere Teilzeichenketten generieren und diese dann aneinanderhngen. Das compilierte Programm ist dagegen derart optimiert, da es nur die Ergebniszeichenkette berechnet. Zwischenergebnisse entstehen nicht. Dadurch arbeitet diese zusammengesetzte Formel fast genauso schnell, wie eine einzelne Funktion. Durch diese Fhigkeit und die schnelle Garbage Collection wird die Programmiersprache Basic nun auch fr anspruchsvollere Programme einsetzbar.


3.4 Integer-Optimierung

Im Commodore-Basic existieren zwei verschiedene Datentypen zur Darstellung von numerischen Werten. Diese sind die Gleitkommazahlen (REAL) und die ganzen Zahlen (INTEGER). Eine Variable zur Aufnahme von Gleitkommazahlen kann einen beliebigen Namen haben, dabei werden nur die ersten beiden Zeichen vom Interpreter beachtet. Eine Variable, die als letztes Zeichen ihres Namens ein %-Zeichen besitzt, kann dagegen nur ganze Zahlen aufnehmen, der Interpreter beachtet nur die ersten beiden Zeichen des Namens und das %-Zeichen. Eine Variable, die auf diese Weise gekennzeichnet wurde, kann nur Werte zwischen -32768 und +32767 ohne Nachkommastellen aufnehmen. Obwohl derartige Variablen normalerweise selten benutzt werden, so ist der diesen Variablen zugrundeliegende Datentyp ein wesentlich wichtigerer als der Gleitkommadatentyp. Dies bemerkt ein Basic-Programmierer normalerweise nicht, da der Basic-Interpreter beide Datentypen ineinander umwandelt, wenn dies ntig ist, und manchmal sogar, wenn dies nicht ntig ist.

Es folgt eine Liste aller Befehle, Operationen und Funktionen, zu deren Ausfhrung der Basic-Interpreter nur ganze Zahlen bentigt und eine entsprechende Umwandlung der Gleitkommadarstellung veranlat:

On Goto, On Gosub, Wait, Load, Save, Verify, Poke, Cmd, Sys, Open, Close, Tab, Spc, Not, And, Or, Fre, Pos, Peek, Len, Asc, Chr$, Left$, Right$, Mid$, Index von Feldern, etc.

Bei folgenden Operationen verwendet der Interpreter die Gleitkommadarstellung und wandelt ganze Zahlen entsprechend um:

Schleifenzhler, Input, Print, Read, IF, Def, +, -, *, /, >, <, =, <=, >=, <>, Sgn, Int, Abs, Usr, Sqr, Rnd, Log, Exp, Cos, Sin, Tan, Atn, Str$, Val.

Bei folgenden Operationen ist eine Umwandlung in das Gleitkommaformat nicht immer ntig, obwohl der Basic-Interpreter dies trotzdem macht:

Schleifenzhler, Input, Print, Read, If, +, -, *, /, >, <, =, <=, >= <>, Int.

*** Seite 11


Der Basic-Interpreter fhrt zustzlich alle Berechnungen im Gleitkommaformat durch; handelt es sich um eine ganzzahlige Operation, so wird vor der Operation das Format gewandelt und hinterher wieder zurck. Bei der Verwendung von Integer-Variablen wird vor der Operation zuerst in eine Gleitkommazahl gewandelt und danach wieder zurck.

Aus diesen Aufzhlungen geht hervor, da nichtmathematische Programme vollstndig ohne Gleitkommavariablen auskommen knnen. Bei mathematischen Programmen knnte die Benutzung von Gleitkommavariablen unter Umstnden ebenfalls stark gesenkt werden. Auf jeden Fall ist der Groteil aller Datentypwandlungen des Basic-Interpreters berflssig. Hinzu kommt, da die vom Interpreter benutzten Routinen zur Umwandlung von Datentypen langsam und umstndlich arbeiten. Weiterhin sind Gleitkommaoperationen um Grenordnungen langsamer als ganzzahlige Operationen. Da der Basic-Interpreter bei einer entsprechenden Wahlmglichkeit immer Gleitkommazahlen	 einsetzt, merkt der Basic-Programmierer hiervon nichts. Ein Basic-Programm knnte also um ein Vielfaches schneller arbeiten, wenn die Gleitkommadarstellung nur noch eingesetzt wird, wenn sie ntig ist.

Ein mit BASIC 64 compiliertes Programm macht immer maximalen Gebrauch von der ganzzahligen Darstellung, hierbei ist der Compiler allerdings auf die Mitarbeit des Programmierers angewiesen:

- Der Compiler kann bei der bersetzung des Programmen noch nicht feststellen, welche Datentypen whrend der Laufzeit in welchen Variablen benutzt werden.

- Das laufende Programm knnte dies zwar feststellen, es wrde dadurch allerdings wesentlich langsamer, da es nicht nur nach jeder Rechenoperation den Datentyp feststellen mte, sondern auch eventuell den Datentyp wandeln mu.

Aus diesen Grnden nimmt BASIC 64 an, da es sich bei allen Variablen um Gleitkommavariablen handelt, mit Ausnahme der folgenden Flle:

- Variablen, die mit einem %-Zeichen gekennzeichnet sind, wie dies der Einteilung des Basic-Interpreters entspricht.

- Variablen, die durch eine entsprechende Compileranweisung zu Integer-Variablen gemacht wurden.

- Alle Variablen, die in einem Programm vorkommen, das mit Optimierungsstufe 2 compiliert wird (Kapitel 7).

In Kapitel 2 haben Sie bereits gesehen, da es sehr lohnend ist, wenn Integer-Variablen benutzt werden. Durchschnittlich sind 90% aller Variablen eines Programmes durch Integer-Variablen ersetzbar. Der Basic-Interpreter lt es allerdings nicht zu, da Integer-Variablen als Zhlvariablen einer FOR-NEXT-Schleife eingesetzt werden. In diesem Fall kann man dies mit Hilfe einer Compileranweisung umgehen.

*** Seite 12


Hufig in Schleifen eingesetzte Variablen, wie I,J,K sollten deshalb zur Aufnahme von Integer-Zahlen durch eine entsprechende Compiler-Anweisung reserviert und nur zu diesem Zweck eingesetzt werden. Es gibt noch viele weitere Grnde, Integer-Variablen einzusetzen:

- Eine Integer-Variable belegt 2 Bytes Speicherplatz, eine Gleitkommavariable dagegen 5. Besonders bei Feldern ist dies ein entscheidender Vorteil von Integer-Variablen, der brigens auch beim Basic-Interpreter auftritt.

- Compilierte Programme werden durch die Verwendung von Integer-Variablen krzer, da es fr die Adressen von Integer-Variablen eine Kurzform gibt. Dies gilt nur bei Generierung von P-Code.

- Viele besonders einfache Integer-Operationen gehren zum Befehlsschatz des Mikroprozessors 6510. Sie knnen deshalb in wenigen Mikrosekunden ausgefhrt werden. Hierzu gehren z.B.:

I%+1, I%-1, I%*2, I%+J%, I%-J%.

Alle Programmiersprachen, die durch einen Compiler realisiert werden, unterscheiden streng zwischen Integer- und Gleitkommavariablen. Sollten Sie irgendwann auf eine leistungsfhigere Programmiersprache, wie z.B. Pascal, umsteigen, so ist es von Vorteil, mit dieser Unterscheidung vertraut zu sein. Es gibt sogar Programmiersprachen, die nur mit ganzen Zahlen arbeiten (Forth, Assembler).


3.5 Der Maschinensprache-Generator

Grundstzlich lassen sich Compiler in zwei verschiedene Klassen einteilen, je nach der Art des von ihnen erzeugten Codes. Ein hufig angewendetes Verfahren ist das Generieren eines Pseudo-Codes (Speedcode), welcher dann von einem entsprechenden Interpreter abgearbeitet wird. Der Vorteil dieses Codes ist seine Krze. Compilierte Programme werden dadurch je nach Programm 50-80% krzer als das Original. Dies ist besonders wichtig, da der Compiler zu jedem Programm noch eine Programmsammlung (Runtimemodul) hinzufgt, die das compilierte Programm bentigt, und es dadurch verlngert. Der Nachteil des	P-Codes ist die geringere Ausfhrungsgeschwindigkeit gegenber einem Maschinenspracheprogramm. Obwohl der von BASIC 64 generierte P-Code speziell fr den Commodore 64 entwickelt wurde, trifft dies auch fr diesen P-Code zu.

Eine Alternative zur Generierung eines P-Codes ist die bersetzung des Programmes in Maschinensprache. Dies hat den gewaltigen Vorteil, da das Programm dadurch mit maximaler Geschwindigkeit abluft, es aber wesentlich lnger als ein P-Code Programm ist. Normalerweise verfgen nur grere Computer ber Compiler, die Maschinensprache generieren knnen, da bei diesen Computern die Rechenzeit kostbar, Speicherplatz dagegen gengend vorhanden ist.

Viele Basic-Programme fr den Commodore 64 nutzen den

*** Seite 13


Speicher nicht vollstndig aus, hauptschlich weil mit Hilfe des Interpreters nur 38K Byte der verfgbaren 64K Byte nutzbar sind. Aus diesem Grund kann BASIC 64 wahlweise einen kurzen P-Code oder lngeren Maschinencode generieren oder sogar beides mischen (7. Kapitel). Durch das bersetzen eines Programmen in Maschinesprache fllt bei Ablauf des Programmen natrlich das Interpretieren des P-Codes weg. Der Mikroprozessor des Commodore 64 (6510) bentigt zur Abarbeitung eines Befehles zwischen 2 und 7 Mikrosekunden. Diese Befehle sind gegenber den Basic-Befehlen derart primitiv, da mehrere Befehle ntig sind, um einen Basic-Befehl auszufhren. In vielen Fllen mssen sogar ganze Unterprogramme aufgerufen und ausgefhrt werden. Ein Maschinenspracheprogramm ist nur dann wesentlich schneller als ein P-Code-Programm, wenn die bersetzung mit wenigen Befehlen erfolgen kann, da in diesen Fllen das Interpretieren des P-Codes das Programm stark bremst. Basic-Befehle knnen nur dann in wenige Maschinenbefehle bersetzt werden, wenn es sich um einfache Befehle handelt. Einfache Befehle erkennt man an ihrer hohen Ausfhrungsgeschwindigkeit, wie z.B. alle Operationen mit Integer-Variablen und Integer-Zahlen.	Die meisten Integer-Operationen lassen sich mit wenigen Maschinensprachebefehlen ausfhren. In diesen Fllen wird das Programm nicht nur schneller, weil das Interpretieren des P-Codes entfllt, sondern auch weil spezielle Mglichkeiten der Maschinensprache direkt benutzt werden.

Zusammenfassend kann man sagen, da ein Maschinenspracheprogramm nur dann wesentlich schneller arbeitet als ein P-Code-Programm, wenn das P-Code-Programm    schon ziemlich schnell arbeitet. Bei Programmen, die fast ausschlielich komplexe Gleitkommaoperationen (SIN, SOR, etc.) benutzen, bringt die Generierung von Maschinensprache keine nennenswerte Geschwindigkeitssteigerung.

Die Frage, wie sich die Optimierungsmglichkeiten von BASIC 64 und das Generieren von Maschinencode im Einzelfall auswirken, lt sich natrlich nur durch Ausprobieren beantworten. Durch geschickte Ausnutzung aller Mglichkeiten lassen sich die meisten Programme beachtlich beschleunigen. Ein kleines Beispiel dafr haben Sie ja bereits in Kapitel 2 gesehen.

Das Einschalten des Maschinencodegenerators geschieht ber Punkt "A" im Entwicklungspaket. Drcken Sie hierzu nach Start des Compilers die Taste "3", um in das Entwicklungspaket zu gelangen. Mit der Taste "A" knnen Sie nun das Generieren von 6502/6510-Code whlen und dann mit "Return" wieder ins Hauptmen gelangen. Das vom Compiler generierte Programm erhlt nun ein "M-" vor den Namen, anstelle des bei P-Code blichen "P-". Ansonsten ist die Bedienung des Compilers dieselbe, wie bei Benutzung des P-Code-Generators.

*** Seite 14


4. Kapitel

Details


4.1 Arbeitsweise des Compilers

Nach der Auswahl der Punkte 1 oder 2 im Hauptmen und der Eingabe des Programmnamens beginnt der Compiler mit der bersetzung des Programmes (Kapitel 1). Der Compiler unterscheidet hierbei zwischen zwei Arbeitsphasen. Diese Phasen werden mit Pass 1 und Pass 2 bezeichnet.

Pass 1:

In Pass 1 wird das Programm interpretiert, optimiert und der entsprechende Code (P-Code oder Maschinensprache) erzeugt. Der Compiler gibt dabei die laufende Zeilennummer und jedes Befehlstrennzeichen (Doppelpunkt) aus. Findet der Compiler eine Compileranweisung (REM ), so gibt er ein "R" aus. Befehle oder Funktionen, die nicht innerhalb des Commodore-Basic definiert sind (z.B. aus Basis-Erweiterungen), fhren zur Ausgabe des Buchstabens "E".

Pass 2:

In Pass 2 wird der generierte Code nochmals vom Compiler durchgegangen und vervollstndigt, weiterhin wird das Runtimemodul an das Programm gebunden und die DATA-Zeilen in das Programm eingefgt. Whrend dieser Arbeiten gibt der Compiler folgende Meldungen aus:

- Data-Code-Start: Ab dieser Speicheradresse liegen die Data-Zeilen im compilierten Programm.

- Objekt-Code-Start: Ab der angegebenen Speicheradresse beginnt das eigentliche Programm.

- Strings: Dieser Bereich ist vollstndig frei. Das compilierte Programm benutzt ihn zur Ablage von Zeichenketten. Die Anfangsadresse dieses Bereiches ist identisch mit dem Ende des compilierten Programmes. ber der Endadresse des Zeichenkettenbereiches bis zum Ende des Speichers (normalerweise 65535) werden alle Variablen und Variablenfelder gespeichert, die das Programm bentigt.

- Extentions: Sollte das Programm Befehle einer Basis-Erweiterung benutzen, so nennt der Compiler deren Anzahl.

- Errors: Sind im Programm Fehler aufgetreten, so nennt der Compiler diese in der entsprechenden Zeile und gibt vor Beendigung des Pass 2 eine Liste aller Zeilen aus, in denen Fehler auftraten.

*** Seite 15


4.2 Fehlermeldungen

Die in Basic mglichen Fehlermeldungen teilen sich in zwei Gruppen auf:

Programmfehler:

Fehler, die dazu fhren, da der Compiler einen Befehl nicht bersetzen kann, werden bereits whrend der Compilierung gemeldet. Der Compiler gibt dann dieselbe Fehlerbeschreibung wie der Basic-Interpreter aus, wenn dieser den entsprechenden Befehl ausfhren mte. Vom Compiler entdeckt werden folgende Fehler:

Syntax - Bedeutung wie in Basic.

Redim'd Array - Bedeutung wie in Basic.

Type mismatch - Bedeutung wie in Basic.

Bad Subscript - Ein Feldzugriff besitzt eine falsche Indexanzahl gegenber der Dimensionierung.

Undef'd Statement - Ein GOTO/GOSUB-Befehl bezieht sich auf eine nicht vorhandene Zeile. Dieser Fehler wird erst in Pass 2 entdeckt.

Out of memory - Programm und Variablen passen nicht mehr in den Speicher, dies passiert normalerweise nur, wenn die Speicherobergrenze mit dem Entwicklungspaket herabgesetzt wurde.

Runtime - Der Compiler versucht Formeln, so weit wie mglich, whrend der Compilierung zu berechnen (hauptschlich bei Konstanten). Sollten diese Formeln nicht berechenbar sein, so gibt der Compiler diese Meldung aus, da es sich dabei um einen Fehler handelt, der normalerweise erst whrend der Laufzeit des Programmes aufgetreten wre und deshalb nicht nher bestimmt werden kann. Ein Beispiel hierfr ist eine konstante Division durch Null:

10 A=1/0

System error - Diese Meldung wird ausgegeben, wenn das Betriebssystem des Commodore 64 einen Fehler findet, z.B. wenn die Floppy nicht eingeschaltet ist.
In fast allen Fllen kann der Compiler nach der Entdeckung eines Fehlers seine Arbeit wieder aufnehmen und nach weiteren Fehlern suchen.

Achtung:

Ein Programm, in dem Fehler vorhanden sind, ist natrlich nur eingeschrnkt lauffhig, dies gilt hauptschlich fr die Zeilen nach den Fehlern. Sie sollten die vorhandenen Fehler beheben und das Programm neu compilieren.

Laufzeitfehler:

*** Seite 16


Viele Fehler knnen vom Compiler nicht entdeckt werden, da sie vom Ablauf des Programmes abhngen. Es handelt sich dabei um alle noch nicht erwhnten Fehlermeldungen. Diese Fehlermeldungen haben dieselbe	Bedeutung, wie beim Interpreter, es ist folgendes zu beachten:

Out of Memory - Diese Meldung bedeutet entweder, da der Zeichenkettenbereich nicht alle Zeichenketten aufnehmen kann oder da der Stapel fr FOR, GOSUB und Klammerebenen voll ist. Die Verwendung zuvieler Variablen wird bereits vom Compiler entdeckt.

Bad Subscript - Der Index eines Feldzugriffes liegt ber den Feldgrenzen, eine falsche Indexanzahl wird bereits vom Compiler entdeckt.

Formula too complex - Diese Meldung wird vom Interpreter ausgegeben, wenn eine Zeichenkettenformel zu tief verschachtelt ist, was normalerweise nicht auftritt. Ein  compiliertes Programm gibt diese Meldung nie aus, da eine tiefere Verschachtelung ebenfalls verarbeitet wird.

Illegal Quantity - Diese Meldung wird vom Basic-Interpreter auch ausgegeben, wenn die Ausfhrung des Befehles eigentlich mglich wre, z.B. bei:

10 A=ASC("")

Beim Einlesen von Dateien mit GET wird ein Nullbyte als Leerstring eingelesen. Umgekehrt gilt ein Leerstring dagegen fr den Interpreter nicht als Nullbyte, sondern er gibt eine Fehlermeldung aus. In diesem Fall und weiteren eindeutigen Fllen gibt das compilierte Programm keine Fehlermeldung aus.

Bei der Umwandlung von Gleitkommazahlen in Integer-Werte oder bei Rechnungen mit Integer-Zahlen kann es vorkommen, da das Ergebnis nicht im Integer-Bereich liegt. Der Compiler setzt allerdings nur Integer-Berechnungen ein, wenn ein solcher Fall bei der Ausfhrung des Programmen durch den Interpreter ein "Illegal Quantity" zur Folge htte. Sollte dies bei Ihrem Programm niemals der Fall sein, so knnen Sie sicher sein, da auch bei compilierten Programmen kein Bereichsberlauf auftritt. Aus diesem Grund stellt das compilierte Programm bei Integer-Berechnungen aus Geschwindigkeitsgrnden keine Bereichsberprfung an. Sollte bei Zwischenergebnissen dennoch einmal der Bereich berschritten werden und das Endergebnis wieder im Integer-Bereich liegen, so wird das Ergebnis auch mit Integer-Operationen korrekt ermittelt. Dies kann man sich z.B. beim Poke-Befehl zunutze machen (Kapitel 7).

Der Input-Befehl des C-64-Basics besitzt einige Besonderheiten, die bei fehlerhaften Eingaben wirksam werden:

Die Eingabe einer Zeichenkette anstelle einer Zahl fhrt zur Meldung "Redo from Start" und zur vollstndigen Wiederholung des Input-Befehls. Das compilierte Programm verhlt sich genauso.

*** Seite 17


Bei einer unvollstndigen Eingabe fordert das Programm mit zwei Fragezeichen zur Eingabe weiterer Werte auf (Compiler/Interpreter).

Bei gar keiner Eingabe wird der Input-Befehl dagegen ignoriert und die Variablen nicht verndert. Dies ist eine Besonderheit des C-64-Basics, die auf anderen Commodore-Computern nicht vorhanden ist. BASIC 64 wurde speziell fr den Commodore 64 entwickelt und untersttzt deshalb diese oft benutzte Mglichkeit.

Bei Eingabe von zuvielen Werten gibt der Interpreter die Meldung "Extra ignored" aus. Ein compiliertes Programm ignoriert diese Werte dagegen ohne eine (oft strende) Meldung. Der Input-Befehl ist dadurch innerhalb von Bildschirm-Masken besser einsetzbar.

Disketten-Fehler:

Bei Auftreten eines Fehlers bei der Arbeit der Floppy-Disk meldet der Compiler den Fehler und beendet das Compilieren. Die Bedeutungen der Diskettenfehlermeldungen sind im Handbuch der Floppy-Disk erlutert. Meldungen, wie READ ERROR, WRITE ERROR, NO CHANNEL und WRITE FILE OPEN deuten auf eine beschdigte Diskette hin, diese sollte ausgewechselt werden.

Bei der Arbeit mit BASIC 64 und dem Basic-Interpreter im allgemeinen kann es vorkommen, da ein Basic-Programm verbessert und neu abgespeichert werden mu. Dies geschieht meistens mit folgendem Befehl:

SAVE ":Name",8

Aufgrund eines Fehlverhaltens des Diskettenbetriebssystems kann es bei Anwendung dieses Befehles in seltenen Fllen zu Datenverlusten auf der benutzten Diskette kommen. Dies ist natrlich unabhngig davon, ob BASIC 64 benutzt wird oder nicht. Es ist sehr empfehlenswert, folgende Ersatzbefehle zu benutzen:

OPEN 15,8,15,"S:Name": CLOSE 15: SAVE "Name",8


4.3 Die Zeilenliste

Treten whrend der Laufzeit eines Programmen Fehler auf, so wird eine entsprechende Meldung ausgegeben. Anstelle einer Zeilennummer kann das Programm nur eine Speicheradresse ausgeben, da compilierte Programme nicht mehr in Zeilen organisiert sind. Zur Feststellung der fehlerhaften Zeile wird eine Zeilenliste bentigt, welche der Compiler generieren kann. Dazu dient der Punkt "D" im Entwicklungspaket, mit welchem man das Erstellen einer Zeilenliste einschalten kann. Bei Programmen, die noch nicht ausprobiert wurden, sollte immmer eine Zeilenliste generiert werden. Die Benutzung dieser Liste ist denkbar einfach.

- Notieren Sie sich die Speicheradresse, in der der Fehler auftrat.

*** Seite 18


- Laden Sie die Zeilenliste mit LOAD"Z-Programmname",8.

- Listen Sie die Liste bis zur gewnschten Stelle mit LIST-Fehleradresse.

- Auf der rechten *** Seite der Liste finden Sie nun die entsprechenden Zeilen, die den Speicheradressen auf der linken Seite zugeordnet sind. Die letzte genannte Zeile enthlt den Fehler. Da der Fehler immer vor der genannten Speicheradresse auftrat, kann er in seltenen Fllen auch am Ende der vorhergehenden Zeile liegen.

- Verbessern Sie das Programm und compilieren Sie es erneut. Sie knnen dem Programm auch die Anweisung geben, eine spezielle Programmzeile zu starten, wenn ein Fehler auftritt (Kapitel 6).


4.4 Gleitkommmaberechnungen.

Der Interpreter fhrt Gleitkommaberechnungen auf 9 Stellen (32 Bit) genau aus. Alle weiteren Stellen werden gerundet, wobei die Genauigkeit vor dem Runden sogar 40 Bit betrgt. Trotzdem sind die Gleitkommaroutinen vorsichtig zu benutzen. Ein drastisches Beispiel hierfr ist folgende Basic-Zeile:

10 IF 3^4*4^3=4^3*3^4 THEN PRINT "MULTIPLIKATION UMKEHRBAR"

Die Ausfhrung dieses Programmes bringt eine merkwrdige Erkenntnis. Das Resultat einer Gleitkommamultiplikation ist abhngig von der Reihenfolge der Faktoren. Benutzen Sie in Ihren Programmen derartige Gleitkommaberechnungen nur fr rechnerische Zwecke, niemals aber, um den Ablauf von Programmen zu steuern, sonst ist Ihr Programm abhngig von Rundungsfehlern der Gleitkommarechnung. Besser wre z.B. folgende Zeile:

10 IF ABS(3^4*4^3-4^3*3^4)<.001 THEN PRINT "OK"

Nach dem Compilieren von Programmen werden Formeln teilweise auf andere Art (durch Optimierungen) und teilweise genauer berechnet. Rundungsfehler wirken sich somit in sehr seltenen Fllen anders aus. Besonders drastisch ist dies bei der Funktion SQR, die nach dem Compilieren wesentlich genauer arbeitet. Einen weiteren Rechenfehler des Interpreters zeigt folgendes Beispiel:

10 PRINT INT(30.4*10)

Als Ergebnis erscheint die Zahl 303, obwohl 304 zu erwarten ist. Programme, die von Rundungsfehlern abhngig sind, sollte es aber normalerweise nicht geben.


4.5 Felddimensionierung

Die Grenzen von Feldern	mssen bereits whrend der Compilierung bekannt sein; dies hauptschlich aus folgenden

*** Seite 19


Grnden:

- Felder knnen auch in dem Adressbereich von $A000-$FFFF liegen, was einen zustzlichen Speicher von 24K bedeutet. Einzelvariablen drfen dort allerdings nicht liegen, da auf diesen Bereich auch Maschinenprogramme nicht immer zugreifen knnen. Daraus resultiert eine komplizierte Speicherverwaltung, die nur der Compiler bernehmen kann.

- Auf Felder sollte mglichst schnell und direkt zugegriffen werden knnen. Der Compiler bentigt dazu die Felderadressen.

In manchen Fllen sind die Grenzen eines Feldes whrend der Compilierung nicht bekannt, z.B. bei folgendem DIM-Befehl:

10 INPUTX:DIMA(X)

In diesem Fall gibt der Compiler den Feldnamen, gefolgt von einer Klammer und einem Fragezeichen, aus. Geben Sie dann die maximale Grsse des Feldes an. Im Beispiel wre dies der maximale Wert fr X. Bei mehreren Dimensionen fragt der Compiler nur nach den unbekannten Werten; trennen Sie die Werte dabei durch Drcken der "Return-Taste".

Obwohl dem compilierten Programm normalerweise gengend Speicher zur Verfgung steht, ist die Frage nach dem maximalen Feldindex oft auch eine Frage des bentigten Speicherplatzes. In Kapitel 9 finden Sie eine Liste der verschiedenen Datentypen und ihres Speicherverbrauchs. Alle in einem Programm benutzen Felder sollten soweit wie mglich in den ersten Zeilen des Pragrammes dimensioniert  werden, dies erlaubt nicht nur eine schnellere nderung, sondern hilft dem Compiler auch bei einer effizienten Speicheraufteilung und ist deshalb besonders wichtig.

Bei der Erstellung von Programmen, die mit groen Feldern arbeiten, tritt das Problem auf, da dem interpretierten Programm weniger Speicher (38K) als dem compilierten Programm (62K) zur Verfgung steht. In diesen Fllen ist es sinnvoll, das Programm zuerst mit einem kleineren Feld auszuprobieren und es dann zu compilieren:

10 N=15000:DIM X%(N)

Beim compilieren fragt der Compiler dann nach dem Maximalindex des Feldes, wo dann ein grerer Wert eingesetzt werden kann. In diesem Beispiel wre z.B. 25000 ein mglicher Index.


4.6. Direktaodusbefehle

Einige Basic-Befehle lassen sich normalerweise nicht innerhalb von Programmen einsetzen oder haben dort eine andere Wirkung. Dieses sind folgende Befehle:

LIST, LOAD, SAVE, VERIFY und CONT.

Der Befehl LOAD ldt ein Programm in den Speicher und startet

*** Seite 20


es, wenn er innerhalb eines Programmes eingesetzt wird. Fhrt das compilierte Programm kein CLR durch, so kann es Variablen des vorherigen Programmes benutzen. Dieser Effekt kann in Basic nur benutzt werden, wenn einige Regeln beachtet werden, bei compilierten Programmen ist dies nicht ntig (Kapitel 6). Der Befehl SAVE kann dazu benutzt werden,	bestimmte Speicherbereiche abzuspeichern. Dazu mssen die entsprechenden Speicherzellen (43-46, siehe 64 Intern) mit Poke gendert und nach dem Save auf ihren vorherigen Wert zurckgesetzt werden. Whrend dieser Operation kann der Interpreter auf keine Variablen zugreifen, ein compiliertes Programm ist dazu in der Lage.
Die brigen Befehle ergeben in compilierten Programmen keinen Sinn und werden vom Compiler ignoriert. Z.B. kann ein compiliertes Programm natrlich nicht mehr aufgelistet werden, da es kein Basic-Programm mehr ist.


4.7 Integer-Schleifen

Integer-Variablen drfen normalerweise nicht als Zhler in FOR-NEXT-Schleifen benutzt werden, mit einer entsprechenden Compileranweisung oder der Optimierungsstufe 2 ist dies trotzdem mglich. Integer-Schleifen sind nicht nur schneller, sie belegen auch weniger Stapelplatz und knnen deswegen tiefer ineinander geschachtelt werden. Auerdem ist die Verarbeitung und der Zugriff auf die Schleifenvariable innerhalb der Schleife schneller. Folgendes Beispielprogramm benutzt zwar eine Integer-Schleife, kann aber trotzdem mit dem Interpreter ausgefhrt werden:

5 REM@ I=I,J
10 FOR I=1T0 100:PRINT I
20 FOR J=1T0 50
30 NEXTJ,I

Eine Einschrnkung ergibt sich allerdings fr die Benutzung der Integer-Schleifen. Aus Geschwindigkeitsgrnden wird kein STEP-Wert gespeichert. Die Schrittweite ist immer der Wert 1 und der Befehl STEP ist bei Integer-Schleifen nicht erlaubt. Normalerweise liegt es in der Natur ganzzahliger Schleifen, da sie den Schrittwert 1 besitzen. Um schnelle Schleifen mit anderen STEP-Werten zu benutzen, kann z.B. auf folgende Hilfskanstruktion ausgewichen werden, die aufgrund des geringeren	Verwaltungsaufwandes und der feststehenden Sprungadresse sogar ein wenig schneller ist, als eine hnliche FOR-NEXT-Schleife:

10 I%=1
20 REM Schleifeninneres
10 I%=I%+2:IF<=1000 THEN20

*** Seite 21


Die hhere Geschwindigkeit tritt besonders bei Verwendung des Maschinensprachegenerators auf. Etwas langsamer, aber dafr einfacher, ist folgendes Programm:

5 REM@ I=I
10 FOR I=1 TO 1000
20 REM
30 I=I+1:NEXT

*** Seite 22


5. Kapitel

Basic Erweiterungen


5.1 Compilierbarkeit von Erweiterungen

Der Basic-Befehlsschatz des Commodore 64 ist zwar sehr leistungsfhig, er besitzt aber nicht die Mglichkeit, die speziellen Fhigkeiten des Commodore 64 voll auszunutzen. Besonders bei der Benutzung der hochauflsenden Grafik ist das Entwickeln entsprechender Unterprogramme sehr mhsam und eine Basic-Erweiterung ist notwendig. Leider existiert fr den Commodore 64 keine Standard-Erweiterung. Aus diesem Grund ist BASIC 64 in der Lage, die Befehle der verschiedenen Basic-Erweiterungen ebenfalls zu compilieren und sie in das fertige Programm einzubinden. Damit mglichst viele Erweiterungen compilierbar sind, wendet BASIC 64 ein allgemeines Verfahren zum Compilieren von Erweiterungen an. In einigen Erweiterungen existieren Befehle, die mit diesem Verfahren nicht compilierbar sind, sowie einige Befehle, die berhaupt nicht in ein compiliertes Programm eingefgt werden knnen. Fr die Compilierbarkeit von Erweiterungs-Befehlen sind folgende Punkte zu beachten:

- Ein compilierbarer Befehl hat folgendes Format: 

BEFEHL Wert,Wert,Wert...

Jeder Wert kann eine Konstante, Variable oder Formeln eines beliebigen Datentyps sein. Die Anzahl der Werte ist beliebig. Als Trennzeichen fr Werte sind alle Zeichen und Basic-Wrter erlaubt, die normalerweise nicht innerhalb von Formeln auftreten. Beispiele fr Befehle, die dieses Format erfllen, sind:

PLOT ,1,3*SIN(X) TO 4,A*B	;4 Werte
GMODE 0,1 ;2 Werte

Viele Erweiterungen besitzen auch zustzliche Funktionen, die man mit folgendem Format benutzen kann:

Variable = FUNKTION(Wert,Wert,...)

Die Klammern knnen entfallen, wenn der Funktion kein Wert bergeben wird. Nicht immer kann 'der Compiler den Ergebnisdatentyp einer Funktion aus der Formel entnehmen. Es ist deswegen ratsam, das Funktionsergebnis immer einer Variablen zuzuweisen, die den entsprechenden Datentyp aufnehmen kann.

Beispiele fr compilierbare Funktionen sind:

X=EVAL(A$)
A$=INSERT(B$,C$,2)

- Alle Befehle, die innerhalb von Programmen keinen Sinn

*** Seite 23


ergeben, sind natrlich nicht compilierbar. Hierzu gehren alle Programmierhilfen, wie z.B. TRACE, RENUMBER, AUTO, etc.

- Befehle, die den Ablauf von Programmen direkt verndern, sind nicht compilierbar. Hierzu gehren z.B. Sprungbefehle (CALL, EXEC, CGOTO, etc.) sowie Programmstrukturen (REPEAT, UNTIL, etc.).

- Befehle, die in die Speicherverwaltung des Programmes eingreifen, sind nicht compilierbar. Diese Befehle sind allerdings ziemlich selten (GLOBAL, LOCAL, etc.).

- Befehle, die einer Variablen einen Wert zuordnen, sind nicht compilierbar. In den blichen Erweiterungen werden hierzu allerdings die compilierbaren Funktionen benutzt. Derartige Befehle sind deshalb ebenfalls selten (INPUTLINE, etc.).

Glcklicherweise betreffen diese Einschrnkungen nur wenige und teilweise selten benutzte Befehle der blichen Basic-Erweiterungen. Wichtige Befehle, wie z.B. die Grafik-Befehle, sind dagegen compilierbar. Durch Spezialanpassungen an die meistbenutzten Basic-Erweiterungen werden darber hinaus viele Befehle dieser Erweiterungen vom Compiler akzeptiert, die normalerweise nicht compilierbar wren. Dies betrifft insbesondere die Supergrafik und das Basic 4.0.


5.2 Supergrafik 64 und Supergrafik 64 Plus

Diese Basic-Erweiterung wird von BASIC 64 fast vollstndig untersttzt, da der Befehlsaufbau dieser Erweiterung dem Compiler bekannt ist. Sie knnen somit fast jedes Programm, das fr die Supergrafik geschrieben wurde, auch compilieren. Ausnahmen bilden hierbei folgende Befehle:

Utilitiesi Die Befehle MERGE, RENUM und DTASET sind nicht compilierbar. Die Befehle MERGE und RENUM tauchen normalerweise innerhalb von Programmen sowieso nicht auf. Die ltere Version der Supergrafik enthlt keine Utilities.

Der Befehl SREAD ist nicht compilierbar. Er lt sich aber leicht durch normale Befehle ersetzen:

SREAD A$

wird zu

FOR X=1T063:READ B:A$=A$+CHR$(B):NEXT

Sollten Sie einen Spriteeditor besitzen (z.B.	den Spriteformer der neuen Supergrafik), so ist es empfehlenswert, Sprites direkt von Diskette einzulesen, da bei einer nderung des Sprites das Programm nicht noch einmal compiliert zu werden braucht.

Der Befehl IF# und der zugehrige Befehl IRETURN sind nicht compilierbar. Die Abfrage der Joysticks lt sich auch im

*** Seite 24


normalen Basic programmieren:

10 POKE56322,224:REM Tastatur abschalten
20 J%=PEEK(56320):REM Abfrage Port 2
30 IF(J% AND1)=0THEN PRINT"OBEN"
40 IF(J% AND2)=0THEN PRINT"UNTEN"
50 IF(J% AND4)=0THEN PRINT"LINKS"
60 IF(J% AND8)=0THEN PRINT"RECHTS"
70 IF(J% AND16)=0THEN PRINT"KNOPF"
80 POKE56322,255:REM Tastatur ein

Zur Abfrage von Port 1 wird die Adresse in Zeile 20 auf 56321 gendert.

Die ebenfalls mit IF# mgliche Kollisionsabfrage von Sprites lt sich folgendermaen ersetzen:

10 IF PEEK(53278)THEN PRINT"SPRITE-SPRITE KOLLISION"
20 IF PEEK(53279)THEN PRINT"SPRITE-HINTERGRUND KOLLISION"
30 POKE 53278,0:POKE 53279,0:REM Register lschen

Es lassen sich sogar die betroffenen Sprites feststellen, da in diesen Speicherstellen jedes Bit fr ein Sprite steht.

Achtung:

Programme, in denen nichtcompilierbare Befehle der Supergrafik: vorkommen, sind nicht ablauffhig oder verhalten sich anders als das nichtcompilierte Programm. Achten Sie unbedingt darauf, da diese Befehle in compilierten Programmen nicht benutzt werden. Lesen Sie vor dem Compilieren von Programmen der Supergrafik unbedingt die Abschnitte 5.6 und 5.9.


5.3 Simons' Basic

Beim Simons' Basic sind ebenfalls alle wichtigen Befehle compilierbar. Insbesondere gilt dies fr die Grafikbefehle und die vielfltigen Funktionen. Alle Befehle, die den bereits erwhnten Bedingungen nicht entsprechen, sind nicht compilierbar. Beim Simons' Basic sind dies:

- Programmierhilfen, d.h. alle Befehle, die innerhalb von Programmen sowieso nicht eingesetzt werden oder im Simons' Basic als Programmierhilfen bezeichnet werden, wie:

AUTO, RENUMBER, CGOTO, RESET, MERGE, PAGE, OPTION, DELAY, FIND, TRACE, RETRACE, DUMP, COLD, DISAPA, SECURE,.OLD.

- Eingabekontrollen:

FETCH.

- Zahlenumwandlung:

% = Binr in Dezimal, $ = Hexadezimal in Dezimal.

*** Seite 25


- DESIGN- und PRINT AT-Befehl

- Programmstrukturen (ELSE ist compilierbar):

REPEAT .., RCOMP, LOOP .., PROC.., CALL, EXEC, LOCAL, GLOBAL.

- Fehlerbehandlung:

ON ERROR, NO ERROR, OUT.

Fr die Fehlerbehandlung besitzt BASIC 64 eine eigene Mglichkeit (Kapitel 6).

Viele dieser nichtcompilierbaren Befehle lassen sich uerst einfach ersetzen:

DESIGN:

Es gibt mehrere Mglichkeiten, diesen Befehl zu ersetzen. Die einfachste Mglichkeit zeigt folgendes Programm:

10 A=64*13:REM Basisadresse
20 FOR I=A TO A+62 STEP3
30 READ A$:FOR J=0 TO 2
40 W=0:FOR K=1 TO 8
50 W=W*2:IF MID$(A$,J*8+K,1)="B" THEN W=W+1
60 NEXT:POKE I+J,W:NEXT:NEXT

Sie knnen Ihr Sprite nun wie beim Befehl DESIGN konstruieren, der Klammeraffe wird dabei nur durch den Befehl DATA ersetzt.

Es ist natrlich auch mglich, den Befehl DESIGN als Sprite-Editor zu benutzen. Nach der Konstruktion eines Sprites mit DESIGN und dem Starten des Konstruktions-Programmes kann das Sprite mit PEEK aus den entsprechenden Speicherstellen ausgelesen und auf Diskette abgespeichert und bei Bedarf wieder geladen werden. Dies hat den Vorteil, da ein dieses Sprite benutzendes Programm nicht neu compiliert zu werden braucht, wenn das Sprite gendert wird.

PRINT AT:

Dieser Befehl lt sich leicht ersetzen: 

10 PRINT AT(X,Y);Z

wird zu:

10 POKE 211,X:POKE 214,Y:SYS 58732:PRINT Z

Programmstrukturen:

Die Programmstrukturen des Simons' Basic sind leicht durch die blichen Befehle GOTO, GOSUB und IF ersetzbar:

10 REPEAT
20 ...

*** Seite 26


30 UNTIL X=0

Normales Basic:

10 REM
20 ...
30 IF NOT X=0 THEN10

Struktur:

10 LOOP
20 ...
30 EXIT IF X=0
40 ...
50 END LOOP
60 ...

Ersatz:

10 REM
20 ...
30 IF X=0 THEN 60
40 ...
50 GOTO 10
60 ...

Struktur:

10 PROC LABEL
20 ...
30 END PROC
40 ...
50 EXEC LABEL

Ersatz:

10 REM
20 ...
30 RETURN
40 ...
50 GOSUB 10

Struktur:

10 PROC LABEL
20 ...
30 CALL LABEL

Ersatz:

10 REM
20 ...
30 GOTO 10

Befehl:

10 LOCAL A,B
20 ...
30 GLOBAL

*** Seite 27


Ersatz:

10 AH=A:BH=B
20 ...
30 A=AH:B=BH

Das Programm wird durch diese nderungen schneller, was durch das anschlieende Compilieren nochmals verstrkt wird. Das Programm wird durch diese nderungen nicht unbedingt unstrukturierter, da diese Befehle teilweise selber keine echten Strukturen sind (CALL, EXIT).

Achtung:

Programme, in denen nichtcompilierbare Befehle des Simons' Basic vorkommen, sind nicht ablauffhig oder verhalten sich anders als das nichtcompilierte Programm. Achten Sie unbedingt darauf, da diese Befehle in compilierten Programmen nicht benutzt werden. Lesen Sie vor dem Compilieren von Programmen des Simons' Basic unbedingt die Abschnitte 5.6 und 5.9.


5.4 Basis 4.0 (Diskomat, Master 64)

Einige Basic-Erweiterungen besitzen eine Syntax, die beim Compilieren zu Fehlern fhren kann:

BACKUP D1 TO D0

Die Bezeichnungen D0 und D1 stehen fr die entsprechenden Diskettenlaufwerke, der Compiler wrde sie allerdings als Variablen ansehen und eine entsprechde Berechnung in das Programm einfgen. Fr Erweiterungen, die eine derartige Syntax aufweisen, gibt es ein spezielles Compilierverfahren, bei dem alle Variablen oder Formeln, die in Befehlen der Erweiterung benutzt werden, in Klammern gesetzt werden mssen. Dies ist beim Basic 4.0 sowieso der Fall und dieser Compiliermodus eignet sich deswegen besonders fr Befehle des Basic 4.0. Folgendes Beispiel zeigt eine typische Anwendung:

10 INPUT X
20 CATALOG D(X)

Basic 4.0 ist in den Programmen Diskomat und Master 64 enthalten. Die Variablen DS und DS$ knnen nur direkt nach Befehlen des Basic 4.0 benutz werden und nur jeweils eine der beiden Variablen. Bei Diskomat kann DS berhaupt nicht benutzt werden. Die Verwendung der Variablen DS und DS$ sollte also mglichst durch ein Auslesen des Fehlerkanales ersetzt werden. Die Variablen DS und DS$ werden ansonsten wie normale Funktionen einer Erweiterung behandelt. Nach der Beendigung eines compilierten Programmes unter Master 64 ist die Erweiterung nicht mehr aktiviert und eine Weiterarbeit nicht mglich.

*** Seite 28


Bei der Verwendung von Diskomat ist darauf zu achten, da der Wert fr das Speicherende (Menpunkt "E") versionsabhngig ist.

Achtung:

Programme, in denen nichtcompilierbare Befehle des Master 64 bzw. des Diskomat vorkommen, sind nicht ablauffhig oder verhalten sich anders als das nichtcompilierte Programm. Achten Sie unbedingt darauf, da diese Befehle in compilierten Programmen nicht benutzt werden. Lesen Sie vor dem Compilieren von Programmen des Master 64 bzw. des Diskomat unbedingt die Abschnitte 5.6 und 5.9.


5.5 Anwendung von Erweiterungen

EXBASIC LEVEL II

Im Advanced Development Package ( Punkt 3 ) des Compilers knnen Sie ber die Taste 'H' schon alle notwendigen Voreinstellungen fr die Exbasic Erweiterung aufrufen. Allerdings ist das Hauptanwendungsgebiet von Exbasic die aktive Hilfe bei der Programmerstellung. Hier gelten generell die Bedigungen zum Compilieren, wie bei anderen Erweiterungen - also z.B. kein Compilieren von Hilfsbefehlen.
Ferner mu beachtet werden, da Exbasic ursprnglich fr die Commodore Computer der Serien 2000, 3000, und 8000 konzipiert wurde. Hier gibt es mehrere Versionen dieser Erweiterung, die sich unter Umstnden sehr unterschiedlich verhalten. Testen Sie deshalb bitte vorher aus, welche Funktionen und Befehle Ihrer Erweiterung durch den Compilier vollstndig bersetzt werden.
Beachten Sie bitte auch, da die IF THEN ELSE Struktur durch einen Doppelpunkt gekennzeichnet sein mu:
IF A = 10 THEN B = 10 : ELSE B = 0

- Achten Sie darauf, da Ihr Programm keine nichtcompilierbaren Befehle enthlt. Basic-Erweiterungen werden stndig weiterentwickelt, so da die Compilierbarkeit  von Befehlen auch versionsabhngig sein kann. Im Zweifelsfalle mu dies ausprobiert werden.

- Lschen Sie die Basic-Erweiterung aus dem Speicher, nachdem Sie Ihr Programm gespeichert haben. Dies geschieht am sichersten durch ein kurzes Ausschalten des Computers. Ein Modul mu aus dem Modulschacht entfernt werden.

- Starten Sie den Compiler. Whlen Sie nun Punkt "3" und stellen Sie mit der Taste "H" die benutzte Basis-Erweiterung ein. Achten Sie auf den Unterschied zwischen den beiden Versionen der Supergrafik.

- Drcken Sie "Return" und fahren Sie wie in Kapitel 1 beschrieben fort.

- Sobald der Compiler einen Erweiterungsbefehl findet, gibt er ein "E" aus.

*** Seite 29


Achtung:
Der Compiler kann anhand der vom Interpreter abgespeicherten Codes nicht erkennen, ob es sich um einen compilierbaren Befehl handelt. Dies stellt sich erst beim Programmablauf heraus. Der Compiler kennt weder jeden Befehl einer Basic-Erweiterung noch ist er kompatibel zu einer Erweiterung. Der Compiler akzeptiert lediglich Befehle einer Erweiterung und fgt diese so in das Programm ein, da diese Befehle beim Ablauf des Programmes dem Interpreter bergeben werden knnen.

- Nach Beendigung des zweiten Durchlaufs (Pass 2) nennt der Compiler die Anzahl der benutzten Erweiterungsbefehle.

- Zum Ablauf des compilierten Programmen ist zuvor die entsprechende Erweiterung zu laden bzw. das Modul einzustecken. Sollte das Programm nichtcompilierbare Befehle enthalten, so meldet entweder die Basic-Erweiterung einen Fehler oder das Programm arbeitet nicht wie erwartet. Bei Beachtung der Regeln fr die Compilierbarkeit von Befehlen drfte dies nicht passieren.

- Die Speicherzellen von 704 (Sprite 11) bis 767 drfen nicht mit POKE-Befehlen gendert werden. Dies mu hauptschlich beim Simons' Basic beachtet werden, da in diesen Bereich kein Sprite gelegt werden darf.

- Die Basic-Erweiterung ist nur bei der Ausfhrung von Befehlen der Erweiterung aktiv. Nach einer Unterbrechung des Programmes mit RESTORE ist die Basic-Erweiterung mglicherweise abgeschaltet.

Sollte sich ein compiliertes Programm, welches Befehle einer Erweiterung benutzt, einmal nicht genauso verhalten, wie das uncompilierte Programm, so kann dies folgende Ursachen haben:

- Der Compiler wurde falsch bedient, z.B. wenn die benutzte Basic-Erweiterung falsch eingestellt wurde. Lesen Sie sich in diesem Fall nochmals die Abschnitte 1.1 und 5.6 durch.

- Es wurden Befehle einer Erweiterung benutzt, die nicht mit einem compilierten Programm zusammenarbeiten knnen. Hierber informiert der Abschnitt 5.1 und die entsprechenden Abschnitte zu den einzelnen Erweiterungen.

- Es wurden Befehle benutzt, die in der verwendeten Version der Erweiterung nicht vollstndig implementiert sind. Hierber informiert Abschnitt 5.9.


5.6 Arbeitsweise von compilierten Befehlen einer Erweiterung

Zur Ausfhrung eines compilierten Erweiterungsbefehles bergibt das Programm den Befehl an den erweiterten Interpreter, welcher ihn dann ausfhrt. Es wird dabei nur das Befehlsgerst bergeben, alle Formeln sind bereits vom Programm berechnet. Nach der Ausfhrung des Befehles bernimmt das compilierte Programm wieder die Kontrolle und luft weiter. Da das compilierte Programm eine schnellere, effektivere	und vollstndig andere Speicher- und

*** Seite 30


Programmverwaltung als der Interpreter besitzt, verluft das Umschalten auf den Interpreter nicht bei allen Befehlen reibungslos. Dieses ist der Grund, warum bestimmte Erweiterungsbefehle in einem compilierten Programm nicht ablauffhig sind. Weiterhin wird die Ausfhrung der Befehle einer Erweiterung durch das Compilieren nicht beschleunigt, da das compilierte Programm zur Ausfhrung dieser Befehle auf die Routinen des Interpreters zurckgreifen mu. Beschleunigt werden lediglich die Befehle des eingebauten Commodore-Basic.
Bei Beachtung folgender Regeln knnen Sie auch bei Programmen, die Befehle einer Erweiterung benutzen, die von BASIC 64 gewohnten Geschwindigkeiten erreichen:

- Benutzen Sie sowenig Erweiterungsbefehle wie mglich.

- Benutzen Sie Erweiterungsbefehle nur in Programmteilen, die nicht zeitkritisch sind.

- Benutzen Sie Grafiken zur Darstellung des Rechenergebnisses und nicht whrend der Berechnung.

- Benutzen Sie statt mehrerer Einzelbefehle einen komplexeren Befehl. Das Zeichnen einer Linie mit einem Befehl ist z.B. schneller als die Aneinanderreihung von Punkten fr denselben Zweck.

- Immer wenn sich Befehle einer Erweiterung durch normale Basic-Befehle ersetzen lassen, sollte dies auch getan werden. Dies gilt besonders fr Zeichenkettenfunktionen. Komplexe Zeichenkettenformeln im normalen Basic arbeiten schneller als die entsprechenden Einzelbefehle einer Erweiterung, da der Compiler die entsprechenden Optimierungsmglichkeiten besitzt.

- Grafikbefehle verwenden als Koordinatenangaben nur ganze Zahlen. Die Berechnung von Koordinaten und hnlichem sollte also mglichst mit Integer-Variablen erfolgen.


5.7 Andere Erweiterungen

Sollten Sie eine hier nicht erwhnte Basic-Erweiterung besitzen, so kann BASIC 64 in den meisten Fllen auch Befehle dieser Erweiterung compilieren. Sollte die Erweiterung berhaupt mit BASIC 64 zusammenarbeiten knnen, so gelten fr die Compilierbarkeit von Erweiterungen dieselben Kriterien, wie fr die anderen Erweiterungen auch. Im Einzelfall mu dies natrlich dann ausprobiert werden. Da der Compiler die verwendete Erweiterung nicht kennt, kann diese auch nicht ber die Taste "H" im Entwicklungspaket ausgewhlt werden. Es mssen dagegen alle Werte per Hand eingestellt werden. Der Compiler bentigt Speicherende, Anzahl der Bytes pro Befehl und den Code fr den ELSE-Befehl. Diese Werte mssen vor Start des Compilers festgestellt werden, soweit dies nicht im Handbuch der Erweiterung vermerkt ist.

*** Seite 31


Speicherende:

Folgender Befehl berechnet das Speicherende bei aktivierter Erweiterung:

PRINT PEEK(55)+256*PEEK(56)

Das Speicherende wird ber Punkt "E" eingestellt. Bytes pro Token:
Suchen Sie sich einen reprsentativen Befehl der Erweiterung und tippen Sie ein:

NEW

10 Befehl

Der Befehl mu vollkommen isoliert ohne Werteangaben stehen.

PRINT PEEK(2054)

Erhalten Sie einen Wert ungleich Null, so mssen Sie mit Punkt "I" zwei Bytes pro Token einstellen.

Else-Code:

Soweit Ihre Erweiterung einen ELSE-Befehl besitzt, mu dieser eingestellt werden:

NEW

10 ELSE

PRINT PEEK(2053)

Dieser Wert gibt das erste Byte des Befehls. Das zweite Byte ist nur ntig bei Erweiterungen mit zwei Byte pro Befehl:

PRINT PEEK(2054)

Diese Werte knnen ber Punkt "J" eingegeben werden.

Bei der Benutzung von ELSE mu vor diesen Befehl ein Doppelpunkt gestellt werden.


5.8. Verschiedene Versionen von Basic-Erweiterungen

Einige Befehle aus Basic-Erweiterungen sind nur teilweise implementiert, d.h. die Befehle arbeiten nicht in allen Fllen so, wie es das Handbuch der Erweiterung beschreibt. Hieraus knnen sich unter Umstnden Unterschiede zwischen dem Verhalten von compilierten und nichtcompilierten Befehlen ergeben. Dies trifft insbesondere dann zu, wenn nicht alle Parameter eines Befehles durch Variablen ersetzt werden drfen. Beispiele fr solche Befehle sind MOVE und TEXT im Simons' Basic, bei denen einige Parameter nur Konstanten sein drfen. Derartige Befehle verhalten sich nach dem Compilieren oder nach dem Einsetzen von Variablen fehlerhaft und sollten

*** Seite 32


nicht benutzt werden.

Es ist damit zu rechnen, da in spteren Versionen des Simon's Basic diese Befehle einwandfrei laufen. Mglicherweise sind in frheren Versionen von Basic-Erweiterungen weitere derartige Befehle enthalten.

*** Seite 33


6. Kapitel

Komplexe Programme

6.1 Compilieren von Overlay-Paketen

Im Basic des Commodore 64 existiert die Mglichkeit, mit Hilfe des Befehles LOAD ein Programm zu laden und zu starten, wobei alle bisherigen Variableninhalte erhalten bleiben. Diese Version des Befehles LOAD wird immer dann ausgefhrt, wenn der Befehl innerhalb eines Programmen verwendet wird. Hierbei ergeben sich bei Verwendung des Interpreters allerdings folgende Einschrnkungen:
- Zeichenkettenvariablen, die eine im Programm abgelegte Zeichenkette enthalten, gehen durch das berladen des Programmen verloren, z.B. bei:

10 DATA "TEST"
20 READ A$
30 B$= "KETTE"
40 LOAD"OVERLAY,8

Das in Zeile 40 geladene und gestartete Programm mit dem Namen "OVERLAY" kann auf die Variableninhalte von A$ und B$ nicht zugreifen, diese sind verloren.

- Das aufrufende Programm mu lnger sein, als das aufgerufene, da der Interpreter das aufgerufene Programm sonst verkrzt. Dies hat zur Folge, da bei Overlaypaketen das zuerst geladene Programm auch das lngste sein mu. Dies ist meistens nicht der Fall, aus diesem Grund wird von Basic-Programmierern oft ein Trick angewandt, mit dem das erste Programm sich selber vergrert. Dabei werden die Speicherstellen 45 und 46 mit POKE gendert und mit CLR die Variablentabelle neu angelegt.

Beim Compilieren von Programmen, die den Overlay-Mechanismus benutzen, ist zu beachten, da diese Programme nicht auf die gewohnte Art compiliert werden knnen:

Zum Compilieren eines Programmen aus dem Paket bentigt der Compiler eine Symbol-Tabelle, in der alle benutzten Variablen des Programmpaketes und deren Speicherbelegung aufgefhrt sind. Zum Erstellen dieser Symboltabelle dient der Overlay-Pass 1 (nicht zu verwechseln mit dem Compiler-Pass 1).

Overlay-Pass 1:

Compilieren Sie alle Programme des Programmpaketes einzeln. Vor dem Start des eigentlichen Compilers mit "1" oder "2" ist die Taste "4" (Overlay) und danach "1" (Pass 1) zu drcken. Der Compiler erzeugt nun kein fertiges Programm, weshalb er auch schneller arbeitet, es wird lediglich die Tabelle der Variablen generiert und nach jedem Compilerdurchlauf vervollstndigt.

*** Seite 34


Nachdem die Tabelle vollstndig ist, knnen nun die Programme des Overlay-Paketes compiliert werden. Hierzu dient der Overlay-Pass 2.

Overlay-Pass 2:

Compilieren Sie alle Programme des Paketes, drcken Sie aber vor dem Compilieren die Taste "4" (Overlay) und "2" (Pass 2). Der Compiler ldt nun vor dem Compilieren die entsprechende Overlay-Tabelle. Alle Mglichkeiten des Entwicklungspaketes (Men-Punkt 3) lassen sich weiterhin benutzen. Nachdem alle Programme mit Overlay-Pass 2 compiliert wurden, kann das Paket gestartet werden.

Beim Compilieren von Overlay-Paketen ist weiterhin folgendes zu beachten:

- Die compilierten Programme mssen natrlich noch auf die richtigen Namen umbenannt werden, da der Compiler vor den Namen von compilierten Programmen ein "P-" bzw. "M-" hngt.

- Programme drfen ihre Lnge nicht mit den bereits erwhnten POKE-Befehlen selber einstellen. Dies ist bei compilierten Programmen nicht nur unntig (der Compiler bernimmt dies), sondern sogar unsinnig, da compilierte Programme meistens eine andere Lnge besitzen, als das Original. Derartige POKE-Befehle sollten also vor dem Compilieren entfernt werden.

- Konstante Zeichenketten werden nicht im Programm gespeichert und bleiben nach dem Laden eines anderen Programmes erhalten (anders als beim Interpreter). Dies kann mit Menpunkt "L" auch wieder abgeschaltet werden.

- Sollen grere Overlaypakete compiliert werden, so mssen die Einzelprogramme auf mehrere Disketten verteilt werden, da die compilierten Programme ja ebenfalls Diskettenplatz bentigen. Der Compiler ldt die Overlaytabelle bereits vor der Eingabe des Programmnamens, die Tabelle kann dadurch von einer anderen Diskette als das zu compilierende Programm geladen werden. Wichtig ist dabei nur, da in Overlay-Pass 1 die jeweils zuletzt generierte Tabelle geladen wird (letzter Compilerdurchlauf) und in Overlay-Pass 2 ist immer die letzte in Overlay-Pass 1 generierte Tabelle zu laden.

- Der Compiler speichert die Overlay-Tabelle mit dem Namen "S-OVERLAY" auf Diskette ab. Diese Tabelle mu gelscht werden, wenn ein neues Overlay-Paket compiliert werden soll, da diese Tabelle ansonsten als Grundtabelle fr das neue Paket benutzt wird.

- Mit dem Menpunkt "M" kann ein Befehl an die Floppy gesendet werden. Auf diese Weise knnen Sie z.B. bereits compilierte Programme lschen (natrlich nur bei Programmen, von denen Kopien existieren), um Platz auf der Diskette zu schaffen. Nach der Ausfhrung des Befehles wird die Meldung der Floppy angezeigt und mu mit der "Return"-Taste besttigt werden.

*** Seite 35


6.2 Fehlerbehandlung

Ein compiliertes Programm gibt dieselben Fehlermeldungen aus, wie dies der Basic-Interpreter tun wrde. Natrlich kann nach einer Fehlermeldung das Programm nicht mit GOTO fortgesetzt werden und die vom Programm erarbeiteten Daten sind verloren (Maschinencodeprogramme kann man mit SYS weiterarbeiten lassen, siehe Kapitel 8). Viele Fehlermeldungen lassen sich auch nicht durch Programmnderung vermeiden. So ist es z.B. nicht mglich, festzustellen, ob ein Drucker angeschlossen ist oder ob ein Rechenergebnis einen Wartebereich berschreitet, ohne da die entsprechende Meldung ausgegeben wird. Aus diesem Grund verfgt BASIC 64 ber die Mglichkeit, zu einer bestimmten Basic-Zeile zu verzweigen, anstatt eine Fehlermeldung auszugeben. Die gewnschte Zeile kann mit Punkt "K" im Entwicklungspaket eingestellt werden. Besser ist eine entsprechende Compiler-Anweisung, da dadurch die entsprechende Zeilennummer auch innerhalb eines Programmas angegeben und gendert werder, kann. Die Zeilennummer Null steht hierbei fr das Abschalten der Fehlerbehandlung. Beim nchsten Fehler wird dann eine Meldung ausgegeben. Ein typisches Anwendungsbeispiel ist folgender Fall:

10 REM@ E1000
20 I=-10
30 PRINT 1/I
40 I=I+1:IF I<10THEN30
50 END
1000 PRINT "FEHLER":REM@ E0
1010 GOT040

Der Start einer Basic-Zeile bei Auftreten eines Fehlers hat noch weitere Wirkungen:

Alle FOR und GOSUB werden vom Stapel gelscht. Die zugehrigen Befehle NEXT und RETURN drfen nicht mehr ausgefhrt werden. Dies hat den Vorteil, da der Programmierer sich nicht mehr um die Beendung von Schleifen und Unterprogrammen kmmern mu, der Stapel kann durch vergessene GOSUB und FOR also nicht berlaufen.

Die Nummer des Fehlers wird vom compilierten Programm in der Speicherzelle 700 vermerkt, sie kann dort vom Programm mit PEEK ausgelesen werden. Die Fehlernummer hat folgende Bedeutung:

Fehlermeldungen des Betriebssystems:

1 too many files
2 file open
3 file not open
4 file not found
5 device not present
6 not input file
7 not output file
8 missing filename

*** Seite 36


9 illegal device number

Basic-Fehlermeldungen:

10 Hext without for
11 syntax
12 return without gosub
13 out of data
14 illegal quantity
15 overflow
16 out of memory
17 undef'd Statement
18 bad subscript
19 redim'd array
20 division by zero
21 illegal direct
22 type mismatch
23 string too long
24 file data
25 formula too complex
26 can't continue
27 undef'd function
29 verify
29 load

Einige Fehlernummern treten nicht auf, da diese Fehler vom Compiler bereits gemeldet werden.
Das Drcken der STOP-RESTORE-Taste stellt ebenfalls einen Fehler dar und wird bei eingeschalteter Fehlerbehandlung ebenfalls abgefangen.
Das Abfangen von Fehlermeldungen funktioniert natrlich erst nach dem Compilieren.


6.3 Das Runtimemodul

Das Runtimemodul enthlt alle Routinen, die zur Ausfhrung des compilierten Programmes bentigt werden. Diese Routinen enthlt jedes compilierte Programm. Soll Diskettenplatz gespart werden, so knnen Sie die Generierung des Runtimemoduls abschalten (Menpunkt "G"). Beim aufeinanderfolgenden Laden von Programmen braucht nur das erste Programm ein Runtimemodul zu enthalten. Alle weiteren Programme mssen dann absolut mit LOAD"Name",8,1 geladen werden. Bei Overlay-Paketen kann dadurch Ladezeit und Diskettenplatz gespart werden. Ein einzelnes Runtimemodul erhalten Sie, wenn Sie folgendes Programm Compilieren:

10 REM

Runtimemodul und Programm knnen nun einzeln absolut geladen werden. Ein Programm ohne Runtimemodul ist nur lauffhig, wenn es absolut geladen wird und sich zuvor bereits ein Runtimemodul im Speicher befand.

6.4 Code-Start

Mit dem Men-Punkt "F" besteht die Mglichkeit, die

*** Seite 37


Startadresse eines compilierten Programmes zu erhhen. Der Compiler fgt dann zwischen Runtimemodul und Programmstart entsprechend freien Speicherplatz ein. Natrlich kann das Generieren eines Runtimemoduls auch abgeschaltet werden und das Modul separat geladen werden. Das Programm mu dann allerdings mit "SYS Startadresse" gestartet werden, da die Startadresse verschoben wurde. Eine sinnvolle Adresse fr den Code-Start ist die Adresse 16384. In diesem Fall steht der Speicherbereich von 8192 bis 16191 als Grafikspeicherplatz frei und der Bereich von 16192 bis 16383 kann fr Sprites benutzt werden.

Programme, die diesen Grafikspeicher benutzen knnen, sind auch mit dem Basic-Interpreter entwickelbar. Hierzu brauchen Sie nur den Interpreter anzuweisen, 
den Code-Start ebenfalls zu verlegen:

POKE 44,64:POKE 16384,0:NEW

Nun knnen Sie Ihr Grafik-Programm entwickeln, ausprobieren und anschlieend compilieren.


6.5 Unterbrechen von compilierten Programmen

Die Unterbrechung von compilierten Programmen mit der STOP-Taste ist nur selten mglich, z.B. bei der Verwendung von Basic-Erweiterungen oder von einigen Ein-Ausgabebefehlen. Eine Fortsetzung mit CONT ist nicht mglich. Soll verhindert werden, da ein Programm unterbrochen werden kann, so schaltet folgender Befehl die Stop-Taste ganz ab:

POKE 788,PEEK(788)+3

Das Drcken der Restore-Taste startet eine Routine in den ROM's des Commodore 64. Da das compilierte Programm diese ROM's zeitweise nicht benutzt und abschaltet, kann das Drcken der Stop-Restore-Taste in seltenen Fllen wirkungslos bleiben und eine weitere Programmausfhrung verhindern. Dies gilt besonders bei der Verwendung von Basic-Erweiterungen. Das Unterbrechen eines Programmes mit Restore kann abgefangen werden, indem dem Compiler eine Zeile angegeben wird, die bei Drcken der Restore-Taste ausgefhrt wird (Menpunkt "K" - Fehlerbehandlung).

*** Seite 38


7. Kapitel

Geschwingkeit

7.1 Die Optimierungsstufen

Normalerweise wird das Compilieren mit dem Punkt "1" bzw. der Return-Taste im Hauptmen gestartet. Es besteht allerdings die Mglichkeit, das Compilieren auch mit dem Punkt "2" zu starten, wie dies in Kapitel 2 bereits erwhnt wurde. Diese beiden Punkte unterscheiden sich lediglich in der Art, wie der Compiler das Programm optimiert.

Optimizer I:

Bei Wahl dieser Optimierungsstufe Werden alle mglichem Optimierungen und Programmvernderungen nur dann durchgefhrt, wenn es absolut sicher ist, da sich am Ablauf des Programmes dadurch nichts ndert. Die Optimierungsstufe 1
ist somit vollstndig kompatibel zum Basic-Interpreter.
Berechnungen mit Integer-Werten werden nur dann als ganzzahlige Operationen ausgefhrt, wenn sichergestellt ist, da als Ergebnis nur eine ganze Zahl im Integer-Wertebereich sinnvoll ist, dies ist aber bei den meisten Basic-Operationen der Fall.

Optimizer II:

Diese Optimierungsstufe besitzt mehrere wichtige Unterschiede zur Stufe 1 und zum Basic-Interpreter:

- Alle Variablen, mit Ausnahme der Zeichenkettenvariablen, werden als Integer-Variablen eingestuft, d.h. der Compiler nimmt an, da hinter jeder Variable ein "%"-Zeichen steht; das compilierte Programm arbeitet entsprechend schneller. Variablen-Felder werden dagegen mit dem richtigen Datentyp eingestuft.

- Die Division zweier Integer-Variablen oder Integer-Werte wird von. Optimierungsstufe 1 immer mit einer Gleitkommadivision ausgefhrt. Stufe 2 fhrt dagegen eine derartige Division als ganzzahlige Operation durch und vernachlssigt die Nachkommastellen, in seltenen Fllen fhrt dies zu einem Unterschied zum Interpreter. Meistens ist dies nicht der Fall, da bei Operationen mit Integer-Variablen keine Gleitkommaergebnisse gefragt sind. Eine Integer-Division ist wesentlich schneller als eine Gleitkommadivision.

- Die Funktion INT Wird von Stufe 2 nicht als Abschneiden der Nachkommastellen angesehen, sondern als eine Umwandlung in den Datentyp Integer. Die Weiterverarbeitung des entsprechenden Wertes in einer Formel wird mit Integer-Operationen geschehen. Ein Unterschied zum Interpreter ergibt sich dadurch, da die Funktion INT nicht mehr auf Werte anwendbar ist, die auerhalb des Integer-Bereiches liegen (-32768 bis 32767).

Die Optimierungsstufe 2 hat verschiedene Anwendungsgebiete.

*** Seite 39


Sie ist fr die folgende Art von Programmen gedacht:

- Programme, bei denen es wesentlich strker auf eine hohe Geschwindigkeit ankommt, als auf die Kompatibilitt zum Interpreter.

- Programme, bei denen von Anfang an klar ist, da alle Variablen nur Integer-Werte aufnehmen.

- Programme, bei denen nicht auf die Verwendung von Integer-Variablen geachtet wurde und bei denen dies nun der Compiler nachholen soll.

Folgendes Beispiel ist eine typische Anwendung der Optimierungsstufe 2:

10 A=INT(RND(1)*1000)

Die Variable A dient nur zur Aufnahme einer ganzen Zahl, trotzdem wird Gleitkommarechnung eingesetzt ( RND(1)*1000 ), zumindest diese Zeile des entsprechenden Programmen kann mit Optimierungsstufe 2 compiliert werden.

Programme, bei denen die Optimierungsstufe 2 nur dazu eingesetzt wird, um die Verwendung von Integer-Variablen dem Compiler zu berlassen, bentigen meist einige wenige Gleitkommavariablen. Da die Optimierungsstufe 2 diese nicht erkennt, ist es ntig, diese Variablen dem Compiler mit einer Compileranweisung mitzuteilen.

Anweisung:

REM@ R-Variable,Variable,...

Die aufgezhlten Variablen werden von Optimierungsstufe 2 als Gleitkommavariablen eingestuft.

Beispiel:

10 FOR I=1 TO 1000
20 A=SQR(I): PRINT A;
30 NEXT

Soll dieses Programm mit Optimizer II compiliert werden, so ist folgende Zeile einzufgen:

5 REM@ R=A

Die Optimierungsstufen knnen auch innerhalb eines Programmen gewechselt werden:

REM@ 01   ;schaltet auf Stufe 1
REM@ 02   ;schaltet auf Stufe 2

Das Umschalten der Optimierungsstufe hat nur einen Einflu auf den Datentyp von Variablen, wenn diese Variablen vor dem Umschalten noch nicht benutzt wurden.
Die Optimierungsstufe 2 hat keinen Einflu auf den Datentyp

*** Seite 40


von Feldern. Felder, die zur Aufnahme von ganzen Zahlen gedacht sind, sollten immer mit einem "%"-Zeichen gekennzeichnet werden, da der Basic-Interpreter dadurch sehr viel Speicherplatz spart. Dies macht das Ausprobieren eines solchen Programmes mit dem Interpreter meist erst mglich. Nach dem Compilieren ist der Speicherplatz fr Felder sowieso wesentlich grer.

Achtung!

Wenden Sie die Optimierungsstufe 2 nur bei Programmen an, die Sie selber entwickelt haben und bei denen Sie die Arbeitsweise des Programmes und die Verwendung von Datentypen aus diesem Grund kennen. Dies gilt auch fr alle anderen zustzlichen Mglichkeiten des Compilers gegenber dem Interpreter (z.B. Compileranweisungen).


7.2 P-Code (Speedcode) und Maschinensprache

Sehr groe Programme lassen sich meistens nicht vollstndig in Maschinensprache bersetzen, da ein Programm, das in Maschinencode bersetzt wurde, immer lnger ist als das Original. In greren Programmen gibt es natrlich auch zeitkritische Programme, bei denen eine bersetzung in Maschinensprache notwendig ist. Aus diesem Grund verfgt BASIC 64 ber die Mglichkeit, den Code-Generator whrend des Compilierens zu wechseln. Hierzu existieren zwei Compileranweisungen:

REM@ M

Diese Anweisung veranlat den Compiler, alle folgenden Programmzeilen in Maschinensprache zu bersetzen. Wird diese Programmzeile durchlaufen, so wird das entsprechende nachfolgende Maschinenprogramm gestartet.

REM@ P

Nach dieser Anweisung werden die folgenden Zeilen wieder in P-Code bersetzt. Beim Durchlaufen dieser Programmzeile wird der P-Code-Interpreter gestartet und die folgenden Befehle wieder interpretiert.

Diese beiden Compileranweisungen sollten Sie nur einsetzen, wenn Sie deren Wirkungsweise vollstndig verstanden haben. Beim Einsatz dieser Befehle ergeben  sich nmlich folgende Einschrnkungen:

- Der Mikroprozessor des Commodore 64 kann nur Maschinencode ausfhren und keinen P-Code.

- Der P-Code-Interpreter kann nur P-Code interpretieren und keine Maschinensprache.

Sollte der Code wechseln, ohne da eine entsprechende Umschaltstelle (Compileranweisung) durchlaufen wird, so ist das Verhalten des Programmes nicht vorhersagbar, auf keinen Fall arbeitet es korrekt weiter. Demzufolge drfen keine

*** Seite 41


Programmsprnge innerhalb eines Programmen erfolgen, die in einem Programmteil mit einem anderen Code enden. Programmsprnge fhren lediglich die Befehle GOTO, GOSUB, RETURN und meistens auch NEXT durch.

Das Umschalten des Code-Generators kann in blockstrukturierten Programmen gefahrlos an Anfang und Ende eines Blockes erfolgen. Ein Programmblock ist dadurch gekennzeichnet, da in ihn weder hineingesprungen noch aus ihm hinausgesprungen wird. Er wird an seinem Anfang gestartet und an seinem Ende wieder verlassen. Grere Programme sind meistens blockstrukturiert, ein teilweises Umschalten auf Maschinensprache ist also mglich. Bei Programmen, die weder blockstrukturiert sind noch irgend eine andere erkennbare Struktur besitzen, sollte auf das Umschalten des Code-Generators innerhalb des Programmes verzichtet werden.

Besonders sinnvoll und einfach ist das Umschalten des Code-Generators bei Unterprogrammen. Ein derartiges Unterprogramm knnte z.B. folgende allgemeine Form haben:

1000 REM@ M
...
1980 REM@ P
1990 RETURN

Die Zeilen von 1001 bis 1979 werden bei diesem Beispiel vom Compiler in Maschinencode bersetzt. Das Unterprogramm darf nur mit GOSUB1000 gestartet werden und nur mit dem Durchlaufen der Zeilen 1980 und 1990 wieder verlassen werden (notfalls mit GOT01980). Bei strukturierten Programmen ist dies sowieso der Fall. Soll innerhalb des Unterprogrammes ein anderes Unterprogramm aufgerufen werden, so ist zuvor der Code-Generator wieder umzuschalten. Im Beispielprogramm wrde dies so aussehen:

1500 REM@ P
1510 GOSUB5000
1520 REM@ M

Hierbei ist es natrlich egal, welchen Code-Typ das aufgerufene Unterprogramm besitzt, solange wenigstens die erste Zeile (mit der Compileranweisung) in P-Code bersetzt wurde. Meistens rufen zeitkritische Unterprogramme keine weiteren Unterprogramme auf.


7.3 Integer-Wertebereich beim Poke-Befehl

Die vielen Mglichkeiten des Commodore 64 sind in Basic nur mit Hilfe der Befehle PEEK und POKE nutzbar. Diese Befehle sollten also mglichst schnell ausgefhrt werden. Der Einsatz von Integer-Variablen ist in Kombination mit dem POKE-Befehl natrlich besonders sinnvoll, da Speicheradressen durch ganze Zahlen dargestellt werden. Es gibt genau 65536 verschiedene Speicheradressen im Commodore 64 (0-65535) und eine Integer-Variable kann	ebenfalls 65536 verschiedene Zahlenwerte enthalten (-32768 bis 32767). Leider sind die entsprechenden Zahlenbereiche nicht identisch. Fr

*** Seite 42


Speicheradressen ber 32767 mssen somit Gleitkommawerte und Gleitkommavariablen benutzt werden. In Verbindung mit dem POKE-Befehl besitzt der Compiler die Mglichkeit, Integer-Operationen auch fr Werte ber 32767 auszufhren, allerdings unter Verzicht auf die negativen Zahlen. Der Benutzer des Compilers bemerkt dies nur durch eine hhere Programmgeschwindigkeit.

5 REM@I=I
10 FOR I=1024 TO 2023
20 POKE I,65
30 POKE I+54272,0
40 NEXT

Schneller wird das Programm nun durch folgende nderung:

6 OF%=30000
30 POKE I+OF%+24272,0

Diese nderung bewirkt, da nur noch Integer-Werte verarbeitet werden und da eine Gleitkommaaddition zu zwei Integer-Additionen wird. Derartige Tricks sollten allerdings nur an extrem zeitkritischen Programmstellen angewendet werden.

*** Seite 43


8. Kapitel

Speicheradressen und Maschinensprache

Dieses Kapitel sollten Sie unbedingt durchlesen, wenn Ihre Basic-Programme mit Assembler-Programmen zusammenarbeiten sollen oder wenn Sie in Ihren Programmen viele POKE-Befehle benutzen.


8.1 Speicherbelegung

Die Speicherbelegung von compilierten Programmen ergibt sich aus den vom Compiler ausgegebenen Werten:

0 - 1024                      Systemspeicher
1024 - 2023                   Bildschirmspeicher
2048 - Codestart              Runtimemodul
Codestart - Stringsanfang     Programm-Code
Stringsanfang - Stringsende   Freier Speicher fr Zeichenketten
Stringsende - Memory-Top      Speicher fr Variablen und Felder

Das compilierte Programm legt die benutzten Variablen in der folgenden Form ab:
Integer-Variablen:

2 Bytes: low Byte, high Byte

Gleitkomma-Variablen:

5 Bytes: Exponent, 4-Byte Mantisse

Zeichenketten-Variablen:

3 Bytes: Lnge, Adresse der Zeichenkette low Byte, Adresse high Byte

Zeichenketten:

2 Bytes plus 1 Byte pro Zeichen

Ein Assemblerprogramm kann die Inhalte der Variablen ndern. Die Adressen der Variablen erhlt man ber die Symbol-Tabellen. Bei Zeichenketten darf weder die Lage der Zeichenkette noch deren Lnge von einem Assemblerprogramm
gendert werden, dies kann nur das compilierte Basic-Programm.


8.2 Speicheradressen

Bei der Verwendung von POKE- und PEEK-Befehlen ist darauf zu achten, da das compilierte Programm einige Speicherzellen anders benutzt als der Interpreter. Fr die Verwendbarkeit von Poke-Befehlen gilt folgendes%

*** Seite 44


- Der Bereich von 53248 bis 57343 ($D000-$DFFF) ist wie beim Basic-Interpreter ansprechbar.

- Der Bildschirmspeicher liegt weiterhin von 1024-2023.

- Alle Speicherstellen von 144 bis 828, die vom Betriebssystem benutzt werden, behalten ihre Funktion (Tastaturpuffer, gedrckte Taste, IO-Vektoren, etc.).

nderungen ergeben sich lediglich bei folgenden Speicherzellen:

Der Cassettenpuffer wird vom compilierten Programm benutzt. Soll der Cassettenpuffer z.B. fr Sprites benutzt werden, so kann er mit einer Compileranweisung freigegeben werden:

REM@ S Adresse

Der Cassettenpuffer wird nun unterhalb dieser Adresse vom compilierten Programm nicht benutzt. Zur Freigabe des gesamten Puffers dient folgender Befehl:

REM@ S1024

Der Bereich von $2C0 bis $2FF wird bei der Verwendung von Basic-Erweiterungen mit Daten belegt, ansonsten ist dieser Bereich frei.

Speicherzellen, die der Basic-Interpreter zur Interpretation des Programmes benutzt, verlieren ihre Bedeutung teilweise. Erhalten bleiben nur die Speicherzellen, die sich normalerweise mit POKE-Befehlen sinnvoll benutzen lassen. Hierzu gehren:

- Gleitkommaregister
- Zufallszahl
- Chrget-Routine
- Statuswort ST
- RND-Wert
- Zeiger auf Programmstart (43-44)
- Zeiger Auf Programmende (45-46)
- Zeiger auf Beginn des Stringstapels (51-52)
- Zeiger auf nchstes DATA-Element (65-66)

So ist es z.B. mglich, das Programmende (45-46) zu erhhen und in dem freigewordenen Bereich Assembler-Programme, Daten oder compilierte Basic-Programme mit verschobenem Code-Start zu speichern.

Bei der Verwendung von Adressenspeicher (2-Bytes) ist darauf zu achten, da in diesen Speicherzellen mglicherweise andere Adressen gespeichert werden, als bei Verwendung des Interpreters. Dies gilt besonders fr die Speicherverwaltung (43-56) und fr die Fehlerbehandlung (768-769).

Eine neue Bedeutung bekommt die Speicherstelle 64, sie wird fr den Strukturstapelzeiger benutzt:

10 A%=PEEK(64):REM Stapelzustand merken

*** Seite 45


20 FORI=ITO1000
30 POKE64,A%:REM Stapelzustand wiederherstellen
40 NEXT:REM ergibt NEXT WITHOUT FOR

Der Bereich von $A000-$FFFF wird vom compilierten Programm normalerweise mit Variablen belegt. Die ROMs von $A000-$BFFF und $E000-$FFFF sind trotzdem zugreifbar. Soll im Bereich von $C000-$CFFF ein Maschinenprogramm, ein Zeichengenerator, etc. gespeichert werden, so kann die niedrigste vom compilierten Programm nicht mehr zu benutzende Adresse dem Compiler als Speicherende mitgeteilt werden. Dies geschieht ber Menpunkt "E". Zur Freigabe des Bereichs ab $C000 mte der Wert fr Memory-Top auf 49152 gesetzt werden.


8.3 Spezielle Befehle

SYS:

Oft wird der Befehl SYS in der folgenden Form benutzt:

SYS Adresse,Wert,Wert...

Obwohl der Basic-Interpreter die nachfolgenden Werte nicht berechnet, meldet er keinen Fehler, wenn das aufgerufene Assemblerprogramm dies macht. Eine derartige Erweiterung des SYS-Befehls wird vom Compiler wie eine Basic-Erweiterung behandelt. Es gilt das in Kapitel 6 zur Compilierbarkeit von beliebigen Basic-Erweiterungen Gesagte.

STOP:

Dieser Befehl bewirkt ein Beenden des compilierten Programmes. hnlich wie bei der Ausgabe einer Fehlermeldung kann der Befehl CONT nicht benutzt werden. Bei der Unterbrechung mit STOP oder durch eine Fehlermeldung wird eine Speicheradresse ausgegeben. Handelt es sich bei dem compilierten Programm um Maschinencode, so kann an dieser Speicheradresse das Programm mit SYS fortgesetzt werden. Eine Erhaltung aller Daten und ein Weiterlaufen des Programmes ist allerdings nicht immer garantiert, insbesondere bei echten Fehlermeldungen.

LOAD:

Der Befehl LOAD besitzt in compilierten Programmen eine weitere Mglichkeit:

LOAD"Name",8,128

Die entsprechende Datei wird in den Speicher an die Stelle geladen, von der sie abgespeichert wurde (z.B. mit einem Maschinensprachemonitor). Im Gegensatz zum Laden mit ",8,1" wird das Programm nicht neu gestartet, sondern nach dem LOAD-Befehl fortgesetzt. Dies ist besonders ntzlich zum Laden von Assemblerprogrammen, Grafiken, etc.

*** Seite 46


8.4 Symbol-Tabellen als Schnittstelle zu Profimat

BASIC 64 verfgt ber die Mglichkeit, Symboltabellen zu laden und abzuspeichern. In einer Symboltabelle sind alle Variablen eines Programmes aufgefhrt und die Adressen genannt, an denen sie abgelegt sind. Die Symboltabellen selbst werden in der Form abgespeichert, wie sie der Compiler intern verarbeitet.

Abspeichern einer Symboltabelle:

Zum Abspeichern einer Symboltabelle braucht dem Compiler nur ein Name fr die Tabelle genannt zu werden. Dies geschieht ber Menpunkt "C". Der Name "OVERLAY" ist fr Overlaysymboltabellen reserviert. Das Abspeichern einer Symboltabelle  erfolgt nach dem Compilieren.

Laden einer Symboltabelle:

Mit Menpunkt "B" kann der Name einer zu ladenden Symboltabelle angegeben werden. Das Laden der Tabelle geschieht vor dem Compilieren. Alle in der Symboltabelle genannten Variablen und Speicheradressen werden bernommen. Dies ist ntzlich, wenn mehrere Programme auf gemeinsame Variablen zugreifen sollen, z.B. um dieselben Assemblerprogramme benutzen zu knnen. Beim Compilieren von Overlay-Paketen macht der Compiler hiervon Gebrauch.

Verarbeitung einer Symboltabelle:

Auf der BASIC 64 Diskette befindet sich das Programm SYMBOL. Nach dem Laden und Starten des Programmes fragt dieses nach dem Dateinamen der Symboltabelle. Nach der Eingabe des Namens knnen Sie zwischen zwei Mglichkeiten whlen.

Das Drcken der Taste "1" veranlat das Programm dazu, die Symboltabelle in das Format des Assemblers Profi-Ass umzuwandeln. Der Name der umgeformten Symboltabelle ist identisch mit dem Namen der vom Compiler erzeugten Tabelle. trotzdem wird die alte Tabelle nicht gelscht, da der Compiler ein "S-" vor den Namen der Tabelle gehngt hat. Dieses braucht nicht beachtet zu werden. Der Assembler Profi-Ass kann Symbol-Tabellen mit dem Pseudo-Opcode ".LST" laden (siehe Profi-Ass-Handbuch). Die Namen der Variablen kann ein Assemblerprogramm nun benutzen, als ob sie im Programm definiert wren. Dadurch ist es mglich, da ein assembliertes Programm auf Variablen eines compilierten Programmes zugreift. Zur Unterscheidung der einzelnen Datentypen untereinander und zu Symbolen des jeweiligen Assemblerprogrammes formt das Programm Symbol die Namen von Variablen um, im folgenden Beispiel steht "na" fr die ersten beiden Bytes des Variablennamens:

Einzelvariablen

na   - na
na%  - naIN
na$  - naST

*** Seite 47


Felder:

na   - ARna
na   - ARnaIN
na   - ARnaST

Die Darstellung ist nicht abhngig von der Optimierungsstufe. Sie wird direkt aus dem Variablennamen abgeleitet. Folgender Ausschnitt aus einem Assemblerprogramm vertauscht zwei Basic-Integer-Variablen:

100 LST 8,2,"Name,S,R"
110 ...
1000 LDA AIN
1010 LDX BIN
1020 STX AIN
1030 STA BIN
1040 LDA AIN+1
1050 LDX BIN+1
1060 STX AIN+1
1070 STA BIN+1
1080 ...

Dies entspricht ungefhr folgendem Basic-Programm:

100 H%=A%:A%=B%:B%=H%
110 ...

Sollten Sie keinen Assembler besitzen, so knnen Sie die Symboltabellen trotzdem verarbeiten. Drcken Sie dazu nach Start des Programmen Symbol und Eingabe des Filenamens die Taste "2" zur Ausgabe eines Listings. Das Programm fragt nun nach der Gertenummer, unter der das Listing ausgegeben werden soll. Sinnvoll sind folgende Gerte-Adressen:

0 = Device 0 = Bildschirm
4 = Device 4 = Drucker
8 = Device 8 = Sequentielle Datei auf der Floppy.

Das Programm gibt nun die Namen der Variablen, gefolgt von der Speicheradresse, aus.


8.5 Zugriff auf Speicherbnke

Der Commodore 64 besitzt 64K Ram und 20K ROM sowie einige weitere Speicherzellen (Register, Farbspeicher, etc.). Mit dem Basic-Befehl POKE bzw. PEEK sind dagegen nur 64K Speicheradressen zugnglich. Allerdings	lt sich die Aufteilung dieses Speicherbereiches umschalten:

POKE 1,52   ;Der gesamte Speicher wird auf RAM geschaltet,
der Bereich von $A000 - SFFFF ist dadurch zugreifbar.

POKE 1,51   ;Der Zeichengenerator ist im Bereich von $D000-$DFFF zugreifbar.

POKE 1,55   ;Stellt den Einschaltzustand wieder her.

*** Seite 48


Normalerweise mu in der Speicherzelle 1 immer der Wert 55 stehen, da der Basic-Interpreter sonst abgeschaltet wre und dadurch nicht arbeiten knnte. Compilierte Programme knnen dagegen auch ohne Basic-ROMs laufen. Dabei sind einige Einschrnkungen zu beachten:

- Vor dem ndern der Speicherzelle 1 mu der Interrupt abgeschaltet werden. Dies geschieht mit:

POKE 56334,PEEK(56334)AND254

Nachdem in die Speicherzelle 1 wieder der Wert 55 gePOKEd wurde, sollte der Interrupt wieder eingeschaltet werden:

POKE 56334,PEEK(56334)0R1

- Whrend die Speicherzelle 1 einen anderen Wert als 55 enthlt, drfen keine Ein-Ausgabebefehle benutzt werden.

- Weiterhin drfen in dieser Zeit keine Gleitkommaoperationen durchgefhrt werden, es ist also mit Integer-Variablen und Integer-Werten zu arbeiten. Beachten Sie, da POKE-Adressen ber 32767 nicht direkt mit Integer-Variablen ansprechbar sind (Kapitel 7).

Durch die Zugriffsmglichkeit auf den Zeichengenerator kann dieser z.B. kopiert und danach verndert werden. Der Speicherbereich von $E000-$FFFF knnte z.B. fr  Grafik benutzt werden und vieles mehr. Bei der Benutzung von Speicher ist dies dem Compiler mitzuteilen, indem das Speicherende herabgesetzt wird.

*** Seite 49


9. Kapitel

9.1 bersicht ber die Mglichkeiten von BASIC 64 und deren Anwendung

Optimierungsstufe 1:

Durch Drcken der Taste "1" im Hauptmen oder durch "Return" starten Sie den Compiler mit der Optimierungsstufe 1. Diese Stufe ist vollstndig kompatibel zum Basic-Interpreter V2.0. Alle durchgefhrten Programmoptimierungen verndern in keinem Fall den Ablauf oder das Verhalten des Programmas und dienen nur dem Erreichen einer hheren Geschwindigkeit. Um in Stufe 1 die Geschwindigkeit von Berechnungen mit ganzen Zahlen (INTEGER) nutzen zu knnen, mssen Variablen, die nur ganze Zahlen aufnehmen sollen, entsprechend gekennzeichnet werden. Im Commodore-Basic geschieht dies durch Anhngen eines Prozentzeichens (%) an den Programmnamen.

Optimierungsstufe 2:

Die Stufe 2 wird durch Drcken der Taste "2" gewhlt und startet ebenfalls den Compiler. Sie unterscheidet sich von der Stufe 1 dadurch, da alle Variablen als Integer-Variablen angesehen werden, auch bei Variablen, bei denen dies der Basic-Interpreter nicht macht. Sollten trotzdem einige Variablen Nachkommastellen aufnehmen mssen, so sind diese mit einer entsprechenden Compileranweisung zu kennzeichnen.
Weiterhin fhrt die Stufe 2 Optimierungen mit der Integer-Division und der Integer-Umwandlung (INT) durch, die nicht in allen Fllen kompatibel zum Interpreter sind.

Das Einstellen von Compilerparametern:

Bei Start des Compilers mit den Tasten "1" oder "2" besitzt der Compiler eine Liste von Werten und Anweisungen, die er zum Compilieren bentigt. Um diese Liste anzuzeigen, drcken Sie im Hauptmen die Taste "3". Auf dem Bildschirm erscheint nun die Liste. Diese knnen Sie nun ndern und danach mit "Return" wieder ins Hauptmen gelangen. Vor die einzelnen Punkte der Auflistung sind Buchstaben gestellt, die Sie nur zu drcken brauchen, um einen Punkt zu ndern:

Punkt "A" - Code Generator:

Der Compiler kann wahlweise P-Code, Maschinensprache (6502/6510) oder gar keinen Code erzeugen. Maschinenprogramme erhalten ein "M-" vor den Namen, andere Programme ein "P-". Die	vom Compiler vorgegebene Einstellung ist der P-Code-Generator.

Punkt "B" - Laden von Symboltabellen:

Hiermit kann der Compiler eine Variablenliste laden, die beim Compilieren eines anderen Pragrammes abgespeichert wurde. Dies hat zur Folge, da beide Programme dieselben Adressen fr die entsprechenden Variablen benutzen. (Overlay-Pakete und hnliche Anwendungen)

*** Seite 50


Punkt "C" - Abspeichern von Symboltabellen:

Abgespeicherte Symboltabellen knnen beim Compilieren von anderen Programmen geladen oder vom Assembler Profi-Ass zur Addressenbelegung von Labels benutzt werden. Dies ist ntzlich, wenn ein Basic-Programm mit SYS Unterprogramme in Maschinensprache aufruft.

Punkt "D" - Generieren einer Zeilenliste:

Nach Compilieren eines Programes speichert der Compiler wahlweise eine Zeilenliste des Programmes ab. Diese Liste kann mit LOAD"Z-Programmname" geladen und mit LIST gelistet werden. Jeder Basic-Zeile (rechte Seite) ist eine Speicheradresse (linke Seite) zugeordnet (fr Fehlermeldungen oder Start eines Programmteiles mit SYS).

Punkt "E" - Speicherende:

Dieser Wert gibt die erste nicht verfgbare Speicheradresse an. Da der Commodore 64 ber 64 K Ram verfgt, benutzt der Compiler als Speicherende den Wert 65536. Sie knnen diesen Wert aber auch herabsetzen, wenn Sie Speicher fr Maschinenprogramme, Basic-Erweiterungen, etc. bentigen. Der Basic-Interpreter benutzt als Speicherende brigens den Wert 40960, wodurch 24576 Bytes ungenutzt bleiben.

Punkt "F" - Code Start:

Der generierte Code wird normalerweise vom Compiler direkt hinter das Runtimemodul gelegt. Sie knnen diesen Wert aber auch heraufsetzen, um nach dem Runtimemodul andere Daten zu speichern oder gar mehrere Programme im Speicher unterzubringen. Derartig verschobene Programme knnen nicht mit RUN gestartet werden, sondern mit SYS Startadresse, da RUN nur das erste Programm im Speicher startet.

Punkt "G" - Generieren eines Runtimemoduls:

Sie knnen.das automatische Einbinden des Runtimemoduls (5K) abschalten und dann Modul und Programm einzeln von Diskette laden. Dies spart Diskettenplatz und bei Overlaypaketen Ladezeit.

Punkt "H" - Einstellen der verwendeten Basic-Erweiterung:

Zur Auswahl stehen die Basic-Erweiterungen Supergrafik 64 Plus, Supergrafik 64, Simons' Basic, Exbasic Level II und Disk-Basic (Basic 4.0 enthalten in Master 64 und Diskomat). Alle weiteren notwendigen Parameter stellen sich dann automatisch ein. Sollten Sie eine andere Basic-Erweiterung besitzen, so stellen Sie "others" ein und whlen Sie die brigen Parameter selbst.

Punkt "I" - Anzahl der Bytes pro erweitertem Basic-Befehl:

Auer dem Simons' Basic verwenden alle Erweiterungen ein Byte. Dieser Punkt wird aber automatisch eingestellt.

*** Seite 51


Punkt "J" - Code fr den Befehl ELSE:

In vielen Erweiterungen ist der wichtige Befehl ELSE vorhanden. Der Compiler mu den Code fr diesen Befehl kennen. Dieser Wert wird automatisch eingestellt.

Punkt "K" - Fehlerabbruch-Zeile:

Bei Auftreten eines Fehlers in einem Basic-Programm whrend der Laufzeit wird normalerweise eine entsprechende Meldung ausgegeben. Sie knnen dies abschalten, indem Sie dem Compiler mitteilen, welche Zeile bei Auftreten eines Fehlers ausgefhrt werden soll. Zeile 0 bedeutet Ausgabe einer Meldung.

Punkt "L" - Overlay-Verhalten:

Der Basic-Interpreter speichert Zeichenkettenkonstanten direkt im Programm. Bei Overlay-Paketen ist dies sehr strend. Damit das compilierte Programm sich anders verhlt, knnen Sie dies dem Compiler mitteilen.

Punkt "M" - Befehlskanal der Floppy:

Mit Hilfe dieses Punktes knnen Sie Befehle an die Floppy senden und die Fehlermeldung auslesen, welche mit "Return" besttigt werden mu.

Compilieren von Overlayprogrammen:

Programme, die sich gegenseitig laden und starten, sollen meistens auch dieselben Variablen bzw. deren Inhalt benutzen. In Basic wird eine entsprechende Speicherverwaltung normalerweise mit Hilfe von Poke-Befehlen erreicht. Bei compilierten Programmen bernimmt der Compiler diese Aufgabe.
Das Compilieren von Overlay-Paketen geschieht in zwei Durchgngen:

Durchgang 1:

Compilieren Sie alle Programme des Overlay-Paketes. Drcken Sie dabei gleich nach der Aktivierung des Compilers "4" (Overlay) und danach "l" (Durchgang 1). Beim Durchgang 1 wird kein Programm erzeugt, sondern nur eine Tabelle, der Durchgang 1 ist deswegen relativ schnell beendet.

Durchgang 2:

Compilieren Sie nun alle Programme nochmals, wobei Sie diesmal "4" und "2" (Durchgang 2) drcken. Der Compiler generiert nun das gewnschte Programm, wobei Sie mit Hilfe der Taste "3" im Hauptmen evtl. Parameter verndern knnen.

Sollte der Diskettenspeicherplatz nicht ausreichen, so knnen Sie natrlich auch die Originalprogramme jeweils nach deren Compilierung lschen (Punkt "M" im Untermen).
Um ein Overlaypaket zu starten, mssen natrlich noch die Namen der compilierten Programme so gendert werden, da die

*** Seite 52


Programme sich gegenseitig laden knnen.


Compileranweisungen:

Oft ist es ntig, auch whrend der Compilierung noch Einflu auf den Compiler zu nehmen. Dies geschieht mit Hilfe von speziell gekennzeichneten REM-Anweisungen innerhalb des Programmes:

Umschalten auf Generieren eines Maschinencodes: Format:

REM@ M

Wirkung:

Der Compiler erzeugt ab sofort Maschinensprache. Auerdem wird in das Programm eine Anweisung eingefgt, welche whrend der Laufzeit dem P-Code-Interpreter mitteilt, da nun ein Maschinenprogramm folgt.

Zurckschalten auf P-Code: 

Format:

REM@ P

Wirkung:

Der Compiler generiert wieder P-Code. Zustzlich wird in das Programm ein Befehl eingefgt, welcher den P-Code-Interpreter aktiviert.

Ein- und Ausschalten von Fehlerbehandlung:

Format:

REM@ EZeilennummer

Wirkung:

Dies entspricht der Wirkung des Punktes "K" im Untermen des Compilers. Allerdings wird die Fehlerbehandlung erst aktiviert, wenn die entsprechende Zeile durchlaufen wird. Die Zeilennummer 0 schaltet wieder auf normale Fehlermeldungen. Diese Mglichkeit entspricht dem Befehl ON ERROR GOTO in einigen Basic-Erweiterungen, ist aber auch ohne Erweiterung einsetzbar.

Deklarieren von Integervariablen:

Format:

REM @I=Variable,Variable...

Alle genannten Variablen (Gleitkommavariablen ohne %-Zeichen)

*** Seite 53


werden vom Compiler als Integer-Variablen eingestuft, was eine schnellere Programmausfhrung zur Folge hat. Zustzlich kann man hiermit Integervariablen innerhalb von FOR-NEXT-Schleifen einsetzen, was der Basic-Interpreter normalerweise nicht zult. Dieser Befehl ist nur in Verbindung mit Optimierungsstufe 1 sinnvoll.

Deklarieren von Gleitkommavariablen:

Format:

REM@ R=Variable,Variable...

Alle genannten Variablen werden als	Gleitkommavariablen eingestuft, was	natrlich nur bei Anwendung von Optimierungsstufe 2 ntig ist.

Umschalten der Optimierungstufe:

Format:

REM@ OStufennummer

Wirkung:

Die Optimierungsstufe wird umgeschaltet. Dies hat nur Auswirkungen auf den Datentyp von Variablen, wenn diese im Programm bis zu dieser Stelle nicht erwhnt wurden.

Zuordnen von Variablenadressen:

Format:

REM @AVariable=Adresse

Wirkung:

Die Variable wird an die angegebene Adresse gelegt. So kann man z.B. eine Integervariable in ein Spritesteuerregister legen und das entsprechende Sprite damit extrem einfach und schnell steuern. Adressen unter 768 sind nicht erlaubt.

Freigabe des Bandpuffers:

Format:

REM@ SAdresse

Wirkung:

Der Compiler legt innerhalb des Bandpuffers automatisch alle Variablen ab, auf die besonders schnell und effektiv zugegriffen werden soll. Sie knnen diesen Bereich fr Ihre eigenen Zwecke benutzen, indem Sie die Adresse angeben, bis zu der Sie den Randpuffer bentigen.

Beispiel:

REM@ S1024

*** Seite 54


Dies gibt den Bandpuffer vollstndig frei.

Compilieren von Basic-Erweiterungen:

Obwohl Sie sich viele Basic-Erweiterungen durch Unterprogramme selber programmieren knnen, wo dies bisher aus Geschwindigkeitsgrnden nicht mglich war, so ist die Anwendung von neuen Basic-Befehlen natrlich wesentlich einfacher und bei Grafik-Befehlen auch meistens notwendig.

BASIC 64 ist in der Lage, die meisten Befehle aus beliebigen Basic-Erweiterungen zu compilieren und in das Programm einzubinden. Um ein Programm zu compilieren, das Befehle aus einer Basic-Erweiterung benutzt, brauchen Sie nur vor dem Starten des eigentlichen Compilierens mit dem Punkt "1" im Hauptmen folgendes auszufhren:

- Bei Laden des Compilers darf die Basic-Erweiterung nicht aktiviert sein (evtl. Computer aus-einschalten oder Modul ziehen).

- Whlen Sie das Untermen mit Hilfe der Taste "3" an.

- Drcken Sie so lange die Taste "H", bis die von Ihnen verwendete Basic-Erweiterung erscheint.

- Drcken Sie "Return".

- Starten Sie den Compiler mit "Return", "l" bzw. "2".

- Damit das compilierte Programm lauffhig ist, mu die Erweiterung aktiviert sein.

Bei der Verwendung von Befehlen aus Basic-Erweiterungen sind nicht alle Befehle mit der Speicher- und Programmorganisation des Compilers vertrglich. Es ist folgendes zu beachten:

Supergrafik 64 und Supergrafik 64 Plus:

Die meisten Befehle und Sekundrbefehle der Supergrafik werden untersttzt mit Ausnahme der folgenden Befehle:

SREAD, IF#, IRETURN und Programmierhilfen.

Zumindest die Befehle SREAD und IF# knnen leicht durch normale Basic-Befehle ersetzt werden. Programmierhilfen sind innerhalb von Basic-Programmen sowieso nicht einsetzbar und deswegen auch nicht compilierbar (Renumber, etc.).

Simons' Basic:

Die meisten Befehle und Funktionen werden untersttzt, mit Ausnahme von einigen Toolkitbefehlen und Programmstrukturen. Funktionen und alle sinnvoll in Programmen einsetzbaren Befehle, wie z.B. die Grafikbefehle,. werden untersttzt.

*** Seite 55


Exbasic Level II:

Wie bei allen anderen Erweiterungen werden keine Programmierhilfen und nicht alle Programmstrukturbefehle untersttzt. Trotzdem knnen die Toolkitbefehle natrlich zur Programmentwicklung eingesetzt werden.

Basic 4.0 (Master 64, Diskomat):

Diese Wahlmglichkeit ist fr Basic-Erweiterungen gedacht, die eine komplizierte Syntax und Tokenhandhabung besitzen. Um derartige Befehle verwenden zu knnen, mssen alle zu berechnenden Befehlsparameter in Klammern gesetzt werden, wie dies z.B. beim Basic 4.0 sowieso vorgeschrieben ist. Untersttzt werden Befehle des Basic 4.0.

Ausnutzung der vielfltigen Optimierungsmglichkeiten von BASIC 64:

Obwohl das Compilieren Ihr Programm wesentlich beschleunigt, lt sich die Geschwindigkeit von Programmen nochmals steigern, wenn man bereits beim Schreiben darauf achtet, welche Operationen nach dem Compilieren besondes schnell ausgefhrt werden. Meistens gengt aber	die Beachtung folgender Regeln, um eine hohe Geschwindigkeit zu erreichen:

- Erfahrungen, die Sie mit dem Basic-Interpreter bezglich der relativen Geschwindigkeit von einzelnen Operationen gemacht haben, gelten fr compilierte Programme nicht mehr.

- Operationen mit Integer-Variablen arbeiten wesentlich schneller als mit Gleitkommavariablen. Erfahrungsgem ist der Groteil aller Variablen in den meisten Programmen durch Integer-Variablen ersetzbar (Werte zwischen -32768 und +32767 ohne Nachkommastellen). Integer-Variablen knnen Interpreter und Compiler durch Anhngen eines "%"-Zeichens an den Namen angezeigt werden. Weiterhin kann man dem Compiler dies mit Hilfe von REM-Anweisungen oder mit der Optimierungsstufe 2 mitteilen.

Integer-Werte werden z.B. in folgenden Funktionen und Anwendungen ausschlielich benutzt:

Schleifenzhler, Felderindex, Poke, Peek, On, Wait, Dateiparameter bei Open, Sys, Tab, Spc, Fre, Zahlenparameter bei Zeichenkettenfunktionen, Asc, Chr$, logische Operationen, oft auch bei Vergleichen und und vielen weiteren Anwendungen.

In all diesen Fllen ist die Verwendung von Gleitkommavariablen unsinnig und langsamer. Bei Verwendung des Basic-Interpreters ist dies nicht sprbar, da dieser alle Berechnungen mit Gleitkommazahlen ausfhrt.

- Zeichenkettenoperationen werden von compilierten Programmen anders ausgefhrt als vom Interpreter. Dadurch sind besonders bei komplexeren Zeichenkettenformeln hohe Geschwindigkeiten erreichbar.

*** Seite 56


- Das Aufrumen des Speichers bei Zeichenkettenoperationen (Garbage Collection) dauert maximal 1 Sekunde. Der Basic-Interpreter ist dagegen durch die Garbage-Collection meist minutenlang blockiert. Besonders bei hufiger Benutzung von Zeichenkettenverarbeitung wird das Compilieren dadurch unvermeidbar.

- Der Compiler nimmt dem Programm viele Arbeiten ab, auf diese braucht somit nicht geachtet zu werden, wie z.B. Auffinden von Sprungzielen bei GOTO,GOSUB, Interpretieren von Befehlen und Formeln, Syntaxprfung, Dezimal-Gleitkomma-Integer Umwandlung, Auffinden von Variablen, Umformen und Optimieren von Formeln, Berechnung von Operationen mit konstanten Werten und konstanten Zeichenketten, etc.

*** Seite 57


10. Kapitel

Weitere Anwendungen

10.1 Ein-Ausgabe

Peripheriegerte, wie z.B. Floppy und Drucker, arbeiten nach dem Compilieren eines Programmas natrlich genauso langsam wie zuvor. Beim Abspeichern und Laden von Daten mit der Floppy ist es deswegen empfehlenswert, die zur Verfgung stehende Geschwindigkeit der Floppy maximal auszunutzen. Vor und nach jedem Basic-Befehl, der die Floppy anspricht, sendet das Betriebssystem einen Steuercode. Die bertragung dieses Codes belegt ebenfalls Zeit. Soll dies vermieden werden, so mssen mglichst groe Datenmengen mit einem Befehl bertragen werden:

90 REM@ I=I
100 FOR I=1 TO 100
110 PRINT#l,CHR$(I);
120 NEXT

Dieser Programmausschnitt knnte z.B. auch so lauten:

90 REM@ I=I
100 FOR I=1 TO 100
110 PRINT#1,CHR$(I);CHR$(1+1);
120 I=1+1:NEXT

Besonders langsam arbeitet der Befehl GET#, da er nur einzelne Bytes einliest. Zum Senden von Daten sollte deshalb alle 80 Zeichen ein Zeilenendekennzeichen gewhlt werden, solange die Art der Daten dies zult.

90 REM@ I=l
100 A$="":FOR I=1 TO 80
110 GET#1,B$:A$=A$+B$
120 NEXT

Bei einem entsprechenden Datenformat knnte dies vereinfacht werden zu:

100 INPUT#1,AS

Hierdurch wrde nicht nur das mehrmalige Senden	von Steuercodes, sondern auch die Zusammensetzung einer Zeichenkette gespart werden.

Die Datenausgabe auf dem Bildschirm ist meistens bereits schnell genug, schlielich mssen die Daten noch abgelesen werden. Beim Aufbau von Bildschirmmasken oder hnlichem kann es allerdings passieren, da der Bildschirm durch die Erneuerung der Maske flackert. Hierbei tritt derselbe Effekt ein, der auch beim Schreiben von Programmen auftritt. Sobald der Cursor ber den rechten Bildschirmrand hinaus in die nchste Zeile gelangt, werden alle weitere Zeilen nach unten

*** Seite 58


geschoben. Sobald ein Programm den Bildschirm lscht, um neue oder genderte Daten auszudrucken, kann dieser Effekt auftreten. Der Neuaufbau der Bildschirmdarstellung verzgert sich dadurch. Dies kann verhindert werden, indem das alte Bild einfach berdruckt wird, dabei werden keine neuen Zeilen eingefgt.


10.2 Gleitkommafunktionen

Komplexe Gleitkommafunktionen (Sin, Cos, Tan, Exp, Log, etc.) arbeiten derart langsam, da sie einen entscheidenden Einflu auf die Geschwindigkeit der entsprechenden Programmteile haben. Da diese Funktionen auch vom compilierten Programm mit einer Genauigkeit von 9 Stellen berechnet werden, werden diese Funktionen nicht wesentlich schneller berechnet als vom Interpreter, da der Mikroprozessor des Commodore 64 hier an seine  Grenzen stt. Schneller wird lediglich der restliche der Teil der entsprechenden Formeln und Programme. Oft ist es dagegen nicht ntig, diese Funktionen mit der vollen Rechengenauigkeit zu berechnen, z.B. bei Grafiken mit geringer Auflsung, etc. In diesen Fllen kann man einfachere Formeln benutzen:

10 A=SIN(X):REM -Pi/2<X<Pi/2

Schneller ist:

10 A=X-X*X*X/6

Auf hnliche Art lassen sich die meisten Gleitkommafunktionen beschleunigen. Fr kleine X-Werte lassen sich weitere Umformungen vornehmen:

COS(X)=1-X*X/2
TAN(X)=X+X*X*X/3

Sprbar wird der Geschwindigkeitsgewinn natrlich erst nach dem Compilieren.

Programme, bei denen jede Mglichkeit zur Programmbeschleunigung ausgenutzt werden soll, knnen durch Abschalten des Videoprozessors geringfgig beschleunigt werden:

POKE 53265,PEEK(53265)AND239   ;anschalten des Bildschirms
POKE 53265,PEEK(53265)0R16     ;abschalten des Bildschirms

Weiterhin besteht die Mglichkeit, den Interrupt, wie in Abschnitt 8.5 beschrieben, abzuschalten. Dies deaktiviert allerdings die Tastatur und das Einstellen von TI$.

*** Seite 59


10.3 Grafik

Das Zeichnen von Grafiken dauert mit dem Basic-Interpreter uerst lange. Besonders bei Grafiken zeigen sich deswegen die Vorteile des Compilers gegenber dem Interpreter. Die folgenden Routinen benutzen fast ausschlielich Integer-Operationen:

5 REM@ 02
10 V=53248:AD=8192
20 POKEV+17,59:POKEV+24,24
30 FORI=1024T02023
40 POKEI,1
50 NEXT
60 FORI=8192T016383
70 POKEI,0
80 NEXT
90 L=1:FORI=0T07:MA%(1)=L:L=L*2:NEXT:GOT010000
100 REM DRAW X,Y,X2,Y2
105 X1=X:Y1=Y:IFYI>Y2THENH=Y1:Y1=Y2:Y2=H:H=X1:X1=X2:X2=H
110 DY=(Y2-Y1)*100:DX=X2-X1:V=SGN(X2-X1):Y1=Y1*100:IFV=0THENV=1
115 IFDX=0THENDX=1
116 D=ABS(INT(DY/DX))
120 X=X1
140 FORY=INT(Y1/100)TOINT((Yl+D)/100)-1:GOSUB1000:NEXT
150 Y1=Y1+D
160 IFX<>X2THENX=X+V:GOT0140
170 RETURN
1000 REM PLOT X,Y
1001 REM@ M
1010 OY=320*INT(Y/8)+(YAND7)
1020 OX=8*INT(X/8)
1030 MA=MA%(7-(XAND7))
1040 AV=AD+OX+OY
1050 POKEAV,PEEK(AV)ORMA:REM@ P
1060 RETURN
2000 REM CIRCLE X,Y,R
2001 REM@ 01
2010 S=R*R:Xl=X:Yl=Y
2030 FORX2=OTOCOS(.786)*R+1
2040 Y2=SQR(ABS(X2*X2-S))
2050 X=X2+Xl:Y=Y2+Yl:GOSUB1000
2060 Y=Y1-Y2:GOSUBI000
2070 X=Y2+Xl:Y=X2+Yl:GOSUB1000
2080 X=X1-Y2:GOSUB1000
2085 X2=-X2:IFX2<OTHEN2050
2090 NEXT:RETURN
10000 REM DEMO
10005 FORA=50T0150STEP10
10010 X=A:Y=A:X2=300-A:Y2=160-A:GOSUB100
10020 NEXT
10030 FORW=50T080STEP10
10040 X=150:Y=90:R=W:GOSUB2000
10050 NEXT
10060 GOT010060

*** Seite 60


Zum Compilieren des Programmes mu der Code-Start auf 16384 verschoben werden, um den Grafikspeicher freizugeben (Kapitel 6). Das Programm besitzt folgende Grafikroutinen:

Gosub 100  ;Zeichnet eine Linie von X,Y nach X2,Y2

Gosub 1000 ;Zeichnet einen Punkt mit den Koordinaten X,Y

Gosub 2000 ;Zeichnet einen Kreis mit dem Mittelpunkt X,Y und dem Radius R.

Das Beispielprogramm ab Zeile 10000 knnen Sie natrlich gegen eigene Grafikprogramme austauschen. Das Programm nutzt die Mglichkeiten von BASIC 64 voll aus. Nach dem Entfernen der Compileranweisungen in Zeile 1001 und 1050 kann es sogar vollstndig in Maschinensprache bersetzt werden. Zur vollen Ausnutzung der grafischen Fhigkeiten des Commodore 64 stehen dadurch schnelle Routinen zur Verfgung, die jederzeit ausgebaut werden knnen.

Durch die hhere Geschwindigkeit der compilierten Programme stehen Ihnen mit der Programmiersprache Basic nun Mglichkeiten zur Verfgung, an die Sie bisher noch nicht gedacht haben.

Viel Spa wnscht Ihnen 
Ihr BASIC 64 Autor
Thomas Helbig


*** Seite 61
WICHTIGE HINWEISE ZUM HANDBUCH

Im vorliegenden Handbuch finden Sie an einigen Stellen Zeichen, die Sie auf der Tastatur des C64 vergeblich suchen werden, wie z.B. PRINT1,A$ oder 2^3.
Diese Zeichen haben Ihre Ursache in der Textverarbeitung.

Fr das Parapraphenzeichen '' nehmen sie das Ziffernkreuz # zu erreichen ber SHIFT/3.

Fr das "DACH" '^' nehmen Sie den Pfeil nach oben - zum Potenzieren - zu erreichen ber die entsprechende Taste (neben RESTORE).

*** Seite 62

(Anmerkungen:
 In dieser Text-Version ist bereits '' durch '#' ersetzt worden.
 Einige Fehler des Original-Handbuchs sind korrigiert,
 z.B. das Fehlen von @ hinter REM an mehreren Stellen,
 und die falsche Schreibweise "Simon's Basic".
 Die Angabe "*** Seite xx" folgt immer am Ende der jeweiligen Seite.
)

