Erstellt: 23. Februar 2020 (zuletzt geändert: 8. März 2020)

Turbo-Assembler

C64 StudioMit dem Turbo-Assembler direkt am C64 entwickeln

 
Wie meine Umfragen zeigen, wollen viele lieber direkt am C64 arbeiten, statt einen Emulator und / oder eine PC Entwicklungsumgebungen zu nutzen. Daher möchte ich euch hier kurz zeigen, wie dies mit dem Turbo-Assembler geht.

Immerhin haben 23% (Stand 23.02.2020) bei „Welchen C64 Emulator nutzt ihr hauptsächlich?“ mit „KEINEN: Es muss ein ‚echter‚ C64 sein!“ geantwortet, was die zweit häufigste Antwort ist.

Welchen C64 Emulator nutzt ihr hauptsächlich?

Ergebnisse anzeigen

Loading ... Loading ...
Bei „Womit erstellt ihr eure C64-Programme?“ haben 17% (Stand 23.02.2020) „direkt am C64“ gewählt, auch dies ist die zweit häufigste Antwort.

Womit erstellt ihr eure C64-Programme?

Ergebnisse anzeigen

Loading ... Loading ...

Da der C64 über keinen eingebauten Maschinensprachemonitor oder gar Assembler verfügt, muss ein separates Programm, wie der oben erwähnte Turbo-Assembler her. Natürlich gibt es noch viele andere Möglichkeiten (z. B. Profi-Ass 64, Hypra-Ass, Input-Ass, VirtualAssembler16 für die SuperCPU usw.), hier beschränke ich mich aber einzig auf den Turbo-Assembler.

Vor- und Nachteile

Mir fallen zwar viele Punkte ein, die gegen das Arbeiten direkt am C64 sprechen, z. B.

  • Man muss noch mehr auf den Speicherbedarf achten. Der Assembler selbst und euer Quellcode benötigen natürlich auch Arbeitsspeicher und dieser ist beim C64 knapp bemessen.
  • Die unbequeme C64-Tastatur.
  • Ein fieser Absturz kann eure ganze Arbeit vernichten.
  • Alte Disketten, die evtl. zum Verlust eurer Arbeit führen können.
  • Heutige Standards (Copy & Paste, Undo / Redo, Mausbedienung, Suchen & ersetzen usw.) sind gar nicht vorhanden oder nur sehr simple implementiert und recht hakelig zu nutzen.
  • usw.

Aber wie ich selbst beim Schreiben dieses Artikels bemerkt habe, macht es auch durchaus Spass, wieder wie in der guten alten Zeit zu programmieren. Schließlich war es für Hobby-Entwickler in den Achtzigern auch üblich, direkt am C64 arbeiten.

Download

Zunächst benötigt ihr natürlich den Turbo-Assembler. Dieser wurde ursprünglich 1985 von Wolfram Römhild entwickelt. Vom Turbo-Assembler gibt es sehr – sehr viele Versionen, da er in der Szene äußerst beliebt war und im Laufe der Jahre immer wieder von verschiedenen Gruppen angepasst wurde. Sei es um Fehler zu beheben oder neue Funktionen einzubauen, wie z. B. die REU-Unterstützung.

Ich habe mich hier für die Version 7.4 von 2001 entschieden. Falls ihr eine andere Fassung nutzt, kann es evtl. zu Abweichungen kommen, aber im Großen und Ganzem sollte die Bedienung einheitlich sein.

Im Download findet ihr ein D64-Image mit dem Turbo-Assembler:

Das Image müsst ihr dann natürlich noch zum C64 übertragen (z. B. mit einem SD2IEC, dem Turbo Chameleon 64, Kerberos oder wie ihr das sonst auch immer macht), um es dort zu nutzen und / oder auf einer echten Diskette zu speichern.

Den Turbo-Assembler laden & starten

Nun, da ihr den Turbo-Assembler zum C64 übertragen habt (ich gehe davon aus, dass ihr eine Floppy mit der Gerätenummer 8 verwendet) ladet diesen einfach mit LOAD“:*“,8 und startet ihn anschließen ganz einfach mit RUN.

Ihr solltet folgendes sehen:

Turbo-Assembler: Erster Start
Turbo-Assembler: Erster Start

Beim ersten Start werdet ihr gefragt, ob ihr den Speicher löschen wollt clear memory (y/n)?. Wenn ihr frisch mit der Arbeit beginnt, drückt am besten die Y-Taste, um einen wohl definierten Zustand zu erhalten.
Falls es mal zu einem Absturz kommt, bevor ihr speichern konntet, schaltet den C64 nicht aus. Ihr könnt den Turbo-Assembler (auch nach einem Reset) neu laden und starten. Drückt dann erstmal auf N, mit Glück ist euer Quellcode noch erhalten und ihr könnt diesen sichern.

Die letzten beiden Bildschirmzeilen des Editors sind übrigens für interne Zwecke reserviert.
In der vorletzten Zeile werden Informationen oder Abfragen (z. B. so wie eben clear memory (y/n)?) angezeigt.

Die unterste Zeile hat folgenden Aufbau:

  • Hinter x: findet ihr die aktuelle Spalte in der der Cursor steht, beginnend mit 0.
  • Das line: zeigt an, in welcher Zeile sich der Cursor befindet, beginnt ebenfalls bei 0.
  • Der Turbo-Assembler speichert euren Quellcode gepackt von $8FEB quasi Rückwärts bis $0801.
    Bei bot: (könnte für Begin Of Turbo-Assembler stehen) seht ihr wo euer Quellcode im Arbeitsspeicher beginnt. Jede neue Eingabe verringert diesen Wert also.
  • Hinter insert: seht ihr, welcher Einfügemodus aktuell aktiv ist.
    • Falls dort char steht, wurde der Zeicheneinfügemodus angeschaltet.
    • Steht line dahinter, ist der Zeileneinfügemodus aktiv.

Lasst uns nun mal etwas programmieren…

Einen ersten Quellcode eingeben

Auch wenn ihr jetzt evtl. noch nicht viel mit den Befehlen anfangen könnt, gebt das folgende Programm bitte einfach mal ein und kommt später, sobald ihr das Assembler-Tutorial durchgeht, ggf. nochmal hier her zurück. Ausgangspunkt ist nun folgender Bildschirm:

Turbo-Assembler: Ausgangspunkt
Turbo-Assembler: Ausgangspunkt

Ihr könnt euch frei mit den Cursor-Tasten über den Bildschirm bewegen. Probiert das jetzt mal aus. Dabei solltet ihr bemerken, dass sich die Werte hinter x: und line: in der Statuszeile ganz unten ändern. Sobald euer Quellcode mehr als 22 Zeilen umfasst, wird der Bildschirm zeilenweise gescrollt.

Stellt nun den Cursor wieder oben / links in die Ecke und gebt *=$1000 ein. Dies legt fest, wo euer Programm später im Speicher liegen soll. Statt $1000 könnt ihr übrigens auch den dezimalen Wert 4096 eingeben. Sobald ihr die Zeile mit RETURN bestätigt, werdet ihr bemerken, dass der Turbo-Assembler eure Eingabe verschiebt.

Turbo-Assembler: Startadresse festlegen
Turbo-Assembler: Startadresse festlegen

Wie ihr gleich noch seht, formatiert der Turbo-Assembler eure Eingaben teilweise um, sobald ihr eine Zeile mit RETURN bestätigt oder um genauer zu sein, eine Zeile verlasst. Beim Verlassen wird eure Eingabe geprüft und ggf. umformatiert (z. B. gibt es feste Positionen für Label, Konstanten, Befehle usw.).
Sollte ein Fehler entdeckt werden, wird die Zeile rot eingefärbt und in der Infozeile erscheint ein Hinweis.

Turbo Assembler: Fehlerhafte Eingabe
Turbo Assembler: Fehlerhafte Eingabe

Nach der obigen korrekten Eingabe, sollte der Cursor unter dem * stehen. Gebt dort bitte einfach start ein und drückt wieder RETURN. Bei start handelt es sich übrigens um ein Label, dies wird ganz nach links, in die erste Spalte, verschoben.

Turbo-Assembler: Ein erstes Label
Turbo-Assembler: Ein erstes Label

Wie ihr seht, steht der Cursor automatisch wieder in der 10. (die Zählung beginnt ja bei 0) Spalte. Gebt nun noch die beiden Zeilen inc $d020 und jmp start ein.

Beachtet, dass ihr beim Turbo-Assembler alle Befehle, Label und Konstanten in Kleinbuchstaben eingeben müsst! Verwendet ihr bei einem Label Großbuchstaben, wird euch ein Fehler angezeigt!

Turbo-Assembler: Das komplete Programm
Turbo-Assembler: Das komplette Programm

Da unser Programm nun fertig ist, wollt ihr es bestimmt direkt starten. Ihr solltet eure Arbeit aber immer zu erst speichern, sonst besteht die Gefahr, dass ihr durch einen Programmfehler alles verliert.

Den Quellcode speichern und das Programm erstellen

Der Turbo-Assembler wird mit einer ganze Reihe an Tastaturkommandos gesteuert.
Drückt nun die -Taste, gefolgt von S, um den Quellcode zu speichern. Es erscheint eine Abfrage für den Dateinamen. Gebt einen passenden Namen ein und bestätigt diesen mit RETURN.

Turbo Assembler: Quellcode speichern
Turbo Assembler: Quellcode speichern

Jetzt, da unsere Arbeit erfolgreich gespeichert wurde, in der Infozeile sollte 00, ok,00,00 stehen, können wir das Programm endlich gefahrlos starten. Drückt dazu wieder die -Taste und anschließend 3. Das Programm wird dann erstellt. Es sollten keine Fehler angezeigt werden.

Falls es Probleme beim Erstellen gibt, zeigt euch der Turbo-Assembler die entsprechenden Zeilen, so wie auf dem folgenden Bild, an.

Turbo Assembler: Fehler beim Erstellen
Turbo Assembler: Fehler beim Erstellen

Korrigiert dann die entsprechenden Punkte.
Im obigen Beispiel, fehlt z. B. ein $, es muss inc $d020 lauten. Außerdem heißt unser Label für die Schleife start, daher ist jmp star falsch, es wurde das t am Ende vergessen.

Sobald die Erstellung fehlerfrei durchläuft, könnt ihr zum Schluß die Taste S drücken, um das Programm auszuführen.

Turbo Assembler: Das Programm assemblieren
Turbo Assembler: Das Programm assemblieren

Das Programm läuft und der Rahmen blinkt fröhlich vor sich hin 😉 .

Turbo Assembler: Unser Programm läuft
Turbo Assembler: Unser Programm läuft

Um zurück zum Turbo-Assembler zu kommen, drückt einfach die RESTORE-Taste.

Turbo-Assembler: Liste der Tastaturkommandos

Fast alle Kommandos werden mit der -Taste eingeleitet. Es gibt auch Ausnahmen, wie die Funktionstasten F1 bis F8, aber werft einfach einen Blick auf die folgende Liste.
Ich erhebe hier übrigens keinen Anspruch auf Vollständigkeit! Außerdem kann es, durch die unzähligen Turbo-Assembler-Versionen auch zu Unterschieden kommen, aber das Meiste sollte übereinstimmen.

TasteFunktion
{CRSR LINKS}
{CRSR RECHTS}
{CRSR RAUF}
{CRSR RUNTER}
Wie bereits erwähnt, könnt ihr euch mit den Cursor-Tasten frei über den Bildschirm bewegen.
RETURNBewegt den Cursor in die nächste Zeile, an den eingestellten Cursor-Tab. Falls das Zeileneinfügen aktiv ist, wird vorher eine neue leere Zeile unter der aktuellen eingefügt.
SHIFT+RETURNUnterdrückt das Einfügen einer neuen Zeile, falls dies aktiv ist und verhält sich ansonsten, wie ein einfaches RETURN.
DELZeichen links vom Cursor löschen.
INSTEinfügemodus für einzelne Zeichen umschalten. (Standard = aus)
Hiermit schaltet ihr zwischen Überschreiben und Einfügen bei Eingabe der einzelnen Zeichen um.
In der Statuszeile ganz unten, könnt ihr an einem char hinter insert: erkennen, dass das Einfügen von Zeichen aktiv ist.
F1Scrollt 20 Zeilen rauf.
F2Springt an den Anfang des Quellcodes.
F3
Die Funktionstasten F3 bis F6 können übrigens frei belegt werden (s. K)
.text " " an der aktuellen Cursorposition einfügen.
F4Erstellt das Programm und startet es, sofern die Assemblierung erfolgreich war.
F5.byte $00 an der aktuellen Cursorposition einfügen.
F6Die aktuelle Zeile löschen (s. DEL)
F7Scrollt 20 Zeilen runter.
F8Springt ans Ende des Quellcodes.
Ab hier folgen jetzt Kommandos, die mit eingeleitet werden müssen!
Da viele Kommandos mit begonnen werden, muss man erneut drücken, um das Zeichen zu erhalten.
DELDie aktuelle Zeile komplett löschen, der Quellcode „rutscht“ dabei nach oben, solange es mehr als 22 Zeilen gibt.
INSTDen Zeilen-Einfügemodus umschalten. (Standard = an)
Falls aktiv, wird nach einem RETURN automatisch eine neue leere Zeile eingefügt. In der Statuszeile ganz unten, könnt ihr an einem line hinter insert: erkennen, dass das Einfügen von Zeilen aktiv ist.
SPACELöscht den Inhalt der aktuellen Zeile, indem diese mit lauter Leerzeichen überschrieben wird.
1Den Turbo-Assembler verlassen, um zum BASIC zu wechseln.
Gebt SYS 333 oder SYS 36864 ein und bestätigt dies mit RETURN, um den Turbo-Assembler wieder zu starten.
2Die aktuelle Zeile mit einer Trennline füllen
;----------------------
Achtung: Dabei wird alles überschrieben, was bisher in der Zeile stand!
3Erstellt (assembliert) euer Programm im Arbeitsspeicher.
4Exportiert euren assemblierten Quellcode in eine SEQ-Datei. Ihr seht im Listing die Speicheradressen, Bytes und euren Sourcecode.
Gebt ihr statt eines Dateinamens ein ? ein, wird das Listing ausgedruckt. Mit einem * erfolgt die Ausgabe auf dem Bildschirm, hier könnt ihr die Ausgabe mit der RUN STOP-Taste abbrechen.
5Erstellt (assembliert) euer Programm, wie bei 3, dieses Mal wird es allerdings auf der Diskette gespeichert.
6Fragt einen Speicherbereich ab, der dann ab der aktuellen Cursorposition als .byte-Zeilen in den Quellcode aufgenommen wird.
7Setzt den Cursor-Tab auf die aktuelle Spalte. Nach einem RETURN, erscheint der Cursor dann immer in dieser Spalte.
8Setzt den Quellcode-Tab auf die aktuelle Spalte, solange diese unter 12 liegt.
Mnemonics und Pseudo-Op-Codes werden dort automatisch ausgerichtet.
+Falls ihr mal schnell zwei hexadezimale 16-Bit Zahlen addieren wollt, könnt ihr dieses Kommando nutzen.
-Wie +, nur die Subtraktion.
Die aktuelle Zeile in die „Zwischenablage“ kopieren.
Die Zeile aus der „Zwischenablage“ einfügen.
Achtung: Dabei wird alles überschrieben, was bisher in der Zeile stand!
@Diskettenstatus anzeigen.
Wenn keine Probleme vorliegen, sollte
00, ok,00,00 angezeigt werden.
*Das Inhaltsverzeichnis der Diskette anzeigen.
ADies aktiviert den PETSCII-Modus. Der Cursor blinkt etwas schneller, solange dieser Modus aktiv ist.
In diesem Modus könnt ihr in .text-Zeilen z. B. auch Steuercodes eingeben.
Betätigt , um den PETSCII-Modus zu beenden.
EHiermit könnt ihr Textbausteine oder ganze Quellcodes, die als SEQ-Datei gespeichert sind, von der Diskette in den Editor laden. Die Zeilen werden an der aktuellen Cursorposition eingefügt.
Werft auch einen Blick auf W.
IFunktioniert wie SHIFT+F, nur dass hier automatisch der freie Speicherbereich unter dem vom Turbo-Assembler für den Quellcode verwendetem vorgeschlagen wird.
QAlle Markierung (s. M) löschen.
RStartet das Suchen und Ersetzen. Es wird erst der zu ersetzende Text und danach der neue Text abgefragt. Anschließend wird der Cursor auf die erste gefundene Position, nach der aktuellen Curorposition, gesetzt.
Beachtet auch H, T und Y
TErsetzt beim Suchen und Ersetzen (s. R) die aktuell gefundene Stelle.
USpeichert eine Liste der von euch verwendeten Labels mit den dazugehörigen Adressen als SEQ-Datei. Beachtet, dass die Infos auf dem letzten Erstellen beruhen. Am besten assembliert ihr euer Programm direkt vor dem Aufruf dieses Kommandos.
Gebt ihr statt eines Dateinamens ein ? ein, wird gedruckt. Mit einem * erfolgt die Ausgabe auf dem Bildschirm.
WSpeichert euren Quellcode im ASCII-Format als SEQ-Datei.
Um eine solche Datei wieder zu laden, müsst ihr E nutzen.
YErsetzt beim Suchen und Ersetzen (s. R) alle Stellen ab der aktuellen Cursorposition.
SEuren Quellcode im Turbo-Assembler-Format speichern.
Hinweis: Der Turbo-Assembler verwendet ein binäres Format, ihr könnt euren so gespeicherten Quellcode also nicht direkt „lesen“ oder mit anderen Assemblern nutzen.
Es werden übrigens auch Einstellungen, wie die verwendeten Farben, die Tabs, die Belegung der Funktionstasten F3 bis F6, Markierungen und die aktuelle Cursorposition gespeichert.
DEs erscheint eine Abfrage, die es euch erlaubt, einen DOS-Befehl an das Diskettenlaufwerk zu senden.
FStartet die Suche.
Der Cursor wird auf die erste gefundene Stelle, ab der aktuellen Position gesetzt.
Beachtet auch H.
HWeitersuchen, nach F oder R.
GZu einer Markierung (s. M) springen.
KDie Funktionstasten F3 bis F6 belegen. Drückt auf die gewünschte Funktionstaste und legt dann fest, was beim Betätigen passieren soll.
LEinen Quellcode im Turbo-Assembler-Format laden.
Achtung: Dabei wird alles im Editor überschrieben!
:Zeigt eine Liste der aktuellen Markierungen (s. M) an.
ZAlle Änderung in der aktuellen Zeile rückgängig machen. Dieses Undo klappt nur solange, bis ihr die geänderte Zeile verlasst. Außerdem werden sämtliche Änderungen in der Zeile verworfen.
CKaltstart vom Turbo-Assembler.
Achtung: TASM wird neu initialisiert und der aktuelle Quellcode komplett gelöscht.
BBlockbefehle für den mit M markierten Block.
W: Speichert den Block als SEQ-Datei auf der Diskette.
C: Kopiert den Block an die aktuelle Cursorposition.
K: Den Block löschen.
Vorsicht: Setzt ihr einen Blockstart in Zeile 0 und nutzt K kann es zum Datenverlust kommen!
MMarkierungen (Lesezeichen) und Blöcke setzen.
Es erscheint eine Abfrage, drückt dort eine Ziffer zwischen 0 und 9, um ein einfaches Lesezeichen zu setzen.
Um einen Block (s. B) festzulegen, drückt S für Blockstart und E für Blockende. Ein Block wird in einer anderen Farbe dargestellt.
NGebt die gewünschte Zeilennummer ein, um dort hin zu springen.
=Zwei Zeilen verbinden.
Überschreibt den Inhalt der Zeile über dem Cursor, ab der Spalte, in der der Cursor steht, mit dem Inhalt der aktuellen Zeile ab der Cursorposition. Die aktuelle Zeile wird anschließen gelöscht.
(Klingt vertrackt, probiert es einfach mal aus.)
/Zeigt euch den Status von $DC00 und $DC01 an.
Drückt RESTORE, um die Anzeige zu verlassen.
F1Setzt die frei belegbaren Funktionstasten F3 bis F6 wieder auf Standard zurück.
Achtung: Es erfolgt keine Sicherheitsabfrage!
RETURNTrennt die Zeile, ab der aktuellen Cursorposition auf zwei Zeilen.
PEOR-Verschlüsselung (Standard = $00)
Der Turbo-Assembler speichert euren Quellcode mit S binär. Falls ihr ein unbefugtes Laden unterbinden wollt, könnt ihr mit diesem Kommando eine Art Verschlüsselung aktivieren.
Achtung: Ein Quellcode lässt sich nur mit der richtigen EOR-Verschlüsselung wieder laden!
JEinen Speicherdump anzeigen, dazu werden die Start- und Endadresse abgefragt.
SHIFT+FÜberschreibt einen Speicherbereich mit einem bestimmten Wert. Dazu werden die Start-, Endadresse und der Füllwert abgefragt.
Vorsicht: Füllt ihr den falschen Bereich, kann es zum Absturz und / oder kompletten Datenverlust kommen!
SHIFT+LLädt eine Datei an die angegebene Speicheradresse.
Vorsicht: Überschreibt ihr den falschen Bereich, kann es zum Absturz und / oder kompletten Datenverlust kommen!
SHIFT+SSpeichert den eingegebenen Adressbereich auf der Diskette.
VAktuelle Speicherbelegung anzeigen.
- = frei + = belegt
ODie verfügbaren Farbschemen durchschalten.
SHIFT+KTippgeräusche an- / ausschalten.
Falls eingeschaltet, wird ein Klickgeräusch abgespielt, sobald ihr eine Taste drückt.

Allgemeine Anmerkungen zur Turbo-Assembler-Bedienung

Hier noch einig Infos, die evtl. nützlich sind. Einige Punkte wurden bereits erwähnt, werden hier aber wiederholt.

  • In der Regel gelangt ihr mit der RESTORE-Taste zurück zum Turbo-Assembler. Falls dies mal nicht klappt, geht es auch vom BASIC mit der Eingabe von SYS 333 oder SYS 36864.
  • Der Turbo-Assembler benötigt natürlich auch Arbeitsspeicher. Er ist ab Speichersstelle $9000 zu finden. Außerdem benötigt eurer Quellcode ebenfalls Platz, TASM speichert diesen gepackt von $8feb bis $0801 quasi „rückwärts“.
  • Möchtet ihr beim Speichern eine vorhandene Datei überschreiben, dann gebt direkt vor dem Dateinamen @: ein.
  • Alles muss in eine Zeile passen, d. h. auch .byte-Zeilen können nicht in der nächsten Zeile fortgesetzt werden. Ihr müsst dort wieder mit .byte beginnen.
  • Der Turbo-Assembler verfügt über einen mathematischen Parser. Ihr könnt also im Quellcode Formeln eingeben, die dann bei der Assemblierung berechnet werden.
  • Label und Konstanten dürfen maximal 15 Zeichen lang sein.
  • Falls ihr einen BASIC-Start in eurem Programm nutzt, solltet ihr nach dem Erstellen nicht auf die S-Taste drücken! Geht stattdessen zurück zum Editor und wechselt mit 1 ins BASIC. Dort könnt ihr dann einfach RUN eingeben, um euer Programm zu starten.
Ausdrücke, Operatoren, usw.

Beim Schreiben eurer Programme könnt ihr folgende Ausdrücken und Operatoren verwenden.

KürzelFunktionBeispiel
$Prefix für hexadezimale Zahlen.lda #$e2
%Prefix für binäre Zahlen (max. 8-Bit).lda #%11000011
!
Prefix für dezimale Zahlen.
Das ! ist optional und wird meistens weggelassen.
lda #!123
gleichbedeutend mit
lda #123
“x“Zeichen und Textelda #“a“
(
)
Klammern für Berechnungen.lda #(3+5)*2
*Multiplikationlda #8*2
/Divisionlda #16/2
+Additionlda #3+5
-Subtraktionlda #16-8
&Logisches UNDlda #%10011001&11000011
.Logisches ODERlda #%10011001.11000011
:Exklusives ODERlda #%10011001:11000011
<Unteres Byte eines 16-Bit-Wertlda #<$ffe2
>Oberes Byte eines 16-Bit-Wertlda #>$ffe2
*Aktuelle Speicheradresselda #>*
*=Speicheradresse setzen*= $1000
;Alles ab dem Semikolon ist ein Kommentar und wird vom Assembler bei der Programmerstellung ignoriert.; Mein Kommentar

Unterschiede zum C64 Studio / ACME

Der größte Unterschied liegt in den verfügbaren Pseudo-OP-Codes und deren Schreibweise. Der Turbo-Assembler bietet davon nur vier.

Pseudo-OP-CodeBeschreibungC64 Studio / ACME
.byteEinzelne Bytes (z. B. Spritedaten) abbilden.
Beispiel
.byte $80, $ff, 255, %10010110
!byte
.word16-Bit-Werte (z. B. Adresslisten) abbilden.
Beispiel
.word *, $ffe2, 65535
!word
.textTexte für Bildschirmausgaben.
Beispiel
.text “Bitte warten...“
!text
.offsDie nächste Anweisung wird im Arbeitsspeicher an der Position (aktuelle Adresse + Offsetwert) abgelegt.
Beispiel
.offs 10
Das lässt sich auch über *= *+10 erreichen.
*= *+{Wert}

Wie oben erwähnt, müsst ihr natürlich auf Groß- und Kleinschreibung, sowie die Beschränkung auf 40 Zeichen je Zeile achten.


So, das reicht hoffentlich erstmal.
Falls ihr wirklich größere Projekte direkt am C64 entwickelt, bietet sich noch ein Freezer wie das Action Replay, die The Final Cartridge III oder etwas ähnliches an. Damit könnt ihr eure Programm zur Laufzeit untersuchen und so evtl. Fehler leichter aufspüren.

Nun noch viel Spass und Erfolg beim Programmieren, auf dem guten alten C64.


Schrott!!Naja...Geht so...Ganz gut...SUPER! (4 Bewertungen | Ø 4,00 von 5 | 80,00%)

Loading...


Zurück

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.

Protected by WP Anti Spam