public void OpcodeDefinition_Y_TranslatesToP_and_Q_3()
{
var od = new OpcodeDefinition(0, 3, 0);
od.P.Should().Be(1);
od.Q.Should().Be(1);
}
private void DetermineINT(DigitalLevel level)
{
if (Cpu.Registers.Interrupt.IFF1 &&
level == DigitalLevel.Low)
{
var def = OpcodeDefinition.GetInterruptDefinition(Cpu.Registers.Interrupt.InterruptMode);
_pendingINT = new CpuInterrupt(Cpu, def);
}
}
private void DetermineNMI(DigitalLevel level)
{
// NMI is edge triggered
if (level == DigitalLevel.NegEdge)
{
var def = OpcodeDefinition.GetNmiDefinition();
_pendingNMI = new CpuInterrupt(Cpu, def);
}
}
// use after instruction has completed
public void Reset()
{
_continueCycles = 0;
_continueCount = 0;
_opcodeDefinition = null;
_opcodeCycles = null;
CycleName = CycleNames.NotInitialized;
MachineCycle = MachineCycleNames.M1;
}
private static CpuZ80 ExecuteTest(OpcodeByte ob, Func <RegisterSet, bool> preTest)
{
var cpuZ80 = new CpuZ80();
var buffer = new[] { ob.Value, AddressLsb, AddressMsb };
var model = cpuZ80.Initialize(buffer);
model.Cpu.FillRegisters();
var conditionMet = preTest(cpuZ80.Registers);
var def = OpcodeDefinition.Find(ob);
model.ClockGen.SquareWave(def.Cycles.Sum());
Console.WriteLine(model.LogicAnalyzer.ToWaveJson());
return(cpuZ80);
}
public CpuInterrupt(Die die, OpcodeDefinition definition)
: base(die)
{
if (definition == null)
{
throw new ArgumentNullException("definition");
}
_definition = definition;
if (_definition.Instruction == null)
{
throw new InvalidOperationException(
"The Interrupt OpcodeDefinition has no associated Instruction: "
+ definition.ToString());
}
_interrupt = (Interrupt)Activator.CreateInstance(
_definition.Instruction, Die, _definition);
}
internal static T Create <T>(CpuZ80 cpu, OpcodeDefinition opcodeDefinition)
where T : Instruction
{
if (opcodeDefinition == null)
{
throw new ArgumentNullException("opcodeDefintion",
"There is no OpcodeDefinition available.");
}
if (opcodeDefinition.Instruction == null)
{
throw new InvalidOperationException(
"The OpcodeDefinition has no associated Instruction: "
+ opcodeDefinition.ToString());
}
if (!typeof(T).IsAssignableFrom(opcodeDefinition.Instruction))
{
throw Errors.AssignedToIllegalOpcode();
}
return((T)Activator.CreateInstance(opcodeDefinition.Instruction, cpu));
}
private static SimulationModel ExecuteTest(OpcodeByte ret,
Action <SimulationModel> preTest, bool conditionMet,
byte extension = 0)
{
var cpuZ80 = new CpuZ80();
var buffer = (extension == 0) ?
new byte[] { ret.Value, 0, 0, 0, 0x55, 0xAA } :
new byte[] { extension, ret.Value, 0, 0, 0x55, 0xAA };
var model = cpuZ80.Initialize(buffer);
model.Cpu.FillRegisters(sp: Stack);
preTest(model);
var def = OpcodeDefinition.Find(ret, extension == 0 ? null : new OpcodeByte(extension));
model.ClockGen.SquareWave(conditionMet ? def.Cycles.Sum() : def.AltCycles.Sum());
Console.WriteLine(model.LogicAnalyzer.ToWaveJson());
return(model);
}
public Interrupt(Die die, OpcodeDefinition opcodeDefinition)
: base(die)
{
_opcodeDefinition = opcodeDefinition;
}
public SingleByteOpcode(OpcodeDefinition opcodeDefinition)
{
Definition = opcodeDefinition;
}
public void OpcodeDefinition_P_andQ_TranslatesToY_3()
{
var od = new OpcodeDefinition(0, 1, 1, 0);
od.Y.Should().Be(3);
}
public NmiInterrupt(Die die, OpcodeDefinition opcodeDefinition)
: base(die, opcodeDefinition)
{
}
public NmiInterrupt(CpuZ80 cpu, OpcodeDefinition opcodeDefinition)
: base(cpu, opcodeDefinition)
{
}
public Interrupt(CpuZ80 cpu, OpcodeDefinition opcodeDefinition)
: base(cpu)
{
_opcodeDefinition = opcodeDefinition;
}
