BASIC

Dieser Artikel behandelt die Programmiersprache BASIC in Sicht der Commodore Computersysteme.

Die Abkürzung BASIC (Beginner’s All-purpose Symbolic Instruction Code) steht für eine beliebte und bekannte Programmiersprache, die 1964 von John George Kemeny und Thomas Eugene Kurtz entwickelt wurde. Hieraus sind eine Reihe von weiteren BASIC-Dialekten wie z.B. Visual-BASIC entstanden. Dieser Artikel behandelt die Programmiersprache BASIC für Commodore-Computersysteme, bei denen BASIC meist sowohl als Programmiersprache als auch als allgemeine Benutzeroberfläche (Direktmodus) benutzt wird.

Einschaltbild eines Commodore 64.

Das BASIC V2 des C64

Einen weiteren Überblick zum BASIC des C64 gibt es unter C64-Befehle.

Der Commodore 64 hat ein eingebautes Betriebssystem, das auf BASIC V2 basiert (das wiederum eine abgespeckte Version des CBM BASIC 4.0 darstellt - siehe Abschnitt zur Geschichte weiter unten) und 38911 Bytes für BASIC-Programm und seine Variablen in seinem Arbeitsspeicher (auch Hauptspeicher oder RAM) Platz hat.

Der BASIC-Interpreter zeigt durch die Eingabeaufforderung READY. und dem blinkenden Cursor dem Computernutzer an, dass er im Direktmodus ist und Eingaben entgegennehmen kann. Wird ein BASIC-Befehl syntaktisch ordnungsgemäß verwendet, wird dieser ausgeführt, ansonsten wird eine Fehlermeldung ausgegeben, immer gefolgt von der Bereitschaftsmeldung READY.

Eingabe eines Programms

Wird ein BASIC-Befehl mit vorangestellter Zeilennummer eingegeben, fasst der BASIC-Interpreter diesen Befehl als Zeile eines Programms auf und fügt die Zeile dem im Speicher abgelegten Programm hinzu bzw. ersetzt die jeweilige Programmzeile durch die gerade eingegebene. Programme lassen sich mit dem Befehl LIST wieder anzeigen. Die Zeilennummern dienen auch als Sprungmarken für Befehle wie GOTO.

Der Befehl RUN veranlasst BASIC dazu, das gespeicherte Programm abzuarbeiten. Laufende BASIC-Programme können vom Benutzer über die Taste RUN/STOP  unterbrochen werden, BASIC befindet sich dann wieder im Direktmodus.

Da BASIC-Programme im RAM-Speicher editiert und ausgeführt werden, müssen sie mit dem Befehl SAVE auf einen Datenträger (Diskette, Datasette) abgespeichert werden, will man sie nicht beim Ausschalten des Rechners verlieren. Der Befehl LOAD lädt entsprechende Programme von Datenträgern zurück in den Speicher.

Beispiel

Einschaltbild und Editieren eines Programms.

In der Animation finden folgende Schritte statt:

• Rechnung im Direktmodus ausführen: PRINT
• Programm von Diskette laden: LOAD
• Programm starten: RUN
• Programm ausgeben: LIST
• Programm ändern (nur erste Zeile)
• Programm nochmals starten
• Soft-Reset per SYS

Das Programm zählt eine Fließkomma-Variable ganzzahlig von 1 bis 10 hoch und gibt dabei entsprechende Meldungen aus.

10 I = 1
20 PRINT "TEST NR.";I
30 I = I + 1
40 IF I<=10 GOTO 20

Hinweise

• Die Eingabe eines BASIC-Befehls oder einer Programmzeile muss immer mit der Taste RETURN  bestätigt werden.
• Es können mehrere Befehle in einer Zeile stehen, wenn diese mit dem Doppelpunkt : abgetrennt werden.
• Einrückungen lassen sich mit einem Doppelpunkt : am Zeilenanfang und nachfolgenden Leerzeichen in erforderlicher Menge erreichen.
• Eine Zeile darf maximal 80 Zeichen bei der Eingabe lang sein. Überzählige Zeichen werden ignoriert. Zeilen, die mit abgekürzten Befehlen eingegeben wurden (z.B. ? statt PRINT), können in der Langfassung über 80 Zeichen lang werden und lassen sich dann nicht mehr richtig editieren.
• Variablen stehen im Direktmodus auch zur Verfügung, einige Befehle (z.B. INPUT) aber nicht.
• Wird ein Programm im Direktmodus editiert, gehen alle Variablen verloren (implizites CLR).
• Sofern keine BASIC-Erweiterung benutzt wird, die einen Befehl wie RENUMBER zur Verfügung stellt, sollten Zeilennummern mit Abstand gewählt werden, weil ansonsten Zeilen nur sehr umständlich nachträglich eingefügt werden können.
• Programme, bei denen LIST nur eine BASIC-Zeile mit einem SYS-Befehl zutage fördert, sind keine BASIC-Programme, sondern in Assembler geschrieben. Die eine Zeile BASIC-Code dient nur zum (bequemeren) Aufruf des von BASIC aus "unsichtbaren" Assembler-Programms.
• Die Variablennamen dürfen nicht aus BASIC-Schlüsselwörtern (siehe unten) bestehen oder diese in irgendeiner Form enthalten.
• Zahlenwerte und Zeichen können entsprechenden Variablen vom richtigen Typ zugeordnet werden.
• Es werden nur Zeilennummern von 0 bis 63999 unterstützt.

Befehle und Variablentypen

BASIC V2-Befehle des Commodore 64

ABS | AND | ASC | ATN | CHR$ | CLOSE | CLR | CMD | CONT | COS | DATA | DEF | DIM | END | EXP | FN | FOR | FRE | GET | GET# | GOSUB | GOTO | IF | INPUT | INPUT# | INT | LEFT$ | LEN | LET | LIST | LOAD | LOG | MID$ | NEW | NEXT | NOT | ON | OPEN | OR | PEEK | POKE | POS | PRINT | PRINT# | READ | REM | RESTORE | RETURN | RIGHT$ | RND | RUN | SAVE | SGN | SIN | SPC | SQR | STATUS/ST | STEP | STOP | STR$ | SYS | TAB | TAN | THEN | TIME/TI | TIME$/TI$ | TO | USR | VAL | VERIFY | WAIT

 

Es werden drei Variablentypen (Integer, Fließkommazahlen, Zeichenketten) sowie Felder unterstützt.

Technische Realisierung

Das BASIC bzw. der BASIC-Interpreter im Umfang von ca. 9 KByte befindet sich in ROM-Chips und ist beim C64 normalerweise zum wesentlichen Teil im BASIC-ROM mit Adressbereich $A000-$BFFF (40960-49151) und zu einem Teil im KERNAL-ROM im Bereich $E000-$E4D2 (57344-58578) untergebracht (Speicherbelegungsplan). Siehe auch Details zum Inhalt des BASIC-ROMs.

Eine BASIC-Programmzeile darf intern bis zu 256 Bytes lang sein* und ist folgendermaßen aufgebaut:

1. Startadresse der folgenden Programmzeile in der Reihenfolge Low-Byte, High-Byte (=$0000 kennzeichnet das Programmende).
2. Zeilennummer in der Form Low-Byte, High-Byte.
3. Der eigentliche Programmcode (bis zu 251 Bytes) im Token-Format.
4. Ein Null-Byte kennzeichnet das Ende der Programmzeile.

*) Längere Zeilen bringen BASIC beim LOAD des jeweiligen Programms zum Hängen, da das Rechaining der Zeilen bei $A544 im von der Routine betrachteten 256-Byte-Fenster kein Zeilenende mehr findet.
Wird das Programm auf einem anderen Weg in den Speicher gebracht, zeigt LIST nur das erste Stück von überlangen Zeilen an.
Bei der eigentlichen Programmabarbeitung kann eine einzige BASIC-Zeile sogar zum Ende des BASIC-Speichers ausgedehnt sein (normalerweise Adresse $9FFF (40959) abzüglich etwaigem Platz für Variablen, Felder und Zeichenketten). Solche Zeilenlängen lassen sich nur durch Manipulation der Programmdatei oder z. B. durch Erzeugung der Programmdatei via Petcat und ähnlichen Tools erreichen.

Direktmodus

• Nach einem Reset wird vom KERNAL der Warmstart des BASIC angesprungen, der letztendlich über $A474 in die Schleife für den Direktmodus mündet.
• $A483 ruft dabei $A560 INLIN auf, das wiederum $E112 BASIN aufruft und die gelesenen Zeichen bis zu einem Return in den Eingabepuffer bei $0200 kopiert.
• Der Puffer wird dann sogleich ab $A486 über $73 CHRGET wieder angefangen zu lesen.
  • Fängt er mit einer Zahl an, wird ab $A49C die Zeilennummer gelesen, der Puffer tokenisiert und das BASIC-Programm im Speicher entsprechend verändert.
  • Fängt er nicht mit einer Zahl an, wird der Puffer bei $A496 tokenisiert und dann via $A7E1 ausgeführt.
    • Für Tokens wird die Adresse der zuständigen ausführenden Routine bei $A7F7 aus der Tabelle ab $A00C geholt und als Rücksprungadresse für das nächste RTS auf den Stack gelegt. Das RTS im bei $A801 angesprungenen CHRGET springt also direkt zur Routine für das jeweilige Token.
• Der komplette Bildschirmeditor versteckt sich dabei hinter BASIN bzw. dem dazugehörigen Code ab $F157.
  • Per $99 wird dabei vom Interpreter in BASIN das Gerät 0 (Tastatur) ausgewählt - was den Bildschirmeditor einschließt.
    • BASIN kann auch Zeilen von Kassette, RS232, dem Bildschirm (dann einfach die aktuelle Zeile, kein Warten auf Return von Tastatur) und IEC lesen...
  • BASIN liest dabei Tastatureingaben (ab $E5CD), bearbeitet u.a. SHIFT +Run/Stop  und endet erst, wenn Return gedrückt wird.
    • Die Routine ab $E716 gibt jeweils die gelesenen Zeichen am Bildschirm aus und bearbeitet Cursortasten und so weiter.
    • Dabei arbeitet BASIN Hand in Hand mit der Tastaturleseroutine $EA87, die im Interrupt via $EA31 läuft und den Tastaturpuffer ab $0277 befüllt.
  • BASIN wandelt dabei den Bildschirmcode aus dem Bildschirmspeicher um und gibt PETSCII zurück.

Programmausführung

• Die Programmausführung startet z.B. per RUN $A871.
• Ab $A7AE läuft die Interpreterschleife, die auf Run/Stop  prüft und ansonsten ähnlich wie der Direktmodus Befehle via $A7E1 (Sprung bei $A7DD) ausführt.
  • Der eigentliche Befehl wird via CHRGET $73 geholt, das Lesen der Bytes für Zeilennummern und Zeilenendemarke etc. wird aber direkt via LDA($7A),Y erledigt, da CHRGET Leerzeichen überliest.

Fehler und Ungereimtheiten

In BASIC V2 sind eine Reihe von Fehlern (engl. Bugs), die sich in Abstürzen, Fehlermeldungen oder Fehlberechnungen manifestieren. Diese gibt es nicht nur in dieser Version (auch auf anderer Hardware, etwa beim VC-20), sondern sie vererbten sich in neuere, davon abgeleitete Versionen späterer Modelle.
Eine Zusammenfassung findet sich unter Fehler in BASIC-ROM und KERNAL.

Die Geschichte von CBM-BASIC

Angefangen von der PET/CBM 2001 bzw. -Serie bis hin zu den Heimcomputern C64/128/D/DCR, sowie VC10/20, C16/116 und Plus/4 bzw. dem nie erschienen C65 benutzte Commodore eine eigene, aus dem lizenzierten Microsoft BASIC entwickelte BASIC-Version, die CBM-BASIC genannt wird. Diese gab es in verschiedenen Versionen, die bekannteste davon ist vermutlich die Version V2, die in den hier bekannten Heimcomputern ihre Anwendung fand.

Commodore lizenzierte im Herbst 1976 den BASIC-Dialekt von Microsoft und passte ihn den entsprechenden Computersystemen für seine Zwecke an. BASIC wird nicht nur als Programmiersprache eingesetzt, sondern auch als Betriebssystem und ist im ROM des Computers untergebracht.

Weniger bekannt ist unter C64-Benutzern, dass aus dem gleichen ursprünglichen Microsoft-Code unter anderem auch das "Applesoft BASIC" der Apple II Rechnermodelle und das BASIC des Oric-1 und Oric Atmos der Firma Tangerine und auch die 6809-Implementierungen auf Dragon 32/64 (der Firma Dragon Data oder Tano) bzw. TRS-80 Color Computer (von Tandy/Radio Shack) abgeleitet wurden. Diese verhalten sich daher, was den geräteunabhängigen Grundbestand der Sprache angeht, fast genau gleich wie das CBM-BASIC. Das Atari-BASIC des Atari 800 und der folgenden Modelle oder etwa das sehr portable BBC-Basic (bekannt durch den Acorn BBC Micro) war dagegen nicht aus diesem Code hergeleitet, obwohl auch diese Computer einen 6502-Prozessor haben; daher unterscheidet es sich deutlich stärker vom CBM-BASIC. Allerdings gibt es auch ein weniger bekanntes "Atari Microsoft BASIC" als Steckmodul für die Ataris, das wiederum aus der gleichen Codebasis stammt.

Folgende Versionen von CBM-BASIC existieren:

Jahr	Version	Beschreibung
1977	Version 1.0	Noch recht fehlerbehaftet, erste Versionen im PET 2001
1977, August	Version 2.0	Fehlerkorrekturen, eingebaut in weitere Versionen des PET
1978, Juli	Version 3.0	Leichte Fehlerkorrekturen und Integration des Maschinensprachemonitors TIM, schnelle Garbage Collection. CBM 3000 Serie (Standard) und PET 2001 (angezeigte Versionsnummer dort ist allerdings noch 2).
1979, Oktober	Version 4.0	Neue Befehle für leichtere Handhabung für Diskettenlaufwerke für CBM 4000. Auch durch ROM-Austausch für CBM 3000 Serie und PET 2001 verfügbar.
1980	Version 4.1	Fehlerkorrigierte Fassung der Version 4.0 mit erweiterter Bildschirmeditor für CBM 8000. Auch durch ROM-Austausch für CBM 3000/4000 Serie verfügbar.
1981	Version 4.2	Geänderte und ergänzte Befehle für den CBM 8096. Zusätzlich gibt es ein Eingabe- und Hilfswerkzeug für die Programmierung namens LOS-96, das von Diskette ins RAM geladen werden kann.
1981, September	VIC BASIC V2	Funktionsumfang von V 2.0 mit Korrekturen aus der Version-4-Linie. Einsatz im VC20.
1982, Januar	Version 4+ (intern bis 4.75)	Neue Befehle und RAM-Unterstützung bis 256 KByte für CBM-II-Serie (CBM 500, 6x0, 7x0). Fortsetzung und Ende der Version-4-Linie.
1982, August	C64 BASIC V2	Anpassung des VIC BASIC V2 für VC10, C64, C128 (C64-Modus), SX64, PET 64.
1983	Version 3.5	Neue Befehle für die Heimcomputer C16/116 und Plus/4. Zusammenführung aus C64 BASIC V2 und Version-4-Linie.
1985	Version 3.6	Neue Befehle für LCD-Prototypen.
1985	Version 7.0	Neue Befehle für den C128/D/DCR. Weiterentwicklung des C16/116 BASIC 3.5 .
1989	Version 10	Neue Befehle für C65, beinhaltet sehr viele Fehler, kam aus dem Entwicklungsstadium nicht heraus. Weiterentwicklung des BASIC 7.0.

Die nicht durchgehend steigenden Versionsnummern ergeben sich aufgrund der Abspaltung einer CBM-BASIC-Version für Heimcomputer ab 1981. Das CBM-BASIC war bei den PET/CBM-Computern 1981 bereits recht weit entwickelt. Wegen des hohen Platzbedarfs dieses BASICs verwendete man für VC20 und C64 aber nur eine vereinfachte Version, bei der neue Konzepte und Erweiterungen des BASIC 4.0 weg gelassen wurden, und nannte es aufgrund des vergleichsweise eingeschränkten, der ursprünglichen Version 2.0 ähnlichen Funktionsumfangs V2. Diese Version profitierte aber schon von der bei Version 4.0 eingeführten Trennung zum Kernal über dessen Aufruf-Interface. Außerdem wurde bei Fehlerbereinigungen auf den verschiedenen Hardware-Plattformen die BASIC-Version nicht immer entsprechend angepasst bzw. erhöht bzw. bei den jeweiligen Version nach außen hin nicht offengelegt.
Speziell bei den 4.x Versionen wurde in der Dokumentation von Commodore und von den Systemen selbst (Einschaltmeldung) diese stets mit BASIC 4.0 bezeichnet. Die konkrete Variante ergibt sich aus dem Einsatz bei einem konkreten Gerät bzw. einer Modellreihe oder ist gelegentlich auch in mittlerweile veröffentlichten Sourcecodes belegt.

Anmerkung: Die Aktualisierung (Update) des PET CBM-BASIC auf höhere Versionen erfolgt durch den zusätzlichen Einbau von Erweiterungs-BASIC-ROMs oder den kompletten Austausch des bestehenden ROM-Satzes (inkl. Betriebssystem).
Die BASIC-Erweiterung der Heimcomputermodelle erfolgt in der Regel extern über sogenannte Erweiterungskarten (Steckmodul) oder den internen Einbau von entsprechenden EPROMs.

BASIC-Schlüsselwörter in Version V2

BASIC V2 kommt im C64/VC20 und C128/D/DCR im C64-Modus zum Einsatz und unterstützt 71 BASIC-Schlüsselwörter (siehe oben).

Zusätzliche Schlüsselwörter in Version 3.5

BASIC 3.5 baut auf dem Commodore BASIC der Version V2 auf und kommt in den Heimcomputern C16/116 und Plus/4 zum Einsatz.
Auf dem C64 kann man es mit C64 Basic V3.5 aus dem 64'er-Magazin 6/90 oder dem Business-Basic-Modul ausprobieren.

BASIC V3.5-Befehle der Commodore-264-Serie

AUTO | BACKUP | BOX | CHAR | CIRCLE | COLLECT | COLOR | COPY | DEC | DELETE | DIRECTORY | DLOAD | DO | DRAW | DS | DS$ | DSAVE | EL | ELSE | ER | ERR$ | EXIT | GETKEY | GRAPHIC | GSHAPE | HEADER | HELP | HEX$ | INSTR | JOY | KEY | LOCATE | LOOP | MONITOR | PAINT | PRINT USING | PUDEF | RCLR | RDOT | RENAME | RENUMBER | RESUME | RGR | RLUM | SCALE | SCNCLR | SCRATCH | SOUND | SSHAPE | TRAP | TROFF | TRON | UNTIL | VOL | WHILE

 

Zusätzliche Schlüsselwörter in Version 3.6

BASIC 3.6 wurde mit dem LCD-Prototypen verwendet und diente als Basis für das BASIC 7.0 des C128. Dies ist auch dadurch zu belegen, dass der Befehl "OFF" in BASIC 7.0 und 10.0 einen "UNIMPLEMENTED COMMAND ERROR" ausgibt, während dieser in älteren Versionen einen "SYNTAX ERROR" zur Folge hat. Weiterhin im LCD-BASIC vorhanden war der Grafik-Befehl "CIRCLE". Aufbauend auf Commodore BASIC Version 3.5 wurden unter anderem folgende Befehle ergänzt (unvollständige Liste):

QUIT (Verlassen), OFF (Ausschalten), EXIT (zurück zum Hauptmenü) und POPUPS (Verwendung der eingebauten Office-Programme, z.B. Überlagerung des BASICs mit einem Taschenrechner)

Zusätzliche Schlüsselwörter in Version 4.0

Aufbauend auf Commodore BASIC Version 2.0, wurde BASIC 4.0 (Einsatz in PET- und CBM-Computern/Standard der CBM 4000/8000 Serie) um folgende Befehle erweitert.

APPEND, BACKUP, CATALOG, COLLECT, CONCAT, COPY, DIRECTORY, DLOAD, DOPEN, DCLOSE, DSAVE, DS, DS$, GO, HEADER, RECORD, RENAME, SCRATCH

Mit dem Modul von VicTree Programming wird auch ein C64 oder VIC-20 um 42 Befehle auf den vollständigen BASIC-4.0-Befehlsumfang erweitert. Abweichend sind Feinheiten in der Programmsyntax, die nicht beschleunigte Garbage Collection und etwaige Maschinencode-Erweiterungen für BASIC 4.0 sind dazu nicht kompatibel.

Zusätzliche Schlüsselwörter in Version 4.2

Für den CBM 8096/8296 wurde wegen der Arbeitsspeicherüberschreitung von 64 KByte auf 96 KByte bzw. auf 128 KByte die BASIC-Befehle des BASIC 4.0 angepasst:

• LOAD, SAVE, VERIFY Voreinstellung für 8 Geräte, sowie Entfernung der Datasettenunterstützung (Geräteadresse 1 entfällt und wurde durch Standard-Geräteadresse 8 ersetzt). Weiterhin lassen sich durch Angabe von Speicherbereiche beliebige Speicherdaten abspeichern oder gezielt an gewünschter Speicheradresse laden.
• LIST Durch Angabe von LIST wird jeder Befehl in einer neuen Zeile dargestellt.
• DELETE Löscht mehrere BASIC-Zeilen. Nur im Direktmodus verwendbar.
• FRE Mit FRE(0) wird der freie BASIC-Programmspeicher, mit FRE(1) (oder Parameter ungleich 0) der freie Variablenspeicher angezeigt.
• CLR Durch Hinzufügen eines Variablennamens können einzelne Variablen gezielt aus dem Speicher gelöscht werden, z.B. CLR X, I%, A$, F$(
• INPUT Der Eingabepuffer ist von 88 auf 255 Byte angewachsen, trotzdem ist der neue Befehl GET$ mächtiger und universeller einsetzbar.
• REDIM Verlängert oder verkürzt (löscht) dimensionierte Variablen-Felder.
• RESTORE <Zeile>,<Element> durch Angabe von Zeile und Element (optionale Angaben), kann der DATA-Zeiger gezielt zurückgesetzt werden.
• POKE, PEEK, SYS, WAIT Umschalten auf jeweils 32 KByte Bereiche (0-32 KByte Betriebssystem u.a. Zeropage und Stack, 32-64 KByte ROM, 64-96 KByte RAM für BASIC-Programmspeicher, 96-128 KByte RAM für Variablenspeicher.
• GET$<logische Adresse>,Variable$,<maximale Zeichenanzahl>,<Endzeichen>,<ignorierte Zeichen> Es werden maximal 255 Zeichen aus einer Datei in einen String hineingelesen. Dieser Befehl geht über so manche Einschränkung von INPUT# hinweg. Die Parameter nach Variable$ können weggelassen werden.
• INSTR(Suchzeichenkette,Variable$,Startposition,Suchart) Dient dazu in Variable$nach einer bestimmten Zeichenfolge (Suchzeichenkette) auf Übereinstimmung oder Abweichung zu suchen. Es gibt folgende Sucharten: Von links nach rechts (vorwärts) auf Übereinstimmung (0) oder auf Abweichung (1) bzw. von rechts nach links (rückwärts) auf Übereinstimmung (2) oder Abweichung (3).
• MIDSTR(Variable$,Startposition)="Ersatzzeichenkette" Ersetzen bzw. Einfügen der Zeichenfolge "Ersatzzeichenkette" in der vorhandene Stringvariable an Position Startposition.
• ASC(String,Spalte,Länge), CHR$(Zahl,Länge) Angaben Spalte (1 bis 255) und Länge (1 bis 5) sind optional. Durch die Länge bei CHR$ kann die Anzahl der maximal für die Umwandlung genutzten Bits einer Zahl und der daraus erzeugten Zeichen bestimmt werden. Umgekehrt liefert ASC aus einer Zeichenfolge eine korrespondierende Zahl.

1 | 0 - 255        (2 hoch 8 - 1)
2 | 0 - 65535      (2 hoch 16 - 1) 
3 | 0 - 16777215   (2 hoch 24 - 1)
4 | 0 - 4294967275 (2 hoch 32 - 1)
5 | Gleitkommazahl 

• CATALOG$ Feldvariable$(Anfangsindex),Gerätenummer,Laufwerk(0|1),Muster, Modus(0|1|2) Das Directory einer Diskette wird in ein String-Feld ab Element Feldvariable$(Anfangsindex) übertragen. Abgesehen vom String-Feld (Strings haben das Format: Dateiname, Dateityp, belegte Blöcke, insgesamt 16+1+5 Zeichen lang) sind die restlichen Parameter optional. Über den Modus kann der Umfang eines Eintrags (Name, Name+Typ, Name+Typ+Blöcke) gesteuert werden.
• IF ... (THEN|GOTO) ... : ELSE ... Die Konstruktion kennt nun einen ELSE-Zweig. Sie darf aber nicht den Umfang einer Zeile sprengen.
• ON ERROR GOTO ... Hiermit kann bei Auftreten eines BASIC-Fehlers der Programmabbruch vermieden werden und zu einer eigenen Fehlerbehandlungsroutine verzweigt werden. In den Systemvariablen EL (Error Line, Zeilennummer, wo der Fehler auftrat), EC (Error Code, Fehlernummer, wobei BASIC-Interpreter-Fehler positive Vorzeichen haben und Betriebssystem-Fehler negative Vorzeichen haben) und EO (Error Offset, Wert von 0 bis 255) befinden sich nach aufgetretenen Fehler weitere Informationen. Die Funktion ERROR(EO) liefert dazu den String mit der Fehlermeldung (ohne dem Fragezeichen ?).
• RESUME [NEXT|<Zeilennummer>|ERROR] Die Fortsetzung der Programmausführung nach einer ON-ERROR-Abzweigung folgt im Fall ohne Parameter an der Fehlerstelle, mit NEXT nach der Fehlerstelle, in der Zeile mit <Zeilennummer> oder endet bei ERROR mit einem Abbruch in den Direktmodus.
• DISPOSE NEXT|RETURN|<Stackebenen> Parameter NEXT und RETURN können auch durch Komma getrennt mehrfach vorkommen, der Stackebenen-Wert muss alleine stehen. Dient der Manipulation des BASIC-Stacks. Mit DISPOSE 1 wird der Stack komplett geleert.
• INPUT/PRINT @(Zeile, Spalte) dient der gezielten Cursorpositionierung mit Zeile 0-24 und Spalte 0-79.
• USING(Format, Variablenliste) Formatierungschablone für Zuweisungen, INPUT und PRINT, nicht verwendbar im Direktmodus. Aufruf mit PRINT USING oder INPUT USING.
• BASIC-Stack für mehr geöffnete FOR-NEXT-Schleifen, Unterporgramme (mehr als 26) und Klammerebenen in Rechenausdrücken. Durch die Auslagerung des Stacks aus dem CPU-Stapel-Bereich in das BASIC-RAM (Variablenspeicher) hat dieser mehr Platz für geöffnete FOR-NEXT-Schleifen, Unterprogrammverschachtelungen und Klammerverschachtelungen bei der Auswertung von Ausdrücken. Da sich jedoch der Stack im BASIC-RAM von hohen Adressen beginnend nach "unten" ausdehnt und das BASIC-Programm von unten nach oben ausdehnt, sich den freien Platz teilen, ist der Stack dahingehend limitiert.
• Programmänderungen ohne Variablenverlust. Dies erleichtert u.a. auch die Fehlersuche.
• Automatische Zeilennummerierung bei der BASIC-Programmierung.
• BASIC-Zeilen bis zu 250 Byte Länge (im undekodierten Zustand, also mit umgewandelte Schlüsselwörter). Die logische Bildschirmzeile ist weiterhin 80 Zeichen lang.
• ROM Abschalten des BASIC-RAM und Umschalten auf LOS-96, dass sich im RAM befinden muss. Zurück mit SYS 0 über einen Warmstart.
• FUNC und CALL werden mit Hilfe des LOS-96 zum Aufruf von Maschinenspracheprogramme genutzt.

Zusätzliche Schlüsselwörter in Version 4+

Aufbauend auf dem Commodore BASIC der Version 4.0 (auch in der Einschaltmeldung so angezeigt, hat laut Sourcecode intern Version 4.75 entsprochen), gab es für die CBM-II-Computer der Serie CBM 500/600/700 folgende Befehlsergänzungen:

BANK, BLOAD, BSAVE, DCLEAR, DELETE, DISPOSE, EL, ELSE, ERR$, ESC , INSTR, KEY, USING/PRINT(Using), PUDEF, RESUME, TRAP

Zusätzliche Schlüsselwörter in Version 7.0

BASIC 7.0 wurde mit C128/D/DCR-Systemen eingeführt und ist später auch auf Plus/4-Systeme portiert worden (von einem Dritthersteller). Aufbauend auf Commodore BASIC Version 3.5 wurden folgende Befehle ergänzt:

BASIC V7.0-Befehle des C128/D/DCR

APPEND | BANK | BEGIN | BEND | BLOAD | BOOT | BSAVE | BUMP | CATALOG | COLLISION | COLOR | CONCAT | DCLEAR | DCLOSE | DOPEN | DVERIFY | ENVELOPE | FAST | FETCH | FILTER | GO64 | MOVSPR | (OFF) | PEN | PLAY | POINTER | POT | (QUIT) | RECORD | RREG | RSPCOLOR | RSPPOS | RSPRITE | RWINDOW | SLEEP | SLOW | SOUND | SPRCOLOR | SPRDEF | SPRITE | SPRSAV | STASH | SWAP | TEMPO | WIDTH | WINDOW | XOR

 

Zusätzliche Schlüsselwörter in Version 10.0

Kommt im C65 zum Einsatz. Aufbauend auf Commodore BASIC Version 7.0 wurden folgende Befehle ergänzt:

BACKGROUND, BORDER, BVERIFY, CHANGE, CUT, DIR, DISK, DMA, DMODE, DPAT, ELLIPSE, ERASE, FIND, FOREGROUND, GCOPY, GENLOCK, HIGHLIGHT, LINE, LPEN, MOUSE, OFF, PAINT, PALETTE, PASTE, PIC, POLYGON, RGR, RMOUSE, SCREEN, SET, TYPE, VIEWPORT

Da der C65 nur als Prototyp existiert, sind die BASIC-Befehle nicht 100%ig implementiert und somit fehlerbehaftet!

Literatur

• Basiswissen C64

von Joachim Hänsel

Westermann Verlag, ISBN 3-14-508810-6

ein ausführliches Nachschlagewerk

Weblinks

Wikipedia: Commodore BASIC

• "Programmieren in Basic" bei homecomputermuseum.de
• CBM8096 LOS-96 Handbuch (BASIC 4.0 Erweiterung)
• Handbuch BASIC 4 (inkl. Versionen 1-3) bei commodore.ca
• BASIC 3.5 Übersicht von Janne Peräaho und Anders Persson
• CBM BASIC History
• Create your own Version of Microsoft BASIC for 6502
• Bill Gates’ Personal Easter Eggs in 8 Bit BASIC
• BASIC 7.0 für den Plus/4
• Artikel:"BASIC 7.0 für den Plus/4", Hinweise

Quellen

Programmierung-Portalseite
C64-BASIC: BASIC V2 · BASIC-Befehle · Variable

C64-Assembler: Assembler · Assembler-Befehle · Zeropage · KERNAL · BASIC-ROM · Speicherbelegungsplan