diff options
Diffstat (limited to 'src/Noddybox.Emulation.EightBit.Z80')
| -rw-r--r-- | src/Noddybox.Emulation.EightBit.Z80/Z80Cpu.cs | 226 | ||||
| -rw-r--r-- | src/Noddybox.Emulation.EightBit.Z80/Z80CpuBaseOpcodes.cs | 695 |
2 files changed, 921 insertions, 0 deletions
diff --git a/src/Noddybox.Emulation.EightBit.Z80/Z80Cpu.cs b/src/Noddybox.Emulation.EightBit.Z80/Z80Cpu.cs new file mode 100644 index 0000000..5c40854 --- /dev/null +++ b/src/Noddybox.Emulation.EightBit.Z80/Z80Cpu.cs @@ -0,0 +1,226 @@ +//
+// Copyright (c) 2012 Ian Cowburn
+//
+using System;
+using System.Net;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Documents;
+using System.Windows.Ink;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Animation;
+using System.Windows.Shapes;
+
+namespace Noddybox.Emulation.EightBit.Z80
+{
+ /// <summary>
+ /// Provides an implementation of a Zilog Z80 processor.
+ /// </summary>
+ public partial class Z80Cpu : ICpu
+ {
+ #region Private types
+
+ [Flags]
+ private enum Z80Flags
+ {
+ None = 0x00,
+ Carry = 0x01,
+ Neg = 0x02,
+ PV = 0x04,
+ Hidden3 = 0x08,
+ HalfCarry = 0x10,
+ Hidden5 = 0x20,
+ Zero = 0x40,
+ Sign = 0x80
+ };
+
+ #endregion
+
+ #region Private data
+
+ // Lookup tables
+ //
+ private Z80Flags[] PSZtable = new Z80Flags[512];
+ private Z80Flags[] SZtable = new Z80Flags[512];
+ private Z80Flags[] Ptable = new Z80Flags[512];
+ private Z80Flags[] Stable = new Z80Flags[512];
+ private Z80Flags[] Ztable = new Z80Flags[512];
+ private Z80Flags[] H35table = new Z80Flags[256];
+
+ // Machine accessors
+ //
+ private IMemory memory;
+ private IDevice device;
+ private Clock clock;
+
+ // Main registers
+ //
+ private byte A;
+ private Z80Flags F;
+ private Register16 BC = new Register16(0);
+ private Register16 DE = new Register16(0);
+ private Register16 HL = new Register16(0);
+ private Register16 IX = new Register16(0);
+ private Register16 IY = new Register16(0);
+ private ushort SP;
+ private ushort PC;
+
+ // Alternate registers
+ //
+ private Register16 AF_ = new Register16(0);
+ private Register16 BC_ = new Register16(0);
+ private Register16 DE_ = new Register16(0);
+ private Register16 HL_ = new Register16(0);
+
+ // Auxilliary registers and flags
+ //
+ private byte I;
+ private byte R;
+ private bool IFF1;
+ private bool IFF2;
+ private int IM;
+ private bool HALT;
+
+ #endregion
+
+ #region ICpu Members
+
+ public void Initialise(IMemory memory, IDevice device, Clock clock)
+ {
+ this.memory = memory;
+ this.device = device;
+ this.clock = clock;
+
+ Reset();
+ }
+
+ public void Reset()
+ {
+ PC = 0;
+ A = 0xff;
+ F = (Z80Flags)0xff;
+
+ BC.reg = 0xffff;
+ DE.reg = 0xffff;
+ HL.reg = 0xffff;
+ AF_.reg = 0xffff;
+ BC_.reg = 0xffff;
+ DE_.reg = 0xffff;
+ HL_.reg = 0xffff;
+
+ IX.reg = 0xffff;
+ IY.reg = 0xffff;
+
+ SP = 0xffff;
+
+ IFF1 = false;
+ IFF2 = false;
+ IM = 0;
+ I = 0;
+ R = 0;
+ HALT = false;
+ }
+
+ public void Step()
+ {
+ // TODO: Single step.
+ }
+
+ public void Run()
+ {
+ while(!clock.FrameDone)
+ {
+ Step();
+ }
+ }
+
+ public void MaskableInterrupt(byte value)
+ {
+ clock.Add(2);
+
+ // TODO: INT
+ }
+
+ public void NonMaskableInterrupt(byte value)
+ {
+ clock.Add(2);
+
+ // TODO: NMI
+ }
+
+ #endregion
+
+ #region Constructors
+
+ public Z80Cpu()
+ {
+ // Verify runtime
+ //
+ Register16.Verify();
+
+ // Setup lookup tables
+ //
+ for(int f = 0; f < 256; f++)
+ {
+ Z80Flags p = Z80Flags.None;
+ Z80Flags z = Z80Flags.None;
+ Z80Flags s = Z80Flags.None;
+ Z80Flags h3 = Z80Flags.None;
+ Z80Flags h5 = Z80Flags.None;
+
+ int parity = 0;
+
+ for(int b=0; b < 8; b++)
+ {
+ if ((f & (1<<b)) == (1<<b))
+ {
+ parity++;
+ }
+ }
+
+ if ((parity & 1) == 1)
+ {
+ p = Z80Flags.PV;
+ }
+
+ if (f == 0)
+ {
+ z = Z80Flags.Zero;
+ }
+
+ if ((f & 0x80) == 0x80)
+ {
+ s = Z80Flags.Sign;
+ }
+
+ if ((f & (int)Z80Flags.Hidden3) == (int)Z80Flags.Hidden3)
+ {
+ h3 = Z80Flags.Hidden3;
+ }
+
+ if ((f & (int)Z80Flags.Hidden5) == (int)Z80Flags.Hidden5)
+ {
+ h5 = Z80Flags.Hidden5;
+ }
+
+ Ptable[f] = p;
+ Stable[f] = s;
+ Ztable[f] = z;
+ SZtable[f] =z | s;
+ PSZtable[f] = z | s | p;
+ H35table[f] = h3 | h5;
+
+ Ptable[f+256] = Ptable[f] | Z80Flags.Carry;
+ Stable[f+256] = Stable[f] | Z80Flags.Carry;
+ Ztable[f+256] = Ztable[f] | Z80Flags.Carry;
+ SZtable[f+256] = SZtable[f] | Z80Flags.Carry;
+ PSZtable[f+256] = PSZtable[f] | Z80Flags.Carry;
+ }
+
+ Reset();
+ }
+
+ #endregion
+ }
+}
diff --git a/src/Noddybox.Emulation.EightBit.Z80/Z80CpuBaseOpcodes.cs b/src/Noddybox.Emulation.EightBit.Z80/Z80CpuBaseOpcodes.cs new file mode 100644 index 0000000..40b31ca --- /dev/null +++ b/src/Noddybox.Emulation.EightBit.Z80/Z80CpuBaseOpcodes.cs @@ -0,0 +1,695 @@ +//
+// Copyright (c) 2012 Ian Cowburn
+//
+using System;
+using System.Net;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Documents;
+using System.Windows.Ink;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Animation;
+using System.Windows.Shapes;
+
+namespace Noddybox.Emulation.EightBit.Z80
+{
+ public partial class Z80Cpu
+ {
+ #region Status register helpers
+
+ /// <summary>
+ /// Set a flag in the status register.
+ /// </summary>
+ /// <param name="flag">The flag.</param>
+ private void SetFlag(Z80Flags flag)
+ {
+ F |= flag;
+ }
+
+ /// <summary>
+ /// Clear a flag in the status register.
+ /// </summary>
+ /// <param name="flag">The flag.</param>
+ private void ClearFlag(Z80Flags flag)
+ {
+ F &= ~flag;
+ }
+
+ #endregion
+
+ #region Stack commands
+
+ /// <summary>
+ /// Push a value on the stack.
+ /// </summary>
+ /// <param name="val">The value.</param>
+ private void PUSH(ushort val)
+ {
+ memory.Write(--SP, (byte)(val & 0xff));
+ memory.Write(--SP, (byte)(Binary.ShiftRight(val, 8) & 0xff));
+ }
+
+ /// <summary>
+ /// Pop a value from the stack.
+ /// </summary>
+ /// <returns></returns>
+ private ushort POP()
+ {
+ SP = (ushort)((SP + 2) & 0xffff);
+ return (ushort)(memory.Read((ushort)(SP-2)) |
+ (memory.Read((ushort)(SP - 1)) >> 8));
+ }
+
+ #endregion
+
+ #region ALU arithmetic and comparison
+
+ /// <summary>
+ /// Add an 8-bit value to the accumulator without carry.
+ /// </summary>
+ /// <param name="b">The vakue.</param>
+ private void Add8(byte b)
+ {
+ int w = A + b;
+
+ F = SZtable[w] | H35table[w & 0xff];
+
+ if (((A ^ w ^ b) & (int)Z80Flags.HalfCarry) == (int)Z80Flags.HalfCarry)
+ {
+ F |= Z80Flags.HalfCarry;
+ }
+
+ if (((b ^ A) & (b ^ w) & 0x80) > 0)
+ {
+ F |= Z80Flags.PV;
+ }
+
+ A = (byte)(w & 0xff);
+ }
+
+ /// <summary>
+ /// Add an 8-bit value to the accumulator with carry.
+ /// </summary>
+ /// <param name="b">The vakue.</param>
+ private void Adc8(byte b)
+ {
+ int w = A + b + (int)(F & Z80Flags.Carry);
+
+ F = SZtable[w] | H35table[w & 0xff];
+
+ if (((A ^ w ^ b) & (int)Z80Flags.HalfCarry) == (int)Z80Flags.HalfCarry)
+ {
+ F |= Z80Flags.HalfCarry;
+ }
+
+ if (((b ^ A) & (b ^ w) & 0x80) > 0)
+ {
+ F |= Z80Flags.PV;
+ }
+
+ A = (byte)(w & 0xff);
+ }
+
+ /// <summary>
+ /// Subtract an 8-bit value from the accumulator without carry.
+ /// </summary>
+ /// <param name="b">The vakue.</param>
+ private void Sub8(byte b)
+ {
+ int w = A - b;
+
+ if (w < 0)
+ {
+ w += 0x200;
+ }
+
+ F = SZtable[w] | H35table[w & 0xff] | Z80Flags.Neg;
+
+ if (((A ^ w ^ b) & (int)Z80Flags.HalfCarry) == (int)Z80Flags.HalfCarry)
+ {
+ F |= Z80Flags.HalfCarry;
+ }
+
+ if (((b ^ A) & (b ^ w) & 0x80) > 0)
+ {
+ F |= Z80Flags.PV;
+ }
+
+ A = (byte)(w & 0xff);
+ }
+
+ /// <summary>
+ /// Compare an 8-bit value with the accumulator.
+ /// </summary>
+ /// <param name="b">The vakue.</param>
+ private void Cmp8(byte b)
+ {
+ int w = A - b;
+
+ if (w < 0)
+ {
+ w += 0x200;
+ }
+
+ F = SZtable[w] | H35table[w & 0xff] | Z80Flags.Neg;
+
+ if (((A ^ w ^ b) & (int)Z80Flags.HalfCarry) == (int)Z80Flags.HalfCarry)
+ {
+ F |= Z80Flags.HalfCarry;
+ }
+
+ if (((b ^ A) & (b ^ w) & 0x80) > 0)
+ {
+ F |= Z80Flags.PV;
+ }
+ }
+
+ /// <summary>
+ /// Subtract an 8-bit value from the accumulator with carry.
+ /// </summary>
+ /// <param name="b">The vakue.</param>
+ private void Sbc8(byte b)
+ {
+ int w = A - b - (int)(F & Z80Flags.Carry);
+
+ if (w < 0)
+ {
+ w += 0x200;
+ }
+
+ F = SZtable[w] | H35table[w & 0xff] | Z80Flags.Neg;
+
+ if (((A ^ w ^ b) & (int)Z80Flags.HalfCarry) == (int)Z80Flags.HalfCarry)
+ {
+ F |= Z80Flags.HalfCarry;
+ }
+
+ if (((b ^ A) & (b ^ w) & 0x80) > 0)
+ {
+ F |= Z80Flags.PV;
+ }
+
+ A = (byte)(w & 0xff);
+ }
+
+ /// <summary>
+ /// Add a 16-bit value to a register without carry.
+ /// </summary>
+ /// <param name="b">The vakue.</param>
+ private void Add16(ref ushort reg, ushort b)
+ {
+ int w = reg + b;
+
+ F &= Z80Flags.Sign | Z80Flags.Zero | Z80Flags.PV;
+
+ if (w > 0xffff)
+ {
+ F |= Z80Flags.Carry;
+ }
+
+ if ((reg ^ w ^ b) == 0x1000)
+ {
+ F |= Z80Flags.HalfCarry;
+ }
+
+ reg = (ushort)(w & 0xffff);
+
+ F |= H35table[reg >> 8];
+ }
+
+ /// <summary>
+ /// Add a 16-bit value to a register with carry.
+ /// </summary>
+ /// <param name="b">The vakue.</param>
+ private void Adc16(ref ushort reg, ushort b)
+ {
+ int w = reg + b + (int)(F & Z80Flags.Carry);
+
+ F = Z80Flags.None;
+
+ if ((w & 0xffff) == 0)
+ {
+ F |= Z80Flags.Zero;
+ }
+
+ if ((w & 0x8000) == 0x8000)
+ {
+ F |= Z80Flags.Sign;
+ }
+
+ if (w > 0xffff)
+ {
+ F |= Z80Flags.Carry;
+ }
+
+ if (((b ^ reg ^ 0x8000) & ((reg ^ w) & 0x8000)) == 0x8000)
+ {
+ F |= Z80Flags.PV;
+ }
+
+ if ((reg ^ w ^ b) == 0x1000)
+ {
+ F |= Z80Flags.HalfCarry;
+ }
+
+ reg = (ushort)(w & 0xffff);
+
+ F |= H35table[reg >> 8];
+ }
+
+
+ /// <summary>
+ /// Subtract a 16-bit value from a register with carry.
+ /// </summary>
+ /// <param name="b">The vakue.</param>
+ private void Sbc16(ref ushort reg, ushort b)
+ {
+ int w = reg - b - (int)(F & Z80Flags.Carry);
+
+ F = Z80Flags.Neg;
+
+ if (w < 0)
+ {
+ w += 0x10000;
+ F |= Z80Flags.Carry;
+ }
+
+ if ((w & 0xffff) == 0)
+ {
+ F |= Z80Flags.Zero;
+ }
+
+ if ((w & 0x8000) == 0x8000)
+ {
+ F |= Z80Flags.Sign;
+ }
+
+ if (((b ^ reg) & ((reg ^ w) & 0x8000)) == 0x8000)
+ {
+ F |= Z80Flags.PV;
+ }
+
+ if ((reg ^ w ^ b) == 0x1000)
+ {
+ F |= Z80Flags.HalfCarry;
+ }
+
+ reg = (ushort)(w & 0xffff);
+
+ F |= H35table[reg >> 8];
+ }
+
+ /// <summary>
+ /// Increment an 8-bit register.
+ /// </summary>
+ /// <param name="reg">The register to increment.</param>
+ void Inc8(ref byte reg)
+ {
+ reg++;
+
+ F = Z80Flags.Carry;
+
+ if (reg == 0x80)
+ {
+ F |= Z80Flags.PV;
+ }
+
+ if ((reg & 0x0f) == 0x00)
+ {
+ F |= Z80Flags.HalfCarry;
+ }
+ }
+
+ /// <summary>
+ /// Decrement an 8-bit register.
+ /// </summary>
+ /// <param name="reg">The register to decrement.</param>
+ void Dec8(ref byte reg)
+ {
+ reg--;
+
+ F = Z80Flags.Carry | Z80Flags.Neg;
+
+ if (reg == 0x7f)
+ {
+ F |= Z80Flags.PV;
+ }
+
+ if ((reg & 0x0f) == 0x0f)
+ {
+ F |= Z80Flags.HalfCarry;
+ }
+ }
+
+ #endregion
+
+ #region ALU rotate and shift operations
+
+ /// <summary>
+ /// Do RRCA.
+ /// </summary>
+ private void RRCA()
+ {
+ F &= Z80Flags.Sign | Z80Flags.Zero | Z80Flags.PV;
+ F |= (Z80Flags)(A & 1);
+ A = (byte)(Binary.ShiftRight(A, 1) | Binary.ShiftLeft(A, 7));
+ F |= H35table[A];
+ }
+
+ /// <summary>
+ /// Do RRA.
+ /// </summary>
+ private void RRA()
+ {
+ byte carry = (byte)(F & Z80Flags.Carry);
+ F &= Z80Flags.Sign | Z80Flags.Zero | Z80Flags.PV;
+ F |= (Z80Flags)(A & 1);
+ A = (byte)(Binary.ShiftRight(A, 1) | Binary.ShiftLeft(carry, 7));
+ F |= H35table[A];
+ }
+
+ /// <summary>
+ /// Do RRC.
+ /// </summary>
+ /// <param name="reg">The register to operate on.</param>
+ private void RRC(ref byte reg)
+ {
+ F = (Z80Flags)(reg & (int)Z80Flags.Carry);
+ reg = (byte)(Binary.ShiftRight(reg, 1) | Binary.ShiftLeft(reg, 7));
+ F |= PSZtable[reg] | H35table[reg];
+ }
+
+ /// <summary>
+ /// Do RR.
+ /// </summary>
+ /// <param name="reg">The register to operate on.</param>
+ private void RR(ref byte reg)
+ {
+ byte carry = (byte)(F & Z80Flags.Carry);
+ F = (Z80Flags)(reg & (int)Z80Flags.Carry);
+ reg = (byte)(Binary.ShiftRight(reg, 1) | Binary.ShiftLeft(carry, 7));
+ F |= PSZtable[reg] | H35table[reg];
+ }
+
+ /// <summary>
+ /// Do RLCA.
+ /// </summary>
+ private void RLCA()
+ {
+ F = (F & Z80Flags.PV | Z80Flags.Sign | Z80Flags.Zero)
+ | (Z80Flags)Binary.ShiftRight(A, 7);
+
+ A = (byte)(Binary.ShiftLeft(A, 1) | Binary.ShiftRight(A, 7));
+
+ F |= H35table[A];
+ }
+
+ /// <summary>
+ /// Do RLA.
+ /// </summary>
+ private void RLA()
+ {
+ byte carry = (byte)(F & Z80Flags.Carry);
+ F = (F & Z80Flags.PV | Z80Flags.Sign | Z80Flags.Zero)
+ | (Z80Flags)Binary.ShiftRight(A, 7);
+ A = (byte)(Binary.ShiftRight(A, 1) | carry);
+ F |= H35table[A];
+ }
+
+ /// <summary>
+ /// Do RLC.
+ /// </summary>
+ /// <param name="reg">The register to operate on.</param>
+ private void RLC(ref byte reg)
+ {
+ byte carry = Binary.ShiftRight(reg, 7);
+ reg = (byte)(Binary.ShiftLeft(reg, 1) | carry);
+ F = PSZtable[reg] | (Z80Flags)carry | H35table[reg];
+ }
+
+ /// <summary>
+ /// Do RL.
+ /// </summary>
+ /// <param name="reg">The register to operate on.</param>
+ private void RL(ref byte reg)
+ {
+ byte carry = Binary.ShiftRight(reg, 7);
+ reg = (byte)(Binary.ShiftLeft(reg, 1) | (int)(F & Z80Flags.Carry));
+ F = PSZtable[reg] | (Z80Flags)carry | H35table[reg];
+ }
+
+ /// <summary>
+ /// Do SRL.
+ /// </summary>
+ /// <param name="reg">The register to operate on.</param>
+ private void SRL(ref byte reg)
+ {
+ byte carry = (byte)(reg & 1);
+ reg = Binary.ShiftLeft(reg, 1);
+ F = PSZtable[reg] | (Z80Flags)carry | H35table[reg];
+ }
+
+ /// <summary>
+ /// Do SRA.
+ /// </summary>
+ /// <param name="reg">The register to operate on.</param>
+ private void SRA(ref byte reg)
+ {
+ byte carry = (byte)(reg & 1);
+ reg = (byte)(Binary.ShiftLeft(reg, 1) | (reg & 0x80));
+ F = PSZtable[reg] | (Z80Flags)carry | H35table[reg];
+ }
+
+ /// <summary>
+ /// Do SLL.
+ /// </summary>
+ /// <param name="reg">The register to operate on.</param>
+ private void SLL(ref byte reg)
+ {
+ byte carry = Binary.ShiftRight(reg, 7);
+ reg = (byte)(Binary.ShiftRight(reg, 1) | 0x01);
+ F = PSZtable[reg] | (Z80Flags)carry | H35table[reg];
+ }
+
+ /// <summary>
+ /// Do SLA.
+ /// </summary>
+ /// <param name="reg">The register to operate on.</param>
+ private void SLA(ref byte reg)
+ {
+ byte carry = Binary.ShiftRight(reg, 7);
+ reg = Binary.ShiftRight(reg, 1);
+ F = PSZtable[reg] | (Z80Flags)carry | H35table[reg];
+ }
+
+ #endregion
+
+ #region ALU boolean operations
+
+ /// <summary>
+ /// AND a value with the accumulator.
+ /// </summary>
+ /// <param name="val">The value.</param>
+ void AND(byte val)
+ {
+ A &= val;
+ F = PSZtable[A] | Z80Flags.HalfCarry | H35table[A];
+ }
+
+ /// <summary>
+ /// OR a value with the accumulator.
+ /// </summary>
+ /// <param name="val">The value.</param>
+ void OR(byte val)
+ {
+ A |= val;
+ F = PSZtable[A] | Z80Flags.HalfCarry | H35table[A];
+ }
+
+ /// <summary>
+ /// XOR a value with the accumulator.
+ /// </summary>
+ /// <param name="val">The value.</param>
+ void XOR(byte val)
+ {
+ A ^= val;
+ F = PSZtable[A] | Z80Flags.HalfCarry | H35table[A];
+ }
+
+ /// <summary>
+ /// Perform the BIT operation.
+ /// </summary>
+ /// <param name="reg">The register to operate on.</param>
+ /// <param name="bit">The bit to test.</param>
+ void BIT(ref byte reg, int bit)
+ {
+ F &= Z80Flags.Carry;
+ F |= Z80Flags.HalfCarry;
+
+ if ((reg & (1 << bit)) != 0)
+ {
+ if (bit == 7 && (reg & (int)Z80Flags.Sign) != 0)
+ {
+ F |= Z80Flags.Sign;
+ }
+
+ if (bit == 5 && (reg & (int)Z80Flags.Hidden5) != 0)
+ {
+ F |= Z80Flags.Hidden5;
+ }
+
+ if (bit == 3 && (reg & (int)Z80Flags.Hidden3) != 0)
+ {
+ F |= Z80Flags.Hidden3;
+ }
+ }
+ else
+ {
+ F |= Z80Flags.Zero | Z80Flags.PV;
+ }
+ }
+
+ /// <summary>
+ /// Perform the bit set operation.
+ /// </summary>
+ /// <param name="reg">The register to operate on.</param>
+ /// <param name="bit">The bit to test.</param>
+ void BIT_SET(ref byte reg, int bit)
+ {
+ reg |= (byte)(1 << bit);
+ }
+
+ /// <summary>
+ /// Perform the bit clear operation.
+ /// </summary>
+ /// <param name="reg">The register to operate on.</param>
+ /// <param name="bit">The bit to test.</param>
+ void BIT_RES(ref byte reg, int bit)
+ {
+ reg &= (byte)~(1 << bit);
+ }
+
+ #endregion
+
+ #region Jump operations
+
+ /// <summary>
+ /// The call operation.
+ /// </summary>
+ private void CALL()
+ {
+ PUSH((ushort)(PC + 2));
+ PC = (ushort)(memory.Read(PC) | memory.Read((ushort)(PC+1)) >> 8);
+ }
+
+ /// <summary>
+ /// The jump operation.
+ /// </summary>
+ private void JP()
+ {
+ PC = (ushort)(memory.Read(PC) | memory.Read((ushort)(PC+1)) >> 8);
+ }
+
+ /// <summary>
+ /// The jump relative operation.
+ /// </summary>
+ private void JR()
+ {
+ PC = (ushort)(PC + (sbyte)memory.Read(PC) + 1);
+ }
+
+ /// <summary>
+ /// Jump relative if the passed condition flag ANDed with the flag
+ /// register equals the passed check value.
+ /// </summary>
+ /// <param name="cond">The condition flag.</param>
+ /// <param name="val">The check value.</param>
+ private void JR_COND(Z80Flags cond, Z80Flags val)
+ {
+ if ((F & cond) == val)
+ {
+ clock.Add(12);
+ JR();
+ }
+ else
+ {
+ clock.Add(7);
+ PC++;
+ }
+ }
+
+ /// <summary>
+ /// Jump if the passed condition flag ANDed with the flag
+ /// register equals the passed check value.
+ /// </summary>
+ /// <param name="cond">The condition flag.</param>
+ /// <param name="val">The check value.</param>
+ private void JP_COND(Z80Flags cond, Z80Flags val)
+ {
+ clock.Add(10);
+
+ if ((F & cond) == val)
+ {
+ JP();
+ }
+ else
+ {
+ PC+=2;
+ }
+ }
+
+ /// <summary>
+ /// Call if the passed condition flag ANDed with the flag
+ /// register equals the passed check value.
+ /// </summary>
+ /// <param name="cond">The condition flag.</param>
+ /// <param name="val">The check value.</param>
+ private void CALL_COND(Z80Flags cond, Z80Flags val)
+ {
+ if ((F & cond) == val)
+ {
+ clock.Add(17);
+ CALL();
+ }
+ else
+ {
+ clock.Add(10);
+ PC+=2;
+ }
+ }
+
+ /// <summary>
+ /// Return if the passed condition flag ANDed with the flag
+ /// register equals the passed check value.
+ /// </summary>
+ /// <param name="cond">The condition flag.</param>
+ /// <param name="val">The check value.</param>
+ private void RET_COND(Z80Flags cond, Z80Flags val)
+ {
+ if ((F & cond) == val)
+ {
+ clock.Add(11);
+ PC = POP();
+ }
+ else
+ {
+ clock.Add(5);
+ }
+ }
+
+ /// <summary>
+ /// Reset the PC to an address
+ /// register equals the passed check value.
+ /// </summary>
+ /// <param name="addr">The address.</param>
+ private void RST(ushort addr)
+ {
+ clock.Add(11);
+ PUSH(PC);
+ PC = addr;
+ }
+
+ #endregion
+ }
+}
|