private static void Main(string[] args)
{
var memory = new SystemMemory(1024);
var span = memory.RetrieveAddress(0);
Console.WriteLine("Hello World!");
}
public Cpu(SystemMemory memory)
{
ProgramCounter = 0;
this.Memory = memory;
this.Registers = new Vector <byte> [255];
}
public void Step(int cycles)
{
while (cycles > 0)
{
cycles--;
byte a = SystemMemory.ReadByte(m_CodeEngine.PC);
byte b = SystemMemory.ReadByte(m_CodeEngine.PC + 1);
ushort data = Tools.Create16(a, b);
ChipOpCode opcode = Disassembler.DecodeInstruction(data);
//Console.WriteLine("Instuction: " + opcode.ToString());
//Console.WriteLine(m_CodeEngine.PC.ToString("X2") + " " + opcode.ToString());
ChipInstruction inst = new ChipInstruction(data, opcode);
inst.Address = m_CodeEngine.PC;
m_CodeEngine.IncrementPC();
if (m_PatchEngine.PatchAddress(m_CodeEngine, (ushort)(m_CodeEngine.PC - 2)))
{
continue;
}
if (opcode == ChipOpCode.Unknown)
{
if (data != 0)
{
//Console.WriteLine(m_CodeEngine.PC.ToString("X2"));
Console.WriteLine("Syscall: " + inst.NNN.ToString("x"));
if (m_UseHybridDynarec)
{
if (inst.NNN < SystemMemory.Size)
{
m_HybridDynarec.Execute(inst.NNN, m_CodeEngine);
}
else
{
Console.WriteLine("1802 Call is beyond memory bounds! (" + inst.NNN.ToString("X4") + ")");
}
}
else
{
Console.WriteLine("Syscall Emitter Disabled!");
}
}
else
{
Console.WriteLine("Warning: 0 opcode doing Nop!");
}
}
else
{
m_CodeEngine.Call(inst);
}
}
}
private static Cpu BuildCpu(List <IOperation> source, ulong programBase = 0)
{
var memory = new SystemMemory(200L);
var machineCode = new Assembler.Assembler().Assemble(source);
memory.WriteBlock(machineCode, programBase);
var cpu = new Cpu(memory);
return(cpu);
}
public async Task <TpktPayload> ReadAsync()
{
int nextTpktPositon = await FindNextPacketAsync();
int usefulDataSize = _nonParsedDataSize - nextTpktPositon;
if (nextTpktPositon != 0)
{
Buffer.BlockCopy(_readBuffer, nextTpktPositon, _readBuffer, 0, usefulDataSize);
}
int readCount = TpktHeader.Size - usefulDataSize;
if (readCount > 0)
{
await _stream.ReadExactAsync(_readBuffer, usefulDataSize, readCount);
usefulDataSize = 0;
}
else
{
usefulDataSize = -readCount;
}
int channel = _readBuffer[1];
int payloadSize = BigEndianConverter.ReadUInt16(_readBuffer, 2);
int totalSize = TpktHeader.Size + payloadSize;
if (_readBuffer.Length < totalSize)
{
int alignedTotalSize = SystemMemory.RoundToPageAlignmentSize(totalSize);
Array.Resize(ref _readBuffer, alignedTotalSize);
}
readCount = payloadSize - usefulDataSize;
if (readCount > 0)
{
await _stream.ReadExactAsync(_readBuffer, TpktHeader.Size + usefulDataSize, readCount);
_nonParsedDataSize = 0;
}
else
{
_nonParsedDataSize = -readCount;
_nonParsedDataOffset = totalSize;
}
var payloadSegment = new ArraySegment <byte>(_readBuffer, TpktHeader.Size, payloadSize);
return(new TpktPayload(channel, payloadSegment));
}
public GameBoy(IVideoFrameSink frameSink, IInputSource inputSource)
{
Clock = new SystemClock();
Interconnect = new Interconnect();
Interconnect.AddAddressHandler(0x0000, 0x00FF, new BootRom());
Memory = new SystemMemory(Interconnect);
InterruptController = new InterruptController(Interconnect);
CPU = new SM83(Clock, Interconnect, InterruptController);
Timer = new Timer(Clock, Interconnect, InterruptController);
SerialIO = new SerialCommunicationController(Clock, Interconnect, InterruptController);
LCD = new LCDController(Clock, Interconnect, InterruptController, frameSink);
PSG = new SoundController(Clock, Interconnect);
Input = new InputController(Interconnect, InterruptController, inputSource);
}
public void ShouldBeAbleToRetrieveA32ByteBlockOfMemoryAsASpan(ulong address)
{
var systemMemory = new SystemMemory(512);
var register = Vector <byte> .One;
Vector <double> .Count.ShouldBe(4);
Vector <byte> .Count.ShouldBe(32);
Vector.IsHardwareAccelerated.ShouldBe(true);
systemMemory.SetValueAtAddress(0, register);
var retrievedMemory = systemMemory.RetrieveAddress(address);
retrievedMemory.ShouldNotBeNull();
retrievedMemory.Length.ShouldBe(32);
var newRegister = retrievedMemory.NonPortableCast <byte, Vector <byte> >()[0];
(newRegister == register).ShouldBeTrue();
newRegister[31].ShouldBe((byte)1);
}
private void LoadOrCreateSystemMemory()
{
string path = GetSystemMemoryFilepath();
if (File.Exists(path))
{
SystemMemory = ReadJsonFromFile <SystemMemory>(path);
Global.Instance().Settings.PopulateFromMemory(SystemMemory.settings);
}
else
{
SystemMemory = new SystemMemory();
Global.Instance().Settings.LoadDefaults();
}
// time to populate from system memory
maxSeenCommands.Clear();
for (int i = 0; i < SystemMemory.maxSeenCommandsKeys.Count; i += 1)
{
variables[SystemMemory.maxSeenCommandsKeys[i]] = SystemMemory.maxSeenCommandsValues[i];
}
}
public void ShouldBeAbleToCreateASystemMemoryThatIsAMultipleOf32Bytes(ulong ramSize)
{
var systemMemory = new SystemMemory(ramSize);
systemMemory.Size.ShouldBe(ramSize);
}
