protected override void AddOpcodes()
{
Opcodes.AddRange(new List <Opcode>
{
new Opcode("AND A", 0xA7, (z80) => { z80.A.Value = (byte)(z80.A.Value & z80.A.Value); return(TStates.Count(4)); }),
new Opcode("AND B", 0xA0, (z80) => { z80.A.Value = (byte)(z80.A.Value & z80.B.Value); return(TStates.Count(4)); }),
new Opcode("AND C", 0xA1, (z80) => { z80.A.Value = (byte)(z80.A.Value & z80.C.Value); return(TStates.Count(4)); }),
new Opcode("AND D", 0xA2, (z80) => { z80.A.Value = (byte)(z80.A.Value & z80.D.Value); return(TStates.Count(4)); }),
new Opcode("AND E", 0xA3, (z80) => { z80.A.Value = (byte)(z80.A.Value & z80.E.Value); return(TStates.Count(4)); }),
new Opcode("AND H", 0xA4, (z80) => { z80.A.Value = (byte)(z80.A.Value & z80.H.Value); return(TStates.Count(4)); }),
new Opcode("AND L", 0xA5, (z80) => { z80.A.Value = (byte)(z80.A.Value & z80.L.Value); return(TStates.Count(4)); }),
new Opcode("AND n", 0xE6, Oprand.Any, (z80) => { z80.A.Value = (byte)(z80.A.Value & z80.Buffer[1]); return(TStates.Count(7)); }),
new Opcode("AND (HL)", 0xA6, (z80) =>
{
z80.A.Value = (byte)(z80.A.Value & z80.Memory.Get(z80.HL));
return(TStates.Count(7));
}),
new Opcode("AND (IX + d)", 0xDD, 0xA6, Oprand.Any, (z80) =>
{
var index = (byte)(z80.IX.Value + z80.Buffer[2]);
z80.A.Value = (byte)(z80.A.Value & index);
return(TStates.Count(19));
}),
new Opcode("AND (IY + d)", 0xFD, 0xA6, Oprand.Any, (z80) =>
{
var index = (byte)(z80.IY.Value + z80.Buffer[2]);
z80.A.Value = (byte)(z80.A.Value & index);
return(TStates.Count(19));
})
});
}
protected override void AddOpcodes()
{
Opcodes.Add(new Opcode("NOP", 0x0, (z80) =>
{
return(TStates.Count(4));
}));
}
protected override void AddOpcodes()
{
Opcodes.AddRange(new List<Opcode>
{
new Opcode("ADC A, A", 0x8F, z80 =>
{
return TStates.Count(4);
}),
new Opcode("ADC A, B", 0x88, z80 =>
{
return TStates.Count(4);
}),
new Opcode("ADC A, C", 0x89, z80 =>
{
return TStates.Count(4);
}),
new Opcode("ADC A, D", 0x8A, z80 =>
{
return TStates.Count(4);
}),
new Opcode("ADC A, E", 0x8B, z80 =>
{
return TStates.Count(4);
}),
new Opcode("ADC A, H", 0x8C, z80 =>
{
return TStates.Count(4);
}),
new Opcode("ADC A, L", 0x8D, z80 =>
{
return TStates.Count(4);
}),
new Opcode("ADC A, n", 0xCE, Oprand.Any, z80 =>
{
return TStates.Count(7);
}),
new Opcode("ADC A, (HL)", 0x8E, z80 =>
{
return TStates.Count(7);
}),
new Opcode("ADC A, (IX + d)", 0xDD, 0x8E, Oprand.Any, z80 =>
{
return TStates.Count(19);
}),
new Opcode("ADC A, (IY + d)", 0xFD, 0x8E, Oprand.Any, z80 =>
{
return TStates.Count(19);
}),
});
}
public TStates SetRegister(Z80 z80, Register8 register)
{
var address = ByteHelper.CreateUShort(z80.B.Value, z80.C.Value);
register.Value = z80.Ports.GetByte(address);
return(TStates.Count(12));
}
public TStates SetA(Z80 z80)
{
var low = z80.Buffer[1];
var address = ByteHelper.CreateUShort(z80.A.Value, low);
z80.A.Value = z80.Ports.GetByte(address);
return(TStates.Count(11));
}
protected override void AddOpcodes()
{
Opcodes.Add(new Opcode("EI", 0xFB, (z80) =>
{
z80.InteruptsEnabled = true;
return(TStates.Count(4));
}));
}
private TStates ExchangeRegisters(Register16 register1, Register16 register2)
{
var register1Value = register1.Value;
register1.Value = register2.Value;
register2.Value = register1Value;
return(TStates.Count(4));
}
protected override void AddOpcodes()
{
Opcodes.AddRange(new List <Opcode>
{
new Opcode("LD BC, (nn)", 0xED, 0x4B, Oprand.Any, Oprand.Any, (z80) => { return(LoadFromMemoryIntoRegister(z80, z80.BC)); }),
new Opcode("LD DE, (nn)", 0xED, 0x5B, Oprand.Any, Oprand.Any, (z80) => { return(LoadFromMemoryIntoRegister(z80, z80.DE)); }),
new Opcode("LD HL, (nn)", 0xED, 0x6B, Oprand.Any, Oprand.Any, (z80) => { return(LoadFromMemoryIntoRegister(z80, z80.HL)); }),
new Opcode("LD SP, (nn)", 0xED, 0x7B, Oprand.Any, Oprand.Any, (z80) => { return(LoadFromMemoryIntoRegister(z80, z80.SP)); }),
new Opcode("LD A, n", 0x3E, Oprand.Any, (z80) => { z80.A.Value = z80.Buffer[1]; return(TStates.Count(7)); }),
new Opcode("LD B, n", 0x06, Oprand.Any, (z80) => { z80.B.Value = z80.Buffer[1]; return(TStates.Count(7)); }),
new Opcode("LD C, n", 0x0E, Oprand.Any, (z80) => { z80.C.Value = z80.Buffer[1]; return(TStates.Count(7)); }),
new Opcode("LD D, n", 0x16, Oprand.Any, (z80) => { z80.D.Value = z80.Buffer[1]; return(TStates.Count(7)); }),
new Opcode("LD E, n", 0x1E, Oprand.Any, (z80) => { z80.E.Value = z80.Buffer[1]; return(TStates.Count(7)); }),
new Opcode("LD H, n", 0x26, Oprand.Any, (z80) => { z80.H.Value = z80.Buffer[1]; return(TStates.Count(7)); }),
new Opcode("LD L, n", 0x2E, Oprand.Any, (z80) => { z80.L.Value = z80.Buffer[1]; return(TStates.Count(7)); }),
new Opcode("LD BC, nn", 0x01, Oprand.Any, Oprand.Any, (z80) => { return(LoadIntoRegister(z80, z80.BC)); }),
new Opcode("LD DE, nn", 0x11, Oprand.Any, Oprand.Any, (z80) => { return(LoadIntoRegister(z80, z80.DE)); }),
new Opcode("LD HL, nn", 0x21, Oprand.Any, Oprand.Any, (z80) => { return(LoadIntoRegister(z80, z80.HL)); }),
new Opcode("LD SP, nn", 0x31, Oprand.Any, Oprand.Any, (z80) => { return(LoadIntoRegister(z80, z80.SP)); }),
//page 295
new Opcode("LD (BC), A", 0x02, (z80) =>
{
var bc = z80.BC.Value;
var a = z80.A.Value;
z80.Memory.Set(bc, a);
return(TStates.Count(7));
}),
new Opcode("LD (DE), A", 0x12, (z80) =>
{
var de = z80.DE.Value;
var a = z80.A.Value;
z80.Memory.Set(de, a);
return(TStates.Count(7));
}),
new Opcode("LD (HL), n", 0x36, Oprand.Any, (z80) =>
{
var hl = z80.HL.Value;
var value = z80.Buffer[1];
z80.Memory.Set(hl, value);
return(TStates.Count(10));
}),
new Opcode("LD (HL), A", 0x77, (z80) => { z80.Memory.Set(z80.HL, z80.A.Value); return(TStates.Count(7)); }),
new Opcode("LD (HL), B", 0x70, (z80) => { z80.Memory.Set(z80.HL, z80.B.Value); return(TStates.Count(7)); }),
new Opcode("LD (HL), C", 0x71, (z80) => { z80.Memory.Set(z80.HL, z80.C.Value); return(TStates.Count(7)); }),
new Opcode("LD (HL), D", 0x72, (z80) => { z80.Memory.Set(z80.HL, z80.D.Value); return(TStates.Count(7)); }),
new Opcode("LD (HL), E", 0x73, (z80) => { z80.Memory.Set(z80.HL, z80.E.Value); return(TStates.Count(7)); }),
new Opcode("LD (HL), H", 0x74, (z80) => { z80.Memory.Set(z80.HL, z80.H.Value); return(TStates.Count(7)); }),
new Opcode("LD (HL), L", 0x75, (z80) => { z80.Memory.Set(z80.HL, z80.L.Value); return(TStates.Count(7)); })
});
}
private TStates LoadFromMemoryIntoRegister(Z80 z80, Register16 register)
{
var address = ByteHelper.CreateUShort(z80.Buffer[3], z80.Buffer[2]);
var low = z80.Memory.Get(address);
var high = z80.Memory.Get(++address);
register.Value = ByteHelper.CreateUShort(high, low);
return(TStates.Count(20));
}
protected override void AddOpcodes()
{
Opcodes.AddRange(new List <Opcode>
{
new Opcode("ADD A, (HL)", 0x86, (z80) => {
var value = z80.Memory.Get(z80.HL);
z80.A.Add(value);
return(TStates.Count(7));
}),
new Opcode("ADD A, (IX + d)", 0xDD, 0x86, Oprand.Any, (z80) =>
{
var offset = z80.Buffer[2];
var ix_offset = z80.IX.Value + offset;
var value = z80.Memory.Get((ushort)ix_offset);
z80.A.Add(value);
return(TStates.Count(17));
}),
new Opcode("ADD A, (IY + d)", 0xFD, 0x86, Oprand.Any, (z80) =>
{
var offset = z80.Buffer[2];
var iy_offset = z80.IY.Value + offset;
var value = z80.Memory.Get((ushort)iy_offset);
z80.A.Add(value);
return(TStates.Count(17));
}),
new Opcode("ADD A, n", 0xC6, Oprand.Any, (z80) => { z80.A.Add(z80.Buffer[1]); return(TStates.Count(7)); }),
new Opcode("ADD A, A", 0x87, (z80) => { z80.A.Add(z80.A.Value); return(TStates.Count(4)); }),
new Opcode("ADD A, B", 0x80, (z80) => { z80.A.Add(z80.B.Value); return(TStates.Count(4)); }),
new Opcode("ADD A, C", 0x81, (z80) => { z80.A.Add(z80.C.Value); return(TStates.Count(4)); }),
new Opcode("ADD A, D", 0x82, (z80) => { z80.A.Add(z80.D.Value); return(TStates.Count(4)); }),
new Opcode("ADD A, E", 0x83, (z80) => { z80.A.Add(z80.E.Value); return(TStates.Count(4)); }),
new Opcode("ADD A, H", 0x84, (z80) => { z80.A.Add(z80.H.Value); return(TStates.Count(4)); }),
new Opcode("ADD A, L", 0x85, (z80) => { z80.A.Add(z80.L.Value); return(TStates.Count(4)); }),
/*
* new Opcode("ADD HL, BC", 0x09, (z80) => { AddToRegister(z80, z80.HL, z80.BC.Value); }),
* new Opcode("ADD HL, DE", 0x19, (z80) => { AddToRegister(z80, z80.HL, z80.DE.Value); }),
* new Opcode("ADD HL, HL", 0x29, (z80) => { AddToRegister(z80, z80.HL, z80.HL.Value); }),
* new Opcode("ADD HL, SP", 0x39, (z80) => { AddToRegister(z80, z80.HL, z80.SP.Value); }),
*
* new Opcode("ADD IX, BC", 0xDD, 0x09, (z80) => { AddToRegister(z80, z80.IX, z80.BC.Value); }),
* new Opcode("ADD IX, DE", 0xDD, 0x19, (z80) => { AddToRegister(z80, z80.IX, z80.DE.Value); }),
* new Opcode("ADD IX, IX", 0xDD, 0x29, (z80) => { AddToRegister(z80, z80.IX, z80.IX.Value); }),
* new Opcode("ADD IX, SP", 0xDD, 0x39, (z80) => { AddToRegister(z80, z80.IX, z80.SP.Value); }),
*
* new Opcode("ADD IY, BC", 0xFD, 0x09, (z80) => { AddToRegister(z80, z80.IY, z80.BC.Value); }),
* new Opcode("ADD IY, DE", 0xFD, 0x19, (z80) => { AddToRegister(z80, z80.IY, z80.DE.Value); }),
* new Opcode("ADD IY, IY", 0xFD, 0x29, (z80) => { AddToRegister(z80, z80.IY, z80.IY.Value); }),
* new Opcode("ADD IY, SP", 0xFD, 0x39, (z80) => { AddToRegister(z80, z80.IY, z80.SP.Value); })
*/
});
}
private TStates Jump(Z80 z80, bool performJump)
{
if (!performJump)
{
return(TStates.Count(7));
}
//TODO: test 2s-complement arithmitic
z80.PC.Value = (ushort)(z80.PC.Value + z80.Buffer[1]);
return(TStates.Count(12));
}
protected override void AddOpcodes()
{
Opcodes.AddRange(new List <Opcode>
{
new Opcode("PUSH BC", 0xC5, (z80) => { Push(z80, z80.BC); return(TStates.Count(11)); }),
new Opcode("PUSH DE", 0xD5, (z80) => { Push(z80, z80.DE); return(TStates.Count(11)); }),
new Opcode("PUSH HL", 0xE5, (z80) => { Push(z80, z80.HL); return(TStates.Count(11)); }),
new Opcode("PUSH AF", 0xF5, (z80) => { Push(z80, z80.AF); return(TStates.Count(11)); }),
new Opcode("PUSH IX", 0xDD, 0xE5, (z80) => { Push(z80, z80.IX); return(TStates.Count(15)); }),
new Opcode("PUSH IY", 0xFD, 0xE5, (z80) => { Push(z80, z80.IY); return(TStates.Count(15)); }),
});
}
private TStates ExchangeStackPointer(Z80 z80, Register16 register)
{
var low = register.Low.Value;
var high = register.High.Value;
var sp = z80.SP.Value;
register.Low.Value = z80.Memory.Get(sp);
register.High.Value = z80.Memory.Get((ushort)(sp + 1));
z80.Memory.Set(sp, low);
z80.Memory.Set((ushort)(sp + 1), high);
return(TStates.Count(19));
}
protected override void AddOpcodes()
{
Opcodes.AddRange(new List <Opcode>
{
new Opcode("RET", 0xC9, z80 => { Ret(z80, true); return(TStates.Count(10)); }),
new Opcode("RET NZ", 0xC0, z80 => { return(Ret(z80, !z80.F.Zero)); }),
new Opcode("RET Z", 0xC8, z80 => { return(Ret(z80, z80.F.Zero)); }),
new Opcode("RET NC", 0xD0, z80 => { return(Ret(z80, !z80.F.Carry)); }),
new Opcode("RET C", 0xD8, z80 => { return(Ret(z80, z80.F.Carry)); }),
new Opcode("RET PO", 0xE0, z80 => { return(Ret(z80, !z80.F.ParityOrOverflow)); }),
new Opcode("RET PE", 0xE8, z80 => { return(Ret(z80, z80.F.ParityOrOverflow)); }),
new Opcode("RET P", 0xF0, z80 => { return(Ret(z80, !z80.F.Sign)); }),
new Opcode("RET M", 0xF8, z80 => { return(Ret(z80, z80.F.Sign)); }),
});
}
protected override void AddOpcodes()
{
Opcodes.Add(new Opcode("IND", 0xED, 0xAA, (z80) =>
{
var value = z80.Ports.GetByte(z80.C.Value);
z80.Memory.Set(z80.HL.Value, value);
z80.HL.Value--;
z80.B.Value--;
z80.F.Zero = z80.B.Value.IsZero();
return(TStates.Count(16));
}));
}
protected override void AddOpcodes()
{
Opcodes.Add(new Opcode("LDI", 0xED, 0xA0, (z80) =>
{
var value = z80.Memory.Get(z80.HL.Value);
z80.Memory.Set(z80.DE.Value, value);
z80.DE.Value++;
z80.HL.Value++;
z80.BC.Value--;
z80.F.ParityOrOverflow = !z80.BC.Value.IsZero();
return(TStates.Count(16));
}));
}
private TStates Ret(Z80 z80, bool invokeReturn)
{
if (invokeReturn)
{
z80.PC.Low.Value = z80.Memory.Get(z80.SP);
z80.PC.High.Value = z80.Memory.Get((ushort)(z80.SP.Value + 1));
z80.SP.Increment();
z80.SP.Increment();
return(TStates.Count(11));
}
return(TStates.Count(5));
}
public TStates Call(Z80 z80, bool performCall)
{
if (!performCall)
{
return(TStates.Count(10));
}
z80.SP.Decrement();
z80.Memory.Set(z80.SP.Value, z80.PC.High.Value);
z80.SP.Decrement();
z80.Memory.Set(z80.SP.Value, z80.PC.Low.Value);
z80.PC.Low.Value = z80.Memory.Get((ushort)(z80.PC.Value - 1));
z80.PC.High.Value = z80.Memory.Get((ushort)(z80.PC.Value - 2));
return(TStates.Count(17));
}
protected override void AddOpcodes()
{
Opcodes.AddRange(new List <Opcode>
{
new Opcode("INC A", 0x3C, (z80) => { z80.A.Increment(); return(TStates.Count(4)); }),
new Opcode("INC B", 0x04, (z80) => { z80.B.Increment(); return(TStates.Count(4)); }),
new Opcode("INC C", 0x0C, (z80) => { z80.C.Increment(); return(TStates.Count(4)); }),
new Opcode("INC D", 0x14, (z80) => { z80.D.Increment(); return(TStates.Count(4)); }),
new Opcode("INC E", 0x1C, (z80) => { z80.E.Increment(); return(TStates.Count(4)); }),
new Opcode("INC H", 0x24, (z80) => { z80.H.Increment(); return(TStates.Count(4)); }),
new Opcode("INC L", 0x2C, (z80) => { z80.L.Increment(); return(TStates.Count(4)); }),
new Opcode("INC BC", 0x03, (z80) => { z80.BC.Increment(); return(TStates.Count(11)); }).SetAllFlagsAffectToNone(),
new Opcode("INC DE", 0x13, (z80) => { z80.DE.Increment(); return(TStates.Count(11)); }).SetAllFlagsAffectToNone(),
new Opcode("INC HL", 0x23, (z80) => { z80.HL.Increment(); return(TStates.Count(11)); }).SetAllFlagsAffectToNone(),
new Opcode("INC SP", 0x33, (z80) => { z80.SP.Increment(); return(TStates.Count(11)); }).SetAllFlagsAffectToNone(),
new Opcode("INC (HL)", 0x34, (z80) =>
{
var value = z80.Memory.Get(z80.HL);
z80.Memory.Set(z80.HL, ++value);
return(TStates.Count(11));
}).SetAllFlagsAffectToNone(),
new Opcode("INC (IX + d)", 0xDD, 0x34, (z80) =>
{
var offset = z80.GetByte();
var index = (ushort)(z80.IX.Value + offset);
var value = z80.Memory.Get(index);
z80.Memory.Set(index, ++value);
return(TStates.Count(23));
}).SetAllFlagsAffectToNone(),
new Opcode("INC (IY + d)", 0xFD, 0x34, (z80) =>
{
var offset = z80.GetByte();
var index = (ushort)(z80.IY.Value + offset);
var value = z80.Memory.Get(index);
z80.Memory.Set(index, ++value);
return(TStates.Count(23));
}).SetAllFlagsAffectToNone(),
new Opcode("INC IX", 0xDD, 0x23, (z80) => { z80.IX.Increment(); return(TStates.Count(10)); }).SetAllFlagsAffectToNone(),
new Opcode("INC IY", 0xFD, 0x23, (z80) => { z80.IY.Increment(); return(TStates.Count(10)); }).SetAllFlagsAffectToNone(),
});
}
protected override void AddOpcodes()
{
Opcodes.Add(new Opcode("HALT", 0x76, z80 =>
{
var nop = new NOP().Opcodes.First();
while (true)
{
// excute nop
nop.Execute(z80);
//check if reset has been received
//check if interupt has been received
break;
}
return(TStates.Count(0));
}));
}
protected override void AddOpcodes()
{
Opcodes.Add(new Opcode("EXX", 0xD9, (z80) =>
{
var bc = z80.BC.Value;
var de = z80.DE.Value;
var hl = z80.HL.Value;
z80.BC.Value = z80.BC_.Value;
z80.DE.Value = z80.DE_.Value;
z80.HL.Value = z80.HL_.Value;
z80.BC_.Value = bc;
z80.DE_.Value = de;
z80.HL_.Value = hl;
return(TStates.Count(4));
}));
}
//TODO: check low/high byte orders
protected override void AddOpcodes()
{
Opcodes.AddRange(new List <Opcode>
{
new Opcode("POP BC", 0xC1, (z80) =>
{
Pop(z80, z80.BC);
return(TStates.Count(10));
}),
new Opcode("POP DE", 0xD1, (z80) =>
{
Pop(z80, z80.DE);
return(TStates.Count(10));
}),
new Opcode("POP HL", 0xE1, (z80) =>
{
Pop(z80, z80.HL);
return(TStates.Count(10));
}),
new Opcode("POP AF", 0x11, (z80) =>
{
Pop(z80, z80.AF);
return(TStates.Count(10));
}),
new Opcode("POP IX", 0xDD, 0xE1, (z80) =>
{
Pop(z80, z80.IX);
return(TStates.Count(14));
}),
new Opcode("POP IY", 0xDD, 0xE1, (z80) =>
{
Pop(z80, z80.IY);
return(TStates.Count(14));
})
});
}
protected override void AddOpcodes()
{
Opcodes.Add(new Opcode("LDDR", 0xED, 0xB8, (z80) =>
{
var value = z80.Memory.Get(z80.HL);
z80.Memory.Set(z80.DE, value);
z80.DE.Decrement();
z80.HL.Decrement();
z80.BC.Decrement();
if (z80.BC.IsNotZero)
{
z80.PC.Decrement();
z80.PC.Decrement();
return(TStates.Count(21));
}
return(TStates.Count(16));
}));
}
protected override void AddOpcodes()
{
Opcodes.Add(new Opcode("DJNZ e", 0x10, (z80) =>
{
z80.B.Value--;
if (z80.B.Value.IsZero())
{
var offset = z80.Memory.Get(z80.PC.Value);
var pc = z80.PC.Value + (sbyte)offset;
z80.PC.Value = (ushort)pc;
return(TStates.Count(8));
}
else
{
//increment PC to skip the offset
z80.PC.Increment();
return(TStates.Count(13));
}
}));
}
protected override void AddOpcodes()
{
Opcodes.Add(new Opcode("LDIR", 0xED, 0xB0, (z80) =>
{
var value = z80.Memory.Get(z80.HL.Value);
z80.Memory.Set(z80.DE.Value, value);
z80.DE.Value++;
z80.HL.Value++;
z80.BC.Value--;
if (z80.BC.Value.IsZero())
{
return(TStates.Count(16));
}
else
{
z80.PC.Value--;
z80.PC.Value--;
return(TStates.Count(21));
}
}));
}
private TStates LoadIntoRegister(Z80 z80, Register16 register)
{
register.Value = ByteHelper.CreateUShort(z80.Buffer[2], z80.Buffer[1]);
return(TStates.Count(10));
}
protected override void AddOpcodes()
{
Opcodes.AddRange(new List <Opcode>
{
new Opcode("IM 0", 0xED, 0x46, (z80) => { z80.InteruptMode = InterruptMode.Mode0; return(TStates.Count(8)); }),
new Opcode("IM 1", 0xED, 0x56, (z80) => { z80.InteruptMode = InterruptMode.Mode1; return(TStates.Count(8)); }),
new Opcode("IM 2", 0xED, 0x5E, (z80) => { z80.InteruptMode = InterruptMode.Mode2; return(TStates.Count(8)); }),
});
}
protected override void AddOpcodes()
{
Opcodes.AddRange(new List <Opcode>
{
new Opcode("BIT 0, (HL)", 0xCB, 0x46, (z80) => { z80.F.Zero = z80.Memory.Get(z80.HL.Value).GetBit(0).IsZero(); return(TStates.Count(12)); }),
new Opcode("BIT 1, (HL)", 0xCB, 0x4E, (z80) => { z80.F.Zero = z80.Memory.Get(z80.HL.Value).GetBit(1).IsZero(); return(TStates.Count(12)); }),
new Opcode("BIT 2, (HL)", 0xCB, 0x56, (z80) => { z80.F.Zero = z80.Memory.Get(z80.HL.Value).GetBit(2).IsZero(); return(TStates.Count(12)); }),
new Opcode("BIT 3, (HL)", 0xCB, 0x5E, (z80) => { z80.F.Zero = z80.Memory.Get(z80.HL.Value).GetBit(3).IsZero(); return(TStates.Count(12)); }),
new Opcode("BIT 4, (HL)", 0xCB, 0x66, (z80) => { z80.F.Zero = z80.Memory.Get(z80.HL.Value).GetBit(4).IsZero(); return(TStates.Count(12)); }),
new Opcode("BIT 5, (HL)", 0xCB, 0x6E, (z80) => { z80.F.Zero = z80.Memory.Get(z80.HL.Value).GetBit(5).IsZero(); return(TStates.Count(12)); }),
new Opcode("BIT 6, (HL)", 0xCB, 0x76, (z80) => { z80.F.Zero = z80.Memory.Get(z80.HL.Value).GetBit(6).IsZero(); return(TStates.Count(12)); }),
new Opcode("BIT 7, (HL)", 0xCB, 0x7E, (z80) => { z80.F.Zero = z80.Memory.Get(z80.HL.Value).GetBit(7).IsZero(); return(TStates.Count(12)); }),
new Opcode("BIT 0, (IX + d)", 0xDD, 0xCB, Oprand.Any, 0x46, (z80) => { z80.F.Zero = z80.Memory.Get((ushort)(z80.IX.Value + z80.Buffer[2])).GetBit(0).IsZero(); return(TStates.Count(20)); }),
new Opcode("BIT 1, (IX + d)", 0xDD, 0xCB, Oprand.Any, 0x4E, (z80) => { z80.F.Zero = z80.Memory.Get((ushort)(z80.IX.Value + z80.Buffer[2])).GetBit(1).IsZero(); return(TStates.Count(20)); }),
new Opcode("BIT 2, (IX + d)", 0xDD, 0xCB, Oprand.Any, 0x56, (z80) => { z80.F.Zero = z80.Memory.Get((ushort)(z80.IX.Value + z80.Buffer[2])).GetBit(2).IsZero(); return(TStates.Count(20)); }),
new Opcode("BIT 3, (IX + d)", 0xDD, 0xCB, Oprand.Any, 0x5E, (z80) => { z80.F.Zero = z80.Memory.Get((ushort)(z80.IX.Value + z80.Buffer[2])).GetBit(3).IsZero(); return(TStates.Count(20)); }),
new Opcode("BIT 4, (IX + d)", 0xDD, 0xCB, Oprand.Any, 0x66, (z80) => { z80.F.Zero = z80.Memory.Get((ushort)(z80.IX.Value + z80.Buffer[2])).GetBit(4).IsZero(); return(TStates.Count(20)); }),
new Opcode("BIT 5, (IX + d)", 0xDD, 0xCB, Oprand.Any, 0x6E, (z80) => { z80.F.Zero = z80.Memory.Get((ushort)(z80.IX.Value + z80.Buffer[2])).GetBit(5).IsZero(); return(TStates.Count(20)); }),
new Opcode("BIT 6, (IX + d)", 0xDD, 0xCB, Oprand.Any, 0x76, (z80) => { z80.F.Zero = z80.Memory.Get((ushort)(z80.IX.Value + z80.Buffer[2])).GetBit(6).IsZero(); return(TStates.Count(20)); }),
new Opcode("BIT 7, (IX + d)", 0xDD, 0xCB, Oprand.Any, 0x7E, (z80) => { z80.F.Zero = z80.Memory.Get((ushort)(z80.IX.Value + z80.Buffer[2])).GetBit(7).IsZero(); return(TStates.Count(20)); }),
new Opcode("BIT 0, (IY + d)", 0xFD, 0xCB, Oprand.Any, 0x46, (z80) => { z80.F.Zero = z80.Memory.Get((ushort)(z80.IY.Value + z80.Buffer[2])).GetBit(0).IsZero(); return(TStates.Count(20)); }),
new Opcode("BIT 1, (IY + d)", 0xFD, 0xCB, Oprand.Any, 0x4E, (z80) => { z80.F.Zero = z80.Memory.Get((ushort)(z80.IY.Value + z80.Buffer[2])).GetBit(1).IsZero(); return(TStates.Count(20)); }),
new Opcode("BIT 2, (IY + d)", 0xFD, 0xCB, Oprand.Any, 0x56, (z80) => { z80.F.Zero = z80.Memory.Get((ushort)(z80.IY.Value + z80.Buffer[2])).GetBit(2).IsZero(); return(TStates.Count(20)); }),
new Opcode("BIT 3, (IY + d)", 0xFD, 0xCB, Oprand.Any, 0x5E, (z80) => { z80.F.Zero = z80.Memory.Get((ushort)(z80.IY.Value + z80.Buffer[2])).GetBit(3).IsZero(); return(TStates.Count(20)); }),
new Opcode("BIT 4, (IY + d)", 0xFD, 0xCB, Oprand.Any, 0x66, (z80) => { z80.F.Zero = z80.Memory.Get((ushort)(z80.IY.Value + z80.Buffer[2])).GetBit(4).IsZero(); return(TStates.Count(20)); }),
new Opcode("BIT 5, (IY + d)", 0xFD, 0xCB, Oprand.Any, 0x6E, (z80) => { z80.F.Zero = z80.Memory.Get((ushort)(z80.IY.Value + z80.Buffer[2])).GetBit(5).IsZero(); return(TStates.Count(20)); }),
new Opcode("BIT 6, (IY + d)", 0xFD, 0xCB, Oprand.Any, 0x76, (z80) => { z80.F.Zero = z80.Memory.Get((ushort)(z80.IY.Value + z80.Buffer[2])).GetBit(6).IsZero(); return(TStates.Count(20)); }),
new Opcode("BIT 7, (IY + d)", 0xFD, 0xCB, Oprand.Any, 0x7E, (z80) => { z80.F.Zero = z80.Memory.Get((ushort)(z80.IY.Value + z80.Buffer[2])).GetBit(7).IsZero(); return(TStates.Count(20)); }),
new Opcode("BIT 0, A", 0x47, (z80) => { z80.F.Zero = z80.A.Value.GetBit(0).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 0, B", 0x40, (z80) => { z80.F.Zero = z80.B.Value.GetBit(0).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 0, C", 0x41, (z80) => { z80.F.Zero = z80.C.Value.GetBit(0).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 0, D", 0x42, (z80) => { z80.F.Zero = z80.D.Value.GetBit(0).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 0, E", 0x43, (z80) => { z80.F.Zero = z80.E.Value.GetBit(0).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 0, H", 0x47, (z80) => { z80.F.Zero = z80.H.Value.GetBit(0).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 0, L", 0x45, (z80) => { z80.F.Zero = z80.L.Value.GetBit(0).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 1, A", 0x4F, (z80) => { z80.F.Zero = z80.A.Value.GetBit(1).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 1, B", 0x48, (z80) => { z80.F.Zero = z80.B.Value.GetBit(1).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 1, C", 0x49, (z80) => { z80.F.Zero = z80.C.Value.GetBit(1).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 1, D", 0x4A, (z80) => { z80.F.Zero = z80.D.Value.GetBit(1).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 1, E", 0x4B, (z80) => { z80.F.Zero = z80.E.Value.GetBit(1).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 1, H", 0x4C, (z80) => { z80.F.Zero = z80.H.Value.GetBit(1).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 1, L", 0x4D, (z80) => { z80.F.Zero = z80.L.Value.GetBit(1).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 2, A", 0x57, (z80) => { z80.F.Zero = z80.A.Value.GetBit(2).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 2, B", 0x50, (z80) => { z80.F.Zero = z80.B.Value.GetBit(2).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 2, C", 0x51, (z80) => { z80.F.Zero = z80.C.Value.GetBit(2).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 2, D", 0x52, (z80) => { z80.F.Zero = z80.D.Value.GetBit(2).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 2, E", 0x53, (z80) => { z80.F.Zero = z80.E.Value.GetBit(2).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 2, H", 0x54, (z80) => { z80.F.Zero = z80.H.Value.GetBit(2).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 2, L", 0x55, (z80) => { z80.F.Zero = z80.L.Value.GetBit(2).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 3, A", 0x5F, (z80) => { z80.F.Zero = z80.A.Value.GetBit(3).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 3, B", 0x58, (z80) => { z80.F.Zero = z80.B.Value.GetBit(3).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 3, C", 0x59, (z80) => { z80.F.Zero = z80.C.Value.GetBit(3).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 3, D", 0x5A, (z80) => { z80.F.Zero = z80.D.Value.GetBit(3).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 3, E", 0x5B, (z80) => { z80.F.Zero = z80.E.Value.GetBit(3).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 3, H", 0x5C, (z80) => { z80.F.Zero = z80.H.Value.GetBit(3).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 3, L", 0x5D, (z80) => { z80.F.Zero = z80.L.Value.GetBit(3).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 4, A", 0x67, (z80) => { z80.F.Zero = z80.A.Value.GetBit(4).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 4, B", 0x60, (z80) => { z80.F.Zero = z80.B.Value.GetBit(4).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 4, C", 0x61, (z80) => { z80.F.Zero = z80.C.Value.GetBit(4).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 4, D", 0x62, (z80) => { z80.F.Zero = z80.D.Value.GetBit(4).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 4, E", 0x63, (z80) => { z80.F.Zero = z80.E.Value.GetBit(4).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 4, H", 0x64, (z80) => { z80.F.Zero = z80.H.Value.GetBit(4).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 4, L", 0x65, (z80) => { z80.F.Zero = z80.L.Value.GetBit(4).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 5, A", 0x6F, (z80) => { z80.F.Zero = z80.A.Value.GetBit(5).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 5, B", 0x68, (z80) => { z80.F.Zero = z80.B.Value.GetBit(5).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 5, C", 0x69, (z80) => { z80.F.Zero = z80.C.Value.GetBit(5).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 5, D", 0x6A, (z80) => { z80.F.Zero = z80.D.Value.GetBit(5).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 5, E", 0x6B, (z80) => { z80.F.Zero = z80.E.Value.GetBit(5).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 5, H", 0x6C, (z80) => { z80.F.Zero = z80.H.Value.GetBit(5).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 5, L", 0x6D, (z80) => { z80.F.Zero = z80.L.Value.GetBit(5).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 6, A", 0x77, (z80) => { z80.F.Zero = z80.A.Value.GetBit(6).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 6, B", 0x70, (z80) => { z80.F.Zero = z80.B.Value.GetBit(6).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 6, C", 0x71, (z80) => { z80.F.Zero = z80.C.Value.GetBit(6).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 6, D", 0x72, (z80) => { z80.F.Zero = z80.D.Value.GetBit(6).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 6, E", 0x73, (z80) => { z80.F.Zero = z80.E.Value.GetBit(6).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 6, H", 0x74, (z80) => { z80.F.Zero = z80.H.Value.GetBit(6).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 6, L", 0x75, (z80) => { z80.F.Zero = z80.L.Value.GetBit(6).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 7, A", 0x7F, (z80) => { z80.F.Zero = z80.A.Value.GetBit(7).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 7, B", 0x78, (z80) => { z80.F.Zero = z80.B.Value.GetBit(7).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 7, C", 0x79, (z80) => { z80.F.Zero = z80.C.Value.GetBit(7).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 7, D", 0x7A, (z80) => { z80.F.Zero = z80.D.Value.GetBit(7).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 7, E", 0x7B, (z80) => { z80.F.Zero = z80.E.Value.GetBit(7).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 7, H", 0x7C, (z80) => { z80.F.Zero = z80.H.Value.GetBit(7).IsZero(); return(TStates.Count(8)); }),
new Opcode("BIT 7, L", 0x7D, (z80) => { z80.F.Zero = z80.L.Value.GetBit(7).IsZero(); return(TStates.Count(8)); }),
});
}
protected override void AddOpcodes()
{
Opcodes.AddRange(new List <Opcode>
{
new Opcode("JP NZ, pq", 0xC2, Oprand.Any, Oprand.Any, (z80) => { Jump(z80, !z80.F.Zero); return(TStates.Count(10)); }),
new Opcode("JP Z, pq", 0xCA, Oprand.Any, Oprand.Any, (z80) => { Jump(z80, z80.F.Zero); return(TStates.Count(10)); }),
new Opcode("JP NC, pq", 0xD2, Oprand.Any, Oprand.Any, (z80) => { Jump(z80, !z80.F.Carry); return(TStates.Count(10)); }),
new Opcode("JP C, pq", 0xDA, Oprand.Any, Oprand.Any, (z80) => { Jump(z80, z80.F.Carry); return(TStates.Count(10)); }),
new Opcode("JP PO, pq", 0xE2, Oprand.Any, Oprand.Any, (z80) => { Jump(z80, !z80.F.ParityOrOverflow); return(TStates.Count(10)); }),
new Opcode("JP PE, pq", 0xEA, Oprand.Any, Oprand.Any, (z80) => { Jump(z80, z80.F.ParityOrOverflow); return(TStates.Count(10)); }),
new Opcode("JP P, pq", 0xF2, Oprand.Any, Oprand.Any, (z80) => { Jump(z80, !z80.F.Sign); return(TStates.Count(10)); }),
new Opcode("JP M, pq", 0xFA, Oprand.Any, Oprand.Any, (z80) => { Jump(z80, z80.F.Sign); return(TStates.Count(10)); }),
new Opcode("JP pq", 0xC3, Oprand.Any, Oprand.Any, (z80) => { Jump(z80, true); return(TStates.Count(10)); }),
new Opcode("JP (HL)", 0xE9, (z80) => { z80.PC.Value = z80.HL.Value; return(TStates.Count(4)); }),
new Opcode("JP (IX)", 0xDD, 0xE9, (z80) => { z80.PC.Value = z80.IX.Value; return(TStates.Count(8)); }),
new Opcode("JP (IY)", 0xFD, 0xE9, (z80) => { z80.PC.Value = z80.IY.Value; return(TStates.Count(8)); })
});
}
