BASIC-Erweiterung

Aus C64-Wiki
Zur Navigation springenZur Suche springen

Eine BASIC-Erweiterung ergänzt oder verbessert die bereits vorhanden BASIC-Befehle und -Anweisungen. Manche BASIC-Erweiterungen sind für allgemeine Zwecke geeignet, andere für bestimmte Bereiche optimiert, wie z.B. für Grafikdarstellungen, Musikerzeugung, für die Diskettenverwaltung oder zum komfortableren Programmieren.

Arten von BASIC-Erweiterungen[Bearbeiten | Quelltext bearbeiten]

Eine BASIC-Erweiterung wird in Maschinensprache programmiert und kann auf dem C64 entweder als Software, die von einem Datenträger geladen wird, oder als Steckmodul (Hardware), das in den Expansionsport eingesteckt werden muss, genutzt werden.

BASIC-Programme, die Befehle der BASIC-Erweiterungen beinhalten, sind nur mit der entsprechenden BASIC-Erweiterung funktionsfähig. Ohne diese gibt es Fehlermeldungen des BASIC V2.

  • Üblich ist es, das Erweiterungsprogramm zu laden und zu starten, bevor ein Programm ausgeführt wird, das die neuen Befehle benutzt. Zur Automatisierung kann ein kleiner "Loader" benutzt werden (siehe z.B. TSB Tipps#TSB Boot für TSB).
  • Einige Compiler, wie z.B. der Basic-Boss oder der Laser BASIC-Compiler, bieten zusätzliche BASIC-Befehle und haben damit schon eine Erweiterung eingebaut.
  • Ein Steckmodul hat den Vorteil, dass die BASIC-Erweiterung sofort verfügbar ist und bietet die Möglichkeit, zusätzlichen Speicher bereitzustellen. Die Software kann nun nicht mehr so leicht wie solche auf Diskette weitergegeben werden, was vom Hersteller aber durchaus gewünscht war.
  • Innerhalb von BASIC lassen sich Maschinenprogramme mittels DATA-Zeilen einfügen. Dies ist eine beliebte Art, zusätzliche einzelne BASIC-Befehle zu implementieren. Zwar ist dadurch der verfügbare (BASIC-)Speicher kleiner, doch werden die neuen Befehle immer gleich mitgeladen.

Methoden der Implementierung[Bearbeiten | Quelltext bearbeiten]

Die beiden folgenden Methoden, eine BASIC-Erweiterung beim C64 zu erstellen, sind am häufigsten anzutreffen:

  • Wedge: Hier klinkt sich der Programmierer in die Verarbeitung von BASIC-Code ein. Zwei Stellen sind dafür gut geeignet:
    1. CHRGET liegt ab $0073 in der Zeropage und verwaltet den Programmzeiger. Durch einen Patch dieser Routine kann auf zusätzlichen Programmcode umgeschaltet werden. Dieses Verfahren lässt sich bis auf die CBM-Basic Anfänge (BASIC 1.0) zurückführen und war damals bei den PETs und Nachfolger die einzige Möglichkeit den Interpreter zu erweitern. Ein Beispiel dafür ist das DOS 5.1 von der 1541-Test/Demo Diskette.
    2. Die Routine "BASIC-Befehl ausführen" ($A7E4) lässt sich über den Vektor $308/$309 auf eigenen Code umleiten. Im Buch 64 intern wird dieses Verfahren im Abschnitt "Wie erweitert man BASIC?" erklärt.
Bei der Wedge-Methode wird das Programm etwas langsamer ausgeführt, da zusätzlicher Code zu verarbeiten ist. Die neuen BASIC-Befehle beginnen hier in der Regel mit einem speziellen Kennzeichen, wie "!" oder "@", wonach meistens nur noch ein Buchstabe bzw. ein Token folgt.
  • Befehle mit eigenen Token: Mit dieser eleganteren Methode können längere und damit aussagekräftigere Befehlsnamen erzeugt werden, sie erfordert aber größeren Aufwand (da mittels weiterer Vektoren auch noch das Anzeigen von Tokens und das Umwandeln in Tokens zu behandeln sind). Am Beispiel von Simons Basic kann man sehen, welche Vektoren dazu auf neue Routinen umgeleitet werden.

Geschwindigkeit[Bearbeiten | Quelltext bearbeiten]

Erweiterungen ist gemein, dass sie die Verarbeitungsgeschwindigkeit des BASIC-Interpreters verlangsamen. Das gilt auch bereits für reine BASIC V2-Programme. Zum Beispiel läuft ein einfaches BASIC V2-Programm unter TSB oder Laser BASIC bis zu 40 % langsamer als mit dem normalen BASIC-V2-Interpreter.[1]

Weitere Artikel[Bearbeiten | Quelltext bearbeiten]

Alle Artikel zum Thema BASIC-Erweiterung findet man in der Kategorie BASIC-Erweiterung.


BASIC-Erweiterungen für den C64


Programmierung[Bearbeiten | Quelltext bearbeiten]

;###############################################################################
;# Programm:      BASIC-Erweiterung mit 2 neuen Befehlen @A und @B
;# Dateiname:     basic_erweiterung.asm
;#
;# Assembler:     ACME
;# Assemblierung: acme -f cbm -o basic_erweiterung.prg basic_erweiterung.asm
;#
;# Start mit:     SYS 49152
;#
;# Quelltext:     * Kleinschreibung (bis auf Kommentare)
;#                * nur Leerzeichen, keine Tabulatoren
;#                * Abstand: jeweils 20 Zeichen (Label --> Befehl --> Kommentar)
;#                * Zeilenlänge max. 80 Zeichen
;#
;# Beschreibung:  BASIC-Erweiterung als Wedge-Methode in der
;#                Interpreterschleifenvektor-Variante:
;#                Befehl: @A Adresse, 16-Bit-Wert
;#                Befehl: @B Rahmenfarbe, Hintergrundfarbe
;#
;###############################################################################

                    *=$c000             ; Startadresse des Programms: 49152
                    
; ----- @Initialisierung@ -----

                    lda #<start         ; Vektor ($0308) der Interpreterschleife
                    sta $0308           ; auf eigene Routine umbiegen
                    lda #>start
                    sta $0309

                    lda #<$0803         ; Programmende zurücksetzen
                    sta $2d
                    lda #>$0803
                    sta $2e
                    rts                 ; Rücksprung zu BASIC

; ----- @neue Interpreterschleife@ -----

start:              jsr $0073           ; CHRGET: Byte aus Programm holen
                    cmp #"@"            ; auf @ prüfen
                    bne normal          ; wenn kein @ --> verzweige nach normal

                    jsr $0073           ; holt weiteres Byte
                    jsr $b113           ; auf Buchstaben prüfen
                    bcc fehler          ; nein, dann Syntax-Error ausgeben

                    sbc #65             ; ja, dann 65 subtrahieren
                                        ; --> A=0, B=1, C=2, .... 
                    asl                 ; Zahl verdoppeln A=0, B=2, C=4, ....
                    tay                 ; Y = A
                    lda tabelle+1,y     ; Befehlsadresse MSB holen
                    pha                 ; am Stapel sichern
                    lda tabelle,y       ; Befehlsadresse LSB holen
                    pha                 ; am Stapel sichern
                    jmp $0073           ; holt Byte und führt Befehl aus

normal:             jsr $0079           ; CHRGOT: letztes Byte auffrischen
                    jmp $a7e7           ; zur alten Interpreterschleife nach dem CHRGET

fehler:             jmp $af08           ; Fehlermeldung "?SYNTAX ERROR" ausgeben

; ----- @Befehl: @A Adresse, 16Bit-Wert@ -----

befehl_a:           jsr $ad8a           ; Ausdruck holen
                    jsr $b7f7           ; auf numerisch prüfen
                                        ; Selbstmodifizierender Code:
                    sty adresse+1       ; Adresse Low-Byte schreiben
                    sta adresse+2       ; Adresse High-Byte schreiben
                    jsr $aefd           ; auf "," prüfen
                    jsr $ad8a           ; Ausdruck holen (Wert in Y/A)
                    jsr $b7f7           ; auf numerisch prüfen

                    ldx #1              ; mit High-Byte beginnen 
adresse:            sta $0000,x         ; Adresse wir oben modifiziert
                    tya                 ; Low-Byte 
                    dex
                    bpl adresse         ; beim 3. Durchlauf verlassen

                    jmp $a7ae           ; zurück in die alte Interpreterschleife

; ----- @Befehl: @B Rahmenfarbe, Hintergrundfarbe@ -----

befehl_b:           jsr $ad8a           ; Ausdruck holen
                    jsr $b7f7           ; auf numerisch prüfen
                    sty $d020           ; Rahmenfarbe setzen

                    jsr $aefd           ; auf "," prüfen
                    jsr $ad8a           ; Ausdruck holen
                    jsr $b7f7           ; auf numerisch prüfen
                    sty $d021           ; Hintergrundfarbe setzen

                    jmp $a7ae           ; zurück in die alte Interpreterschleife

; ----- @Zeigertabelle der neuen Befehle@ -----

tabelle:            !word befehl_a - 1  ; Zeiger Befehl @A minus 1 
                    !word befehl_b - 1  ; Zeiger Befehl @B minus 1
                    !word $af07         ; Zeiger Befehl @C ("Syntax Error")
                    !word $af07         ; Zeiger Befehl @D ("Syntax Error")
                    !word $af07         ; Zeiger Befehl @E ("Syntax Error")
                                        ; ...

Weblinks[Bearbeiten | Quelltext bearbeiten]


Quellen

  1. ↑ Thema: Laser BASIC - Interpreter und Compiler - Mein Praxistest auf Forum64.de mit Test zur Geschwindigkeit
  2. ↑ DotBASIC Sprache:englisch
Abgerufen von „https://www.c64-wiki.de/index.php?title=BASIC-Erweiterung&oldid=288844“