=Z80=
Hier folgt jetzt die Version für die andere Fraktion. Der größte Teil behandelt dabei die Konstruktion der Schleife; das ist eigentlich nicht das Thema dieses Threads, bietet aber einige interessante Einsichten speziell in die Unterschiede zwischen den Prozessoren.
Die Beispiele sind alles "Trockenübungen" und deshalb nicht verifiziert - sollte ich einen Fehler drin haben bitte ich um sachdienliche Hinweise 
Eine einfache Übersetzung der Syntax sähe etwa so aus:
- LD (4000),B
- LD (4001),C
- LD B,75
- L1: LD C,FF
- L2: DEC C
- JR NZ, L2
- DEC B
- JR NZ, L1
- LD B,(4000)
- LD C,(4001)
- RET
Alles anzeigen
Leider funktioniert das so nicht, aber dazu später.
Wir sehen zunächst, dass der Befehl zum Schreiben in oder aus dem RAM derselbe ist wie zum direkten Laden von Registern oder auch zum Transfer zwischen zwei Registern:
LD [Ziel],[Quelle] ; kopiere (lade) den Wert aus Quelle in das Ziel
Details hierzu folgen hoffentlich noch in dem entsprechenden Nachbarthread.
Außerdem treffen wir den relativen Sprung wieder, diesmal mit Bedingung. Beim Z80 unterscheiden wir absolute Sprünge, die den gesamten Adressraum von 64K erreichen können, von den relativen Sprüngen im Bereich von 256 Adressen in unmittelbarer Nachbarschaft.
Beide Sprungarten können mit Bedingungen versehen werden:
- JP nnnn ; unbedingter absoluter Sprung
- JP Z,nnnn ; absoluter Sprung, wenn Zeroflag gesetzt
- JR NZ,nnnn ; relativer Sprung, wenn Zeroflag nicht gesetzt
- JR C,nnnn ; relativer Sprung, wenn Carryflag (Übertrag) gesetzt
- etc.
Jetzt aber zu der Frage, warum die obige Version nicht funktioniert:
Tatsächlich ist es leider so, dass die Register B und C nicht einfach in und aus dem RAM übertragen werden können. Das ginge nur über den Umweg über den Akku.
Allerdings hat der Z80 einen Befehl, um das Registerpaar BC im Speicher zu sichern bzw. zurück zu lesen:
- LD (4000),BC ; BC nach 4000 und 4001 sichern
- LD BC,(4000) ; BC von dort zurücklesen
Damit ergibt sich dann folgende Version:
- LD (4000),BC
- LD BC, 7500
- L1: DEC C
- JR NZ, L1
- DEC B
- JR NZ, L1
- LD BC,(4000)
- RET
Das sollte jetzt funktionieren.
Eine Kleinigkeit ist noch anders als im 6502-Beispiel: Hier startet die innere Schleife immer bei 0. Der erste DEC-Befehl liefert dann den Wert $FF; insgesamt zählen wir einmal mehr (256 mal gegenüber 255 mal). Dafür sparen wir uns das erneute Laden des C-Registers, da es - wenn nach 256 Durchläufen der inneren Schleife nun die äußere Schlife einen Schritt macht - wieder beim gleichen Startwert 0 angekommen ist.
Außerdem nutzen wir wieder die Möglichkeit, die beiden Register B und C zusammenzufassen und mit einem Befehl zu laden.
Unschön an dieser Lösung ist das Sichern und Zurücklesen des BC-Registers. Der Z80 braucht für diese Opcodes jeweils 4 Byte, und überhaupt ist es (zumindest beim Z80) üblich, sowas grundsätzlich auf dem Stack zu machen. Vielleicht liegt es daran, dass der Z80 problemlos alle (Doppel-)Register sichern kann:
- PUSH BC
- LD BC, 7500
- L1: DEC C
- JR NZ, L1
- DEC B
- JR NZ, L1
- POP BC
- RET
Während die erste Version 18 Byte benötigt, sind es hier nur noch 12. Schneller ist es auch, aber das sollte bei einer Warteschleife ja keine Rolle spielen ... 
Sorry, wenn ich den Stack hier vorgezogen habe - da sollten wir schleunigst mal ein eigenes Kapitel zu schreiben.
Und damit wir auch etwas über die Feinheiten des Z80 lernen, hier die "typische" Lösung unter maximaler Ausnutzung der 16 Bit Register:
- PUSH BC
- LD BC, 7500
- L1: DEC BC
- LD A,B
- OR C
- JR NZ, L1
- POP BC
- RET
In diesem Fall schachtelt man nicht zwei Schleifen mit je einem 8 Bit Zählern, sondern benutzt eine Schleife mit einem 16 Bit Zähler. Denn der Z80 inkrementiert und dekrementiert problemlos auch die Doppelregister.
Dummerweise werden dabei aber (anders als bei den 8 Bit Decrements) die Flags nicht gesetzt. Das muss man unbedingt wissen, um kapitale Programmfehler zu vermeiden. Als Abhilfe wird der Umweg über den Akku genommen. Das ist ein klassischer Weg, die Doppelregister zu prüfen: ein Register wird in den Akku übertragen, und das zweite wird damit logisch "or" verknüpft. Das Ergebnis ist genau dann 0, wenn beide Register B und C den Wert 0 haben - und diesmal wird auch das Zeroflag gesetzt, das im nachfolgenden JR NZ abgefragt wird.
Als Nachteil wird der Akku zerstört - wer das verhindern will, sichert den eben auch vorher auf dem Stack.
Zu guter Letzt die Frage nach dem Aufruf: Der erfolgt beim Z80 über die Call-Befehle. Diese sind grundsätzlich absolut, d.h. sie können jede 16-Bit-Adresse erreichen, und es gibt sie sowohl unbedingt als auch mit den Bedingungen, wie wir sie schon bei den Sprüngen kennengelernt haben:
- CALL nnnn ; unbedingter Aufruf einer Subroutine
- CALL Z,nnnn ; Aufruf der Subroutine nur bei gesetztem Zeroföag
- CALL NC,nnnn ; dito nur bei nicht gesetztem Übertragsflag
- etc.
Ansonsten ist der Mechanismus für den geordneten Sprung zur Subroutine und zurück wie oben beschrieben: nach dem Einlesen des vollständigen Call-Befehls zeigt der Programmzähler (instruction pointer) auf den nächsten Befehl im Speicher. Bei Ausführung des Calls wird dieses Register auf den Stack gesichert und mit der Zieladresse neu geladen - wodurch die Programmausführung bei der Subroutine fortgesetzt wird.
Wenn der Ret-Befehl gelesen und verarbeitet wird wird der letzte Eintrag vom Stack zurückgelesen und in den Programmzähler geladen, woraufhin die Ausführung an der Stelle hinter den Call fortgesetzt wird.
Damit das Ganze auch sauber funktioniert muss die Subroutine dafür sorgen, dass sie den Stack so hinterlässt, wie sie ihn vorgefunden hat: wenn sie Register dort geretter hat muss sie genau so viele Register wieder zurücklesen (genausoviele POPs wie PUSHs). Andernfalls werden Daten als Adresse des Programms interpretiert, was in aller Regel zum Crash führt.
Soll ich das heute noch abholen ?
