C64/C128 Alles über Maschinensprache
| C64/C128 Alles über Maschinensprache | |||
|---|---|---|---|
 |
Sprache | deutsch | |
| Autor(en) | Frank Riemenschneider | ||
| Verlag | Markt&Technik Verlag (1988) | ||
| Jahr | 1988 | ||
| ISBN | ISBN 3-89090-571-4 | ||
| Neupreis | DM 59.- | ||
| Datenträger | |||
| Seitenzahl | 314 | ||
| letzte Auflage | 1. Auflage, 1988 | ||
| Genre | Fortgeschrittene | ||
| Information | Commodore Sachbuchreihe | ||
Buchrückseite[Bearbeiten | Quelltext bearbeiten]
Bei kaum einem anderen Heimcomputer ist die Diskrepanz zwischen der Leistungsfähigkeit der Hardware und deren Ausnutzung durch das eingebaute Basic so groB wie beim C64. So nutzen Maschinensprache-Programme gegenüber Basic den gesamten Speicher aus, erreichen eine bis zu 100mal schnellere Verarbeitungsgeschwindigkeit und lassen neue Programmiertechniken wie die Interrupt-Programmierung zu.
Da jetzt aber viele C64-Besitzer sagen: Assembler bzw. Maschinensprache ist mir zu schwierig, zu kompliziert, ging der Autor dieses Buches einen neuen Weg. Er führt den Leser über Theorie und anschließende, vertiefende Praxis zum Erfolg, wobei die nötige Software auf der beiliegenden Diskette enthalten ist.
Im ersten Kapitel finden Sie jeden einzelnen 6510-Prozessorbefehl in Funktion, Wirkung und anhand von Beispielen erklärt. Alle weiteren Kapitel beschäftigen sich, aufgeteilt nach Anwendungsgebieten, mit ausführlichen, praktischen Übungen.
Die Grundlage bildet das beiliegende Assembler-Entwicklungspaket mit den Programmen Hypra-Ass-Plus Makroassembler, SMON-Plus Maschinensprachemonitor, Reassembler und Einzelschrittsimulator.
Folgende Themen werden umfassend beschrieben:
- der 6510-Mikroprozessor
- die Interrupt-Programmierung
- der Variableneinsatz in Maschinensprache
- die HiRes-Grafik-Programmierung
- die Programmierung einer Basic-Erweiterung
Mit den gewonnenen Kenntnissen lassen sich z.B. Hunderte von Datensätzen in Sekunden sortieren, anspruchsvolle Grafiken programmieren, oder Sie richten Ihren C64 mit eigenen Basic-Befehlen auf Ihre individuellen Bedürfnisse ein. Zu allen beschriebenen Anwendungen finden Sie Beispielprogramme, die auch auf der beiliegenden Diskette, im Format 1541, enthalten sind.
Ein umfangreicher Anhang mit Tabellen, Übersichten und Aufstellungen aller wichtigen Daten für die Maschinenprogrammierung wie Befehle, Opcodes, Token, ROM-Routinen rundet das Buch ab.
Hardware-Voraussetzungen:
C64 bzw. C128 im 64er-Modus mit einer Floppy (1541, 1570, 1571)
Inhalt der Begleitdiskette:
Hypra-Ass-Plus Makroassembler, SMON-Plus Maschinensprachemonitor, Reassembler, Einzelschrittsimulator, Beispielprogramme.
Inhaltsverzeichnis[Bearbeiten | Quelltext bearbeiten]
Vorwort 9
Ladehinweise zur beiliegenden Diskette 11
-----------------------------------------------------------------------
Kapitel 1: Maschinensprache auf dem C64 15
-----------------------------------------------------------------------
1.1. Der 6510-Mikroprozessor 16
1.2. Die Adressierungsarten des 6510 21
1.2.1 Die implizite Adressierung 21
1.2.2 Die Akkumulator-Adressierung 22
1.2.3 Die relative Adressierung 22
1.2.4 Die indirekt-absolute Adressierung 22
1.2.5 Die unmittelbare Adressierung 22
1.2.6 Die absolute Adressierung 23
1.2.7 Die Zeropage-Adressierung 23
1.2.8 Die absolut-X-indizierte Adressierung 23
1.2.9 Die Zeropage-X-indizierte Adressierung 23
1.2.10 Die absolut-Y-indizierte Adressierung 24
1.2.11 Die Zeropage-Y-indizierte Adressierung 24
1.2.12 Die X-indiziert-indirekte Adressierung 24
1.2.13 Die indirekt-Y-indizierte Adressierung 25
1.3 Übersicht und Funktionen aller 6510-Befehle 25
1.3.1 Die Ladebefehle 26
1.3.2 Die Speicherbefehle 28
1.3.3 Die Transferbefehle innerhalb des Prozessors 29
1.3.4 Die arithmetischen Befehle 31
1.3.5 Die logischen Befehle 35
1.3.6 Die Zählbefehle 35
1.3.7 Die Verschiebebefehle 37
1.3.8 Die Vergleichsbefehle 41
1.3.9 Die Befehle zur bedingten Verzweigung 42
1.3.10 Die Befehle zur Beeinflussung der Flags 47
1.3.11 Die unbedingten Sprungbefehle 49
1.3.12 Die Unterprogrammbefehle 50
1.3.13 Die Stackbefehle 51
1.3.14 Die Interruptbefehle 53
1.3.15 Die Sonderbefehle 53
1.3.16 Die illegalen Opcodes 54
1.4 Das Assembler-Entwicklungssystem 59
1.4.1 Der Hypra-Ass-Plus-Makroassembler 60
1.4.1.1 Der Quelltext 60
1.4.1.2 Hypra-Ass-Variable (Label) 64
1.4.1.3 Die Makros von Hypra-Ass 65
1.4.1.4 Rechnen im Quelltext 67
1.4.1.5 Die Pseudobefehle 68
1.4.1.6 Die Assemblierung 71
1.4.1.7 Nützliche Makros für den Hypra-Ass 72
1.4.2 Der Reassembler zum Hypra-Ass 73
1.4.3 Der SMON-Maschinensprachemonitor 76
1.4.3.1 Die Befehle des SMON 77
1.4.3.2 Die speziellen Befehle des SMON Plus 85
1.4.3.3 Die speziellen Befehle des SMON Illegal 86
1.4.3.4 Die speziellen Befehle des SMON Floppy 86
-----------------------------------------------------------------------
Kapitel 2: interruptprogrammierung von A — Z 89
-----------------------------------------------------------------------
2.1 Was ist ein Interrupt und wodurch wird er ausgelöst 90
2.2 Der NMI und seine »Quellen« 92
2.2.1 Die NMI-Quelle CIA 2 94
2.2.1.1 Die Echtzeituhr der CIA 2 als NMI-Auslöser 97
2.2.1.2 Die 16-Bit-Timer als NMI-Auslöser 103
2.3 Der IRQ und seine »Quellen« 109
2.3.1 Der Systeminterrupt als IRQ-Quelle 111
2.3.2 Die »restliche« CIA 1 als IRQ-Quelle 113
2.3.3 Der Video-Interface-Chip (VIC) als IRQ-Quelle 113
2.3.3.1 Der Rasterzeileninterrupt als IRQ-Auslöser 117
2.3.3.2 Die Sprite-Kollisionen als IRQ-Auslöser 120
2.3.3.3 Impuls vom Lightpen/Joystick als IRQ-Auslöser 123
2.3.4 Die Unterbrechung des IRQ durch einen IRQ 126
2.4 Die BREAK-Routine 127
2.5 Der Abbruch eines IRQ durch den Programmierer 128
-----------------------------------------------------------------------
Kapitel 3: Variablen in Maschinensprache 135
-----------------------------------------------------------------------
3.1 Aufbau der nichtindizierten Variablen 135
3.1.1 Der Variablentyp INTEGER 135
3.1.1.1 Rechnen mit Integerzahlen 138
3.1.1.2 Bildschirmausgabe einer Integerzahl 140
3.1.2 Der Variablentyp STRING 141
3.1.2.1 Bildschirmausgabe einer Stringvariablen 142
3.1.3 Der Variablentyp FUNKTION 142
3.1.4 Der Variablentyp FLIESSKOMMA 143
3.1.4.1 Rechnen mit Fließkommazahlen 149
3.1.4.2 Übersicht aller Fließkommaroutinen 168
3.1.4.3 Bildschirmausgabe einer Fließkommazahl 169
3.1.5 Umwandlung der Variablenformate 169
3.1.6 Einrichten/Suchen einer nichtindizierten Variablen 171
3.1.7 Wertetabelle in Maschinensprache 172
3.2 Aufbau der indizierten Variablen (Arrays) 179
3.2.1 Das Arrayelement vom Typ INTEGER 181
3.2.2 Das Arrayelement vom Typ FLIESSKOMMA 181
3.2.3 Das Arrayelement vom Typ STRING 182
3.2.4 Suchen/Anlegen eines Arrayelementes 182
3.2.5 Bubblesort in Maschinensprache 186
3.2.5.1 Bubblesort für Integer-Variablen 186
3.2.5.2 Bubblesort für Fließkommavariablen 190
3.2.5.3 Bubblesort für Strings 193
-----------------------------------------------------------------------
Kapitel 4: Programmierung der HiRes-Grafik 199
-----------------------------------------------------------------------
4.1 Lage der HiRes-Grafik und des Farb-RAMs 200
4.2 Aufbau des Grafikspeichers und des Farb-RAMs 205
4.3 Zeichnen von Rechtecken 216
4.4 Zeichnen von Kreisen/Ellipsen 226
4.5 Das Schreiben von Text in die HiRes-Grafik 245
-----------------------------------------------------------------------
Kapitel 5: Programmierung von Basic-Erweiterungen 261
-----------------------------------------------------------------------
5.1 Die Umwandlung in Interpretercode 262
5.2 Die Umwandlung des Interpretercodes in Klartext 271
5.3 Die Ausführung der Basic-Befehle 273
-----------------------------------------------------------------------
Anhang 277
-----------------------------------------------------------------------
Anhang 1 Umrechnungstabelle Dezimal — Hexadezimal — Binär 277
Anhang 2 Alphabetische Tabelle der Prozessorbefehle und Opcodes 281
Anhang 3 Nach Wert sortierte Übersicht über die Prozessorbefehle
inklusive illegaler Opcodes 285
Anhang 4 Beeinflussung der Prozessor-Flags 289
Anhang 5 Routinen für Kooperation von Basic und Maschinensprache 293
Anhang 6 Betriebssystemroutinen des C64 295
Anhang 7 Befehlsübersicht Hypra-Ass 297
Anhang 8 Befehlsübersicht SMON Plus 299
Anhang 9 Adressen und Token der Befehle, Funktionen und Operatoren 301
Anhang 10 Die Codes des C64 303
Stichwortverzeichnis 311
Hinweise auf weitere Markt&Technik-Produkte 315
Leseprobe[Bearbeiten | Quelltext bearbeiten]
Seite 126/127: 2.3.4 Die Unterbrechung des IRQ durch einen IRQ
Wenn Sie die IRQ-Beispiele des VIC einmal vergleichen, sehen Sie, daß alle Routinen eine scheinbar merkwürdige Gemeinsamkeit aufweisen: Wenn sich herausstellte, daß der IRQ durch den Systeminterrupt ausgelöst wurde, wird das ICR der CIA 1 gelöscht und der IRQ mit dem CLI-Befehl freigegeben, obwohl wir uns in einer Interrupt-Routine befanden. An Hand des Rasterzeileninterrupts wollen wir dieses Rätsel lösen.
Wie in Abschnitt 1.3.3.1. erwähnt wurde, dauert der Aufbau eines kompletten Bildschirms ca. 1/20 Sekunde. Da wir im Beispielprogramm während eines solchen Aufbaus zwei IRQs durch Rasterzeilen ausgelöst haben, bleibt zwischen je zwei IRQs eine Zeitspanne von ca. 1/40 Sekunde. Da jedoch gleichzeitig der Systeminterrupt ca. alle 1/60 Sekunde ausgelöst wird, lassen sich Überschneidungen der beiden IRQs auf Dauer nicht vermeiden, d.h., während ein Systeminterrupt abgearbeitet wird, wird irgendwann ein IRQ durch Rasterzeilen auftreten. Wir haben jedoch ganz zum Anfang des IRQ-Abschnitts gesehen, daß beim Auslösen eines IRQ automatisch das Interrupt-Flag gesetzt wird und somit weitere IRQs verhindert werden. Unser Rasterzeilen-Interrupt müßte also so lange warten, bis die Systeminterruptroutine beendet wäre. Da in dieser Zeit der Bildschirmaufbau jedoch schon fortgeschritten ist, wäre die Folge für unser Beispielprogramm eine unsaubere Trennung zwischen Klein- und Großschrift-Zeichensatz, die wir vermeiden wollen. Daher hat für uns der IRQ vom VIC höchste Priorität: Wir müssen auf jeden Fall einen IRQ auslösen, auch wenn gerade der Systeminterrupt behandelt wird. Das bedeutet, daß dieser System-IRQ durch unseren VIC-IRQ unterbrochen werden muß, um eine einwandfreie Funktion der Rasterroutine zu haben. Dies ist durchaus zulässig: Wird die normale IRQ-Routine unterbrochen, wird zunächst unsere VIC-Routine abgearbeitet und dann mit der Systeminterruptroutine fortgefahren. Wenn diese beendet ist. kann mit der Bearbeitung des ursprünglich unterbrochenen Programms weitergemacht werden. Dies klingt zwar kompliziert, ist aber im Prinzip sehr einfach und logisch. Durch das Lesen des ICR der CIA 1 müssen wir daher wie bei allen Interrupts die Ursache (Unterlauf Timer A (siehe Systeminterrupt)) löschen. Dann wird mit dem CLI-Befehl der IRQ freigegeben. Hätten wir vergessen, das ICR der CIA 1 zu löschen, würde jetzt sofort ein neuer IRQ ausgelöst, was ja nicht geschehen darf. Jetzt darf man die alte IRQ-Routine anspringen, da sie nun ja vom VIC wie gewünscht unterbrochen werden kann.
Meinung[Bearbeiten | Quelltext bearbeiten]
User: "Deine Meinung zu diesem Buch"
Weblinks[Bearbeiten | Quelltext bearbeiten]
- C64 C128 - Alles über Maschinensprache im Internet Archiv
- Commodore 128 bei retrozone.ch mit PDF und Buchdiskette
- Katalog der Deutschen Nationalbibliothek: 3-89090-571-4
