\language\{Deutsch}

\title\{Transportbefehle für 8 Bit}

\subtitle\{LD d,s}
\text\{Kopiert 8-Bit-Daten von s nach d. 
d kann sein: A,B,C.D,E,H,L, (HL), (IX+e) und (IY+e)
s kann sein: A,B,C,D,E,H,L, (HL), (IX+e), (IY+e) und n.}

\subtitle\{LD A,(ss)}
\text\{Kopiert den Inhalt der Speicherzelle, die durch das 
Registerpaar ss adressiert wird, in das Register A.
ss kann sein: (BC), (DE), (HL) und (nn).
\newline\
Bemerkung: (nn) ist ein Zeiger auf einen Speicherbereich!}

\subtitle\{LD (ss),A}
\text\{Kopiert den Inhalt von A in die Speicherzelle, die durch das
Registerpaar ss angegeben wird.
ss kann sein: (BC), (DE), (HL) und (nn).
\newline\
Bemerkung: (nn) ist ein Zeiger auf einen Speicherbereich!}

\subtitle\{LD A,I}
\text\{Kopiert den Inhalt des Interruptvektor-Registers in das Register A.}

\subtitle\{LD A,R}
\text\{Kopiert den Inhalt des Refresh-Registers in das Register A.}

\subtitle\{LD I,A}
\text\{Kopiert den Inhalt von Register A in das Interruptvektor-Register.}

\subtitle\{LD R,A}
\text\{Kopiert den Inhalt von Register A in das Refresh-Register.}

\title\{Transportbefehle für 16 Bit}

\subtitle\{LD dd,nn}
\text\{Kopiert den 16-Bit-Wert nn in das Register dd.
dd kann sein: BC, DE, HL, SP, IX und IY.}

\subtitle\{LD dd,(nn)}
\text\{Kopiert den Wert, der in der Speicherzelle  nn
und in der Speicherzelle nn+1 steht, in das Registerpaar dd.
dd kann sein: BC, DE, HL, SP, IX und IY.
\newline\
Beispiel: LD HL,(0C000H)
          Das Byte, das sich an der Adresse 0C000H bfindet, wird in
          das Register L kopiert. Das darauffolgende Byte (0C001H)
          wird in das Register H kopiert.}

\subtitle\{LD (nn),ss}
\text\{Kopiert den Inhalt des Registerpaars ss in die zwei 
aufeinanderfolgende Speicherzellen nn und nn+1.
ss kann sein: BC, DE, HL, SP, IX und IY.
\newline\
Beispiel: LD (0C000H),HL
          Der Inhalt des Registers H wird in die Speicherzelle mit der
          Adresse 0C001H geschrieben, der Inhalt des Registers L wird
          in die Speicherzelle 0C000H geschrieben.}

\subtitle\{LD SP,ss}
\text\{Kopiert den Inhalt des Registerpaars ss in das 
Registerpaar SP.
ss kann sein: HL, IX und IY.}

\subtitle\{PUSH gg}
\text\{Speichert den Inhalt des Registerpaars gg auf dem 
Stack ab.
gg kann sein: BC, DE, HL, AF, IX und IY.}

\subtitle\{POP gg}
\text\{Ladet das Registerpaar gg mit den Daten, die auf
dem Stack abgespeichert wurden.
gg kann sein: BC, DE, HL, AF, IX und IY.}

\title\{Eingabe- und Ausgabebefehle}

\subtitle\{IN A,(n)}
\text\{Der Inhalt der IO-Adresse n wird nach A kopiert.}

\subtitle\{IN d,(C)}
\text\{Der Inhalt der IO_Adresse, die durch das Register C adressiert wird,
wird nach d kopiert. d kann sein: A, B, C, D, E, H und L.}

\subtitle\{INI}
\text\{Keine Informationen vorhanden!}

\subtitle\{INIR}
\text\{Keine Informationen vorhanden!}

\subtitle\{IND}
\text\{Keine Informationen vorhanden!}

\subtitle\{INDR}
\text\{Keine Informationen vorhanden!}

\subtitle\{OUT (n),A}
\text\{Der Inhalt des Registers A wird im IO-Bereich, auf der Adresse n
ausgegeben.}

\subtitle\{OUT (C),s}
\text\{Der Inhalt des Registers s wird im IO-Bereich, auf der Adresse, die
durch das Register C adressiert wird, ausgegeben.}

\subtitle\{OUTI}
\text\{Keine Informationen vorhanden!}

\subtitle\{OTIR}
\text\{Keine Informationen vorhanden!}

\subtitle\{OUTD}
\text\{Keine Informationen vorhanden!}

\subtitle\{OTDR}
\text\{Keine Informationen vorhanden!}

\title\{Exchange-, Blocktransfer- und Suchbefehle}

\subtitle\{EX DE,HL}
\text\{Tauscht den Inhalt der beiden Registerpaare DE und HL.}

\subtitle\{EX AF,AF`}
\text\{Tauscht den Inhalt der beiden Doppelregister AF und AF`.}

\subtitle\{EXX}
\text\{Tauscht den Inhalt folgender Dopelregister:
BC mit BC`
DE mit DE` und
HL mit HL`.}

\subtitle\{EX (SP),HL}
\text\{Tauscht den Inhalt des Doppelregisters HL mit dem Inhalt
des Stacks. Nach dem Aufruf enthält H=SP+1 und L=SP. 
Der Stack enthält dagegen den Inhalt von HL.
SP+1=H und SP=L.}

\subtitle\{EX (SP),IX}
\text\{Tauscht den Inhalt des Doppelregisters IX mit dem Inhalt
des Stacks.}

\subtitle\{EX (SP),IY}
\text\{Tauscht den Inhalt des Doppelregisters IY mit dem Inhalt
des Stacks.}

\subtitle\{LDI}
\text\{Keine Informationen vorhanden!}

\subtitle\{LDIR}
\text\{Keine Informationen vorhanden!}

\subtitle\{LDD}
\text\{Keine Informationen vorhanden!}

\subtitle\{LDDR}
\text\{Keine Informationen vorhanden!}

\subtitle\{CPI}
\text\{Keine Informationen vorhanden!}

\subtitle\{CPIR}
\text\{Keine Informationen vorhanden!}

\subtitle\{CPD}
\text\{Keine Informationen vorhanden!}

\subtitle\{CPDR}
\text\{Keine Informationen vorhanden!}

\title\{Arithmetische und logische Befehle für 8 Bit}

\subtitle\{ADD A,s}
\text\{Addiert den Inhalt von s zum Inhalt von A und speichert das
Ergebnis in A ab.
s kann sein: A, B, C, D, E, H, L, (HL), (IX+e) und (IY+e).
\newline\
(HL) bedeutet: Inhalt der Speicherzelle, auf die HL zeigt.}

\subtitle\{ADD A,n}
\text\{Addiert n zum Inhalt von A und speichert das
Ergebnis in A ab.}

\subtitle\{ADC A,s}
\text\{Addiert den Inhalt von s unter Beachtung des Carryflags zum
Inhalt von A und speichert das Ergebnis in A ab. 
s kann sein: A, B, C, D, E, H, L, (HL), (IX+e) und (IY+e).
\newline\
(HL) bedeutet: Inhalt der Speicherzelle, auf die HL zeigt.}

\subtitle\{ADC A,n}
\text\{Addiert n unter Beachtung des Carryflags zum Inhalt von A und
speichert das Ergebnis in A ab.}

\subtitle\{SUB s}
\text\{Subtrahiert den Inhalt von s zum Inhalt von A und speichert das
Ergebnis in A ab.
s kann sein: A, B, C, D, E, H, L, (HL), (IX+e) und (IY+e).
\newline\
(HL) bedeutet: Inhalt der Speicherzelle, auf die HL zeigt.}

\subtitle\{SUB n}
\text\{Subtrahiert n zum Inhalt von A und speichert das
Ergebnis in A ab.}

\subtitle\{SBC A,s}
\text\{Subtrahiert den Inhalt von s unter Beachtung des Carryflags
zum Inhalt von A und speichert das Ergebnis in A ab.
s kann sein: A, B, C, D, E, H, L, (HL), (IX+e) und (IY+e).
\newline\
(HL) bedeutet: Inhalt der Speicherzelle, auf die HL zeigt.}

\subtitle\{SBC A,n}
\text\{Subtrahiert n unter Beachtung des Carryflags zum Inhalt von A und speichert das
Ergebnis in A ab.}

\subtitle\{AND s}
\text\{Verknüpft das Register A und s durch logisch UND.
s kann sein: A, B, C, D, E, H, L, (HL), n, (IX+e) und (IY+e).}

\subtitle\{OR s}
\text\{Verknüpft das Register A und s durch logisch ODER. s kann sein:
A, B, C, D, E, H, L, (HL), n, (IX+e) und (IY+e).}

\subtitle\{XOR s}
\text\{Verknüpft das Register A und s durch logisch Exklusiv-Oder.
s kann sein: A, B, C, D, E, H, L, (HL), n, (IX+e) und (IY+e).}

\subtitle\{CP s}
\text\{Vergleicht das Register A und s auf Gleichheit.
s kann sein: A, B, C, D, E, H, L, (HL), n, (IX+e) und (IY+e).}

\subtitle\{INC s}
\text\{Erhöht s um 1.
s kann sein: A, B, C, D, E, H, L, (HL), (IX+e) und (IY+e).}

\subtitle\{DEC s}
\text\{Erniedrigt s um 1.
s kann sein: A, B, C, D, E, H, L, (HL), (IX+e) und (IY+e).}

\title\{Arithmetische Befehle für 16 Bit}

\subtitle\{ADD HL,ss}
\text\{Addiert den Inhalt von ss zum Doppelregister HL und speichert
das Ergebnis in HL ab.
ss kann sein: BC, DE, HL und SP.}

\subtitle\{ADC HL,ss}
\text\{Addiert den Inhalt von ss unter Beachtung des Carryflags zum 
Doppelregister HL und speichert das Ergebnis in HL ab.
HL = HL+ss+CFL.
ss kann sein: BC, DE, HL und SP.}

\subtitle\{SBC HL,ss}
\text\{Subtrahiert den Inhalt von ss unter Beachtung des Carryflags
vom Doppelregister HL und speichert das Ergebnis in HL ab.
HL = HL-ss-CFL.
ss kann sein: BC, DE, HL und SP.}

\subtitle\{ADD IX,ss}
\text\{Addiert den Inhalt von ss zum 
Doppelregister IX und speichert das Ergebnis in IX ab.
IX = IX+ss.
ss kann sein: BC, DE, IX und SP.}

\subtitle\{ADD IY,ss}
\text\{Addiert den Inhalt von ss zum 
Doppelregister IY und speichert das Ergebnis in IY ab.
IY = IY+ss.
ss kann sein: BC, DE, IY und SP.}

\subtitle\{INC ss}
\text\{Erhöht ss um 1.
ss kann sein: BC, DE, HL, IX, IY und SP.}

\subtitle\{DEC ss}
\text\{Erniedrigt ss um 1.
ss kann sein: BC, DE, HL, IX, IY und SP.}

\title\{Rotier- und Shiftbefehle}

\subtitle\{RLCA}
\text\{A wird um eine Stelle nach links verschoben. Das "überlaufende"
siebte Bit kommt in das Carryflag und außerdem an die Bitstelle 0.}

\subtitl\{RLA}
\text\{A wird um eine Stelle nach links verschoben. Das "überlaufende"
siebte Bit kommt in das Carryflag. Das Bit im Carryflag kommt an die
Bitstelle 0.}

\subtitle\{RRCA}
\text\{A wird um eine Stelle nach rechts verschoben. Die Bitstelle 0
kommt in das Carryflag und außerdem an die Bitstelle 7.}

\subtitle\{RRA}
\text\{A wird um eine Stelle nach rechts verschoben. Die Bitstelle 0
kommt in das Carryflag. Das Bit im Carryflag kommt an die Bitstelle 7.}

\subtitle\{RLC s}
\text\{Das Register s wird um eine Stelle nach links verschoben. Das 
"überlaufende" siebte Bit kommt in das Carryflag und außerdem
an die Bitstelle 0.
s kann sein: A, B, C, D, E, H, L, (HL),
(IX+e) und (IY+e).}

\subtitle\{RL s}
\text\{Das Registers s wird um eine Stelle nach links verschoben. Das 
"überlaufende" siebte Bit kommt in das Carryflag. Das Bit im Carryflag
kommt an die Bitstelle 0.
s kann sein: A, B, C, D, E, H, L, (HL), (IX+e) und (IY+e).}

\subtitle\{RRC s}
\text\{Das Register s wird um eine Stelle nach rechts verschoben.
Die Bitstelle 0 kommt in das Carryflag und außerdem an die
Bitstelle 7.
s kann sein: A, B, C, D, E, H, L, (HL), (IX+e) und (IY+e).}

\subtitle\{RR s}
\text\{Das Register s wird um eine Stelle nach rechts verschoben.
Die Bitstelle 0 kommt in das Carryflag. Das Bit im Carryflag 
kommt an die Bitstelle 7.
s kann sein: A, B, C, D, E, H, L, (HL), (IX+e) und (IY+e).}

\subtitl\{SLA s}
\text\{Register s wird um eine Stelle nach links verschoben.
Das "überlaufende" siebte Bit kommt in das Carryflag. Das Bit 
im Carryflag geht verloren, die Bitstelle 0 wird durch eine Null
aufgefüllt.}

\subtitle\{SRA s}
\text\{Register s wird um eine Stelle nach rechts verschoben. 
Bitstelle 7 bleibt unverändert. Bitstelle 0 wird in das Carryflag
geschoben. Das Bit im Carryflag geht verloren.}

\subtitle\{RLD}
\text\{Keine Informationen vorhanden.}

\subtitle\{RRD}
\text\{Keine Informationen vorhanden.}

\title\{Einzelbitbefehle}

\subtitle\{BIT b,s}
\text\{Das Zeroflag wird je nach Zustand des Bits b gesetzt oder
gelöscht.
b kann sein: 0, 1, 2, 3, 4, 5, 6 oder 7.
s kann sein: A, B, C, D, E, H, L, (HL), (IX+e) oder (IY+e).}

\subtitle\{SET b,s}
\text\{Im Register s wird das Bit b auf 1 gesetzt.
b kann sein: 0, 1, 2, 3, 4, 5, 6 oder 7.
s kann sein: A, B, C, D, E, H, L, (HL), (IX+e) oder (IY+e).}

\subtitle\{RES b,s}
\text\{Im Register s wird das Bit b gelöscht.
b kann sein: 0, 1, 2, 3, 4, 5, 6 oder 7.
s kann sein: A, B, C, D, E, H, L, (HL), (IX+e) oder (IY+e).}

\title\{Verzweigungs- und Sprungbefehle}

\subtitle\{JP nn}
\text\{Springt an die absolute Adresse nn.}

\subtitle\{JP cc,nn}
\text\{Wenn cc wahr ist, erfolgt ein Sprung an die absolute 
Adresse nn.
cc kan sein:
NZ  (Not Zero)    = ungleich Null.
Z   (Zero)        = gleich Null.
C   (Carry)       = Überlaufbit.
PO  (Parity odd)  = ungerade.
PE  (Parity Even) = gerade.
P   (Plus)        = positives Vorzeichen.
M   (Minus)       = negatives Vorzeichen.}

\subtitle\{JR e}
\text\{Sprung über die Vorzeichenbehaftete Distanz e. e ist ein 
8-Bit-Wert, dadurch sind nur Sprünge über Distanzen von 
max. 128 Bytes möglich.}

\subtitle\{JR cc,e}
\text\{Wenn cc wahr ist, erfolgt ein sprung über die 
Vorzeichenbehaftete Distanz e. e ist ein 8-Bit-Wert, dadurch sind
nur Sprünge über Distanzen von max. 128 Bytes möglich.
cc kan sein:
NZ  (Not Zero)    = ungleich Null.
Z   (Zero)        = gleich Null.
NC  (Not Carry)   = kein Überlauf.
C   (Carry)       = Überlauf.}

\subtitle\{JP (HL)}
\text\{Sprung and die Adresse, die im Register HL steht.}

\subtitle\{JP (IX)}
\text\{Sprung and die Adresse, die im Register IX steht.}

\subtitle\{JP (IY)}
\text\{Sprung and die Adresse, die im Register IY steht.}

\subtitle\{DJNZ e}
\text\{Dekrementiert den Inhalt des Registers B und springt dann über
die Distanz e solange B ungleich Null ist. Achtung: e ist ein 
8-Bit-Wert. Deshalb kann max. nur eine Distanz von +/- 128 Bytes
übersprungen werden. Wenn Register B zu Null wird, wird der 
darauffolgende Befehl ausgeführt.}

\title\{Unterprogrammbefehle}

\subtitle\{CALL nn}
\text\{Sprung an die Adresse nn. Vorher wird die Rücksprungadresse
auf dem Stack abgespeichert. (Rücksprung dann durch RET oder RET cc).}

\subtitle\{CALL cc, nn}
\text\{Wenn cc wahr ist, erfolgt ein Sprung an die absolute Adresse nn.
Vorher wird die Rücksprungadresse auf dem Stack abgespeichert.
(Rücksprung dann durch RET oder RET cc).
cc kan sein:
NZ  (Not Zero)    = ungleich Null.
Z   (Zero)        = gleich Null.
C   (Carry)       = Überlaufbit.
PO  (Parity odd)  = ungerade.
PE  (Parity Even) = gerade.
P   (Plus)        = positives Vorzeichen.
M   (Minus)       = negatives Vorzeichen.}

\subtitle\{RETI}
\text\{Rücksprung bei auftreten eines Interrupts im Interruptprogramm.}

\subtitle\{RETN}
\text\{Rücksprung bei auftreten eines Nicht Maskierbaren Interrupts 
(non maskable interrupt) im Interruptprogramm.}

\subtitle\{RST a}
\text\{Unterprogrammaufruf bei der durch a festgelegten Adresse.
a kann sein:
0  oder 00 -> Startadresse steht in 00H.
1  oder 08 -> Startadresse steht in 08H.
2  oder 10 -> Startadresse steht in 10H.
3  oder 18 -> Startadresse steht in 18H.
4  oder 20 -> Startadresse steht in 20H.
5  oder 28 -> Startadresse steht in 28H.
6  oder 30 -> Startadresse steht in 30H.
7  oder 38 -> Startadresse steht in 38H.}

\title\{CPU-Steuerbefehle}

\subtitle\{DAA}
\text\{Wandelt den Inhalt des Registers A in die gepackte BCD-Darstelllung
um.}

\subtitle\{CPL}
\text\{Invertiert Register A. (Einerkomplement)}

\subtitle\{NEG}
\text\{Negiert Register A. (Zweierkomplement)}

\subtitle\{CCF}
\text\{Invertiert das Carryflag.}

\subtitle\{SCF}
\text\{Setzt das Carryflag auf 1.}

\subtitle\{NOP}
\text\{Leerbefehl, es wird keine Operation ausgeführt.}

\subtitle\{HALT}
\text\{Prozessor wird angehalten. Der Refresh wird trotzdem weiter
ausgeführt. Aktivierung erfolgt dann wieder durch einen Interrupt.}

\subtitle\{DI}
\text\{Interrupt verbieten.}

\subtitle\{EI}
\text\{Interrupt zulassen.}

\subtitle\{IM0}
\text\{Interruptmodus 0 wird aktiviert.}

\subtitle\{IM1}
\text\{Interruptmodus 1 wird aktiviert.}

\subtitle\{IM2}
\text\{Interruptmodus 2 wird aktiviert.}