BASIC 64 Compiler

Basic 64
Entwickler	Thomas Helbig
Verleger	Data Becker, Abacus Software
Release	1984
Plattform(en)	C64
Genre	Programmierung
Steuerung
Medien
Sprache(n)	Programm: , Handbuch V1.00:
Information	damaliger Preis 99,- DM

Beschreibung

BASIC 64 ist ein 2-Pass-Compiler für den Commodore 64, der BASIC-Programme in einen P-Code oder direkt in Maschinensprache übersetzt und damit ca. 3- bis 10-mal schneller macht. Er bietet zwei allgemeine Optimierungsstufen und diverse Einstellungsmöglichkeiten in Menüs und durch Compileranweisungen.

Weitere Eigenschaften sind

• freies Verschieben des Compilats im Speicher,
• Nutzung von mehr als 60 KByte,
• Modifizierte Integer-Arithmetik,
• Simulation von ON ERROR GOTO-Befehlen,
• Overlay-Unterstützung: beim Nachladen von Programmteilen werden die Variablen nicht gelöscht,
• Zusammenarbeit mit diversen BASIC-Erweiterungen.

BASIC 64 Compiler von Data Becker in der Version V1.00 wurde auf einer Diskette mit einem 62-Seiten umfassenden Handbuch ausgeliefert, das alle Funktionen des Compilers gut erklärt.

Später erschien von Abacus Software die Version V1.03, zu der es nur noch eine weit weniger ausführliche Anleitung in englischer Sprache gab. Die beiden Programmversionen unterscheiden sich nur wenig:

• Bei V1.03 ist im Menü "Advanced Development Package" zusätzlich eine Option "N" vorhanden, mit der das Verzeichnis der Diskette angezeigt werden kann.

Bedienung

Die Bedienung des BASIC 64 Compilers gestaltet sich einfach und geschieht mit einigen wenigen, übersichtlichen Menüs.

Start

Das zu kompilierende BASIC-Programm sollte auf einer Arbeitsdiskette gespeichert sein, auf der noch Platz für das Kompilat vorhanden ist. Der BASIC 64 Compiler wird geladen und gestartet mit

LOAD"BASIC 64",8
RUN

Das Laden dauert einige Zeit, ein Schnelllader ist deshalb zu empfehlen.
Wenn das Hauptmenü erscheint, legt man die Arbeitsdiskette ein. Am Einfachsten ist es nun, die vorgegebene Optimierungsstufe I mit 1  oder RETURN  auszuwählen. Danach muss man den Namen des zu kompilierenden Programms eingeben, das der Compiler dann in ein P-Code Programm übersetzt. Auf dem Bildschirm werden nun die jeweils verarbeitete Zeilennummer, dahinter die in der Zeile vorhandenen Doppelpunkte und ggf. ein "R" bei einer Compiler-Anweisung oder ein "E" bei einem Erweiterungsbefehl ausgegeben. Am Ende von Pass 2 sieht man Angaben zum gerade generierten Programm, das jetzt auf der Diskette gespeichert und an dem vorangestellten "P-" zu erkennen ist. Man kann es jetzt mit LOAD"P-Programmname" laden und mit RUN starten.

Reicht die Geschwindigkeit des Programms nicht aus, bietet BASIC 64 diverse Möglichkeiten, dies zu ändern (Optimierungsstufe 2, Generieren eines Maschinenprogrammen, Verwendung von Integer-Variablen, etc.).

BASIC 64 Compiler: Pass 1.

BASIC 64 Compiler: Pass 2.

Hauptmenü

BASIC 64 Compiler V1.03 Hauptmenü.

• 1: Optimierungsstufe I

Diese Option wählt man, will man z.B. ein nicht selbst geschriebenes Programm ein wenig schneller machen. Sie ist vollständig kompatibel zum Basic-Interpreter V2.0. Um hier die Geschwindigkeit von Berechnungen mit ganzen Zahlen nutzen zu können, müssen die entsprechenden Variablen als Integer gekennzeichnet werden. Das geht am bequemsten mit der Compiler-Anweisung REM@ I=... (s.u.)

• 2: Optimierungsstufe II

Hier werden alle Variablen als Integer-Variablen angesehen, also auch solche, bei denen der BASIC-Interpreter das nicht macht. Deshalb muss man Variablen mit Fließkommazahlen mit der Compiler-Anweisung REM@ R=... kennzeichnen. Diese Stufe kann unter Umständen deutlich schnelleren Code erzeugen.

Advanced Development Package

Compiler-Einstellungen.

Nach 3  im Hauptmenü wird dieses Untermenü aufgerufen, in dem die Einstellungen des Compilers verwaltet werden.

• "A" - Code Generator

Der Compiler kann wahlweise P-Code (dies ist die vorgegebene Einstellung), Maschinensprache (6502/6510) oder gar keinen Code erzeugen. Maschinenprogramme erhalten ein "M-" vor den Namen, andere Programme ein "P-". In P-Code kompilierte Programme können kürzer sein, als das Original, obwohl ein Runtime-Modul von 5 KByte hinzukommt. Erzeugte Maschinenspracheprogramme sind ca. doppelt so lang wie das Original, aber schneller als ein P-Code-Programm. Mischen von kurzem P-Code und schneller Maschinensprache ist ebenfalls möglich.

• "B" / "C" - Laden und Speichern von Symboltabellen

Der Compiler kann eine Variablenliste laden, die beim Kompilieren eines anderen Programms abgespeichert wurde. So können beide Programme dieselben Adressen für die entsprechenden Variablen benutzen (z.B. Overlay-Pakete).

• "D" - Generieren einer Zeilenliste (für Fehlermeldungen oder Start eines Programmteiles mit SYS)

Ist dies ausgewählt, speichert der Compiler auch eine Zeilenliste des Programms ab, die mit LOAD"Z-Programmname" geladen und mit LIST gelistet werden kann. Jeder BASIC-Zeile (rechte Seite) ist eine Speicheradresse (linke Seite) zugeordnet.

• "E" - Speicherende

Gibt die erste nicht verfügbare Speicheradresse an. Standardwert ist 65536. Man setzt diesen Wert herab, um Speicher für Maschinenprogramme, BASIC-Erweiterungen, etc. zu gewinnen.

• "F" - Code-Start

Normalerweise wird der Code direkt hinter das Runtime-Modul gelegt. Wird der Wert heraufgesetzt, muss das so verschobene Programme nicht mehr mit RUN, sondern mit SYS Startadresse gestartet werden.

• "H" - Einstellen der verwendeten Basic-Erweiterung

Zur Auswahl stehen Supergrafik 64 Plus, Supergrafik 64, Simons' Basic, Exbasic Level II und Disk-Basic (Basic 4.0 enthalten in Master 64 und Diskomat). Die gewünschte Erweiterung wird durch (ggf. mehrmaliges) Drücken von H  angewählt. Alle weiteren notwendigen Parameter stellen sich dann automatisch ein. Andere Basic-Erweiterung werden mit "others" gewählt, wobei man die übrigen Parameter selbst einstellen muss.

• "K" - Fehlerabbruchszeile:

Tritt im BASIC-Programm während der Laufzeit ein Fehler auf, wird normalerweise eine Meldung ausgegeben. Dies kann man abschalten, indem man dem Compiler mitteilt, welche Zeile bei Auftreten eines Fehlers ausgeführt werden soll.

Zeile 0 bedeutet Ausgabe einer Meldung.

• "L" - Overlay-Verhalten:

Der BASIC-Interpreter speichert Zeichenkettenkonstanten direkt im Programm. Damit das kompilierte Programm sich anders verhält (z.B. bei Overlay-Paketen), kann man dies dem Compiler mit dieser Einstellung mitteilen.

Overlay-Programme

Das Overlay-Menü.

Programme, die sich gegenseitig laden und starten, sollen i.a. auch dieselben Variablen bzw. deren Inhalt benutzen. Diese Aufgabe übernimmt der Compiler. Das Kompilieren von Overlay-Paketen geschieht in zwei Durchgängen:

• Durchgang 1

Gleich nach der Aktivierung des Compilers drückt man 4  (Overlay), danach 1  (Durchgang 1) und kompiliert nun alle Programme des Overlay-Paketes. Da beim Durchgang 1 kein Programm erzeugt wird, sondern nur eine sequentiellen Datei "S-OVERLAY", ist er relativ schnell beendet.

• Durchgang 2:

Nachdem man im Hauptmenü 4  und dann 2  (Durchgang 2) wählt, kompiliert man nun alle Programme nochmals. Der Compiler generiert nun das gewünschte Programm, wobei man mit 3  im Hauptmenü eventuell noch Parameter verändern kann.

Schließlich müssen noch die Namen der kompilierten Programme so geändert werden, dass sie sich gegenseitig laden können.

Compiler-Anweisungen

Mit speziell gekennzeichneten REM-Anweisungen (REM@) innerhalb des Programms kann man während der Kompilierung Einfluss auf den Compiler nehmen.

REM@ M	Umschalten auf Generieren von Maschinencode	Der Compiler erzeugt ab sofort Maschinensprache und in das Programm wird eine entsprechende Anweisung eingefügt.
REM@ P	Umschalten auf Generieren von P-Code	Der Compiler generiert wieder P-Code und in das Programm wird ein entsprechender Befehl eingefügt.
REM@ EZeilennummer	Ein- und Ausschalten von Fehlerbehandlung	Diese Möglichkeit entspricht dem Befehl ON ERROR GOTO in einigen BASIC-Erweiterungen. Die Zeilennummer 0 schaltet wieder auf die Generierung normaler Fehlermeldungen zurück.
REM@ I=Variable,Variable...	Deklarieren von Integer-Variablen	Alle genannten Variablen (Gleitkommavariablen, also ohne %-Zeichen) werden vom Compiler als Integer-Variablen eingestuft, wodurch das Programm schneller wird. Dieser Befehl ist nur in Verbindung mit Optimierungsstufe 1 sinnvoll.
REM@ R=Variable,Variable...	Deklarieren von Gleitkommavariablen	Alle genannten Variablen werden als Gleitkommavariablen eingestuft. Dies ist nur bei Anwendung von Optimierungsstufe 2 nötig.
REM@ OStufennummer	Umschalten der Optimierungstufe	Die Optimierungsstufe wird umgeschaltet. Auswirkung hat das nur auf den Datentyp von Variablen, die im Programm bis hier nicht vorgekommen sind.
REM@ AVariable=Adresse	Zuordnen von Variablenadressen	Die Variable wird an die angegebene Adresse gelegt. Adressen unter 768 sind nicht erlaubt.
REM@ SAdresse	Bereich im Bandpuffer reservieren	Der Compiler legt innerhalb des Bandpuffers (Datasetten-/Kassettenpuffer) alle Variablen ab, auf die besonders schnell zugegriffen werden soll. Diesen Bereich kann man für eigene Zwecke nutzen, indem man die Adresse angibt, bis zu der man den Bandpuffer benötigt. Beispiel: REM@ S1024

Hinweise

Geschwindigkeit

Die Geschwindigkeit des kompilierten Programms hängt nicht nur von der Optimierung ab, sondern auch von der Art des Programms. So werden z.B. Programme, die viele mathematische Funktionen wie EXP, SIN, TAN usw. benutzen, aber wenige Integer-Variablen, nicht so stark beschleunigt.

Die folgende Tabelle (Zeiten in Sekunden) zeigt den Geschwindigkeitsgewinn durch Kompilieren anhand des Benchmark-Test-Programms aus dem 64'er-Sonderheft 12 (ausgeführt mit VICE):

BASIC 64 Benchmark-Test.

• B1: FOR-NEXT-Schleife
• B2: IF-THEN-Schleife
• B3: Rechnen
• B4: GOSUB und RETURN
• B5: Indizierte Felder beschreiben
• B6: Funktionen SIN, TAN, EXP, VAL, STR$
• B7: READ und RESTORE
• B8: Zufallsfeld mit 100 Elementen mit Bubble-Sort sortieren

Test	BASIC V2.0	BASIC 64 Compiler
	Interpreter	P-Code Opt. 1	P-Code Opt. 2	M-Code Opt. 2
B1:	1,35	1,05	0,33	0,31
B2:	10,22	1,85	0,67	0,13
B3:	70,95	62,47	64,70	63,72
B4:	5,38	1,35	0,65	0,60
B5:	8,78	3,23	2,03	1,55
B6:	130,13	120,35	124,33	123,22
B7:	25,78	2,48	1,73	1,53
B8:	143,97	40,50	29,55	23,75

Die Geschwindigkeit beim Kompiliervorgang ist im Vergleich zu anderen bekannten Compilern eher gering. Für "Eddi", das Testprogramm des 64'er-Magazins, benötigt BASIC 64 für die Kompilierung in Maschinensprache 6:22 Min., Basic-Boss schafft dies in 1:33 Min.

Platzbedarf auf Diskette

• Die folgende Tabelle zeigt an Beispielprogrammen von verschiedenem Umfang, wie die Größe des Compilats (Blöcke auf Diskette) von der Größe des BASIC-Programms und der Art des Kompilierens abhängt:

Programm	BASIC	P-Code 1	P-Code 2	M-Code 1
Benchmark	7	25	25	29
Eddi	14	32	31	41
Blockfolge	21	36	36	50
Diskass	27	38	37	46
Labyrinth	40	56	51	93
Diskverw	59	66	63	110
Sound-Editor+	92	115	108	206
DBII	129	118	109	234

• Auf der Arbeitsdiskette sollte nicht nur genug Platz für das Compilat, sondern auch noch für die in Pass 1 erstellten temporären sequentiellen Dateien vorhanden sein. Generiert man P-Code, so meldet der Compiler "Disk full", wenn der Platz nicht mehr reicht. Will man aber ein Maschinensprache-Programm erstellen, so kann es vorkommen, dass sich der Compiler aufhängt, wenn kein Platz mehr auf der Diskette vorhanden ist.

Erweiterungen

• Programme, die in einer der anwählbaren Erweiterungen geschrieben worden sind, können leider nicht ohne Vorbereitung kompiliert werden, denn BASIC 64 unterstützt nicht sämtliche Befehle. Nur Supergrafik wird fast vollständig umgesetzt, bei den anderen Erweiterungen gilt als Faustregel: Grafik-, Sprite-Steuerungs-, Musik-Befehle funktionieren, Programmstrukturbefehle nicht.
  Das Handbuch enthält viele Details dazu. SYS-Befehle mit Parametern werden aber unterstützt.

• Die Erweiterung muss aktiv (also ev. zuvor geladen) sein, damit das Programm ausgeführt werden kann.

• Erweiterungsbefehle werden nicht beschleunigt, da für sie der BASIC-Interpreter benutzt wird.

Handbuch

BASIC 64 Compiler
	Sprache	deutsch
	Autor(en)	...
	Verlag	Data Becker
	Jahr	1988
	ISBN	ISBN ISBN 3-89011-213-7
	Neupreis
	Datenträger
	Seitenzahl
	letzte Auflage
	Genre
	Information

Diskette

Diskette

0 "BASIC 64 V1.00  " LE 2A
89   "BASIC 64"         PRG
1    "FLADER"           PRG
6    "FE"               PRG
5    "SYMBOL"           PRG
556 BLOCKS FREE.

Inhaltsverzeichnis

Vorwort ..................................................  1
1. Kapitel
   1.1 Bedienung von BASIC 64 ............................  2
   1.2 BASIC 64 und Floppy-Express .......................  3
2. Kapitel
   2.1 Auswahlmöglichkeiten ..............................  4
   2.2 Das erweiterte Entwicklungspaket ..................  4
   2.3 Compileranweisungen ...............................  5
   2.4 Ein Beispiel für 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 Speicherbänke ......................... 48
9.Kapitel
   9.1 Übersicht über die Möglichkeiten 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

Meinung

Petrus: "Der BASIC 64 Compiler ist für mich erste Wahl, wenn ich mal rasch ein Basic-Programm ein wenig beschleunigen will. Er ist unkompliziert und arbeitet zuverlässig. Weniger schön finde ich, dass das Programm nur mit einem Reset zu beenden ist."

Weblinks

Literatur

• "Basic im Galopp" im 64'er-SH12 ab S. 51: Compiler-Vergleich von Austro-Comp, Austro-Speed, BASIC 64, Austro-Comp 128 und BASIC 128.
• "Compiler - Geschwindigkeit ohne Assembler" im 64'er-Magazin 08/87: Software-Test "BASIC 64 Compiler V1.02" und "Pascal 64".
• "Konkurrenz für den Boss" im 64'er-Magazin 08/94 S. 26-27: Vergleich von "Basic-Boss" und "BASIC 64 Compiler V1.03 (Abacus)"
• "Benchmarks für Compiler, C64" im 64'er sonderheft_12 auf archive.org

Programm

• BASIC 64 V1.00 von Data Becker incl. Handbuch bei c64-online.com
• BASIC 64 V1.03 (Abacus) bei arnold.c64.org
• Utility - Programmazione mit BASIC 64 V1.0, Austro Speed, Austro Decompiler, Blitz Compiler u.a. bei ready64.org
• Basic mit BASIC 64 Compiler V1.00 u.a. bei Gangsta's Paradise
• Commodore 64 Software Manuals bei Retro Commodore mit englischem Handbuch "Basic 64 Compiler".

Dieser Artikel wurde Artikel des Monats.