- [NEW] While debugging you can go back/forward in time

- [NEW] Step by step execution with F6
- [NEW] Memory is tagged as code or data while executing, so later it can be properly disassembled
- [NEW] "reg X value" to set the value of X register
- [FIX] IX opcode table had errors
- [FIX] opcodes with two parameters where printed incorrectly on the disassembler
- [FIX] opcodes can't be lager than 4 bytes
- [CHG] Berserk mode and fernando martin TAP by default, to help with debugging

main.cpp

@@ -82,7 +82,7 @@ int main(int argc, char *argv[])
 
     zx_ula::sound_init();
 
-    zx_tape::load("alien8.tap");
+    zx_tape::load("fernandomartin.tap");
 
     if (argc==3) { z80debug::loadngo(argv[1], argv[2]); }
 
@@ -119,10 +119,25 @@ int main(int argc, char *argv[])
                         const uint8_t dt = z80debug::next();
                         zxscreen::refresh(dt);
                         zxscreen::redraw();
+                    } else if (e.key.keysym.scancode==SDL_SCANCODE_F1) {
+                        z80debug::history::gototop();
+                        z80debug::refresh();
+                    } else if (e.key.keysym.scancode==SDL_SCANCODE_F2) {
+                        z80debug::history::goback();
+                        z80debug::refresh();
+                    } else if (e.key.keysym.scancode==SDL_SCANCODE_F3) {
+                        z80debug::history::goforward();
+                        z80debug::refresh();
                     } else if (e.key.keysym.scancode==SDL_SCANCODE_F5) {
+                        z80debug::history::gototop();
                         const uint8_t dt = z80::step();
                         z80debug::cont();
                         zxscreen::refresh(dt);
+                    } else if (e.key.keysym.scancode==SDL_SCANCODE_F6) {
+                        z80debug::history::gototop();
+                        const uint8_t dt = z80::step();
+                        z80debug::refresh();
+                        zxscreen::refresh(dt);
                     } else if (e.key.keysym.scancode==SDL_SCANCODE_RETURN) {
                         z80debug::executeConsole();
                     } else if (e.key.keysym.scancode==SDL_SCANCODE_BACKSPACE) {

z80.cpp

@@ -6,6 +6,7 @@
 namespace z80
 {
     static uint8_t *memory = nullptr;
+    static uint8_t memtag[65536];
     static uint32_t t = 0;
     static uint16_t current_opcode_address = 0;
 
@@ -145,12 +146,15 @@ namespace z80
     {
         if (z80debug::isbreak(addr, 2)) z80debug::stop();
         t+=3;
+        memtag[addr] = MEMTAG_DATA;
         return memory[addr];
     }
 
     uint8_t READ_MEM_8()
     {
-        return READ_MEM_8(rPC++);
+        uint8_t data = READ_MEM_8(rPC);
+        memtag[rPC++] = MEMTAG_CODE;
+        return data;
     }
 
     uint8_t READ_M1()
@@ -178,6 +182,8 @@ namespace z80
         if (z80debug::isbreak(addr, 4)) z80debug::stop();
         //if (z80debug::debugging())
         z80debug::setmemmodified(addr);
+        memtag[addr] = MEMTAG_DATA;
+
         return value;
     }
 
@@ -1033,6 +1039,7 @@ namespace z80
     void reset(uint8_t* mem)
     {
         memory = mem;
+        for (int i=0; i<65536; ++i) memtag[i] = MEMTAG_NONE;
         rPC = iff1 = iff2 = im = 0;
         rAF = rAF2 = rBC = rBC2 = rDE = rDE2 = rHL = rHL2 = rIX = rIY = rSP = 0xffff;
         t = 0;
@@ -1061,6 +1068,7 @@ namespace z80
         current_opcode_address = rPC;
         t = 0;
         const uint8_t opcode = READ_M1();
+        memtag[current_opcode_address] = MEMTAG_INST;
         uint16_t tmp;
 
         switch (opcode)
@@ -1340,6 +1348,8 @@ namespace z80
 
         if (pending_ei==2) { pending_ei=0; actualEI(); }
         if (pending_ei==1) pending_ei=2;
+
+        z80debug::history::store();
         return t;
     }
 
@@ -2720,4 +2730,7 @@ namespace z80
     uint16_t getPC() { return rPC; }
 
     void setPC(const uint16_t addr) { rPC = addr; }
+
+    uint8_t getMemTag(const uint16_t addr) { return memtag[addr]; };
+
 }

z80.h

@@ -4,6 +4,11 @@
 
 namespace z80
 {
+    #define MEMTAG_NONE     0
+    #define MEMTAG_INST     1
+    #define MEMTAG_CODE     2
+    #define MEMTAG_DATA     3
+
     void reset(uint8_t* mem);
     void connect_port(int num, int (*in_ptr)(int), void (*out_ptr)(int,int));
     void interrupt();
@@ -24,4 +29,5 @@ namespace z80
     uint16_t getPC();
 
     void setPC(const uint16_t addr);
+    uint8_t getMemTag(const uint16_t addr);
 }

z80debug.cpp

@@ -7,6 +7,13 @@
 #include "ui.h"
 namespace z80debug
 {
+    namespace history
+    {
+        uint16_t buffer[65536];
+        uint8_t top=0;
+        uint8_t pos=0;
+    }
+
     uint16_t oAF, oBC, oDE, oHL, oAF2, oBC2, oDE2, oHL2, oIX, oIY, oSP, oPC;
 
     bool mem_modified[65536];
@@ -84,17 +91,24 @@ namespace z80debug
 
     uint16_t find_previous_opcode(uint16_t pc)
     {
-        pc-=4;
+        pc--;
-        if (z80dis::getOpcodeSize(pc) != 4) {
+        if (z80::getMemTag(pc)!=MEMTAG_CODE && z80::getMemTag(pc)!=MEMTAG_INST) return pc;
-            pc++;
+
-            if (z80dis::getOpcodeSize(pc) != 3) {
+        while (z80::getMemTag(pc)!=MEMTAG_INST) pc--;
-                pc++;
+
-                if (z80dis::getOpcodeSize(pc) != 2) {
-                    pc++;
-                }
-            }
-        }
         return pc;
+        /*
+        pc-=4;
+        if (z80dis::getOpcodeSize(pc) == 4) return pc;
+        if (z80dis::getOpcodeSize(pc) == 3) return pc+3;
+        pc++;
+        if (z80dis::getOpcodeSize(pc) == 3) return pc;
+        if (z80dis::getOpcodeSize(pc) == 2) return pc+2;
+        pc++;
+        if (z80dis::getOpcodeSize(pc) == 2) return pc;
+
+        return pc+1;
+        */
     }
 
     void refresh()
@@ -144,8 +158,13 @@ namespace z80debug
             pos = find_previous_opcode(pos);
             if (breakpoints[pos]&9) ui::printtxt(0,i,"*", COLOR_RED);
             ui::printtxt(1,i,tohex(pos,4), COLOR_CYAN);
+            if (z80::getMemTag(pos)==MEMTAG_INST) {
                 ui::printtxt(7,i, z80dis::getOpcode(pos), COLOR_GRAY);
                 ui::printtxt(19,i, z80dis::getAsm(pos), COLOR_WHITE);
+            } else {
+                ui::printtxt(7,i, tohex(z80::getMem()[pos],2), COLOR_GRAY);
+                ui::printtxt(19,i, "?????????", COLOR_GRAY);
+            }
         }
         //for (int i=0;i<20;++i) printtxt(1,i,tohex(pc,4), COLOR_CYAN);
 
@@ -420,6 +439,17 @@ namespace z80debug
             uint8_t *mem = z80::getMem();
             int value = mem[address];
             SDL_itoa(value, console_error, 10);
+        } else if (strcmp(cmd, "reg")==0) {
+            getcmd();
+            if (strcmp(cmd, "f")==0) { getcmd(); int value = getnum(cmd); z80::getRegs()[0] = value; }
+            else if (strcmp(cmd, "a")==0) { getcmd(); int value = getnum(cmd); z80::getRegs()[1] = value; }
+            else if (strcmp(cmd, "c")==0) { getcmd(); int value = getnum(cmd); z80::getRegs()[2] = value; }
+            else if (strcmp(cmd, "b")==0) { getcmd(); int value = getnum(cmd); z80::getRegs()[3] = value; }
+            else if (strcmp(cmd, "e")==0) { getcmd(); int value = getnum(cmd); z80::getRegs()[4] = value; }
+            else if (strcmp(cmd, "d")==0) { getcmd(); int value = getnum(cmd); z80::getRegs()[5] = value; }
+            else if (strcmp(cmd, "l")==0) { getcmd(); int value = getnum(cmd); z80::getRegs()[6] = value; }
+            else if (strcmp(cmd, "h")==0) { getcmd(); int value = getnum(cmd); z80::getRegs()[7] = value; }
+            else { strcpy(console_error, "Syntax error: invalid register"); return; }
         }
     }  
 
@@ -476,4 +506,33 @@ namespace z80debug
         fread(&memory[16*1024], 48*1024, 1, f);
         fclose(f);
     }
+
+    namespace history
+    {
+        void store()
+        {
+            buffer[++top] = z80::getPC();
+            pos=top;
+        }
+
+        void gototop()
+        {
+            pos = top;
+            z80::setPC(buffer[pos]);
+        }
+
+        void goforward()
+        {
+            if (pos == top) return;
+            z80::setPC(buffer[++pos]);
+        }
+
+        void goback()
+        {
+            if (uint8_t(pos-1) == top) return;
+            z80::setPC(buffer[--pos]);
+        }
+
+    }
+
 }

z80debug.h

@@ -24,5 +24,14 @@ namespace z80debug
 
     void savestate(const char *filename);
     void loadstate(const char *filename);
+
     void loadngo(const char* filename, const char* addr);
+
+    namespace history
+    {
+        void store();
+        void gototop();
+        void goforward();
+        void goback();
+    }
 }

z80dis.cpp

@@ -13,7 +13,7 @@ namespace z80dis
 
     const char *base_opcodes[256] = {"nop", "ld bc,$%04x", "ld (bc),a", "inc bc", "inc b", "dec b", "ld b,$%02x", "rlca", "ex af,af'", "add hl,bc", "ld a,(bc)", "dec bc", "inc c", "dec c", "ld c,$%02x", "rrca", "djnz $%Xx", "ld de,$%04x", "ld (de),a", "inc de", "inc d", "dec d", "ld d,$%02x", "rla", "jr $%Xx", "add hl,de", "ld a,(de)", "dec de", "inc e", "dec e", "ld e,$%02x", "rra", "jr nz,$%Xx", "ld hl,$%04x", "ld ($%04x),hl", "inc hl", "inc h", "dec h", "ld h,$%02x", "daa", "jr z,$%Xx", "add hl,hl", "ld hl,($%04x)", "dec hl", "inc l", "dec l", "ld l,$%02x", "cpl", "jr nc,$%Xx", "ld sp,$%04x", "ld ($%04x),a", "inc sp", "inc (hl)", "dec (hl)", "ld (hl),$%02x", "scf", "jr c,$%Xx", "add hl,sp", "ld a,($%04x)", "dec sp", "inc a", "dec a", "ld a,$%02x", "ccf", "ld b,b", "ld b,c", "ld b,d", "ld b,e", "ld b,h", "ld b,l", "ld b,(hl)", "ld b,a", "ld c,b", "ld c,c", "ld c,d", "ld c,e", "ld c,h", "ld c,l", "ld c,(hl)", "ld c,a", "ld d,b", "ld d,c", "ld d,d", "ld d,e", "ld d,h", "ld d,l", "ld d,(hl)", "ld d,a", "ld e,b", "ld e,c", "ld e,d", "ld e,e", "ld e,h", "ld e,l", "ld e,(hl)", "ld e,a", "ld h,b", "ld h,c", "ld h,d", "ld h,e", "ld h,h", "ld h,l", "ld h,(hl)", "ld h,a", "ld l,b", "ld l,c", "ld l,d", "ld l,e", "ld l,h", "ld l,l", "ld l,(hl)", "ld l,a", "ld (hl),b", "ld (hl),c", "ld (hl),d", "ld (hl),e", "ld (hl),h", "ld (hl),l", "halt", "ld (hl),a", "ld a,b", "ld a,c", "ld a,d", "ld a,e", "ld a,h", "ld a,l", "ld a,(hl)", "ld a,a", "add a,b", "add a,c", "add a,d", "add a,e", "add a,h", "add a,l", "add a,(hl)", "add a,a", "adc a,b", "adc a,c", "adc a,d", "adc a,e", "adc a,h", "adc a,l", "adc a,(hl)", "adc a,a", "sub b", "sub c", "sub d", "sub e", "sub h", "sub l", "sub (hl)", "sub a", "sbc a,b", "sbc a,c", "sbc a,d", "sbc a,e", "sbc a,h", "sbc a,l", "sbc a,(hl)", "sbc a,a", "and b", "and c", "and d", "and e", "and h", "and l", "and (hl)", "and a", "xor b", "xor c", "xor d", "xor e", "xor h", "xor l", "xor (hl)", "xor a", "or b", "or c", "or d", "or e", "or h", "or l", "or (hl)", "or a", "cp b", "cp c", "cp d", "cp e", "cp h", "cp l", "cp (hl)", "cp a", "ret nz", "pop bc", "jp nz,$%04x", "jp $%04x", "call nz,$%04x", "push bc", "add a,$%02x", "rst 00h", "ret z", "ret", "jp z,$%04x", "_Bit_", "call z,$%04x", "call $%04x", "adc a,$%02x", "rst 08h", "ret nc", "pop de", "jp nc,$%04x", "out ($%02x),a", "call nc,$%04x", "push de", "sub $%02x", "rst 10h", "ret c", "exx", "jp c,$%04x", "in a,($%02x)", "call c,$%04x", "_IX_", "sbc a,$%02x", "rst 18h", "ret po", "pop hl", "jp po,$%04x", "ex (sp),hl", "call po,$%04x", "push hl", "and $%02x", "rst 20h", "ret pe", "jp (hl)", "jp pe,$%04x", "ex de,hl", "call pe,$%04x", "_Misc._", "xor $%02x", "rst 28h", "ret p", "pop af", "jp p,$%04x", "di", "call p,$%04x", "push af", "or $%02x", "rst 30h", "ret m", "ld sp,hl", "jp m,$%04x", "ei", "call m,$%04x", "_IY_", "cp $%02x", "rst 38h"};
     const char *cb_opcodes[256] = {"rlc b", "rlc c", "rlc d", "rlc e", "rlc h", "rlc l", "rlc (hl)", "rlc a", "rrc b", "rrc c", "rrc d", "rrc e", "rrc h", "rrc l", "rrc (hl)", "rrc a", "rl b", "rl c", "rl d", "rl e", "rl h", "rl l", "rl (hl)", "rl a", "rr b", "rr c", "rr d", "rr e", "rr h", "rr l", "rr (hl)", "rr a", "sla b", "sla c", "sla d", "sla e", "sla h", "sla l", "sla (hl)", "sla a", "sra b", "sra c", "sra d", "sra e", "sra h", "sra l", "sra (hl)", "sra a", "sll b", "sll c", "sll d", "sll e", "sll h", "sll l", "sll (hl)", "sll a", "srl b", "srl c", "srl d", "srl e", "srl h", "srl l", "srl (hl)", "srl a", "bit 0,b", "bit 0,c", "bit 0,d", "bit 0,e", "bit 0,h", "bit 0,l", "bit 0,(hl)", "bit 0,a", "bit 1,b", "bit 1,c", "bit 1,d", "bit 1,e", "bit 1,h", "bit 1,l", "bit 1,(hl)", "bit 1,a", "bit 2,b", "bit 2,c", "bit 2,d", "bit 2,e", "bit 2,h", "bit 2,l", "bit 2,(hl)", "bit 2,a", "bit 3,b", "bit 3,c", "bit 3,d", "bit 3,e", "bit 3,h", "bit 3,l", "bit 3,(hl)", "bit 3,a", "bit 4,b", "bit 4,c", "bit 4,d", "bit 4,e", "bit 4,h", "bit 4,l", "bit 4,(hl)", "bit 4,a", "bit 5,b", "bit 5,c", "bit 5,d", "bit 5,e", "bit 5,h", "bit 5,l", "bit 5,(hl)", "bit 5,a", "bit 6,b", "bit 6,c", "bit 6,d", "bit 6,e", "bit 6,h", "bit 6,l", "bit 6,(hl)", "bit 6,a", "bit 7,b", "bit 7,c", "bit 7,d", "bit 7,e", "bit 7,h", "bit 7,l", "bit 7,(hl)", "bit 7,a", "res 0,b", "res 0,c", "res 0,d", "res 0,e", "res 0,h", "res 0,l", "res 0,(hl)", "res 0,a", "res 1,b", "res 1,c", "res 1,d", "res 1,e", "res 1,h", "res 1,l", "res 1,(hl)", "res 1,a", "res 2,b", "res 2,c", "res 2,d", "res 2,e", "res 2,h", "res 2,l", "res 2,(hl)", "res 2,a", "res 3,b", "res 3,c", "res 3,d", "res 3,e", "res 3,h", "res 3,l", "res 3,(hl)", "res 3,a", "res 4,b", "res 4,c", "res 4,d", "res 4,e", "res 4,h", "res 4,l", "res 4,(hl)", "res 4,a", "res 5,b", "res 5,c", "res 5,d", "res 5,e", "res 5,h", "res 5,l", "res 5,(hl)", "res 5,a", "res 6,b", "res 6,c", "res 6,d", "res 6,e", "res 6,h", "res 6,l", "res 6,(hl)", "res 6,a", "res 7,b", "res 7,c", "res 7,d", "res 7,e", "res 7,h", "res 7,l", "res 7,(hl)", "res 7,a", "set 0,b", "set 0,c", "set 0,d", "set 0,e", "set 0,h", "set 0,l", "set 0,(hl)", "set 0,a", "set 1,b", "set 1,c", "set 1,d", "set 1,e", "set 1,h", "set 1,l", "set 1,(hl)", "set 1,a", "set 2,b", "set 2,c", "set 2,d", "set 2,e", "set 2,h", "set 2,l", "set 2,(hl)", "set 2,a", "set 3,b", "set 3,c", "set 3,d", "set 3,e", "set 3,h", "set 3,l", "set 3,(hl)", "set 3,a", "set 4,b", "set 4,c", "set 4,d", "set 4,e", "set 4,h", "set 4,l", "set 4,(hl)", "set 4,a", "set 5,b", "set 5,c", "set 5,d", "set 5,e", "set 5,h", "set 5,l", "set 5,(hl)", "set 5,a", "set 6,b", "set 6,c", "set 6,d", "set 6,e", "set 6,h", "set 6,l", "set 6,(hl)", "set 6,a", "set 7,b", "set 7,c", "set 7,d", "set 7,e", "set 7,h", "set 7,l", "set 7,(hl)", "set 7,a"};
-    const char *ix_opcodes[256] = {"", "", "", "", "inc b", "dec b", "ld b,$%02x", "", "", "add ix,bc", "", "", "inc c", "dec c", "ld c,$%02x", "", "", "", "", "", "inc d", "dec d", "ld d,$%02x", "", "", "add ix,de", "", "", "inc e", "dec e", "ld e,$%02x", "", "", "ld ix,$%04x", "ld ($%04x),ix", "inc ix", "inc ixh", "dec ixh", "ld ixh,$%02x", "", "", "add ix,ix", "ld ix,($%04x)", "dec ix", "inc ixl", "dec ixl", "ld ixl,$%02x", "", "", "", "", "", "inc (ix+%hhd)", "dec (ix+%hhd)", "ld (ix+%hhd),$%02x", "", "", "add ix,sp", "", "", "inc a", "dec a", "ld a,$%02x", "", "ld b,b", "ld b,c", "ld b,d", "ld b,e", "ld b,ixh", "ld b,ixl", "ld b,(ix+%hhd)", "ld b,a", "ld c,b", "ld c,c", "ld c,d", "ld c,e", "ld c,ixh", "ld c,ixl", "ld c,(ix+%hhd)", "ld c,a", "ld d,b", "ld d,c", "ld d,d", "ld d,e", "ld d,ixh", "ld d,ixl", "ld d,(ix+%hhd)", "ld d,a", "ld e,b", "ld e,c", "ld e,d", "ld e,e", "ld e,ixh", "ld e,ixl", "ld e,(ix+%hhd)", "ld e,a", "ld ixh,b", "ld ixh,c", "ld ixh,d", "ld ixh,e", "ld ixh,ixh", "ld ixh,ixl", "ld h,(ix+%hhd)", "ld ixh,a", "ld ixl,b", "ld ixl,c", "ld ixl,d", "ld ixl,e", "ld ixl,ixh", "ld ixl,ixl", "ld l,(ix+%hhd)", "ld ixl,a", "ld (ix+%hhd),b", "ld (ix+%hhd),c", "ld (ix+%hhd),d", "ld (ix+%hhd),e", "ld (ix+%hhd),h", "ld (ix+%hhd),l", "", "ld (ix+%hhd),a", "ld a,b", "ld a,c", "ld a,d", "ld a,e", "ld a,ixh", "ld a,ixl", "ld a,(ix+%hhd)", "ld a,a", "add a,b", "add a,c", "add a,d", "add a,e", "add a,ixh", "add a,ixl", "add a,(ix+%hhd)", "add a,a", "adc a,b", "adc a,c", "adc a,d", "adc a,e", "adc a,ixh", "adc a,ixl", "adc a,(ix+%hhd)", "adc a,a", "sub b", "sub c", "sub d", "sub e", "sub ixh", "sub ixl", "sub (ix+%hhd)", "sub a", "sbc a,b", "sbc a,c", "sbc a,d", "sbc a,e", "sbc a,ixh", "sbc a,ixl", "sbc a,(ix+%hhd)", "sbc a,a", "and b", "and c", "and d", "and e", "and ixh", "and ixl", "and (ix+%hhd)", "and a", "xor b", "xor c", "xor d", "xor e", "xor ixh", "xor ixl", "xor (ix+%hhd)", "xor a", "or b", "or c", "or d", "or e", "or ixh", "or ixl", "or (ix+%hhd)", "or a", "cp b", "cp c", "cp d", "cp e", "cp ixh", "cp ixl", "cp (ix+%hhd)", "cp a", "", "", "", "", "", "", "", "", "", "", "", "_IX Bit_", "", "", "", "", "", "pop ix", "", "ex (sp),ix", "", "push ix", "", "", "", "jp (ix)", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "ld sp,ix", "", "", "", "", "", ""};
+    const char *ix_opcodes[256] = {"", "", "", "", "inc b", "dec b", "ld b,$%02x", "", "", "add ix,bc", "", "", "inc c", "dec c", "ld c,$%02x", "", "", "", "", "", "inc d", "dec d", "ld d,$%02x", "", "", "add ix,de", "", "", "inc e", "dec e", "ld e,$%02x", "", "", "ld ix,$%04x", "ld ($%04x),ix", "inc ix", "inc ixh", "dec ixh", "ld ixh,$%02x", "", "", "add ix,ix", "ld ix,($%04x)", "dec ix", "inc ixl", "dec ixl", "ld ixl,$%02x", "", "", "", "", "", "inc (ix+%hhd)", "dec (ix+%hhd)", "ld (ix+%hhd),$%02x", "", "", "add ix,sp", "", "", "inc a", "dec a", "ld a,$%02x", "", "ld b,b", "ld b,c", "ld b,d", "ld b,e", "ld b,ixh", "ld b,ixl", "ld b,(ix+%hhd)", "ld b,a", "ld c,b", "ld c,c", "ld c,d", "ld c,e", "ld c,ixh", "ld c,ixl", "ld c,(ix+%hhd)", "ld c,a", "ld d,b", "ld d,c", "ld d,d", "ld d,e", "ld d,ixh", "ld d,ixl", "ld d,(ix+%hhd)", "ld d,a", "ld e,b", "ld e,c", "ld e,d", "ld e,e", "ld e,ixh", "ld e,ixl", "ld e,(ix+%hhd)", "ld e,a", "ld ixh,b", "ld ixh,c", "ld ixh,d", "ld ixh,e", "ld ixh,ixh", "ld ixh,ixl", "ld h,(ix+%hhd)", "ld ixh,a", "ld ixl,b", "ld ixl,c", "ld ixl,d", "ld ixl,e", "ld ixl,ixh", "ld ixl,ixl", "ld l,(ix+%hhd)", "ld ixl,a", "ld (ix+%hhd),b", "ld (ix+%hhd),c", "ld (ix+%hhd),d", "ld (ix+%hhd),e", "ld (ix+%hhd),h", "ld (ix+%hhd),l", "", "ld (ix+%hhd),a", "ld a,b", "ld a,c", "ld a,d", "ld a,e", "ld a,ixh", "ld a,ixl", "ld a,(ix+%hhd)", "ld a,a", "add a,b", "add a,c", "add a,d", "add a,e", "add a,ixh", "add a,ixl", "add a,(ix+%hhd)", "add a,a", "adc a,b", "adc a,c", "adc a,d", "adc a,e", "adc a,ixh", "adc a,ixl", "adc a,(ix+%hhd)", "adc a,a", "sub b", "sub c", "sub d", "sub e", "sub ixh", "sub ixl", "sub (ix+%hhd)", "sub a", "sbc a,b", "sbc a,c", "sbc a,d", "sbc a,e", "sbc a,ixh", "sbc a,ixl", "sbc a,(ix+%hhd)", "sbc a,a", "and b", "and c", "and d", "and e", "and ixh", "and ixl", "and (ix+%hhd)", "and a", "xor b", "xor c", "xor d", "xor e", "xor ixh", "xor ixl", "xor (ix+%hhd)", "xor a", "or b", "or c", "or d", "or e", "or ixh", "or ixl", "or (ix+%hhd)", "or a", "cp b", "cp c", "cp d", "cp e", "cp ixh", "cp ixl", "cp (ix+%hhd)", "cp a", "", "", "", "", "", "", "", "", "", "", "", "_IX Bit_", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "pop ix", "", "ex (sp),ix", "", "push ix", "", "", "", "jp (ix)", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "ld sp,ix", "", "", "", "", "", ""};
     const char *ix_bit_opcodes[256] = {"rlc (ix+%hhd),b", "rlc (ix+%hhd),c", "rlc (ix+%hhd),d", "rlc (ix+%hhd),e", "rlc (ix+%hhd),h", "rlc (ix+%hhd),l", "rlc (ix+%hhd)", "rlc (ix+%hhd),a", "rrc (ix+%hhd),b", "rrc (ix+%hhd),c", "rrc (ix+%hhd),d", "rrc (ix+%hhd),e", "rrc (ix+%hhd),h", "rrc (ix+%hhd),l", "rrc (ix+%hhd)", "rrc (ix+%hhd),a", "rl (ix+%hhd),b", "rl (ix+%hhd),c", "rl (ix+%hhd),d", "rl (ix+%hhd),e", "rl (ix+%hhd),h", "rl (ix+%hhd),l", "rl (ix+%hhd)", "rl (ix+%hhd),a", "rr (ix+%hhd),b", "rr (ix+%hhd),c", "rr (ix+%hhd),d", "rr (ix+%hhd),e", "rr (ix+%hhd),h", "rr (ix+%hhd),l", "rr (ix+%hhd)", "rr (ix+%hhd),a", "sla (ix+%hhd),b", "sla (ix+%hhd),c", "sla (ix+%hhd),d", "sla (ix+%hhd),e", "sla (ix+%hhd),h", "sla (ix+%hhd),l", "sla (ix+%hhd)", "sla (ix+%hhd),a", "sra (ix+%hhd),b", "sra (ix+%hhd),c", "sra (ix+%hhd),d", "sra (ix+%hhd),e", "sra (ix+%hhd),h", "sra (ix+%hhd),l", "sra (ix+%hhd)", "sra (ix+%hhd),a", "sll (ix+%hhd),b", "sll (ix+%hhd),c", "sll (ix+%hhd),d", "sll (ix+%hhd),e", "sll (ix+%hhd),h", "sll (ix+%hhd),l", "sll (ix+%hhd)", "sll (ix+%hhd),a", "srl (ix+%hhd),b", "srl (ix+%hhd),c", "srl (ix+%hhd),d", "srl (ix+%hhd),e", "srl (ix+%hhd),h", "srl (ix+%hhd),l", "srl (ix+%hhd)", "srl (ix+%hhd),a", "bit 0,(ix+%hhd)", "bit 0,(ix+%hhd)", "bit 0,(ix+%hhd)", "bit 0,(ix+%hhd)", "bit 0,(ix+%hhd)", "bit 0,(ix+%hhd)", "bit 0,(ix+%hhd)", "bit 0,(ix+%hhd)", "bit 1,(ix+%hhd)", "bit 1,(ix+%hhd)", "bit 1,(ix+%hhd)", "bit 1,(ix+%hhd)", "bit 1,(ix+%hhd)", "bit 1,(ix+%hhd)", "bit 1,(ix+%hhd)", "bit 1,(ix+%hhd)", "bit 2,(ix+%hhd)", "bit 2,(ix+%hhd)", "bit 2,(ix+%hhd)", "bit 2,(ix+%hhd)", "bit 2,(ix+%hhd)", "bit 2,(ix+%hhd)", "bit 2,(ix+%hhd)", "bit 2,(ix+%hhd)", "bit 3,(ix+%hhd)", "bit 3,(ix+%hhd)", "bit 3,(ix+%hhd)", "bit 3,(ix+%hhd)", "bit 3,(ix+%hhd)", "bit 3,(ix+%hhd)", "bit 3,(ix+%hhd)", "bit 3,(ix+%hhd)", "bit 4,(ix+%hhd)", "bit 4,(ix+%hhd)", "bit 4,(ix+%hhd)", "bit 4,(ix+%hhd)", "bit 4,(ix+%hhd)", "bit 4,(ix+%hhd)", "bit 4,(ix+%hhd)", "bit 4,(ix+%hhd)", "bit 5,(ix+%hhd)", "bit 5,(ix+%hhd)", "bit 5,(ix+%hhd)", "bit 5,(ix+%hhd)", "bit 5,(ix+%hhd)", "bit 5,(ix+%hhd)", "bit 5,(ix+%hhd)", "bit 5,(ix+%hhd)", "bit 6,(ix+%hhd)", "bit 6,(ix+%hhd)", "bit 6,(ix+%hhd)", "bit 6,(ix+%hhd)", "bit 6,(ix+%hhd)", "bit 6,(ix+%hhd)", "bit 6,(ix+%hhd)", "bit 6,(ix+%hhd)", "bit 7,(ix+%hhd)", "bit 7,(ix+%hhd)", "bit 7,(ix+%hhd)", "bit 7,(ix+%hhd)", "bit 7,(ix+%hhd)", "bit 7,(ix+%hhd)", "bit 7,(ix+%hhd)", "bit 7,(ix+%hhd)", "res 0,(ix+%hhd),b", "res 0,(ix+%hhd),c", "res 0,(ix+%hhd),d", "res 0,(ix+%hhd),e", "res 0,(ix+%hhd),h", "res 0,(ix+%hhd),l", "res 0,(ix+%hhd)", "res 0,(ix+%hhd),a", "res 1,(ix+%hhd),b", "res 1,(ix+%hhd),c", "res 1,(ix+%hhd),d", "res 1,(ix+%hhd),e", "res 1,(ix+%hhd),h", "res 1,(ix+%hhd),l", "res 1,(ix+%hhd)", "res 1,(ix+%hhd),a", "res 2,(ix+%hhd),b", "res 2,(ix+%hhd),c", "res 2,(ix+%hhd),d", "res 2,(ix+%hhd),e", "res 2,(ix+%hhd),h", "res 2,(ix+%hhd),l", "res 2,(ix+%hhd)", "res 2,(ix+%hhd),a", "res 3,(ix+%hhd),b", "res 3,(ix+%hhd),c", "res 3,(ix+%hhd),d", "res 3,(ix+%hhd),e", "res 3,(ix+%hhd),h", "res 3,(ix+%hhd),l", "res 3,(ix+%hhd)", "res 3,(ix+%hhd),a", "res 4,(ix+%hhd),b", "res 4,(ix+%hhd),c", "res 4,(ix+%hhd),d", "res 4,(ix+%hhd),e", "res 4,(ix+%hhd),h", "res 4,(ix+%hhd),l", "res 4,(ix+%hhd)", "res 4,(ix+%hhd),a", "res 5,(ix+%hhd),b", "res 5,(ix+%hhd),c", "res 5,(ix+%hhd),d", "res 5,(ix+%hhd),e", "res 5,(ix+%hhd),h", "res 5,(ix+%hhd),l", "res 5,(ix+%hhd)", "res 5,(ix+%hhd),a", "res 6,(ix+%hhd),b", "res 6,(ix+%hhd),c", "res 6,(ix+%hhd),d", "res 6,(ix+%hhd),e", "res 6,(ix+%hhd),h", "res 6,(ix+%hhd),l", "res 6,(ix+%hhd)", "res 6,(ix+%hhd),a", "res 7,(ix+%hhd),b", "res 7,(ix+%hhd),c", "res 7,(ix+%hhd),d", "res 7,(ix+%hhd),e", "res 7,(ix+%hhd),h", "res 7,(ix+%hhd),l", "res 7,(ix+%hhd)", "res 7,(ix+%hhd),a", "set 0,(ix+%hhd),b", "set 0,(ix+%hhd),c", "set 0,(ix+%hhd),d", "set 0,(ix+%hhd),e", "set 0,(ix+%hhd),h", "set 0,(ix+%hhd),l", "set 0,(ix+%hhd)", "set 0,(ix+%hhd),a", "set 1,(ix+%hhd),b", "set 1,(ix+%hhd),c", "set 1,(ix+%hhd),d", "set 1,(ix+%hhd),e", "set 1,(ix+%hhd),h", "set 1,(ix+%hhd),l", "set 1,(ix+%hhd)", "set 1,(ix+%hhd),a", "set 2,(ix+%hhd),b", "set 2,(ix+%hhd),c", "set 2,(ix+%hhd),d", "set 2,(ix+%hhd),e", "set 2,(ix+%hhd),h", "set 2,(ix+%hhd),l", "set 2,(ix+%hhd)", "set 2,(ix+%hhd),a", "set 3,(ix+%hhd),b", "set 3,(ix+%hhd),c", "set 3,(ix+%hhd),d", "set 3,(ix+%hhd),e", "set 3,(ix+%hhd),h", "set 3,(ix+%hhd),l", "set 3,(ix+%hhd)", "set 3,(ix+%hhd),a", "set 4,(ix+%hhd),b", "set 4,(ix+%hhd),c", "set 4,(ix+%hhd),d", "set 4,(ix+%hhd),e", "set 4,(ix+%hhd),h", "set 4,(ix+%hhd),l", "set 4,(ix+%hhd)", "set 4,(ix+%hhd),a", "set 5,(ix+%hhd),b", "set 5,(ix+%hhd),c", "set 5,(ix+%hhd),d", "set 5,(ix+%hhd),e", "set 5,(ix+%hhd),h", "set 5,(ix+%hhd),l", "set 5,(ix+%hhd)", "set 5,(ix+%hhd),a", "set 6,(ix+%hhd),b", "set 6,(ix+%hhd),c", "set 6,(ix+%hhd),d", "set 6,(ix+%hhd),e", "set 6,(ix+%hhd),h", "set 6,(ix+%hhd),l", "set 6,(ix+%hhd)", "set 6,(ix+%hhd),a", "set 7,(ix+%hhd),b", "set 7,(ix+%hhd),c", "set 7,(ix+%hhd),d", "set 7,Line truncated
     const char *misc_opcodes[128] = {"in b,(c)", "out (c),b", "sbc hl,bc", "ld ($%04x),bc", "neg", "retn", "im 0", "ld i,a", "in c,(c)", "out (c),c", "adc hl,bc", "ld bc,($%04x)", "mlt bc", "reti", "", "ld r,a", "in d,(c)", "out (c),d", "sbc hl,de", "ld ($%04x),de", "", "", "im 1", "ld a,i", "in e,(c)", "out (c),e", "adc hl,de", "ld de,($%04x)", "mlt de", "", "im 2", "ld a,r", "in h,(c)", "out (c),h", "sbc hl,hl", "ld ($%04x),hl", "tst $%02x", "", "", "rrd", "in l,(c)", "out (c),l", "adc hl,hl", "ld hl,($%04x)", "mlt hl", "", "", "rld", "in (c)", "out (c),0", "sbc hl,sp", "ld ($%04x),sp", "tstio $%02x", "", "slp", "", "in a,(c)", "out (c),a", "adc hl,sp", "ld sp,($%04x)", "mlt sp", "", "", "", "", "", "", "otim", "", "", "", "", "", "", "", "otdm", "", "", "", "", "", "", "", "otimr", "", "", "", "", "", "", "", "otdmr", "", "", "", "", "ldi", "cpi", "ini", "outi", "", "", "", "", "ldd", "cpd", "ind", "outd", "", "", "", "", "ldir", "cpir", "inir", "otir", "", "", "", "", "lddr", "cpdr", "indr", "otdr", "", "", "", ""};
     const char *iy_opcodes[256] = {"", "", "", "", "inc b", "dec b", "ld b,$%02x", "", "", "add iy,bc", "", "", "inc c", "dec c", "ld c,$%02x", "", "", "", "", "", "inc d", "dec d", "ld d,$%02x", "", "", "add iy,de", "", "", "inc e", "dec e", "ld e,$%02x", "", "", "ld iy,$%04x", "ld ($%04x),iy", "inc iy", "inc iyh", "dec iyh", "ld iyh,$%02x", "", "", "add iy,iy", "ld iy,($%04x)", "dec iy", "inc iyl", "dec iyl", "ld iyl,$%02x", "", "", "", "", "", "inc (iy+%hhd)", "dec (iy+%hhd)", "ld (iy+%hhd),$%02x", "", "", "add iy,sp", "", "", "inc a", "dec a", "ld a,$%02x", "", "ld b,b", "ld b,c", "ld b,d", "ld b,e", "ld b,iyh", "ld b,iyl", "ld b,(iy+%hhd)", "ld b,a", "ld c,b", "ld c,c", "ld c,d", "ld c,e", "ld c,iyh", "ld c,iyl", "ld c,(iy+%hhd)", "ld c,a", "ld d,b", "ld d,c", "ld d,d", "ld d,e", "ld d,iyh", "ld d,iyl", "ld d,(iy+%hhd)", "ld d,a", "ld e,b", "ld e,c", "ld e,d", "ld e,e", "ld e,iyh", "ld e,iyl", "ld e,(iy+%hhd)", "ld e,a", "ld iyh,b", "ld iyh,c", "ld iyh,d", "ld iyh,e", "ld iyh,iyh", "ld iyh,iyl", "ld h,(iy+%hhd)", "ld iyh,a", "ld iyl,b", "ld iyl,c", "ld iyl,d", "ld iyl,e", "ld iyl,iyh", "ld iyl,iyl", "ld l,(iy+%hhd)", "ld iyl,a", "ld (iy+%hhd),b", "ld (iy+%hhd),c", "ld (iy+%hhd),d", "ld (iy+%hhd),e", "ld (iy+%hhd),h", "ld (iy+%hhd),l", "", "ld (iy+%hhd),a", "ld a,b", "ld a,c", "ld a,d", "ld a,e", "ld a,iyh", "ld a,iyl", "ld a,(iy+%hhd)", "ld a,a", "add a,b", "add a,c", "add a,d", "add a,e", "add a,iyh", "add a,iyl", "add a,(iy+%hhd)", "add a,a", "adc a,b", "adc a,c", "adc a,d", "adc a,e", "adc a,iyh", "adc a,iyl", "adc a,(iy+%hhd)", "adc a,a", "sub b", "sub c", "sub d", "sub e", "sub iyh", "sub iyl", "sub (iy+%hhd)", "sub a", "sbc a,b", "sbc a,c", "sbc a,d", "sbc a,e", "sbc a,iyh", "sbc a,iyl", "sbc a,(iy+%hhd)", "sbc a,a", "and b", "and c", "and d", "and e", "and iyh", "and iyl", "and (iy+%hhd)", "and a", "xor b", "xor c", "xor d", "xor e", "xor iyh", "xor iyl", "xor (iy+%hhd)", "xor a", "or b", "or c", "or d", "or e", "or iyh", "or iyl", "or (iy+%hhd)", "or a", "cp b", "cp c", "cp d", "cp e", "cp iyh", "cp iyl", "cp (iy+%hhd)", "cp a", "", "", "", "", "", "", "", "", "", "", "", "_IY Bit_", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "pop iy", "", "ex (sp),iy", "", "push iy", "", "", "", "jp (iy)", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "ld sp,iy", "", "", "", "", "", ""};
@@ -97,6 +97,14 @@ namespace z80dis
             sprintf(buffer, base, word);
         }
 
+        if (strstr(buffer, "2x") && strstr(buffer, "hhd"))
+        {
+            opcode_size = 4;
+            strcpy(base, buffer);
+            sprintf(buffer, base, *(memory+2), (int8_t)*(memory+3));
+            return buffer;
+        }
+
         if (strstr(buffer, "2x"))
         {
             opcode_size+=1;
@@ -143,6 +151,7 @@ namespace z80dis
         if (strstr(base, "2x")) opcode_size+=1;
         if (strstr(base, "Xx")) opcode_size+=1;
         if (strstr(base, "hh")) opcode_size+=1;
+        if (opcode_size>4) opcode_size=4;
         printOpcode(pos);
         return buffer;
     }
@@ -156,6 +165,7 @@ namespace z80dis
         if (strstr(base, "2x")) opcode_size+=1;
         if (strstr(base, "Xx")) opcode_size+=1;
         if (strstr(base, "hh")) opcode_size+=1;
+        if (opcode_size>4) opcode_size=4;
         return opcode_size;
     }
 

zx_tape.cpp

@@ -34,7 +34,7 @@ namespace zx_tape
 
     bool playing = false;
     bool loaded = false;
-    bool berserk_mode = false;
+    bool berserk_mode = true;
 
     std::vector<block_t> blocks;
     uint8_t current_block = 0;