Maschinensprache auf dem Commodore 64
| Maschinensprache auf dem Commodore 64 | |||
|---|---|---|---|
 |
Sprache | deutsch | |
| Autor(en) | Heinz Sterner, T. Tutughamiarsa | ||
| Verlag | IWT-Verlag (1984) | ||
| Jahr | 1984 | ||
| ISBN | ISBN 3-88322-047-7 | ||
| Neupreis | 56 DM | ||
| Datenträger | keiner | ||
| Seitenzahl | 242 | ||
| letzte Auflage | 1. Auflage 1985 | ||
| Genre | Einsteiger | ||
| Information | |||
Buchrückseite[Bearbeiten | Quelltext bearbeiten]
Das vorliegende Buch ist in seiner Konzeption an den Bedürfnissen des „Einsteigers“ orientiert: offensichtlich ist es wenig sinnvoll, den Befehlssatz des 6510-Prozessors ohne Anwendungsbeispiele zunächst nur „auf dem Trockenen“ zu besprechen. Deshalb wird ein Befehl dann eingeführt und erklärt, wenn er für eine Problemlösung erforderlich ist. Die Erarbeitung des Befehlssatzes erfolgt also aus den jeweiligen praktischen Anforderungen heraus.
Den zentralen Teil des Buches bildet ein Paket von 16-Bit-Routinen, die z. B. für die Grafik-Programmierung genutzt werden können.
Weiterhin werden einige häufig verwendete interne ROM-Routinen des COMMODORE 64 beschrieben, die der Benutzer auch in seine eigenen Programme einbauen kann.
Den Abschluß des Buches bildet eine Übersicht über die Adressierungsarten des 6510.
Inhaltsverzeichnis[Bearbeiten | Quelltext bearbeiten]
Vorwort ...................................................................... 5
Einleitung .................................................................. 11
1. Schematische Darstellung des Mikroprozessors 6510 ....................... 13
1.1 Akkumulator ......................................................... 16
1.2 Index-Register X und Y .............................................. 16
1.3 Programmzadhler ..................................................... 16
1.4 Stapelzeiger ........................................................ 16
1.5 Prozessor-Status-Register ........................................... 17
2. Algorithmen ............................................................. 19
2.1 Hauptaufgaben einer Programmiersprache .............................. 22
2.2 Grundlegende Elemente zur Darstellung von Flußdiagrammen ............ 22
3. Zahlensysteme ........................................................... 27
3.1 Das Binär-System .................................................... 29
3.1.1 Die Addition mit Binärzahlen .................................. 30
3.1.2 Zahlen mit Vorzeichen ......................................... 30
3.1.2.1 Das Einerkomplement ................................... 31
3.1.2.2 Das Zweierkomplement .................................. 31
3.1.3 Übertrag und Überlauf ......................................... 32
3.1.4 High- und Low-Byte ............................................ 35
3.2 Das Hexadezimal-System .............................................. 35
4. Wie schreibt man ein Programm in Assembler? ............................. 39
4.1 Addition zweier Zahlen .............................................. 41
4.2 Addition mehrerer Zahlen ............................................ 46
4.3 16-Bit-Addition ..................................................... 52
5. Unterprogramme .......................................................... 59
5.1 Parameterübergabe ................................................... 64
5.1.1 Parameterübergabe durch Register .............................. 65
5.1.2 Parameterübergabe durch den Stack ............................. 66
5.1.3 Parameterübergabe durch vereinbarte Speicher .................. 70
5.1.4 Direkte Parameterübergabe ..................................... 73
6. 16-Bit-Simulationen ..................................................... 75
6.1 Häufig verwendete 16-Bit-Routinen ................................... 80
6.2 Der 16-Bit-Interpreter ............................................. 101
7. Grafik-Anwendungen der Assembler-Routinen .............................. 107
7.1 16-Bit-Routinen zur hochauflösenden Grafik ......................... 109
7.1.1 Grafik einschalten ........................................... 109
7.1.2 Grafik ausschalten ........................................... 110
7.1.3 Grafikspeicher löschen ....................................... 110
7.1.4 Hintergrundfarbe setzen ...................................... 112
7.1.5 Adressberechnung für Grafikspeicher .......................... 112
7.1.6 Grafikpunkt setzen/löschen ................................... 117
7.1.7 Zeichnen und Löschen von Geraden ............................. 120
7.2 16-Bit-Routinen zur Sprite-Programmierung .......................... 126
7.2.1 Erstellen von Sprites ........................................ 129
7.2.2 Sprite-Positionierung ........................................ 133
7.3 Weitere Routinen zur Sprite-Programmierung ......................... 134
7.3.1 Ein- und Ausschalten von Sprites ............................. 134
7.3.2 Bestimmung der Sprite-Farbe .................................. 136
7.3.3 Bestimmung der Anfangsadresse von Sprites .................... 137
7.4 Anwendungsbeispiele zur Benutzung der Sprite- und Grafik-Routinen .. 138
7.4.1 Beispiel zur Benutzung der Sprite-Routinen ................... 139
7.4.2 Beispiel zur Benutzung der Grafik-Routinen ................... 140
8. Verwendung von ROM-Routinen ............................................ 141
8.1 Parameterübergabe von BASIC-Programmen aus ......................... 143
8.2 Weitere Beispiele mit ROM-Routinen ................................. 147
9. Kurze Darstellung der in den Programmen nicht verwendeten Befehle ...... 153
9.1 Dezimal-Arithmetik ................................................. 156
9.2 Programmunterbrechungen (Interrupts) ............................... 156
10. Adressierungsarten ..................................................... 159
10.1 Nicht indizierte Adressierungsarten ............................... 161
10.1.1 Implizite Adressierung ..................................... 161
10.1.2 Unmittelbare Adressierung .................................. 161
10.1.3 Absolute Adressierung ...................................... 162
10.1.4 Zero Page Adressierung ..................................... 162
10.1.5 Relative Adressierung ...................................... 163
10.2 Indizierte Adressierungsarten ..................................... 163
10.2.1 Absolut indizierte Adressierung ............................ 164
10.2.2 Zero Page Adressierung ..................................... 164
10.2.3 Indirekte Adressierung ..................................... 164
10.2.4 Indiziert-indirekte Adressierung ........................... 165
10.2.5 Indirekt-indizierte Adressierung ........................... 165
10.2.6 Indirekt absolute Adressierung ............................. 166
Anhang ..................................................................... 167
Alphabetische Kurzübersicht der 6510-Befehle .......................... 169
Alphabetische Übersicht der 6510-Befehle und Adressierungsarten ....... 172
6510-Befehlsliste in hexadezimaler Reihenfolge ........................ 201
Klassifikation der 6510-Befehle ....................................... 205
Hexadezimalcode-Eingabe/Disassembler .................................. 206
BASIC-Ladeprogramm-Generator .......................................... 214
Listing der 16-Bit-Routinen ........................................... 216
BASIC-Ladeprogramm für die 16-Bit-Routinen ............................ 234
Literaturverzeichnis ....................................................... 239
Register ................................................................... 240
Leseprobe[Bearbeiten | Quelltext bearbeiten]
Seiten 61-62
5. Unterprogramme
Die bisherigen Programme besaßen alle wesentliche Einschränkungen, die ihre Anwendbarkeit auf einen jeweils nur ganz bestimmten Bereich ermöglichten. Um nun allgemeiner verwendbare Programme entwickeln zu können, werden wir im folgenden Programmiertechniken kennenlernen, die bei der Entwicklung von modular aufgebauten Programmen eine große Rolle spielen.
Wird in einem Programm eine bestimmte Folge von Befehlen mehrmals benötigt, so ist es offensichtlich nicht sinnvoll, diese identischen Befehlsfolgen immer wieder neu in das Programm einzufügen, da dies zu einem unnötigen Verbrauch von Speicherplatz im Arbeitsspeicher des Computers führt. Außerdem entsteht auf diese Weise unnötiger Schreibaufwand. Noch wichtiger aber ist die Tatsache, daß die Programme erheblich übersichtlicher werden, wenn eine solche sich wiederholende Anweisungsfolge nur einmal im Arbeitsspeicher steht und dann von jeder gewünschten Stelle des aufrufenden Programms aufgerufen werden kann: dieser sich wiederholende Programmteil wird allgemein als Unterprogramm (subroutine) bezeichnet.
Woran erkennt der Prozessor aber, wann ein Unterprogramm abgearbeitet werden soll und an welcher Stelle sich Anfang und Ende des Unterprogramms im Arbeitsspeicher befinden?
Die Ausführung eines Unterprogramms wird durch einen speziellen Befehl eingeleitet, der die Anfangsadresse des betreffenden Unterprogramms enthält: JSR dieser Befehl heißt in unserem Fall JSR (Jump to SubRoutine), also Sprung zum Unterprogramm. Wenn ein solcher Befehl im Programm ausgeführt wird, laufen in der Befehlsabarbeitung eine ganze Reihe von Aktionen ab:
Zuerst muß der Prozessor dafür sorgen, daß er weiß, an welcher Stelle im aufrufenden Programm die Programmabarbeitung nach der Ausführung des Unterprogramms fortgesetzt werden muß, d.h. diese Adresse muß zunächst einmal notiert werden. Dies geschieht ohne Zutun des Programmierers im Stack (Stapel-Speicher, vgl. Beschreibung des Prozessoraufbaus). Diese wichtige Datenstruktur wird gleich ausführlicher beschrieben.
Dann wird die Anfangsadresse des Unterprogramms, die ja im JSR-Befehl angegeben ist, in den Programmzähler geladen, womit eine Verzweigung zu der angegebenen Unterprogramm-Adresse bewirkt wird.
Im Unterprogramm selbst wird das Ende des Unterprogramms durch den Befehl RTS (ReTurn from Subroutine) markiert, RTS d.h. Rücksprung vom Unterprogramm. Dieser Befehl lädt den Programmzähler (PC) mit der Adresse im Stack, die durch den Aufruf dieses Unterprogramms gespeichert worden ist (s. JSR).
Auf diese Weise kann also ein Unterprogramm aus der Sicht des Programmierers wie ein einziger Befehl betrachtet werden, wodurch die Übersichtlichkeit des gesamten Programms deutlich erhöht wird.
Die folgende Abbildung soll die Vorteile der Unterprogramm-Technik noch einmal grafisch illustrieren:
Meinung[Bearbeiten | Quelltext bearbeiten]
User: "Deine Meinung zu diesem Buch"
