639 lines
21 KiB
NASM
639 lines
21 KiB
NASM
TITLE 'Z80-Disassembler'
|
|
|
|
; Hardware-unabhaengiger, ROM-faehiger Z80-Disassembler
|
|
;
|
|
; Die Adresse, ab der disassembliert serden soll, ist in der
|
|
; 16-Bit Speicherzelle DADR abzulegen. Danach kann eines der
|
|
; Entrys DISSCR (Ausgabe eines Bildschirms) oder DISLIN
|
|
; (Ausgabe einer Zeile) aufgerufen werden. Da die Folgeadressen
|
|
; durch das Programm ebenfalls wieder in der Speicherzelle
|
|
; DADR abgelegt werden, ist mehrfacher Aufruf ohne Laden
|
|
; von neuen Adressen moeglich.
|
|
; Zur Ausgabe muss ein Unterprogramm mit dem Namen PRTSTR
|
|
; erstellt werden, dem in HL die Adresse eines Null-terminierten
|
|
; Strings uebergeben wird.
|
|
;
|
|
; 27-JUN-89 Udo Munk
|
|
|
|
LPP EQU 15 ; Anzahl Zeilen/Bildschirm Ausgabe
|
|
MNEPOS EQU 11H ; Offset des Mnemonics in Ausgabe-Workspace
|
|
|
|
; Disassembliere einen Bildschirm voll
|
|
DISSCR: LD B,LPP ; einen Bildschirm mit LPP Zeilen
|
|
$DLP1: PUSH BC ; disassemblieren
|
|
CALL DISLIN
|
|
POP BC
|
|
DJNZ $DLP1
|
|
RET
|
|
|
|
; Disassembliere eine Zeile
|
|
DISLIN: CALL CLWO ; Workspace fuer eine Zeile Ausgabe loeschen
|
|
LD HL,WRKS ; Adresse der Ausgabe-Workspace -> HL
|
|
LD DE,(DADR) ; Disassemblier-Adresse -> DE
|
|
CALL PRBY ; Adresse in DE ausgeben
|
|
INC HL ; Blank ausgeben
|
|
LD (PRTMP),HL ; vordere Printposition retten
|
|
LD C,0 ; Steuerflag loeschen
|
|
DEC DE ; laufende Adr.-1 -> DE
|
|
$DL13: CALL PRNB ; laufendes Byte ausgeben
|
|
LD A,(DE) ; laufendes Byte -> A
|
|
LD B,A ; und in B retten
|
|
CP 0EDH ; Preafix ED ?
|
|
JR NZ,$DL14
|
|
SET 4,C ; ja, ED-Flag setzen
|
|
JR $DL13 ; und naechstes Byte bearbeiten
|
|
$DL14: CP 0FDH ; Preafix FD ?
|
|
JR NZ,$DL15
|
|
SET 6,C ; ja, FD-Flag setzen
|
|
JR $DL16 ; und Index-Flag setzen
|
|
$DL15: CP 0DDH ; Preafix DD ?
|
|
JR NZ,$DL17
|
|
$DL16: SET 5,C ; Index-Flag fuer IX/IY-Adressierung setzen
|
|
LD HL,(PRTMP) ; vordere Printposition -> HL
|
|
JR $DL13 ; naechstes Byte bearbeiten
|
|
$DL17: LD HL,WRKS+MNEPOS ; HL auf Operator Position setzen
|
|
|
|
; nach Praefix CB
|
|
CB: LD A,B ; Befehlsbyte aus B holen
|
|
CP 0CBH ; Preafix CB ?
|
|
JP NZ,OHNE
|
|
INC DE ; ja, Pointer auf naechstes Byte setzen
|
|
BIT 5,C ; IX/IY-Flag ?
|
|
JR Z,$DL18
|
|
INC DE ; ja, Pointer auf naechstes Byte setzen
|
|
$DL18: LD A,(DE) ; naechstes Byte -> A
|
|
LD B,A ; und in B retten
|
|
PUSH DE ; Disassemblieradr. retten
|
|
LD D,MNETAB > 8 ; High-Byte Operatorentabelle -> D
|
|
LD E,0E8H ; DE = Pointer auf "SET"
|
|
CP 0C0H ; SET ?
|
|
JR NC,$DL19
|
|
LD E,0E4H ; nein, DE = Pointer auf "RES"
|
|
CP 80H ; RES ?
|
|
JR NC,$DL19
|
|
LD E,0E0H ; nein, DE = Pointer auf "BIT"
|
|
CP 40H ; BIT ?
|
|
JR NC,$DL19
|
|
AND 38H ; loesche Bits 0..2 und 6..7
|
|
RRCA ; Division durch 2
|
|
ADD A,CBMTAB & 0FFH ; zur Basis der CB-Mnemonics addieren
|
|
LD E,A
|
|
LD D,CBMTAB > 8 ; DE = Pointer auf CB-Mnemonic
|
|
$DL19: CALL TRBY ; Mnemonic ausgeben
|
|
POP DE ; akt. Disassemblieradr. wieder -> DE
|
|
LD A,B ; Byte wieder -> A
|
|
BIT 5,C ; IX/IY-Flag ?
|
|
JR Z,$DL20
|
|
DEC DE ; eins zurueck bei IX/IY-Adressierung
|
|
$DL20: DEC DE ; Pointer wieder auf CB-Preafix
|
|
CP 40H ; CB-Befehl < 40H ?
|
|
JR C,$DL21
|
|
AND 38H ; nein, Bits 0..2 und 6..7 loeschen
|
|
RRCA ; Division durch 8 -> 1. Operanden
|
|
RRCA
|
|
RRCA
|
|
CALL PRO1 ; 1. Operanden ausgeben
|
|
LD A,B ; Byte wieder -> A
|
|
SET 7,C ; Komma-Flag setzen
|
|
$DL21: AND 7 ; Bits 3..7 loeschen -> 2. Operanden
|
|
SET 4,A ; Buchstaben-Flag setzen
|
|
CALL PRO1 ; 2. Operanden ausgeben
|
|
CALL PRNB ; Befehlsbyte vorne ausgeben
|
|
JP INAD ; fertig, Adresse merken und Workspace ausgeben
|
|
|
|
; ohne Preafix CB/ED
|
|
OHNE: PUSH DE ; Disassemblieradr. retten
|
|
BIT 4,C ; ED-Flag ?
|
|
JP NZ,ED
|
|
CP 40H ; nein, < 40H ?
|
|
JR C,$DL25
|
|
CP 80H ; nein, > 80H ?
|
|
JR NC,$DL23
|
|
LD E,50H ; nein, DE = Pointer auf "LD"
|
|
CP 76H ; HALT ?
|
|
JR NZ,$DL22
|
|
LD E,5CH ; nein, DE = Pointer auf "HALT"
|
|
$DL22: JR $DL26 ; Mnemonic ausgeben
|
|
$DL23: CP 0C0H ; > C0H ?
|
|
JR NC,$DL24
|
|
AND 38H ; ja, Bits 0..2 und 6..7 loeschen
|
|
RRCA ; Division durch 2 -> Operator
|
|
LD E,A ; Operator -> E
|
|
JR $DL26 ; Mnemonic ausgeben
|
|
$DL24: SUB 80H ; wenn > C0H, -80 -> Tabellenoperator
|
|
$DL25: LD E,A ; Operator -> E
|
|
LD D,CODTAB > 8 ; High-Byte Operatortabelle -> D
|
|
LD A,(DE) ; LSB Mnemonic-Adresse -> A
|
|
LD E,A ; und nach E
|
|
$DL26: LD D,MNETAB > 8 ; MSB Mnemonic-Adresse -> D
|
|
CALL TRBY ; Mnemonic ausgeben
|
|
POP DE ; akt. Disassemblieradr. wieder -> DE
|
|
LD A,B ; Befehlsbyte wieder -> A
|
|
PUSH DE ; Disassemblieradr. retten
|
|
CP 40H ; Byte < 40 ?
|
|
JR C,$DL30
|
|
CP 80H ; nein, > 80 ?
|
|
JR NC,$DL28
|
|
CP 76H ; nein, HALT ?
|
|
JR NZ,$DL27
|
|
LD A,0FFH ; ja, leeren Operanden -> A
|
|
JR $DL31 ; Operanden ausgeben
|
|
$DL27: AND 38H ; loesche Bits 0..2 und 6..7
|
|
RRCA ; Division durch 8 -> 1. Operanden
|
|
RRCA
|
|
RRCA
|
|
SET 4,A ; Buchstabenflag setzen
|
|
JR $DL31 ; Operanden ausgeben
|
|
$DL28: CP 0C0H ; > C0 ?
|
|
JR NC,$DL29
|
|
CP 90H ; > 90 ?
|
|
JR C,$DL51
|
|
AND 0F8H ; ja, Register-Bits loeschen
|
|
CP 98H ; "SBC" ?
|
|
JR Z,$DL51
|
|
LD A,B ; Byte wieder -> A
|
|
AND 7 ; nur Register Bits uebrig lassen
|
|
SET 4,A ; Buchstaben-Flag setzen
|
|
JR $DL52
|
|
$DL51: LD A,17H ; ja, 17 = Register A ausgeben
|
|
JR $DL31 ; Operanden ausgeben
|
|
$DL29: SUB 80H ; wenn > C0, -80 -> Operandentabelle
|
|
$DL30: LD E,A ; LSB Operandentabelle -> E
|
|
LD D,OPETAB > 8 ; MSB Operandentabelle -> D
|
|
LD A,(DE) ; 1. Operanden -> A
|
|
$DL31: POP DE ; akt. Disassemblieradr. wieder -> DE
|
|
CALL PRO1 ; 1. Operanden ausgeben
|
|
LD A,B ; Befehlsbyte wieder -> A
|
|
PUSH DE ; akt. Disassemblieradr. retten
|
|
CP 40H ; < 40 ?
|
|
JR C,$DL34
|
|
CP 0C0H ; nein, < C0 ?
|
|
JR NC,$DL33
|
|
CP 76H ; ja, HALT ?
|
|
JR NZ,$DL32
|
|
LD A,0FFH ; ja, wieder leeren Operanden -> A
|
|
JR $DL35 ; Operanden ausgeben
|
|
$DL32: AND 7 ; loesche Bits 3..7, -> 2. Operanden
|
|
SET 4,A ; Buchstabenflag setzen
|
|
JR $DL35 ; Operanden ausgeben
|
|
$DL33: SUB 80H ; wenn > C0 : 80 abziehen
|
|
$DL34: ADD A,80H ; LSB Operandentabelle -> A
|
|
LD E,A ; und -> E
|
|
LD D,OPETAB > 8 ; MSB Operandentabelle -> D
|
|
LD A,(DE) ; 2. Operanden -> A
|
|
$DL35: POP DE ; akt. Disassemblieradr. wieder -> DE
|
|
SET 7,C ; Komma-Flag setzen
|
|
CALL PRO1 ; 2. Operanden ausgeben
|
|
JP INAD ; fertig, Adresse merken und Workspace ausgeben
|
|
|
|
; nach Preafix ED
|
|
ED: SUB 40H ; 40 vom 2. Byte subtrahieren
|
|
JP C,ERRO ; Fehler wenn carry
|
|
CP 60H ; 2. Byte < A0 ?
|
|
JR NC,$DL36
|
|
CP 40H ; ja, >= 60 ?
|
|
JP NC,ERRO ; ja, Fehler
|
|
JR $DL37 ; nein, weiter
|
|
$DL36: SUB 20H ; aus 60..7F wird 00..20
|
|
$DL37: ADD A,80H ; LSB Operatortabelle -> A
|
|
LD E,A ; und -> E
|
|
LD D,CODTAB > 8 ; MSB Operatortabelle -> D
|
|
LD A,(DE) ; LSB Mnemonic-Adresse -> A
|
|
CP 0FFH ; leer ?
|
|
JP Z,ERRO ; ja, Fehler
|
|
LD E,A ; nein, -> E
|
|
LD D,MNETAB > 8 ; MSB Mnemonic-Adresse -> D
|
|
CALL TRBY ; Mnemonic ausgeben
|
|
POP DE ; Disassemblieradr. wieder -> DE
|
|
LD A,B ; Befehlsbyte wieder -> A
|
|
CP 80H ; < 80 ?
|
|
JP NC,INAD ; nein, Workspace ausgeben und fertig
|
|
PUSH DE ; Disassemblieradr. retten
|
|
SUB 40H ; LSB 1. Operanden in A
|
|
LD E,A ; und -> E
|
|
LD D,OP2TAB > 8 ; MSB 2. Operanden -> D
|
|
LD A,(DE) ; 1. Operanden -> A
|
|
POP DE ; akt. Disassemblieradr. wieder -> DE
|
|
CALL PRO1 ; 1. Operanden ausgeben
|
|
LD A,B ; Befehlsbyte wieder -> A
|
|
CP 80H ; < 80 ?
|
|
JP NC,INAD ; ja, Workspace ausgeben und fertig
|
|
PUSH DE ; akt. Disassemblieradr. retten
|
|
LD E,A ; LSB Operandentabelle -> E
|
|
LD D,OP2TAB > 8 ; MSB Operandentabelle -> D
|
|
LD A,(DE) ; 2. Operanden -> A
|
|
SET 7,C ; Buchstabenflag setzen
|
|
$DL52: POP DE ; akt. Disassemblieradr. retten
|
|
CALL PRO1 ; 2. Operanden ausgeben
|
|
JP INAD ; fertig, Adresse merken und Workspace ausgeben
|
|
|
|
; Operand 1 ausgeben
|
|
PRO1: CP 0FFH ; leere Operand ?
|
|
RET Z ; ja, fertig
|
|
CP 17H ; nein, Register "A" ausgeben ?
|
|
JR NZ,$DL01
|
|
LD A,18H ; ja, umkodieren
|
|
$DL01: CP 16H ; Register "(HL)" ausgeben ?
|
|
JR NZ,$DL02
|
|
LD A,0B4H ; ja, umkodieren
|
|
$DL02: BIT 7,C ; 2. Operand ?
|
|
JR Z,$DL03
|
|
LD (HL),',' ; ja, "," ausgeben
|
|
INC HL ; naechste Printposition -> HL
|
|
$DL03: BIT 7,A ; "(...)" ?
|
|
JR Z,$DL04
|
|
LD (HL),'(' ; ja, "(" ausgeben
|
|
INC HL ; naechste Printposition -> HL
|
|
$DL04: BIT 4,A ; Buchstabe ?
|
|
JR NZ,PRBU ; ja, Buchstaben ausgeben
|
|
BIT 6,A ; nein, Bitnummer/RST-Adresse ?
|
|
JR NZ,DIST ; ja, Distanz ausgeben
|
|
BIT 5,A ; nein, Bitnummer ?
|
|
JR NZ,PRO2 ; ja, RST ausgeben
|
|
AND 7 ; nein, Bits 3..7 loeschen
|
|
CALL PRCH ; Hexbyte ausgeben
|
|
RET
|
|
|
|
; RST ausgeben
|
|
PRO2: PUSH AF ; A retten
|
|
AND 6 ; loesche Bits 0 und 4..7
|
|
RRCA ; Division durch 2
|
|
CALL PRCH ; oberes Nibble ausgeben
|
|
POP AF ; A wieder herstellen
|
|
BIT 0,A ; RST x8 ?
|
|
LD A,'0' ; nein, "0" -> A
|
|
JR Z,$DL05
|
|
LD A,'8' ; ja, "8" -> A
|
|
$DL05: LD (HL),A ; "0" oder "8" ausgeben
|
|
INC HL ; naechste Printposition -> HL
|
|
RET
|
|
|
|
; Distanz ausgeben
|
|
DIST: BIT 0,A ; relative Distanz ?
|
|
JR Z,PR_N ; nein, N ausgeben
|
|
CALL PRNB ; Byte vorne ausgeben
|
|
PUSH DE ; akt. Disassemblieradr. retten
|
|
LD A,(DE) ; Distanzbyte -> A
|
|
INC DE ; Disassemblieradr. erhoehen
|
|
RLCA ; Bit 7 Distanzbyte -> carry
|
|
RRCA
|
|
JR NC,$DL06 ; Vorwaertsprung
|
|
SET 0,C ; Flag fuer Rueckwaertssprung setzen
|
|
$DL06: ADD A,E ; Distanz zu PC addieren
|
|
LD E,A
|
|
BIT 0,C ; Flag testen
|
|
JR NC,$DL07 ; kein Ueberlauf
|
|
JR NZ,$DL08 ; Rueckwaertssprung
|
|
INC D ; MSB PC erhoehen
|
|
JR $DL08 ; Zieladresse ausgeben
|
|
$DL07: JR Z,$DL08 ; bei Vorwaertssprung Zieladresse ausgeben
|
|
DEC D ; sonst MSB PC erniedrigen
|
|
$DL08: CALL PRBY ; Zieladresse in DE ausgeben
|
|
POP DE ; akt. Disassemblieradresse wieder -> DE
|
|
RET
|
|
|
|
; N ausgeben
|
|
PR_N: PUSH AF ; A retten
|
|
BIT 1,A ; N ?
|
|
JR Z,PRNN ; nein, NN ausgeben
|
|
CALL PRVH ; ja, Byte vorne und hinten ausgeben
|
|
JR $DL12 ; ")" bearbeiten
|
|
|
|
; NN ausgeben
|
|
PRNN: CALL PRNB ; Byte vorne ausgeben
|
|
CALL PRVH ; Byte vorne und hinten ausgeben
|
|
DEC DE ; DE -> LSB von NN
|
|
CALL PRBH ; Byte hinten ausgeben
|
|
INC DE ; akt. Disassemblieradr. wieder -> DE
|
|
JR $DL12 ; ")" bearbeiten
|
|
|
|
; Buchstaben ausgeben
|
|
PRBU: PUSH AF ; A retten
|
|
PUSH BC ; Flags in C retten
|
|
PUSH DE ; akt. Disassemblieradr. retten
|
|
LD B,1 ; Anzahl = 1
|
|
LD DE,REGTAB ; DE zeigt auf die Register-Namen
|
|
BIT 5,A ; 2 Buchstaben ?
|
|
JR Z,$DL09
|
|
INC B ; ja, Anzahl erhoehen
|
|
$DL09: BIT 6,A ; Sprungbedingung ?
|
|
JR Z,$DL10
|
|
LD DE,SPRTAB ; ja, DE zeigt auf Condition-Namen
|
|
$DL10: RES 7,A ; Klammer-Bit loeschen
|
|
CP 34H ; "(HL)" ?
|
|
JR NZ,$DL11
|
|
BIT 5,C ; ja, Indexregister ?
|
|
JR Z,$DL11
|
|
LD A,0AH ; ja, A -> IX-Register
|
|
BIT 6,C ; IY-Register ?
|
|
JR Z,$DL11
|
|
LD A,0CH ; ja, A -> IY-Register
|
|
$DL11: AND 0FH ; loesche oberes Nibble
|
|
ADD A,E ; und addiere zur Basis in DE
|
|
LD E,A
|
|
$DL50: LD A,(DE) ; Zeichen -> A
|
|
LD (HL),A ; Zeichen ausgeben
|
|
INC DE ; Tabellen-Adresse erhoehen
|
|
INC HL ; naechste Printposition
|
|
DJNZ $DL50 ; naechstes Zeichen
|
|
POP DE ; Register wieder herstellen
|
|
POP BC
|
|
POP AF
|
|
PUSH AF ; A retten
|
|
CP 0B4H ; "(HL)" ?
|
|
JR NZ,$DL12
|
|
BIT 5,C ; nein, Indexregister ?
|
|
JR Z,$DL12
|
|
LD A,(DE) ; ja, Befehlsbyte nach DD/FD -> A
|
|
CP 0E9H ; "JP (IX/IY)" ?
|
|
JR Z,$DL12
|
|
LD (HL),'+' ; nein, "+" ausgeben
|
|
INC HL ; naechste Printposition
|
|
CALL PRVH ; Offset ausgeben
|
|
$DL12: POP AF ; A wieder herstellen
|
|
BIT 7,A ; "()" ?
|
|
RET Z ; nein, fertig
|
|
LD (HL),')' ; ja, ")" ausgeben
|
|
INC HL ; naechste Printposition
|
|
RET
|
|
|
|
; Error
|
|
ERRO: LD DE,CBMTAB+24 ; Pointer auf "????" -> DE
|
|
CALL TRBY ; als Mnemonic ausgeben
|
|
POP DE ; akt. Disassemblieradr. vom Stack holen
|
|
|
|
; Disassemblier-Adresse erhoehen und merken
|
|
INAD: INC DE
|
|
LD (DADR),DE
|
|
|
|
; Workspace ausgeben
|
|
PRWO: PUSH AF ; Register retten
|
|
PUSH BC
|
|
PUSH DE
|
|
PUSH HL
|
|
LD HL,WRKS ; Adresse Workspace -> HL
|
|
CALL PRTSTR ; Workspace aufs Terminal ausgeben
|
|
LD HL,NL ; Adresse Newline-String -> HL
|
|
CALL PRTSTR ; Newline ausgeben
|
|
POP HL ; Register wieder herstellen
|
|
POP DE
|
|
POP BC
|
|
POP AF
|
|
RET
|
|
|
|
; Workspace loeschen
|
|
CLWO: LD HL,WRKS ; Workspace mit Space fuellen
|
|
LD DE,WRKS+1 ; und mit Null terminieren
|
|
LD (HL),32
|
|
LD BC,32
|
|
LDIR
|
|
XOR A
|
|
LD (DE),A
|
|
RET
|
|
|
|
; 4 Bytes transferieren
|
|
TRBY: PUSH BC ; BC retten
|
|
LD BC,4 ; 4 Bytes
|
|
EX DE,HL ; DE=Printposition, HL=Mnemonic
|
|
LDIR ; Bytes transferieren
|
|
EX DE,HL ; HL ist wieder Printposition
|
|
POP BC ; BC wieder herstellen
|
|
INC HL ; Leerzeichen
|
|
RET
|
|
|
|
; Byte vorne und hinten ausgeben
|
|
PRVH: CALL PRNB ; Byte vorne ausgeben
|
|
|
|
; Byte hinten ausgeben
|
|
PRBH: PUSH AF ; A retten
|
|
LD A,(DE) ; Byte -> A
|
|
CALL PRAK ; A ausgeben
|
|
POP AF ; A wieder herstellen
|
|
RET
|
|
|
|
; Byte vorne ausgeben
|
|
PRNB: PUSH AF ; A retten
|
|
INC DE ; DE auf naechstes Byte setzen
|
|
PUSH HL ; akt. Printposition retten
|
|
LD HL,(PRTMP) ; vordere Printposition -> HL
|
|
LD A,(DE) ; Byte -> A
|
|
CALL PRAK ; A ausgeben
|
|
INC HL ; Leerzeichen
|
|
LD (PRTMP),HL ; vordere Printposition retten
|
|
POP HL ; akt. Printposition wieder -> HL
|
|
POP AF ; A wieder herstellen
|
|
RET
|
|
|
|
; DE ausgeben
|
|
PRBY: LD A,D ; MSB -> A
|
|
CALL PRAK ; A ausgeben
|
|
LD A,E ; LSB -> A
|
|
|
|
; A ausgeben
|
|
PRAK: PUSH AF ; A retten
|
|
RRCA ; oberes Nibble ins untere schieben
|
|
RRCA
|
|
RRCA
|
|
RRCA
|
|
CALL PRCH ; oberes Nibble ausgeben
|
|
POP AF ; A wieder herstellen
|
|
CALL PRCH ; unteres Nibble ausgeben
|
|
RET
|
|
|
|
; unteres Nibble in ASCII-Hex umwandeln und in Workspace schreiben
|
|
PRCH: AND 0FH
|
|
ADD A,90H
|
|
DAA
|
|
ADC A,40H
|
|
DAA
|
|
LD (HL),A ; ASCII-Ziffer in Workspace schreiben
|
|
INC HL ; Printposition erhoehen
|
|
RET
|
|
|
|
; Die hier folgenden Tabellen muessen am Anfang einer Page
|
|
; beginnen, und die Reihenfolge der Tabellen darf auf keinen
|
|
; Fall geaendert werden, weil das LSB der Tabellenadressen
|
|
; durch arithmetische Operationen mit den Op-Codes berechnet
|
|
; wird !!!
|
|
|
|
DEFS 256 - ($ & 0FFH)
|
|
|
|
MNETAB: ; Tabelle mit den Z80-Mnemonics
|
|
DEFM 'ADD ADC '
|
|
DEFM 'SUB SBC '
|
|
DEFM 'AND XOR '
|
|
DEFM 'OR CP '
|
|
DEFM 'JR NOP '
|
|
DEFM 'DJNZEX '
|
|
DEFM 'RLCARLA '
|
|
DEFM 'DAA SCF '
|
|
DEFM 'RRCARRA '
|
|
DEFM 'CPL CCF '
|
|
DEFM 'LD INC '
|
|
DEFM 'DEC HALT'
|
|
DEFM 'RET POP '
|
|
DEFM 'JP OUT '
|
|
DEFM 'EX DI '
|
|
DEFM 'CALLPUSH'
|
|
DEFM 'RST EXX '
|
|
DEFM 'IN EX '
|
|
DEFM 'EI LDI '
|
|
DEFM 'LDIRINI '
|
|
DEFM 'INIROUTI'
|
|
DEFM 'OTIRNEG '
|
|
DEFM 'RETNRRD '
|
|
DEFM 'LDD LDDR'
|
|
DEFM 'CPD CPDR'
|
|
DEFM 'IND INDR'
|
|
DEFM 'OTDROUTD'
|
|
DEFM 'RETIRLD '
|
|
DEFM 'BIT RES '
|
|
DEFM 'SET ????'
|
|
DEFM 'CPI CPIR'
|
|
DEFM 'IM ----'
|
|
|
|
CODTAB: ; LSB-Adressen der Mnemonics in MNETAB fuer
|
|
; Befehle 00..3F ohne Preafix ED/CB
|
|
|
|
DEFB 024H,050H,050H,054H,054H,058H,050H,030H ; NOP LD LD INC INC DEC LD RLCA
|
|
DEFB 070H,000H,050H,058H,054H,058H,050H,040H ; EX ADD LD DEC INC DEC LD RRCA
|
|
DEFB 028H,050H,050H,054H,054H,058H,050H,034H ; DJNZ LD LD INC INC DEC LD RLA
|
|
DEFB 020H,000H,050H,058H,054H,058H,050H,044H ; JR ADD LD DEC INC DEC LD RRA
|
|
DEFB 020H,050H,050H,054H,054H,058H,050H,038H ; JR LD LD INC INC DEC LD DAA
|
|
DEFB 020H,000H,050H,058H,054H,058H,050H,048H ; JR ADD LD DEC INC DEC LD CPL
|
|
DEFB 020H,050H,050H,054H,054H,058H,050H,03CH ; JR LD LD INC INC DEC LD SCF
|
|
DEFB 020H,000H,050H,058H,054H,058H,050H,04CH ; JR ADD LD DEC INC DEC LD CCF
|
|
|
|
; LSB-Adressen der Mnemonics in MNETAB fuer
|
|
; Befehle C0..FF ohne Preafix ED/CB
|
|
|
|
DEFB 060H,064H,068H,068H,078H,07CH,000H,080H ; RET POP JP JP CALL PUSH ADD RET
|
|
DEFB 060H,060H,068H,0F1H,078H,078H,004H,080H ; RET RET JP (CB) CALL CALL ADC RST
|
|
DEFB 060H,064H,068H,06CH,078H,07CH,008H,080H ; RET POP JP OUT CALL PUSH SUB RST
|
|
DEFB 060H,084H,068H,088H,078H,0F0H,00CH,080H ; RET EXX JP IN CALL (DD) SBC RST
|
|
DEFB 060H,064H,068H,070H,078H,07CH,010H,080H ; RET POP JP EX CALL PUSH AND RST
|
|
DEFB 060H,068H,068H,02CH,078H,0F2H,014H,080H ; RET JP JP EX CALL (ED) XOR RST
|
|
DEFB 060H,064H,068H,074H,078H,07CH,018H,080H ; RET POP JP DI CALL PUSH OR RST
|
|
DEFB 060H,050H,068H,090H,078H,0F8H,01CH,080H ; RET LD JP EI CALL (FD) CP RST
|
|
|
|
; LSB-Adressen der Mnemonics in MNETAB fuer
|
|
; Befehle 40..7F mit Preafix ED
|
|
|
|
DEFB 088H,06CH,00CH,050H,0ACH,0B0H,0F8H,050H ; IN OUT SBC LD NEG RETN IM LD
|
|
DEFB 088H,06CH,004H,050H,0FFH,0D8H,0FFH,050H ; IN OUT ADC LD RETI LD
|
|
DEFB 088H,06CH,00CH,050H,0FFH,0FFH,0F8H,050H ; IN OUT SBC LD IM LD
|
|
DEFB 088H,06CH,004H,050H,0FFH,0FFH,0F8H,050H ; IN OUT ADC LD IM LD
|
|
DEFB 088H,06CH,00CH,0FFH,0FFH,0FFH,0FFH,0B4H ; IN OUT SBC RRD
|
|
DEFB 088H,06CH,004H,0FFH,0FFH,0FFH,0FFH,0DCH ; IN OUT ADC RLD
|
|
DEFB 0FFH,0FFH,00CH,050H,0FFH,0FFH,0FFH,0FFH ; SBC LD
|
|
DEFB 088H,06CH,004H,050H,0FFH,0FFH,0FFH,0FFH ; IN OUT ADC LD
|
|
|
|
; LSB-Adressen der Mnemonics in MNETAB fuer
|
|
; Befehle A0..BF mit Praefix ED
|
|
|
|
DEFB 094H,0F0H,09CH,0A4H,0FFH,0FFH,0FFH,0FFH ; LDI CPI INI OUTI
|
|
DEFB 0B8H,0C0H,0C8H,0D4H,0FFH,0FFH,0FFH,0FFH ; LDD CPD IND OUTD
|
|
DEFB 098H,0F4H,0A0H,0A8H,0FFH,0FFH,0FFH,0FFH ; LDIR CPIR INIR OTIR
|
|
DEFB 0BCH,0C4H,0CCH,0D0H,0FFH,0FFH,0FFH,0FFH ; LDDR CPDR INDR OTDR
|
|
|
|
SPRTAB: ; Tabelle der Sprungbedingungen
|
|
|
|
DEFM 'NZNCPOPEPM'
|
|
DEFB 0FFH,0FFH,0FFH,0FFH,0FFH,0FFH
|
|
|
|
REGTAB: ; Tabelle der Register
|
|
|
|
DEFM 'BCDEHLSPAFIXIYIR'
|
|
|
|
OPETAB: ; Tabelle der Operanden:
|
|
; Bit 7: Zahl/Buchstabe
|
|
; Bit 6: einfach/doppelt
|
|
; Bit 5: Register/Sprungbedingung
|
|
; Bit 4: ohne/mit Klammer
|
|
; Bit 0..3: Offset in der Tabelle der Registernamen
|
|
|
|
; Befehle 00..3F ohne Preafix ED/CB
|
|
; 1. Operand
|
|
|
|
DEFB 0FFH,030H,0B0H,030H,010H,010H,010H,0FFH ; - BC (BC) BC B B B -
|
|
DEFB 038H,034H,017H,030H,011H,011H,011H,0FFH ; AF HL A BC C C C -
|
|
DEFB 041H,032H,0B2H,032H,012H,012H,012H,0FFH ; DIS DE (DE) DE D D D -
|
|
DEFB 041H,034H,017H,032H,013H,013H,013H,0FFH ; DIS HL A DE E E E -
|
|
DEFB 070H,034H,0C4H,034H,014H,014H,014H,0FFH ; NZ HL (NN) HL H H H -
|
|
DEFB 051H,034H,034H,034H,015H,015H,015H,0FFH ; Z HL HL HL L L L -
|
|
DEFB 072H,036H,0C4H,036H,016H,016H,016H,0FFH ; NC SP (NN) SP (HL) (HL) (HL) -
|
|
DEFB 011H,034H,017H,036H,017H,017H,017H,0FFH ; C HL A SP A A A -
|
|
|
|
; Befehle C0..FF ohne Preafix ED/CB
|
|
; 1. Operand
|
|
|
|
DEFB 070H,030H,070H,044H,070H,030H,017H,020H ; NZ BC NZ NN NZ BC A 00
|
|
DEFB 051H,0FFH,051H,0F1H,051H,044H,017H,021H ; Z - Z *CB Z NN A 08
|
|
DEFB 072H,032H,072H,0C2H,072H,032H,042H,022H ; NC DE NC (N) NC DE N 10
|
|
DEFB 053H,0FFH,053H,017H,053H,0F2H,017H,023H ; C - C A C *DD A 18
|
|
DEFB 074H,034H,074H,0B6H,074H,034H,042H,024H ; PO HL PO (SP) PO HL N 20
|
|
DEFB 076H,016H,076H,032H,076H,0F4H,042H,025H ; PE (HL) PE DE PE *ED N 28
|
|
DEFB 058H,038H,058H,0FFH,058H,038H,042H,026H ; P AF P - P AF N 30
|
|
DEFB 059H,036H,059H,0FFH,059H,0F8H,042H,027H ; M SP M - M *FD N 38
|
|
|
|
; Befehle 00..3F ohne Preafix ED/CB
|
|
; 2. Operand
|
|
|
|
DEFB 0FFH,044H,017H,0FFH,0FFH,0FFH,042H,0FFH ; - NN A - - - N -
|
|
DEFB 038H,030H,0B0H,0FFH,0FFH,0FFH,042H,0FFH ; AF BC (BC) - - - N -
|
|
DEFB 0FFH,044H,017H,0FFH,0FFH,0FFH,042H,0FFH ; - NN A - - - N -
|
|
DEFB 0FFH,032H,0B2H,0FFH,0FFH,0FFH,042H,0FFH ; - DE (DE) - - - N -
|
|
DEFB 041H,044H,034H,0FFH,0FFH,0FFH,042H,0FFH ; DIS NN HL - - - N -
|
|
DEFB 041H,034H,0C4H,0FFH,0FFH,0FFH,042H,0FFH ; DIS HL (NN) - - - N -
|
|
DEFB 041H,044H,017H,0FFH,0FFH,0FFH,042H,0FFH ; DIS NN A - - - N -
|
|
DEFB 041H,036H,0C4H,0FFH,0FFH,0FFH,042H,0FFH ; DIS SP (NN) - - - N -
|
|
|
|
; Befehle C0..FF ohne Praefix ED/CB
|
|
; 2. Operand
|
|
|
|
DEFB 0FFH,0FFH,044H,0FFH,044H,0FFH,042H,0FFH ; - - NN - NN - N -
|
|
DEFB 0FFH,0FFH,044H,0FFH,044H,0FFH,042H,0FFH ; - - NN *CB NN - N -
|
|
DEFB 0FFH,0FFH,044H,017H,044H,0FFH,0FFH,0FFH ; - - NN A NN - - -
|
|
DEFB 0FFH,0FFH,044H,0C2H,044H,0FFH,042H,0FFH ; - - NN (N) NN *DD N -
|
|
DEFB 0FFH,0FFH,044H,034H,044H,0FFH,0FFH,0FFH ; - - NN HL NN - - -
|
|
DEFB 0FFH,0FFH,044H,034H,044H,0FFH,0FFH,0FFH ; - - NN HL NN *ED - -
|
|
DEFB 0FFH,0FFH,044H,0FFH,044H,0FFH,0FFH,0FFH ; - - NN - NN - - -
|
|
DEFB 0FFH,034H,044H,0FFH,044H,0FFH,0FFH,0FFH ; - HL NN - NN *FD - -
|
|
|
|
OP2TAB: ; Befehle 40..7F mit Praefix ED
|
|
; 1. Operand
|
|
|
|
DEFB 010H,091H,034H,0C4H,0FFH,0FFH,000H,01EH ; B (C) HL (NN) - - 0 I
|
|
DEFB 011H,091H,034H,030H,0FFH,0FFH,0FFH,01FH ; C (C) HL BC - - - R
|
|
DEFB 012H,091H,034H,0C4H,0FFH,0FFH,001H,017H ; D (C) HL (NN) - - 1 A
|
|
DEFB 013H,091H,034H,032H,0FFH,0FFH,002H,017H ; E (C) HL DE - - 2 A
|
|
DEFB 014H,091H,034H,0C4H,0FFH,0FFH,076H,0FFH ; H (C) HL - - - - -
|
|
DEFB 015H,091H,034H,0FFH,0FFH,0FFH,0FFH,0FFH ; L (C) HL - - - - -
|
|
DEFB 0FFH,0FFH,034H,0C4H,0FFH,0FFH,0FFH,0FFH ; - - HL (NN) - - - -
|
|
DEFB 017H,091H,034H,036H,0FFH,0FFH,0FFH,0FFH ; A (C) HL SP - - - -
|
|
|
|
; Befehle 40..7F mit Preafix ED
|
|
; 2. Operand
|
|
|
|
DEFB 091H,010H,030H,030H,0FFH,0FFH,0FFH,017H ; (C) B BC BC - - - A
|
|
DEFB 091H,011H,030H,0C4H,0FFH,0FFH,0FFH,017H ; (C) C BC (NN) - - - A
|
|
DEFB 091H,012H,032H,032H,0FFH,0FFH,0FFH,01EH ; (C) D DE DE - - - I
|
|
DEFB 091H,013H,032H,0C4H,0FFH,0FFH,0FFH,01FH ; (C) E DE (NN) - - - R
|
|
DEFB 091H,014H,034H,034H,0FFH,0FFH,0FFH,0FFH ; (C) H HL - - - - -
|
|
DEFB 091H,015H,034H,0FFH,0FFH,0FFH,0FFH,0FFH ; (C) L HL - - - - -
|
|
DEFB 0FFH,0FFH,036H,036H,0FFH,0FFH,0FFH,0FFH ; - - SP SP - - - -
|
|
DEFB 091H,017H,036H,0C4H,0FFH,0FFH,0FFH,0FFH ; (C) A SP (NN) - - - -
|
|
|
|
CBMTAB: ; Tabelle der Mnemonics mit Praefix CB
|
|
DEFM 'RLC RRC '
|
|
DEFM 'RL RR '
|
|
DEFM 'SLA SRA '
|
|
DEFM '????SRL '
|
|
|
|
NL: ; Null-terminiertes Newline fuers Terminal
|
|
DEFB 10,13,0
|
|
|
|
WRKS: DEFS 34 ; Workspace zur Aufbereitung einer Ausgabezeile
|
|
PRTMP: DEFS 2 ; temoraerer Speicher fuer Printposition
|
|
DADR: DEFS 2 ; Disassemblier-Adresse
|