1

C64: Video: Mit Turbo Macro Pro den C64 in Assembler programmieren (engl.)

Robin Harbron aus Kanada zeigt in diesem Video (00:22:50, engl.) wie man auf dem C64 mit dem Turbo Macro Pro Editor in Assembler programmiert. Er erklärt kurz und knapp die Grundlagen von Assembler / Maschinensprache (Opcodes) und Turbo Macro Pro. Dieser komfortable Assembler Editor für den Commodore 64 ist 1985 von Wolfram Roemhild (Fa. Omikron) geschrieben worden und wird heute noch von der C64-Szene verwendet. Es gibt den TMP auch als Cross-Assembler für verschiedene Betriebssysteme.




Commodore BASIC V2.0: Funktion: ATN

ATN

  • Token: 193 / $C1 | Abkürzung: aT | ROM Exec: 58128 / $E30E
  • Typ: Funktion, numerisch | Funktion: Arithmetik
  • Syntax: ATN(<Zahl>)

Aktion, Hinweise, Tipps, Tricks:

  • ATN() gibt den Arcustangens der angegebenen Zahl zurück.
  • Das Ergebnis ist der Winkel (im Bogenmaß), dessen Tangens die Zahl ist und liegt immer im Bereich von -pi/2 () bis +pi/2 ().
  • Fehler: ?TYPE MISMATCH ERROR: Wenn das übergebene Argument keine Zahl ist (siehe Zeile 50).
  • Fehler: ?OVERFLOW ERROR: Wenn Zahlen außerhalb des Fließkommazahlenbereichs liegen (siehe Zeile 60).
  • Fehler: ?SYNTAX ERROR: Wenn das Argument fehlt (siehe Zeile 70).

Beispiele:

10 PRINT ATN(1) : REM Gibt  auf dem Bildschirm aus
20 PRINT ATN(1)*4 : REM Gibt  auf dem Bildschirm aus
30 Print π : REM Gibt die Konstante (Pi)  auf dem Bildschirm aus
40 X = ATN(J)*180/π : REM Konvertiert in Grad
50 PRINT ATN(A$) : REM ERROR Zahl erwartet
60 PRINT ATN(99999999999999999999999999999999999999999999999999) : REM ERROR Außerhalb des Zahlenbereichs
70 PRINT ATN() : REM ERROR Argument fehlt

Befehle CLOSE, CLR, CMD, CONT, DATA, DEF, DIM, END, FOR, GET, GOSUB, GOTO, IF, INPUT, INPUT#, LET, LIST, LOAD, NEW, NEXT, ON, OPEN, POKE, PRINT, PRINT#, READ, REM, RESTORE, RETURN, RUN, SAVE, STOP, SYS, VERIFY, WAIT
Befehle Spezial (Bywords) FN, GO, NOT, SPC(, TAB(, THEN, TO, STEP
Arithmetische und logische Operatoren +, -, *, /, ^, >, =, <, AND, OR
Funktionen ABS, ASC, ATN, CHR$, COS, EXP, FRE, INT, LEFT$, LEN, LOG, MID$, PEEK, POS, RIGHT$, RND, SGN, SIN, SQR, STR$, TAN, USR, VAL
Konstanten und Systemvariablen Pi, ST, TI, TI$



Commodore BASIC V2.0: Funktion: ABS

ABS

  • Token: 182 / $B6 | Abkürzung: abS | ROM Exec: 48216 / $BC58
  • Typ: Funktion, numerisch | Funktion: Arithmetik
  • Syntax: ABS(<Ausdruck>)

Aktion, Hinweise, Tipps, Tricks:

  • ABS() gibt den absoluten Wert der Zahl zurück, also den Wert der Zahl ohne Vorzeichen.
  • Der Absolutwert einer negativen Zahl ist die Zahl multipliziert mit -1, was ein positives Ergebnis ergibt.
  • Fehler: ?TYPE MISMATCH ERROR: Wenn das übergebene Argument keine Zahl ist (siehe Zeile 80).
  • Fehler: ?SYNTAX ERROR: Wenn das Argument fehlt (siehe Zeile 90).

Beispiele:

10 PRINT ABS(-5) : REM Gibt 5 auf dem Bildschirm aus
20 PRINT ABS(0) : REM Gibt 0 auf dem Bildschirm aus
30 PRINT ABS(+5) : REM Gibt 5 auf dem Bildschirm aus
40 X = ABS(Y)
50 PRINT ABS(X*J)
60 IF X = ABS(X) THEN PRINT "POSITIV"
70 PRINT ABS(-6+55-12-44+54) : REM Gibt 47 auf dem Bildschirm aus
80 PRINT ABS(A$) : REM ERROR Zahl erwartet
90 PRINT ABS() : REM ERROR Argument fehlt 

Befehle CLOSE, CLR, CMD, CONT, DATA, DEF, DIM, END, FOR, GET, GOSUB, GOTO, IF, INPUT, INPUT#, LET, LIST, LOAD, NEW, NEXT, ON, OPEN, POKE, PRINT, PRINT#, READ, REM, RESTORE, RETURN, RUN, SAVE, STOP, SYS, VERIFY, WAIT
Befehle Spezial (Bywords) FN, GO, NOT, SPC(, TAB(, THEN, TO, STEP
Arithmetische und logische Operatoren +, -, *, /, ^, >, =, <, AND, OR
Funktionen ABS, ASC, ATN, CHR$, COS, EXP, FRE, INT, LEFT$, LEN, LOG, MID$, PEEK, POS, RIGHT$, RND, SGN, SIN, SQR, STR$, TAN, USR, VAL
Konstanten und Systemvariablen Pi, ST, TI, TI$



Commodore BASIC V2.0: Funktion: ASC

ASC

  • Token: 198 / $C6 | Abkürzung: aS | ROM Exec: 46987 / $B78B
  • Typ: Funktion, numerisch | Funktion: Stringbearbeitung
  • Syntax: ASC(<String>)

Aktion, Hinweise, Tipps, Tricks:

  • ASC() gibt eine Zahl von 0 bis 255 zurück, die dem PETSCII-Wert des ersten Zeichens eines Strings entspricht.
  • Für die Umkehrfunktion, der Umwandlung eines ASCII-Codes in ein Zeichen, gibt es die BASIC-Funktion CHR$().
  • Fehler: ?TYPE MISMATCH ERROR: Wenn das übergebene Argument kein String ist (siehe Zeile 40).
  • Fehler: ?ILLEGAL QUANTITY ERROR: Wenn der String keine Zeichen enthält (Nullstring) (siehe Zeile 50).
  • Fehler: ?SYNTAX ERROR: Wenn das Argument fehlt (siehe Zeile 70).

Beispiele:

10 PRINT ASC("Z") : REM Gibt 90 auf dem Bildschirm aus
20 Y = ASC("ZEBRA") : REM Y = 90, 1. Zeichen
30 X = ASC(A$) : REM 1. Zeichen, ERROR wenn Nullstring
40 PRINT ASC(0) : REM ERROR Argument kein String
50 PRINT ASC("") : REM ERROR Argument Nullstring
60 PRINT ASC("" + CHR$(0)) : REM Gibt 0 auf dem Bildschirm aus, Nullstring Error wird abgefangen
70 PRINT ASC() : REM ERROR Argument fehlt 

Befehle CLOSE, CLR, CMD, CONT, DATA, DEF, DIM, END, FOR, GET, GOSUB, GOTO, IF, INPUT, INPUT#, LET, LIST, LOAD, NEW, NEXT, ON, OPEN, POKE, PRINT, PRINT#, READ, REM, RESTORE, RETURN, RUN, SAVE, STOP, SYS, VERIFY, WAIT
Befehle Spezial (Bywords) FN, GO, NOT, SPC(, TAB(, THEN, TO, STEP
Arithmetische und logische Operatoren +, -, *, /, ^, >, =, <, AND, OR
Funktionen ABS, ASC, ATN, CHR$, COS, EXP, FRE, INT, LEFT$, LEN, LOG, MID$, PEEK, POS, RIGHT$, RND, SGN, SIN, SQR, STR$, TAN, USR, VAL
Konstanten und Systemvariablen Pi, ST, TI, TI$



Commodore BASIC V2.0: Ableitung mathematischer Funktionen


Mathematische Funktionen, die nicht Commodore 64 BASIC eigen sind, können wie folgt berechnet werden:

Mathematische Funktion BASIC Äquivalent
SECANT SEC(X) = 1/COS(X)
COSECANT CSC(X) = 1/SIN(X)
COTANGENT COT(X) = 1/TAN(X)
INVERSE SINE ARCSIN(X) = ATN(X/SQR(-X*X+1))
INVERSE COSINE ARCCOS(X) = -ATN(X/SQR(-X*X+1))+{pi}/2
INVERSE SECANT ARCSEC(X) = ATN(X/SQR(X*X-1))
INVERSE COSECANT ARCCSC(X) = ATN(X/SQR(X*X-1))+(SGN(X)-1*{pi}/2
INVERSE COTANGENT ARCOT(X) = ATN(X)+{pi}/2
HYPERBOLIC SINE SINH(X) = (EXP(X)-EXP(-X))/2
HYPERBOLIC COSINE COSH(X) = (EXP(X)+EXP(-X))/2
HYPERBOLIC TANGENT TANH(X) = EXP(-X)/(EXP(X)+EXP(-X))*2+1
HYPERBOLIC SECANT SECH(X) = 2/(EXP(X)+EXP(-X))
HYPERBOLIC COSECANT CSCH(X) = 2/(EXP(X)-EXP(-X))
HYPERBOLIC COTANGENT COTH(X) = EXP(-X)/(EXP(X)-EXP(-X))*2+1
INVERSE HYPERBOLIC SINE ARCSINH(X) = LOG(X+SQR(X*X+1))
INVERSE HYPERBOLIC COSINE ARCCOSH(X) = LOG(X+SQR(X*X-1))
INVERSE HYPERBOLIC TANGENT ARCTANH(X) = LOG((1+X)/(1-X))/2
INVERSE HYPERBOLIC SECANT ARCSECH(X) = LOG((SQR(-X*X+1)+1/X)
INVERSE HYPERBOLIC COSECANT ARCCSCH(X) = LOG((SGN(X)*SQR(X*X+1/X)
INVERSE HYPERBOLIC COTANGENT ARCCOTH(X) = LOG((X+1)/(X-1))/2



Commodore BASIC V2.0: Befehl: END

END

  • Token: 128 / $80 | Abkürzung: eN | ROM Exec: 43057 / $A831
  • Typ: Befehl | Funktion: Strukturkontrolle
  • Syntax: END

Aktion, Hinweise, Tipps, Tricks:

  • Beendet die Ausführung des BASIC-Programms und der Computer kehrt in den Direktmodus zurück.
  • Bei der END Anweisung wird die Zeilennummer, im Gegensatz zur STOP Anweisung, nicht mit angezeigt sondern nur ein READY. ausgegeben.
  • Die END Anweisung ist mit der STOP Anweisung identisch, nur dass bei STOP die Meldung BREAK IN LINE XX ausgegeben wird.
  • Beide Anweisungen (END und STOP) ermöglichen dem Computer die Wiederaufnahme des Programms mit dem Befehl CONT.
  • Ein BASIC-Programm kann beliebig viele END Anweisungen enthalten.
  • Das Einfügen von END ist nicht unbedingt nötig, kann aber zur Fehlersuche wirklich sehr hilfreich sein, da alle Variablen nach einem END ihre Werte behalten.
  • Ein END muss nicht am Programmende stehen, da mit Abarbeitung der letzten Zeile das Programm automatisch beendet wird.

Beispiele:

10 PRINT "WOLLEN SIE DIESES PROGRAMM STARTEN?"
20 INPUT A$
30 IF A$ = "NEIN" THEN END
40 REM REST DES PROGRAMMS
...
1000 END

Befehle CLOSE, CLR, CMD, CONT, DATA, DEF, DIM, END, FOR, GET, GOSUB, GOTO, IF, INPUT, INPUT#, LET, LIST, LOAD, NEW, NEXT, ON, OPEN, POKE, PRINT, PRINT#, READ, REM, RESTORE, RETURN, RUN, SAVE, STOP, SYS, VERIFY, WAIT
Befehle Spezial (Bywords) FN, GO, NOT, SPC(, TAB(, THEN, TO, STEP
Arithmetische und logische Operatoren +, -, *, /, ^, >, =, <, AND, OR
Funktionen ABS, ASC, ATN, CHR$, COS, EXP, FRE, INT, LEFT$, LEN, LOG, MID$, PEEK, POS, RIGHT$, RND, SGN, SIN, SQR, STR$, TAN, USR, VAL
Konstanten und Systemvariablen Pi, ST, TI, TI$



Commodore BASIC V2.0: Befehle, Schlüsselwörter und Token

Beim Commodore 64 (auch VC-20) werden bei der internen Verarbeitung der BASIC-Befehle (Schlüsselwörter) eines BASIC-Programms für eine schnellere Verarbeitung und Speicherplatzersparnis sogenannte Token (Schlüsselzeichen) statt der Schlüsselwörter verwendet.

Die folgende Tabelle zeigt die BASIC-Schlüsselwörter, den dazugehörigen Token (dezimal / hexadezimal), die ROM-Einsprungadresse (hexadezimal), die Abkürzung und den Typ des Befehls.

Ich habe ein kleines C64 Commodore BASIC v2.0 Kompendium für die C64 BASIC-Befehle geschrieben, welches ihr hier findet. Im Kompendium findet ihr genaue Erklärungen des jeweiligen BASIC-Befehls und Programm-Beispiele dazu.

Nach der Tabelle erhalten Sie weiterführende Informationen zur Tokenisation der Befehle.



Commodore BASIC V2.0: Befehle, Schlüsselwörter und Token

BASIC SchlüsselwortToken dezToken hexROM Exec dezROM Exec hexAbk.Typ
END128$8043057$A831eNAnweisung/Befehl
FOR129$8142818$A742fOAnweisung/Befehl
NEXT130$8244318$AD1EnEAnweisung/Befehl
DATA131$8343256$A8F8dAAnweisung/Befehl
INPUT#132$8443941$ABA5iNAnweisung/Befehl
INPUT133$8543967$ABBF-Anweisung/Befehl
DIM134$8645185$B081dIAnweisung/Befehl
READ135$8744038$AC06rEAnweisung/Befehl
LET136$8843429$A9A5lEAnweisung/Befehl
GOTO137$8943168$A8A0gOAnweisung/Befehl
RUN138$8A43121$A871rUAnweisung/Befehl
IF139$8B43304$A928-Anweisung/Befehl
RESTORE140$8C43037$A81DreSAnweisung/Befehl
GOSUB141$8D43139$A883goSAnweisung/Befehl
RETURN142$8E43218$A8D2reTAnweisung/Befehl
REM143$8F43323$A93B-Anweisung/Befehl
STOP144$9043055$A82FsTAnweisung/Befehl
ON145$9143339$A94B-Anweisung/Befehl
WAIT146$9247149$B82DwAAnweisung/Befehl
LOAD147$9357704$E168lOAnweisung/Befehl
SAVE148$9457686$E156sAAnweisung/Befehl
VERIFY149$9557701$E165vEAnweisung/Befehl
DEF150$9646003$B3B3dEAnweisung/Befehl
POKE151$9747140$B824pOAnweisung/Befehl
PRINT#152$9843648$AA80pRAnweisung/Befehl
PRINT153$9943680$AAA0?Anweisung/Befehl
CONT154$9A43095$A857cOAnweisung/Befehl
LIST155$9B42652$A69ClIAnweisung/Befehl
CLR156$9C42590$A65EcLAnweisung/Befehl
CMD157$9D43654$AA86cMAnweisung/Befehl
SYS158$9E57642$E12AsYAnweisung/Befehl
OPEN159$9F57790$E1BEoPAnweisung/Befehl
CLOSE160$A057799$E1C7clOAnweisung/Befehl
GET161$A143899$AB7BgEAnweisung/Befehl
NEW162$A242562$A642-Anweisung/Befehl
TAB(163$A343752$AAE8tAAnweisung/Befehl, Spezial
TO164$A442861$A76D-Anweisung/Befehl, Spezial
FN165$A546068$B3F4-Anweisung/Befehl, Spezial
SPC(166$A643769$AAF9sPAnweisung/Befehl, Spezial
THEN167$A743314$A932tHAnweisung/Befehl, Spezial
NOT168$A844756$AED4nOAnweisung/Befehl, Spezial
STEP169$A942905$A799stEAnweisung/Befehl, Spezial
+170$AA47210$B86A-Operator, numerisch/string
-171$AB47187$B853-Operator, numerisch
*172$AC47659$BA2B-Operator, numerisch
/173$AD47890$BB12-Operator, numerisch
^174$AE49019$BF7B-Operator, numerisch
AND175$AF45033$AFE9aNOperator, logisch
OR176$B045030$AFE6-Operator, logisch
>177$B149076$BFB4-Operator, logisch
=178$B244756$AED4-Operator, logisch
<179$B345078$B016-Operator, logisch
SGN180$B448185$BC39sGFunktion, numerisch
INT181$B548332$BCCC-Funktion, numerisch
ABS182$B648216$BC58abSFunktion, numerisch
USR183$B7784$0310uSFunktion, numerisch/string
FRE184$B845949$B37DfRFunktion, numerisch, Spezial
POS185$B945982$B39E-Funktion, numerisch, Spezial
SQR186$BA49009$BF71sQFunktion, numerisch
RND187$BB57495$E097rNFunktion, numerisch
LOG188$BC45794$B9EA-Funktion, numerisch
EXP189$BD49133$BFEDeXFunktion, numerisch
COS190$BE57956$E264-Funktion, numerisch
SIN191$BF57963$E26BsIFunktion, numerisch
TAN192$C058036$E2B4-Funktion, numerisch
ATN193$C158128$E30EaTFunktion, numerisch
PEEK194$C247117$B80EpEFunktion, numerisch
LEN195$C346972$B77C-Funktion, numerisch
STR$196$C446181$B465stRFunktion, string
VAL197$C547021$B7ADvAFunktion, numerisch
ASC198$C646987$B78BaSFunktion, numerisch
CHR$199$C746828$B6ECcHFunktion, string
LEFT$200$C846848$B700leFFunktion, string
RIGHT$201$C946892$B72CrIFunktion, string
MID$202$CA46903$B737mIFunktion, string
GO203$CB43026$A812-Anweisung/Befehl, Spezial
π255$FF44702$AE9E-Funktion, numerisch, Konstante
ST (STATUS)--65463$FFB7-Systemvariable
TI (TIME)--??-Systemvariable
TI$ (TIME$)--43488$A9E0-Systemvariable


Tokenisation

Hier werden die Schlüsselwörter (Befehle) in ein Single-Byte-Wert (Token) umgewandelt, wenn sie in einem Programm gespeichert sind. Das geschieht entweder durch einen Programmstart mit RUN oder im Direktmodus (Konsole) durch das Drücken der Taste RETURN, wenn dort Kommandos eingegeben worden sind. Der BASIC-Interpreter arbeitet die Token der Reihenfolge nach ab.

De-Tokenisation

Hier werden die Token (Bytes) in lesbare BASIC-Befehle (Schlüsselwörter) umgewandelt, was eigentlich nur für das LIST-Kommando als Ausgabe und für gute menschliche Lesbarkeit zutrifft. Ansonsten wird die De-Tokenisation nicht angewandt.

Single-Byte-Token

Ein Token kann beim Commodore BASIC V2 (ab 4.0) einen Single-Byte-Wert zwischen 128-255 ($80-$FF) haben und belegt nur 1 Byte Arbeitsspeicher. Token-Codes sind immer größer oder gleich 128 ($80); d.h. das höchstwertige Bit in einem Byte, das einen Token repräsentiert, ist immer gesetzt und somit werden keine PETSCII-Zeichen (<128/<$80) als Token-Code benutzt.

Two-Bytes-Token

Ab dem Commodore BASIC 7.0 (C 128) werden wegen des umfangreichen BASIC-Befehlssatzes zwei Bytes für ein Token benötigt.

Ausführen von Token

Jedes Token hat eine sogenannte Ausführungsadresse (EXEC) im ROM, wo dann der entsprechende Code für den jeweiligen Token bzw. BASIC-Befehl ausgeführt wird.

Schlüsselwörter:

BASIC V2 enthält 76 Schlüsselwörter, 8 Operatoren, 1 Konstante und 3 Systemvariablen, die in verschiedenen Gruppen gegliedert sind:

  • 128-162 ($80-$A2): Befehle
  • 163-169 ($A3-$A9): “Bywords“, die Teil der Syntax der vorherigen Befehle sind
  • 170-179 ($AA-$B3): Arithmetische und logische Operatoren
  • 180-202 ($B4-$CA): Funktionen
  • 203 ($CB): Befehl – GO (der hier als Ausnahme hinter den Funktionen liegt)
  • 204-254 ($CC-$FE): Ein freier Bereich für 51 zusätzliche Token, z.B. der für BASIC-Erweiterungen von Drittanbietern genutzt wird
  • 255 ($FF): Konstante – Pi
  • Systemvariablen: ST (STATUS), TI (TIME), TI$ (TIME$). Im BASIC V2 ROM werden die Systemvariablen als Ausnahmen in den Routinen zur Behandlung normaler Variablen behandelt.

Abkürzungen

Die meisten BASIC-Schlüsselwörter kann man bei der Eingabe abkürzen. Abgekürzte Schlüsselwörter werden . gebildet, indem man die ersten (manchmal bis zu drei) Zeichen eintippt und das nächste Zeichen mit SHIFT eingibt.

Auch hier gibt es wieder einige Ausnahmen. Einige Schlüsselwörter (CLOSE, GOSUB, LEFT$, RESTORE, RETURN, STEP, STR$) benötigen gekürzt 3 statt 2 Zeichen. Der BASIC-Befehl PRINT wird nur mit einem Zeichen, dem ? abgekürzt. Es gibt auch einige BASIC-Befehle (INPUT, COS, FN, TO, IF, INT, LEN, LOG, NEW, ON, OR, POS, REM, TAN) die nicht abkürzbar sind.

Speichern

Es kann schon mal vorkommen, dass eine Programmzeile 80 Zeichen überschreitet, also dafür mehr als 2 Zeilen auf dem Bildschirm angezeigt werden. Dies geschieht dadurch, dass die Ausgabe der Token beim LIST-Befehl eben ungekürzt passiert und somit Programmzeilen mit mehr als 80 Zeichen auftreten können.

Wenn sie eine solche Programmzeile ändern wollen, müssen sie die Abkürzungen erneut eingeben bevor sie das Programm speichern. Achten sie dann darauf, dass sie nicht mehr als 80 Zeichen für eine Programmzeile insgesamt verwenden. Alle zusätzlichen Zeichen danach werden nach dem Drücken von RETURN automatisch abgeschnitten. Beim Speichern eines Programms auf einen Datenträger werden die Token und nicht die Schlüsselwörter benutzt.





Commodore BASIC v2.0: Video: 10 selten benutzte BASIC-Features

In diesem Video (00:31:19, engl.) erklärt Robin Harbron einige Features von CBM BASIC v2.0 die eigentlich selten benutzt werden. Robin zeigt Tipps und Beispiele zu jedem BASIC-Feature live am C-64.

Folgende Themen werden dabei angesprochen:

  1. DEF und FN
  2. ON GOSUB / ON GOTO
  3. Wissenschaftliche Notation
  4. INPUT Möglichkeiten
  5. LIST Parameter
  6. STOP und END
  7. CONT
  8. RND()
  9. USR()
  10. WAIT