public void Clock() { // Read from HL pointed address if (!_readCycle.IsComplete) { _readCycle.Clock(); if (_readCycle.IsComplete) { _writeCycle.AddressedValue = _readCycle.AddressedValue; } return; } if (!_writeCycle.IsComplete) { _writeCycle.Clock(); return; } var bcValue = WideRegister.BC.GetValue(_cpu); if (((!_repeats || bcValue == 1) && --_additionalCycles > 0) || (_repeats && _additionalCycles-- > 0)) // If it's not repeating we need the last cycle of the additional cycles to carry out the instruction { return; } if (bcValue != 1 && _repeats && --_additionalRepeatCycles > 0) { // Prefix decrement here so we use the last addtional cycle to actually carry out the instruction return; } var deValue = WideRegister.DE.GetValue(_cpu); var hlValue = WideRegister.HL.GetValue(_cpu); if (_increment) { deValue++; hlValue++; } else { deValue--; hlValue--; } WideRegister.DE.SetValueOnProcessor(_cpu, deValue); WideRegister.HL.SetValueOnProcessor(_cpu, hlValue); WideRegister.BC.SetValueOnProcessor(_cpu, --bcValue); Z80Flags.HalfCarry_H.SetOrReset(_cpu, false); Z80Flags.AddSubtract_N.SetOrReset(_cpu, false); Z80Flags.ParityOverflow_PV.SetOrReset(_cpu, bcValue != 0); if (_repeats && bcValue != 0) { _cpu.PC -= 2; } IsComplete = true; }
public void Clock() { if (!_addressMode.IsComplete) { _addressMode.Clock(); if (_addressMode.IsComplete) { _reader = _addressMode.Reader; if (_reader.IsComplete) { ManipulateBit(); } } return; } if (!_reader.IsComplete) { _reader.Clock(); if (_reader.IsComplete) { ManipulateBit(); } return; } if (!_writer.IsComplete) { _writer.Clock(); } }
public void Clock() { if (!_read.IsComplete) { _read.Clock(); if (_read.IsComplete) { _write.AddressedValue = _targetRegister.GetValue(_cpu); _targetRegister.SetValueOnProcessor(_cpu, _read.AddressedValue); } return; } if (_additionalReadCycles-- > 0) { // http://www.baltazarstudios.com/files/xx.html#E3 shows that the cpu read/write signals aren't affected by // the extended cycles so we can just do nothing for these cycles return; } if (!_write.IsComplete) { _write.Clock(); return; } _additionalWriteCycles--; }
public void Clock() { if (!_addressMode.IsComplete) { _addressMode.Clock(); if (_addressMode.IsComplete) { _valueReader = _addressMode.Reader; _valueWriter = _addressMode.Writer; if (_valueReader.IsComplete) { PerformDecrement(); } } return; } if (!_valueReader.IsComplete) { _valueReader.Clock(); if (_valueReader.IsComplete) { PerformDecrement(); } return; } if (!_valueWriter.IsComplete) { _valueWriter.Clock(); } }
public void Clock() { if (!_addressMode.IsComplete) { _addressMode.Clock(); if (_addressMode.IsComplete) { _reader = _addressMode.Reader; _writer = _addressMode.Writer; } return; } if (!_reader.IsComplete) { _reader.Clock(); if (_reader.IsComplete) { DoRotate(); } return; } if (!_writer.IsComplete) { _writer.Clock(); } }
public void Clock() { if (!_addressMode.IsComplete) { _addressMode.Clock(); if (_addressMode.IsComplete) { _reader = _addressMode.Reader; } return; } if (!_reader.IsComplete) { _reader.Clock(); SetupPushOrComplete(); return; } if (!_internalCycle.IsComplete) { _internalCycle.Clock(); return; } if (!_pushInstruction.IsComplete) { _pushInstruction.Clock(); if (_pushInstruction.IsComplete) { _cpu.PC = _reader.AddressedValue; IsComplete = true; } return; } }
public void Clock() { if (_remainingM1Cycles-- <= 0) { if (!_addressMode.IsComplete) { _addressMode.Clock(); if (_addressMode.IsComplete) { _reader = _addressMode.Reader; JumpIfRequired(); } return; } if (!_reader.IsComplete) { _reader.Clock(); JumpIfRequired(); return; } if (!_internalCycle.IsComplete) { _internalCycle.Clock(); if (_internalCycle.IsComplete) { _cpu.PC = _reader.AddressedValue; IsComplete = true; } } } }
public void Clock() { if (!_source.IsComplete) { _source.Clock(); if (_source.IsComplete) { _inputCycle.Address = (ushort)((_topHalfOfAddressSource.GetValue(_cpu) << 8) | _source.AddressedValue); } return; } if (!_inputCycle.IsComplete) { _inputCycle.Clock(); if (_inputCycle.IsComplete) { _destination.SetValueOnProcessor(_cpu, _inputCycle.LatchedData); // Flags are only updated for the Z80 added instructions. // The 8080 compatible instruction does not. Added Z80 instructions use Reg B for top half of address // The 8080 instruction uses the accumulator if (_topHalfOfAddressSource == Register.B) { var input = _inputCycle.LatchedData; Z80Flags.Sign_S.SetOrReset(_cpu, (input & 0x80) == 0x80); Z80Flags.ParityOverflow_PV.SetOrReset(_cpu, input.IsEvenParity()); Z80Flags.Zero_Z.SetOrReset(_cpu, (input & 0xff) == 0); Z80Flags.AddSubtract_N.SetOrReset(_cpu, false); Z80Flags.HalfCarry_H.SetOrReset(_cpu, false); } } } }
public void Clock() { if (!_readCycle.IsComplete) { _readCycle.Clock(); return; } var bcValue = WideRegister.BC.GetValue(_cpu); if (((!_repeats || bcValue == 1) && --_additionalCycles > 0) || (_repeats && _additionalCycles-- > 0)) // If it's not repeating we need the last cycle of the additional cycles to carry out the instruction { return; } if (bcValue != 1 && _repeats && --_additionalRepeatCycles > 0) { // Prefix decrement here so we use the last addtional cycle to actually carry out the instruction return; } // Set flags as appropriate var difference = _cpu.A - _readCycle.AddressedValue; Z80Flags.Sign_S.SetOrReset(_cpu, difference < 0); Z80Flags.Zero_Z.SetOrReset(_cpu, difference == 0); Z80Flags.HalfCarry_H.SetOrReset(_cpu, (_cpu.A & 0xf) < (_readCycle.AddressedValue & 0xf)); Z80Flags.ParityOverflow_PV.SetOrReset(_cpu, bcValue != 1); Z80Flags.AddSubtract_N.SetOrReset(_cpu, true); // Update registers var hlValue = WideRegister.HL.GetValue(_cpu); if (_increment) { hlValue++; } else { hlValue--; } WideRegister.HL.SetValueOnProcessor(_cpu, hlValue); WideRegister.BC.SetValueOnProcessor(_cpu, --bcValue); if (_repeats && bcValue != 0 && difference != 0) { _cpu.PC -= 2; } IsComplete = true; }
public virtual void Clock() { if (_remainingM1Cycles-- <= 0) { // Destination is checked first as its operand comes first if there are // additional bytes to the instruction. if (!_destinationAddressMode.IsComplete) { _destinationAddressMode.Clock(); if (_destinationAddressMode.IsComplete) { _destinationWriter = _destinationAddressMode.Writer; if (_sourceReader?.IsComplete ?? false) { _destinationWriter.AddressedValue = _sourceReader.AddressedValue; } } return; } if (!_sourceAddressMode.IsComplete) { _sourceAddressMode.Clock(); if (_sourceAddressMode.IsComplete) { _sourceReader = _sourceAddressMode.Reader; if (_sourceReader.IsComplete) { _destinationWriter.AddressedValue = _sourceReader.AddressedValue; } } return; } if (!_sourceReader.IsComplete) { _sourceReader.Clock(); if (_sourceReader.IsComplete) { _destinationWriter.AddressedValue = _sourceReader.AddressedValue; } return; } if (!_destinationWriter.IsComplete) { _destinationWriter.Clock(); } } }
public void Clock() { if (!_reader.IsComplete) { _reader.Clock(); return; } if (!_internalCycle.IsComplete) { _internalCycle.Clock(); if (_internalCycle.IsComplete) { var originalAccBits = _cpu.A & 0x0f; var newAccBits = 0; var shiftedValue = 0; if (_isLeftShift) { newAccBits = (_reader.AddressedValue & 0xf0) >> 4; shiftedValue = _reader.AddressedValue << 4; } else { newAccBits = _reader.AddressedValue & 0x0f; originalAccBits = originalAccBits << 4; shiftedValue = _reader.AddressedValue >> 4; } var newPointedValue = (shiftedValue & 0xff) | originalAccBits; _writer = _addressMode.Writer; _writer.AddressedValue = (byte)newPointedValue; _cpu.A = (byte)((_cpu.A & 0xf0) | newAccBits); // Set the flags Z80Flags.HalfCarry_H.SetOrReset(_cpu, false); Z80Flags.AddSubtract_N.SetOrReset(_cpu, false); Z80Flags.ParityOverflow_PV.SetOrReset(_cpu, _cpu.A.IsEvenParity()); Z80Flags.Sign_S.SetOrReset(_cpu, _cpu.A >= 0x80); Z80Flags.Zero_Z.SetOrReset(_cpu, _cpu.A == 0); } return; } if (!_writer.IsComplete) { _writer.Clock(); } }
public void Clock() { if (!_destination.IsComplete) { _destination.Clock(); if (_destination.IsComplete) { _outputCycle.Address = (ushort)((_topHalfOfAddressSource.GetValue(_cpu) << 8) | _destination.AddressedValue); _outputCycle.DataToOutput = _source.GetValue(_cpu); } return; } if (!_outputCycle.IsComplete) { _outputCycle.Clock(); } }
public void Clock() { if (_remainingM1Cycles-- <= 0) { // if (_remainingM1Cycles == -1) { // _inputCycle.Address = (ushort)(_cpu.B << 8 | _cpu.C); // } if (!_sourceReader.IsComplete) { _sourceReader.Clock(); if (_sourceReader.IsComplete) { _outputCycle.Address = (ushort)(--_cpu.B << 8 | _cpu.C); _outputCycle.DataToOutput = _sourceReader.AddressedValue; } return; } if (!_outputCycle.IsComplete) { _outputCycle.Clock(); if (_outputCycle.IsComplete) { var hlValue = WideRegister.HL.GetValue(_cpu); hlValue = (ushort)(_increment ? hlValue + 1 : hlValue - 1); WideRegister.HL.SetValueOnProcessor(_cpu, hlValue); Z80Flags.Zero_Z.SetOrReset(_cpu, _cpu.B == 0); Z80Flags.AddSubtract_N.SetOrReset(_cpu, true); } return; } if (!_repeatCycles.IsComplete) { _repeatCycles.Clock(); if (_repeatCycles.IsComplete) { _cpu.PC -= 2; } } } }
public void Clock() { if (!_addressMode.IsComplete) { _addressMode.Clock(); if (_addressMode.IsComplete) { _readOperand = _addressMode.Reader; if (_readOperand.IsComplete) { PerformSubtraction(); } } return; } if (!_readOperand.IsComplete) { _readOperand.Clock(); if (_readOperand.IsComplete) { PerformSubtraction(); } } }
public void Clock() { if (!_addressMode.IsComplete) { _addressMode.Clock(); if (_addressMode.IsComplete) { _valueReader = _addressMode.Reader; if (_valueReader.IsComplete) { PerformAdd(); } } return; } if (!_valueReader.IsComplete) { _valueReader.Clock(); if (_valueReader.IsComplete) { PerformAdd(); } } }
public void Clock() { if (!_addressMode.IsComplete) { _addressMode.Clock(); if (_addressMode.IsComplete) { _reader = _addressMode.Reader; if (_reader.IsComplete) { PerformBitTest(); } } return; } if (!_reader.IsComplete) { _reader.Clock(); if (_reader.IsComplete) { PerformBitTest(); } } }