public ExecutionResult Execute(Processor cpu, InstructionPackage package)
{
Instruction instruction = package.Instruction;
InstructionData data = package.Data;
Flags flags = cpu.Flags;
Registers r = cpu.Registers;
if (instruction.TargetsWordRegister)
{
ushort left = r.HL;
cpu.Timing.InternalOperationCycle(4);
cpu.Timing.InternalOperationCycle(3);
ushort right = instruction.MarshalSourceWord(data, cpu, out ushort address);
var addition = ALUOperations.Add(left, right, flags.Carry, true, flags);
r.HL = addition.Result;
flags = addition.Flags;
r.WZ = (ushort)(left + 1);
}
else
{
byte left = r.A;
if (instruction.IsIndexed)
{
cpu.Timing.InternalOperationCycle(5);
}
byte right = instruction.MarshalSourceByte(data, cpu, out ushort address, out ByteRegister source);
var addition = ALUOperations.Add(left, right, flags.Carry);
r.A = addition.Result;
flags = addition.Flags;
}
return(new ExecutionResult(package, flags));
}
public ExecutionResult Execute(Processor cpu, InstructionPackage package)
{
Instruction instruction = package.Instruction;
InstructionData data = package.Data;
Flags flags = cpu.Flags;
bool carry = flags.Carry;
byte a = cpu.Registers.A;
byte b = cpu.Memory.Timed.ReadByteAt(cpu.Registers.HL);
var compare = ALUOperations.Subtract(a, b, false);
flags = compare.Flags;
cpu.Registers.BC--;
flags.ParityOverflow = (cpu.Registers.BC != 0);
cpu.Registers.HL--;
flags.Subtract = true;
flags.Carry = carry;
byte valueXY = (byte)(a - b - (flags.HalfCarry ? 1 : 0));
flags.X = (valueXY & 0x08) > 0; // copy bit 3
flags.Y = (valueXY & 0x02) > 0; // copy bit 1 (note: non-standard behaviour)
cpu.Registers.WZ++;
return(new ExecutionResult(package, flags));
}
public ExecutionResult Execute(Processor cpu, InstructionPackage package)
{
Instruction instruction = package.Instruction;
InstructionData data = package.Data;
Flags flags = cpu.Flags;
bool carry = flags.Carry;
byte a = cpu.Registers.A;
byte b = cpu.Memory.Timed.ReadByteAt(cpu.Registers.HL);
var compare = ALUOperations.Subtract(a, b, false);
flags = compare.Flags;
cpu.Registers.BC--;
flags.ParityOverflow = (cpu.Registers.BC != 0);
cpu.Registers.HL++;
flags.Subtract = true;
flags.Carry = carry;
byte valueXY = (byte)(a - b - (flags.HalfCarry ? 1 : 0));
flags.X = (valueXY & 0x08) > 0; // copy bit 3
flags.Y = (valueXY & 0x02) > 0; // copy bit 1 (note: non-standard behaviour)
bool conditionTrue = (compare.Result == 0 || cpu.Registers.BC == 0);
if (conditionTrue)
{
cpu.Timing.InternalOperationCycle(5);
cpu.Registers.WZ++;
}
else
{
cpu.Registers.PC = package.InstructionAddress;
cpu.Registers.WZ = (ushort)(cpu.Registers.PC + 1);
}
return(new ExecutionResult(package, flags));
}
public ExecutionResult Execute(Processor cpu, InstructionPackage package)
{
Instruction instruction = package.Instruction;
InstructionData data = package.Data;
Flags flags = cpu.Flags;
Registers r = cpu.Registers;
byte left = r.A;
byte right = instruction.MarshalSourceByte(data, cpu, out ushort address, out ByteRegister source);
if (instruction.IsIndexed)
{
cpu.Timing.InternalOperationCycle(5);
}
var sub = ALUOperations.Subtract(left, right, false);
r.A = sub.Result;
flags = sub.Flags;
return(new ExecutionResult(package, flags));
}
public ExecutionResult Execute(Processor cpu, InstructionPackage package)
{
Instruction instruction = package.Instruction;
InstructionData data = package.Data;
Flags flags = cpu.Flags;
Registers r = cpu.Registers;
if (instruction.TargetsWordRegister)
{
// it's one of the 16-bit adds (HL,DE etc)
WordRegister destination = instruction.Target.AsWordRegister();
ushort left = r[destination];
ushort right = instruction.MarshalSourceWord(data, cpu, out ushort address);
cpu.Timing.InternalOperationCycle(4);
cpu.Timing.InternalOperationCycle(3);
var sum = ALUOperations.Add(left, right, false, false, flags);
r[destination] = sum.Result;
flags = sum.Flags;
r.WZ = (ushort)(left + 1);
}
else
{
// it's an 8-bit add to A
byte left = r.A;
if (instruction.IsIndexed)
{
cpu.Timing.InternalOperationCycle(5);
}
byte right = instruction.MarshalSourceByte(data, cpu, out ushort address, out ByteRegister source);
var sum = ALUOperations.Add(left, right, false);
r.A = sum.Result;
flags = sum.Flags;
}
return(new ExecutionResult(package, flags));
}
public ExecutionResult Execute(Processor cpu, InstructionPackage package)
{
Instruction instruction = package.Instruction;
InstructionData data = package.Data;
Registers r = cpu.Registers;
Flags flags = cpu.Flags;
byte left = r.A;
if (instruction.IsIndexed)
{
cpu.Timing.InternalOperationCycle(5);
}
byte right = instruction.MarshalSourceByte(data, cpu, out ushort address, out ByteRegister source);
var sub = ALUOperations.Subtract(left, right, false);
flags = sub.Flags;
flags.X = (right & 0x08) > 0; // copy bit 3 of operand, not result
flags.Y = (right & 0x20) > 0; // copy bit 5 of operand, not result
return(new ExecutionResult(package, flags));
}
