BASIC 64 Compiler

Aus C64-Wiki
(Weitergeleitet von Basic 64 Compiler)
Wechseln zu: Navigation, Suche
Basic 64
Basic 64 Compiler Hauptmenü
Entwickler Thomas Helbig
Verleger Data Becker, Abacus Software
Release 1984
Plattform(en) C64
Genre Programmierung
Steuerung Icon tastatur.png
Medien Icon disk525 1.png
Sprache(n) Programm: Sprache:englisch, Handbuch V1.00: Sprache:deutsch
Information damaliger Preis 99,- DM


Beschreibung[Bearbeiten]

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[Bearbeiten]

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

Start[Bearbeiten]

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ü[Bearbeiten]

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[Bearbeiten]

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[Bearbeiten]

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[Bearbeiten]

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[Bearbeiten]

Geschwindigkeit[Bearbeiten]

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
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[Bearbeiten]

  • 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[Bearbeiten]

  • 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[Bearbeiten]

ISBN 3-89011-213-7

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
Titelseite im Handbuch des Basic 64 Compilers


Diskette[Bearbeiten]

Basic64-Disk.jpg

Inhaltsverzeichnis:

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


Kritik[Bearbeiten]

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[Bearbeiten]

Literatur[Bearbeiten]

  • "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)"

Programm[Bearbeiten]


Artikel des Monats.gif Dieser Artikel wurde Artikel des Monats.