summaryrefslogtreecommitdiff
path: root/Emulator
diff options
context:
space:
mode:
Diffstat (limited to 'Emulator')
-rw-r--r--Emulator/.DS_Storebin0 -> 6148 bytes
-rw-r--r--Emulator/Assembler/Disassembler.cs74
-rw-r--r--Emulator/Chip/Bus.cs37
-rw-r--r--Emulator/Chip/BusDevice.cs49
-rw-r--r--Emulator/Chip/DebugDevice.cs13
-rw-r--r--Emulator/Chip/DisplayDevice.cs76
-rw-r--r--Emulator/Chip/Q1Cpu.cs171
-rw-r--r--Emulator/Chip/Q1CpuAddressingModes.cs187
-rw-r--r--Emulator/Chip/Q1CpuInstructions.cs282
-rw-r--r--Emulator/Chip/RamDevice.cs33
-rw-r--r--Emulator/Content/Content.mgcb15
-rw-r--r--Emulator/DisplayEngine.cs76
-rw-r--r--Emulator/Emulator.csproj32
-rw-r--r--Emulator/Extensions.cs23
-rw-r--r--Emulator/GlobalUsings.cs12
-rw-r--r--Emulator/Icon.bmpbin0 -> 262282 bytes
-rw-r--r--Emulator/Icon.icobin0 -> 147541 bytes
-rw-r--r--Emulator/Make.cs58
-rw-r--r--Emulator/Options.cs7
-rw-r--r--Emulator/Program.cs82
20 files changed, 1227 insertions, 0 deletions
diff --git a/Emulator/.DS_Store b/Emulator/.DS_Store
new file mode 100644
index 0000000..0bebabf
--- /dev/null
+++ b/Emulator/.DS_Store
Binary files differ
diff --git a/Emulator/Assembler/Disassembler.cs b/Emulator/Assembler/Disassembler.cs
new file mode 100644
index 0000000..d49d2eb
--- /dev/null
+++ b/Emulator/Assembler/Disassembler.cs
@@ -0,0 +1,74 @@
+namespace Q1.Emulator.Assembler;
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Chip;
+
+public class Disassembler
+{
+ public readonly StringWriter Writer;
+ public readonly BinaryReader Reader;
+
+ public Disassembler(StringWriter writer, BinaryReader reader)
+ {
+ this.Writer = writer;
+ this.Reader = reader;
+ }
+
+ private static Dictionary<u8, string> ModeLookup = new()
+ {
+ { 0x00, "" },
+ { 0x01, "c" },
+ { 0x02, "[a]" },
+ { 0x03, "@[a]" },
+ { 0x04, "pc + c" },
+ { 0x05, "r" },
+ { 0x06, "[r]" },
+ { 0x07, "[r + c]" },
+ };
+
+ public static string ParseInstruction(u16 instruction)
+ {
+ u8 op = (u8) ((instruction >> 8) & 0xFF); // 256 opcodes
+ u8 m1 = (u8) ((instruction >> 4) & 0x0F); // 16 modes
+ u8 m2 = (u8) (instruction & 0x0F); // 16 modes
+
+ u8 i = (m1, m2) switch
+ {
+ (0x00, 0x00) => 0, // Implicit
+ (0x00, 0x01) => 2, // Extended implicit
+ (_, 0x00) => 1, // Simple addressing mode
+ _ => 3 // Extended addressing mode
+ };
+
+ string opcodeName = Disassembler.GetOpcodeName(op, i);
+
+ if (i == 0 || i == 2)
+ return opcodeName;
+
+ if (i == 1)
+ return $"{opcodeName} {Disassembler.GetModeName(m1)}";
+
+ if (i == 3)
+ return $"{opcodeName} {Disassembler.GetModeName(m1)}, {Disassembler.GetModeName(m2)}";
+
+ throw new InvalidOperationException($"Unknown instruction format for opcode {op:X2} with modes {m1:X2}, {m2:X2}");
+ }
+
+ private static string GetOpcodeName(u8 opcode, u8 i)
+ {
+ if (!Q1Cpu.InstructionLookupStrings.TryGetValue(opcode, out string[]? opNames))
+ return $"[{opcode:X2}]"; // Fallback for unknown opcodes
+
+ return opNames[i];
+ }
+
+ private static string GetModeName(u8 mode)
+ {
+ if (Disassembler.ModeLookup.TryGetValue(mode, out string? modeName))
+ return modeName;
+
+ return $"[{mode:X2}]"; // Fallback for unknown modes
+ }
+} \ No newline at end of file
diff --git a/Emulator/Chip/Bus.cs b/Emulator/Chip/Bus.cs
new file mode 100644
index 0000000..0907f61
--- /dev/null
+++ b/Emulator/Chip/Bus.cs
@@ -0,0 +1,37 @@
+namespace Q1.Emulator.Chip;
+
+using System.Collections.Generic;
+using System.Linq;
+
+public class Bus : BusDevice
+{
+ public List<BusDevice> Devices;
+
+ public Bus(u16 addressableStart, u16 addressableEnd) : base(addressableStart, addressableEnd)
+ {
+ this.Devices = [];
+ }
+ private BusDevice? GetDevice(u16 address)
+ {
+ BusDevice? device = this.Devices.FirstOrDefault(x => address >= x.AddressableStart && address < x.AddressableEnd);
+ return device;
+ }
+
+ public override u8 Read(u16 address)
+ {
+ BusDevice? device = this.GetDevice(address);
+ if (device == null)
+ return 0;
+
+ return device.Read(address);
+ }
+
+ public override void Write(u16 address, u8 value)
+ {
+ BusDevice? device = this.GetDevice(address);
+ if (device == null)
+ return;
+
+ device.Write(address, value);
+ }
+} \ No newline at end of file
diff --git a/Emulator/Chip/BusDevice.cs b/Emulator/Chip/BusDevice.cs
new file mode 100644
index 0000000..1e1e972
--- /dev/null
+++ b/Emulator/Chip/BusDevice.cs
@@ -0,0 +1,49 @@
+namespace Q1.Emulator.Chip;
+
+using System.Runtime.CompilerServices;
+
+public abstract class BusDevice
+{
+ public BusDevice(u16 addressableStart, u16 addressableEnd)
+ {
+ this.AddressableStart = addressableStart;
+ this.AddressableEnd = addressableEnd;
+ }
+
+ public Bus Bus { get; set; }
+ public abstract u8 Read(u16 address);
+ public abstract void Write(u16 address, u8 value);
+
+ public u16 ReadWord(u16 address)
+ {
+ u8 high = this.Read(address);
+ u8 low = this.Read((u16) (address + 1));
+ u16 value = Make.u16(high, low);
+ return value;
+ }
+
+ public void WriteWord(u16 address, u16 value)
+ {
+ ref8 data = Make.ref8(value);
+ this.Write(address, data[0]);
+ this.Write((u16) (address + 1), data[1]);
+ }
+
+ public virtual void Clock() { }
+ public virtual void Reset() { }
+
+ public void AttachToBus(Bus bus)
+ {
+ this.Bus = bus;
+ bus.Devices.Add(this);
+ }
+
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ protected u16 GetRelativeAddress(u16 address)
+ {
+ return (u16) (address - this.AddressableStart);
+ }
+
+ public u16 AddressableStart { get; }
+ public u16 AddressableEnd { get; }
+} \ No newline at end of file
diff --git a/Emulator/Chip/DebugDevice.cs b/Emulator/Chip/DebugDevice.cs
new file mode 100644
index 0000000..4e869bb
--- /dev/null
+++ b/Emulator/Chip/DebugDevice.cs
@@ -0,0 +1,13 @@
+namespace Q1.Emulator.Chip;
+
+using System;
+
+public class DebugDevice(u16 addressPoint)
+ : BusDevice(addressPoint, (u16) (addressPoint + 2))
+{
+ public override u8 Read(u16 address) => throw new Exception("DebugDevice.Read not permitted");
+ public override void Write(u16 address, u8 value)
+ {
+ Console.WriteLine($"DebugDevice.Write: x{value:X4} b{value:b8}");
+ }
+} \ No newline at end of file
diff --git a/Emulator/Chip/DisplayDevice.cs b/Emulator/Chip/DisplayDevice.cs
new file mode 100644
index 0000000..a18dbd4
--- /dev/null
+++ b/Emulator/Chip/DisplayDevice.cs
@@ -0,0 +1,76 @@
+namespace Q1.Emulator.Chip;
+
+using System;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+
+public class DisplayDevice : RamDevice
+{
+ public Texture2D? OutputTexture;
+ private readonly u16 _paletteSize;
+ private readonly u16 _displayWidth;
+ private readonly u16 _displayHeight;
+ private Color[] textureData;
+
+ public DisplayDevice(u16 paletteSize, u16 displayWidth, u16 displayHeight, u16 addressableStart)
+ : base(addressableStart, DisplayDevice.DetermineSize(paletteSize, displayWidth, displayHeight))
+ {
+ this._paletteSize = paletteSize;
+ this._displayWidth = displayWidth;
+ this._displayHeight = displayHeight;
+ this.textureData = new Color[this._displayWidth * this._displayHeight];
+ }
+
+ private static u16 DetermineSize(u16 paletteSize, u16 displayWidth, u16 displayHeight)
+ {
+ return (u16) ((paletteSize * 3) + (displayWidth * displayHeight));
+ }
+
+ public override void Clock()
+ {
+ Color[] palette = this.ReadPalette();
+ ref8 pixelData = this.Memory.AsSpan((u16) (this._paletteSize * 3), (u16) (this._displayWidth * this._displayHeight));
+ // Console.WriteLine($"DisplayDevice.Clock: @{(this.AddressableStart + this._paletteSize * 3):X4} palette size={this._paletteSize} display size={this._displayWidth}x{this._displayHeight}");
+ for (u16 i = 0; i < this.textureData.Length; i++)
+ {
+ u8 pixelValue = pixelData[i];
+ this.textureData[i] = palette[pixelValue % this._paletteSize];
+ }
+
+ if (this.OutputTexture != null)
+ this.OutputTexture.SetData(this.textureData);
+ }
+
+ private Color[] ReadPalette()
+ {
+ ref8 paletteData = this.Memory.AsSpan(0, (u16) (this._paletteSize * 3));
+ Color[] colors = new Color[this._paletteSize + 1];
+ colors[0] = Color.Transparent;
+
+ for (u16 i = 0; i < this._paletteSize; i++)
+ {
+ u16 offset = (u16) (i * 3);
+ byte r = paletteData[offset];
+ byte g = paletteData[offset + 1];
+ byte b = paletteData[offset + 2];
+ colors[(u16) (i + 1)] = new Color(r, g, b);
+ }
+
+ return colors;
+ }
+
+ public void SetPalette(Color[] palette)
+ {
+ if (palette.Length != this._paletteSize)
+ throw new ArgumentException($"Palette must have {this._paletteSize} colors.");
+
+ ref8 paletteData = this.Memory.AsSpan(0, (u16) (this._paletteSize * 3));
+ for (u16 i = 0; i < this._paletteSize; i++)
+ {
+ u16 offset = (u16) (i * 3);
+ paletteData[offset] = palette[i].R;
+ paletteData[offset + 1] = palette[i].G;
+ paletteData[offset + 2] = palette[i].B;
+ }
+ }
+} \ No newline at end of file
diff --git a/Emulator/Chip/Q1Cpu.cs b/Emulator/Chip/Q1Cpu.cs
new file mode 100644
index 0000000..16e1e14
--- /dev/null
+++ b/Emulator/Chip/Q1Cpu.cs
@@ -0,0 +1,171 @@
+namespace Q1.Emulator.Chip;
+
+using System;
+using Assembler;
+
+public partial class Q1Cpu
+{
+ public const u16 StackStart = 0x2FFF;
+ public const u16 StackLength = 16 * 2; // 16 16-bit values
+
+ public Random Random;
+
+ public u16 AX = 0; // Accumulator register
+ public u16 DX = 0; // Data register
+ public u16 LX = 0; // Logical register
+
+ public u16 SP { get; set; } // Stack pointer
+ public u16 PC { get; set; } // Program counter
+
+ public u16[] V { get; set; } // Variable registers (64 total)
+ public u16 I { get; set; } // Index register
+ public u16 Cycles { get; set; } // Number of cycles
+
+ public Bus Bus { get; set; }
+ public bool AbortRequested = false;
+
+ public Q1Cpu()
+ {
+ this.LoadInstructionLookup();
+ }
+
+ public void Reset()
+ {
+ this.AbortRequested = false;
+
+ this.V = new u16[16];
+
+ this.SP = Q1Cpu.StackStart;
+ this.PushStack(0xFFFF);
+
+ this.I = 0;
+ }
+
+ public void Clock()
+ {
+ var pc = this.PC;
+ if (pc == 0xFFFF)
+ {
+ this.AbortRequested = true;
+ return;
+ }
+
+ u16 instruction = this.FetchInstruction(out u8 op, out u8 m1, out u8 m2, out _);
+ if (instruction != 0x0101)
+ Console.WriteLine($"CPU.Clock: {pc:X4} | {Disassembler.ParseInstruction(instruction)}");
+
+ bool ex = m2 > 0;
+ switch (m1, ex)
+ {
+ case (0x00, false):
+ this.InstructionLookup[op].Item1(); // Implicit
+ break;
+ case (> 0x00, false):
+ this.InstructionLookup[op].Item2(m1); // Simple addressing mode
+ break;
+ case (0x00, true):
+ this.InstructionLookup[op].Item3(); // Extended implicit
+ break;
+ case (> 0x00, true):
+ this.InstructionLookup[op].Item4(m1, m2); // Extended addressing mode
+ break;
+ }
+
+ this.Cycles++;
+ }
+ public u16 FetchInstruction(out u8 op, out u8 m1, out u8 m2, out u8 length)
+ {
+ u16 instruction = this.Bus.ReadWord(this.PC);
+ this.PC += 2;
+
+ op = (u8) ((instruction >> 8) & 0xFF); // 256 opcodes
+ m1 = (u8) ((instruction >> 4) & 0x0F); // 16 modes
+ m2 = (u8) (instruction & 0x0F); // 16 modes
+
+ length = (u8) (this.AddressingModeLength(m1) + this.AddressingModeLength(m2));
+ return instruction;
+ }
+
+ private void PushStack(u16 value)
+ {
+ if (this.SP + 2 >= Q1Cpu.StackStart + Q1Cpu.StackLength)
+ throw new InvalidOperationException("Stack overflow");
+
+ this.Bus.WriteWord(this.SP, value);
+ this.SP += 2;
+ }
+
+ private u16 PopStack()
+ {
+ if (this.SP - 2 < Q1Cpu.StackStart)
+ throw new InvalidOperationException("Stack underflow");
+
+ this.SP -= 2;
+ return this.Bus.ReadWord(this.SP);
+ }
+
+ private u16 FetchRegister(u8 regIndex)
+ {
+ return regIndex switch
+ {
+ <= 0x3F => this.V[regIndex],
+
+ 0x40 => this.AX,
+ 0x41 => (u16) (this.AX >> 8), // High byte of AX
+ 0x42 => (u16) (this.AX & 0xFF), // Low byte of AX
+
+ 0x43 => this.DX,
+ 0x44 => (u16) (this.DX >> 8), // High byte of DX
+ 0x45 => (u16) (this.DX & 0xFF), // Low byte of DX
+
+ 0x46 => this.LX,
+ 0x50 => this.PC,
+ 0x51 => this.SP,
+
+ _ => throw new InvalidOperationException($"Unknown register index: {regIndex:X2}"),
+ };
+ }
+
+ private void StoreRegister(u8 regIndex, u16 value)
+ {
+ switch (regIndex)
+ {
+ case <= 0x3F:
+ this.V[regIndex] = value;
+ break;
+
+ case 0x40:
+ this.AX = value;
+ break;
+ case 0x41:
+ this.AX = (u16) ((this.AX & 0x00FF) | (value << 8));
+ break; // Set high byte
+ case 0x42:
+ this.AX = (u16) ((this.AX & 0xFF00) | (value & 0x00FF));
+ break; // Set low byte
+
+ case 0x43:
+ this.DX = value;
+ break;
+ case 0x44:
+ this.DX = (u16) ((this.DX & 0x00FF) | (value << 8));
+ break; // Set high byte
+ case 0x45:
+ this.DX = (u16) ((this.DX & 0xFF00) | (value & 0x00FF));
+ break; // Set low byte
+
+ case 0x46:
+ this.LX = value;
+ break;
+ case 0x50:
+ this.PC = value;
+ break;
+ case 0x51:
+ this.SP = value;
+ break;
+
+ default:
+ throw new InvalidOperationException($"Unknown register index: {regIndex:X2}");
+ }
+ }
+} \ No newline at end of file
diff --git a/Emulator/Chip/Q1CpuAddressingModes.cs b/Emulator/Chip/Q1CpuAddressingModes.cs
new file mode 100644
index 0000000..40020f1
--- /dev/null
+++ b/Emulator/Chip/Q1CpuAddressingModes.cs
@@ -0,0 +1,187 @@
+namespace Q1.Emulator.Chip;
+
+using System;
+
+public partial class Q1Cpu
+{
+ public (Func<u16> read, Action<u16> write, Action<u8> writeByte) Address(u8 mode)
+ {
+ return mode switch
+ {
+ 0x0 => this.AddressingMode_Implicit(),
+ 0x1 => this.AddressingMode_Immediate(),
+ 0x2 => this.AddressingMode_Direct(),
+ 0x3 => this.AddressingMode_Indirect(),
+ 0x4 => this.AddressingMode_Relative(),
+ 0x5 => this.AddressingMode_Register(),
+ 0x6 => this.AddressingMode_RegisterIndirect(),
+ 0x7 => this.AddressingMode_RegisterIndirectOffset(),
+ _ => throw new InvalidOperationException($"Unknown addressing mode: {mode:X2}"),
+ };
+ }
+
+ private u8 AddressingModeLength(u8 mode)
+ {
+ return mode switch
+ {
+ 0x0 => 0, // Implicit
+ 0x1 => 2, // Immediate
+ 0x2 => 2, // Direct
+ 0x3 => 2, // Indirect
+ 0x4 => 2, // Relative
+ 0x5 => 1, // Register
+ 0x6 => 1, // Register indirect
+ 0x7 => 3, // Register indirect with offset
+ _ => throw new InvalidOperationException($"Unknown addressing mode: {mode:X2}"),
+ };
+ }
+
+ public (Func<u16> read, Action<u16> write, Action<u8> writeByte) AddressingMode_Implicit()
+ {
+ u16 Read() => throw new InvalidOperationException("Cannot read from implicit mode.");
+ void Write(u16 value) => throw new InvalidOperationException("Cannot write to implicit mode.");
+ void WriteByte(u8 value) => throw new InvalidOperationException("Cannot write byte to implicit mode.");
+
+ return (Read, Write, WriteByte);
+ }
+
+
+ public (Func<u16> read, Action<u16> write, Action<u8> writeByte) AddressingMode_Immediate()
+ {
+ u16 value = this.Bus.ReadWord(this.PC);
+ this.PC += 2;
+
+ u16 Read() => value;
+ void Write(u16 v) => throw new InvalidOperationException("Cannot write to immediate mode.");
+ void WriteByte(u8 v) => throw new InvalidOperationException("Cannot write byte to immediate mode.");
+
+ return (Read, Write, WriteByte);
+ }
+
+ public (Func<u16> read, Action<u16> write, Action<u8> writeByte) AddressingMode_Direct()
+ {
+ u16 address = this.Bus.ReadWord(this.PC);
+ this.PC += 2;
+
+ u16 Read() => this.Bus.ReadWord(address);
+ void Write(u16 value) => this.Bus.WriteWord(address, value);
+ void WriteByte(u8 value) => this.Bus.Write(address, value);
+
+ return (Read, Write, WriteByte);
+ }
+
+ public (Func<u16> read, Action<u16> write, Action<u8> writeByte) AddressingMode_Indirect()
+ {
+ u16 address = this.Bus.ReadWord(this.PC);
+ this.PC += 2;
+
+ u16 Read()
+ {
+ u16 indirectAddress = this.Bus.ReadWord(address);
+ u16 value = this.Bus.ReadWord(indirectAddress);
+ return value;
+ }
+
+ void Write(u16 value)
+ {
+ u16 indirectAddress = this.Bus.ReadWord(address);
+ this.Bus.WriteWord(indirectAddress, value);
+ }
+
+ void WriteByte(u8 value)
+ {
+ u16 indirectAddress = this.Bus.ReadWord(address);
+ this.Bus.Write(indirectAddress, value);
+ }
+
+ return (Read, Write, WriteByte);
+ }
+
+ public (Func<u16> read, Action<u16> write, Action<u8> writeByte) AddressingMode_Relative()
+ {
+ u16 offset = this.Bus.ReadWord(this.PC);
+ this.PC += 2;
+
+ u16 address = (u16) (this.PC + offset);
+
+ u16 Read() => address;
+ void Write(u16 value) => throw new InvalidOperationException("Cannot write to relative mode.");
+ void WriteByte(u8 value) => throw new InvalidOperationException("Cannot write byte to relative mode.");
+
+ return (Read, Write, WriteByte);
+ }
+
+ public (Func<u16> read, Action<u16> write, Action<u8> writeByte) AddressingMode_Register()
+ {
+ u8 regIndex = this.Bus.Read(this.PC);
+ this.PC += 1;
+
+ u16 Read() => this.FetchRegister(regIndex);
+ void Write(u16 value) => this.StoreRegister(regIndex, value);
+ void WriteByte(u8 value)
+ {
+ u16 currentValue = this.FetchRegister(regIndex);
+ u16 newValue = (u16) ((currentValue & 0xFF00) | (value & 0x00FF)); // Update low byte
+ this.StoreRegister(regIndex, newValue);
+ }
+
+ return (Read, Write, WriteByte);
+ }
+
+ public (Func<u16> read, Action<u16> write, Action<u8> writeByte) AddressingMode_RegisterIndirect()
+ {
+ u8 regIndex = this.Bus.Read(this.PC);
+ this.PC += 1;
+
+ u16 Read()
+ {
+ u16 address = this.FetchRegister(regIndex);
+ u16 value = this.Bus.ReadWord(address);
+ return value;
+ }
+
+ void Write(u16 value)
+ {
+ u16 address = this.FetchRegister(regIndex);
+ this.Bus.WriteWord(address, value);
+ }
+
+ void WriteByte(u8 value)
+ {
+ u16 address = this.FetchRegister(regIndex);
+ this.Bus.Write(address, value);
+ }
+
+ return (Read, Write, WriteByte);
+ }
+
+ public (Func<u16> read, Action<u16> write, Action<u8> writeByte) AddressingMode_RegisterIndirectOffset()
+ {
+ u8 regIndex = this.Bus.Read(this.PC);
+ this.PC += 1;
+
+ u16 offset = this.Bus.ReadWord(this.PC);
+ this.PC += 2;
+
+ u16 Read()
+ {
+ u16 address = (u16) (this.FetchRegister(regIndex) + offset);
+ u16 value = this.Bus.ReadWord(address);
+ return value;
+ }
+
+ void Write(u16 value)
+ {
+ u16 address = (u16) (this.FetchRegister(regIndex) + offset);
+ this.Bus.WriteWord(address, value);
+ }
+
+ void WriteByte(u8 value)
+ {
+ u16 address = (u16) (this.FetchRegister(regIndex) + offset);
+ this.Bus.Write(address, value);
+ }
+
+ return (Read, Write, WriteByte);
+ }
+} \ No newline at end of file
diff --git a/Emulator/Chip/Q1CpuInstructions.cs b/Emulator/Chip/Q1CpuInstructions.cs
new file mode 100644
index 0000000..2da8969
--- /dev/null
+++ b/Emulator/Chip/Q1CpuInstructions.cs
@@ -0,0 +1,282 @@
+namespace Q1.Emulator.Chip;
+
+using System;
+using System.Collections.Generic;
+
+public partial class Q1Cpu
+{
+ public static Dictionary<u8, string[]> InstructionLookupStrings = new()
+ {
+ { 0x00, ["NOP", "JMP", "HALT", "MOV"] },
+ { 0x01, ["RET", "CALL", "SUS", "MOVB"] },
+ { 0x02, ["BZ", "BZ", "BR", "NOP"] },
+ { 0x03, ["NOP", "PUSH", "NOP", "NOP"] },
+ { 0x04, ["NOP", "POP", "NOP", "NOP"] },
+
+ { 0x10, ["INV", "INV", "NOP", "AND"] },
+ { 0x11, ["SHL", "SHL", "NOP", "OR"] },
+ { 0x12, ["SHR", "SHR", "NOP", "XOR"] },
+
+ { 0x20, ["NOT", "NOT", "NOP", "CMP"] },
+ { 0x21, ["NOP", "NOP", "NOP", "LT"] },
+ { 0x22, ["NOP", "NOP", "NOP", "GT"] },
+
+ { 0x30, ["INC_AX", "INC", "NOP", "ADD"] },
+ { 0x31, ["DEC_AX", "DEC", "NOP", "SUB"] },
+ { 0x32, ["NOP", "NOP", "NOP", "DIV"] },
+ { 0x33, ["NOP", "NOP", "NOP", "MUL"] },
+ { 0x34, ["NOP", "NOP", "NOP", "MOD"] },
+ };
+
+ public Dictionary<u8, (Action, Action<u8>, Action, Action<u8, u8>)> InstructionLookup;
+ private void LoadInstructionLookup()
+ {
+ this.InstructionLookup = new Dictionary<u8, (Action, Action<u8>, Action, Action<u8, u8>)>
+ {
+ { 0x00, (this.Instruction_NOP, this.Instruction_JMP, this.Instruction_HALT, this.Instruction_MOV) },
+ { 0x01, (this.Instruction_RET, this.Instruction_CALL, this.Instruction_SUS, this.Instruction_MOVB) },
+ { 0x02, (this.Instruction_BZ_LX, this.Instruction_BZ, this.Instruction_BR, this.Instruction_NOP) },
+ { 0x03, (this.Instruction_NOP, this.Instruction_PUSH, this.Instruction_NOP, this.Instruction_NOP) },
+ { 0x04, (this.Instruction_NOP, this.Instruction_POP, this.Instruction_NOP, this.Instruction_NOP) },
+
+ { 0x10, (this.Instruction_INV_DX, this.Instruction_INV, this.Instruction_NOP, this.Instruction_AND) },
+ { 0x11, (this.Instruction_SHL_DX, this.Instruction_SHL, this.Instruction_NOP, this.Instruction_OR) },
+ { 0x12, (this.Instruction_SHR_DX, this.Instruction_SHR, this.Instruction_NOP, this.Instruction_XOR) },
+
+ { 0x20, (this.Instruction_NOT_LX, this.Instruction_NOT, this.Instruction_NOP, this.Instruction_CMP) },
+ { 0x21, (this.Instruction_NOP, this.Instruction_NOP, this.Instruction_NOP, this.Instruction_LT) },
+ { 0x22, (this.Instruction_NOP, this.Instruction_NOP, this.Instruction_NOP, this.Instruction_GT) },
+
+ { 0x30, (this.Instruction_INC_AX, this.Instruction_INC, this.Instruction_NOP, this.Instruction_ADD) },
+ { 0x31, (this.Instruction_DEC_AX, this.Instruction_DEC, this.Instruction_NOP, this.Instruction_SUB) },
+ { 0x32, (this.Instruction_NOP, this.Instruction_NOP, this.Instruction_NOP, this.Instruction_DIV) },
+ { 0x33, (this.Instruction_NOP, this.Instruction_NOP, this.Instruction_NOP, this.Instruction_MUL) },
+ { 0x34, (this.Instruction_NOP, this.Instruction_NOP, this.Instruction_NOP, this.Instruction_MOD) },
+ };
+ }
+ private void Instruction_ADD(u8 m1, u8 m2)
+ {
+ u16 v1 = this.Address(m1).read();
+ u16 v2 = this.Address(m2).read();
+
+ u16 result = (u16) (v1 + v2);
+ this.AX = result;
+ }
+ private void Instruction_SUB(u8 m1, u8 m2)
+ {
+ u16 v1 = this.Address(m1).read();
+ u16 v2 = this.Address(m2).read();
+
+ u16 result = (u16) (v1 - v2);
+ this.AX = result;
+ }
+ private void Instruction_MUL(u8 m1, u8 m2)
+ {
+ u16 v1 = this.Address(m1).read();
+ u16 v2 = this.Address(m2).read();
+
+ u16 result = (u16) (v1 * v2);
+ this.AX = result;
+ }
+ private void Instruction_DIV(u8 m1, u8 m2)
+ {
+ u16 v1 = this.Address(m1).read();
+ u16 v2 = this.Address(m2).read();
+
+ if (v2 == 0)
+ throw new DivideByZeroException("Cannot perform division by zero.");
+ u16 result = (u16) (v1 / v2);
+ this.AX = result;
+ }
+ private void Instruction_MOD(u8 m1, u8 m2)
+ {
+ u16 v1 = this.Address(m1).read();
+ u16 v2 = this.Address(m2).read();
+
+ if (v2 == 0)
+ throw new DivideByZeroException("Cannot perform modulo operation with divisor zero.");
+ u16 result = (u16) (v1 % v2);
+ this.AX = result;
+ }
+ private void Instruction_INC(u8 obj)
+ {
+ var address = this.Address(obj);
+ u16 value = address.read();
+ address.write((u16) (value + 1));
+ }
+ private void Instruction_DEC(u8 obj)
+ {
+ var address = this.Address(obj);
+ u16 value = address.read();
+ address.write((u16) (value - 1));
+ }
+ private void Instruction_INC_AX()
+ {
+ this.AX = (u16) (this.AX + 1);
+ }
+ private void Instruction_DEC_AX()
+ {
+ this.AX = (u16) (this.AX - 1);
+ }
+ private void Instruction_SHL(u8 obj)
+ {
+ var address = this.Address(obj);
+ u16 value = address.read();
+ u16 result = (u16) (value << 1);
+ address.write(result);
+ }
+ private void Instruction_SHR(u8 obj)
+ {
+ var address = this.Address(obj);
+ u16 value = address.read();
+ u16 result = (u16) (value >> 1);
+ address.write(result);
+ }
+ private void Instruction_SHL_DX()
+ {
+ this.DX = (u16) (this.DX << 1);
+ }
+ private void Instruction_SHR_DX()
+ {
+ this.DX = (u16) (this.DX >> 1);
+ }
+ private void Instruction_XOR(u8 m1, u8 m2)
+ {
+ u16 v1 = this.Address(m1).read();
+ u16 v2 = this.Address(m2).read();
+
+ u16 result = (u16) (v1 ^ v2);
+ this.DX = result;
+ }
+ private void Instruction_OR(u8 m1, u8 m2)
+ {
+ u16 v1 = this.Address(m1).read();
+ u16 v2 = this.Address(m2).read();
+
+ u16 result = (u16) (v1 | v2);
+ this.DX = result;
+ }
+ private void Instruction_INV(u8 obj)
+ {
+ var address = this.Address(obj);
+ u16 value = address.read();
+ u16 result = (u16) ~value;
+ this.DX = result;
+ }
+ private void Instruction_INV_DX()
+ {
+ this.DX = (u16) ~this.DX;
+ }
+ private void Instruction_AND(u8 m1, u8 m2)
+ {
+ u16 v1 = this.Address(m1).read();
+ u16 v2 = this.Address(m2).read();
+
+ u16 result = (u16) (v1 & v2);
+ this.DX = result;
+ }
+ private void Instruction_NOT(u8 obj)
+ {
+ u16 value = this.Address(obj).read();
+ u16 result = value == 0 ? (u16) 1 : (u16) 0;
+ this.LX = result;
+ }
+ private void Instruction_NOT_LX()
+ {
+ this.LX = this.LX == 0 ? (u16) 1 : (u16) 0;
+ }
+ private void Instruction_GT(u8 m1, u8 m2)
+ {
+ u16 v1 = this.Address(m1).read();
+ u16 v2 = this.Address(m2).read();
+
+ this.LX = (u16) (v1 > v2 ? 1 : 0);
+ }
+ private void Instruction_LT(u8 m1, u8 m2)
+ {
+ u16 v1 = this.Address(m1).read();
+ u16 v2 = this.Address(m2).read();
+
+ this.LX = (u16) (v1 < v2 ? 1 : 0);
+ }
+
+ private void Instruction_BR()
+ {
+ this.FetchInstruction(out _, out _, out _, out u8 length);
+ this.PC += length;
+ }
+ private void Instruction_BZ_LX()
+ {
+ if (this.LX == 0)
+ this.Instruction_BR();
+ }
+ private void Instruction_BZ(u8 obj)
+ {
+ u16 value = this.Address(obj).read();
+ if (value == 0)
+ this.Instruction_BR();
+ }
+ private void Instruction_CMP(u8 m1, u8 m2)
+ {
+ u16 v1 = this.Address(m1).read();
+ u16 v2 = this.Address(m2).read();
+
+ // Set LX based on comparison
+ this.LX = (u16) (v1 == v2 ? 1 : 0);
+ }
+ private void Instruction_MOV(u8 m1, u8 m2)
+ {
+ u16 value = this.Address(m1).read();
+ this.Address(m2).write(value);
+ }
+
+ private void Instruction_MOVB(u8 m1, u8 m2)
+ {
+ u16 value = this.Address(m1).read();
+ u8 low = Make.ref8(value)[1];
+ this.Address(m2).writeByte(low);
+ }
+
+ public void Instruction_NOP() { }
+ public void Instruction_NOP(u8 m1) { }
+ public void Instruction_NOP(u8 m1, u8 m2) { }
+
+ public void Instruction_JMP(u8 m1)
+ {
+ this.PC = this.Address(m1).read();
+ }
+
+ public void Instruction_RET()
+ {
+ this.PC = this.PopStack();
+ }
+
+ public void Instruction_CALL(u8 m1)
+ {
+ u16 address = this.Address(m1).read();
+ this.PushStack(this.PC);
+ this.PC = address;
+ }
+
+ public void Instruction_HALT()
+ {
+ this.AbortRequested = true;
+ }
+
+ public void Instruction_SUS()
+ {
+ this.PC -= 2;
+ }
+
+ public void Instruction_PUSH(u8 m1)
+ {
+ u16 value = this.Address(m1).read();
+ this.PushStack(value);
+ }
+
+ public void Instruction_POP(u8 m1)
+ {
+ u16 value = this.PopStack();
+ this.Address(m1).write(value);
+ }
+} \ No newline at end of file
diff --git a/Emulator/Chip/RamDevice.cs b/Emulator/Chip/RamDevice.cs
new file mode 100644
index 0000000..8d5b051
--- /dev/null
+++ b/Emulator/Chip/RamDevice.cs
@@ -0,0 +1,33 @@
+namespace Q1.Emulator.Chip;
+
+public class RamDevice : BusDevice
+{
+ public u8[] Memory;
+
+ public RamDevice(u16 start, u16 size) : base(start, (u16) (start + size))
+ {
+ this.Memory = new u8[size];
+ }
+
+ public override void Reset()
+ {
+ this.Memory = new u8[this.AddressableEnd - this.AddressableStart];
+ }
+
+ public override void Clock()
+ {
+ // No clocking needed for RAM
+ }
+
+ public override u8 Read(u16 address)
+ {
+ u16 relativeAddress = this.GetRelativeAddress(address);
+ return this.Memory[relativeAddress];
+ }
+
+ public override void Write(u16 address, u8 value)
+ {
+ u16 relativeAddress = this.GetRelativeAddress(address);
+ this.Memory[relativeAddress] = value;
+ }
+} \ No newline at end of file
diff --git a/Emulator/Content/Content.mgcb b/Emulator/Content/Content.mgcb
new file mode 100644
index 0000000..ddc4c36
--- /dev/null
+++ b/Emulator/Content/Content.mgcb
@@ -0,0 +1,15 @@
+
+#----------------------------- Global Properties ----------------------------#
+
+/outputDir:bin/$(Platform)
+/intermediateDir:obj/$(Platform)
+/platform:DesktopGL
+/config:
+/profile:Reach
+/compress:False
+
+#-------------------------------- References --------------------------------#
+
+
+#---------------------------------- Content ---------------------------------#
+
diff --git a/Emulator/DisplayEngine.cs b/Emulator/DisplayEngine.cs
new file mode 100644
index 0000000..beb2bba
--- /dev/null
+++ b/Emulator/DisplayEngine.cs
@@ -0,0 +1,76 @@
+namespace Q1.Emulator;
+
+using System;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using Microsoft.Xna.Framework.Input;
+
+public class DisplayEngine : Game
+{
+ private readonly Action<Texture2D> _onScreenTextureLoaded;
+ private readonly Action _requestUpdate;
+ private readonly Func<bool> _checkAbort;
+ private GraphicsDeviceManager _graphics;
+ private SpriteBatch _spriteBatch;
+
+ private Texture2D _texture;
+ public int Scaling { get; }
+ public int Width { get; }
+ public int Height { get; }
+
+ public DisplayEngine(int width, int height, int scaling, Action<Texture2D> onScreenTextureLoaded, Action requestUpdate, Func<bool> checkAbort)
+ {
+ this.Width = width;
+ this.Height = height;
+ this.Scaling = scaling;
+ this._onScreenTextureLoaded = onScreenTextureLoaded;
+ this._requestUpdate = requestUpdate;
+ this._checkAbort = checkAbort;
+
+ this._graphics = new GraphicsDeviceManager(this);
+ this.Content.RootDirectory = "Content";
+ this.IsMouseVisible = true;
+ }
+
+ protected override void Initialize()
+ {
+ this._texture = new Texture2D(this.GraphicsDevice, this.Width, this.Height);
+ this._onScreenTextureLoaded?.Invoke(this._texture);
+ // set window size
+ this._graphics.PreferredBackBufferWidth = this.Width * this.Scaling;
+ this._graphics.PreferredBackBufferHeight = this.Height * this.Scaling;
+ this._graphics.ApplyChanges();
+
+ base.Initialize();
+ }
+
+ protected override void LoadContent()
+ {
+ this._spriteBatch = new SpriteBatch(this.GraphicsDevice);
+ }
+
+ protected override void Update(GameTime gameTime)
+ {
+ var state = Keyboard.GetState();
+
+ if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || state.IsKeyDown(Keys.Escape) || this._checkAbort())
+ this.Exit();
+
+ base.Update(gameTime);
+ }
+
+ protected override void Draw(GameTime gameTime)
+ {
+ // GraphicsDevice.Clear(Color.CornflowerBlue);
+
+ this._requestUpdate();
+
+ this._spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.NonPremultiplied, SamplerState.PointClamp, DepthStencilState.None, RasterizerState.CullNone);
+ // Draw the texture to the screen
+ this._spriteBatch.Draw(this._texture, new Rectangle(0, 0, this.Width * this.Scaling, this.Height * this.Scaling), Color.White);
+
+ this._spriteBatch.End();
+
+ base.Draw(gameTime);
+ }
+} \ No newline at end of file
diff --git a/Emulator/Emulator.csproj b/Emulator/Emulator.csproj
new file mode 100644
index 0000000..8cb327c
--- /dev/null
+++ b/Emulator/Emulator.csproj
@@ -0,0 +1,32 @@
+<Project Sdk="Microsoft.NET.Sdk">
+ <PropertyGroup>
+ <OutputType>WinExe</OutputType>
+ <TargetFramework>net8.0</TargetFramework>
+ <RollForward>Major</RollForward>
+ <PublishReadyToRun>false</PublishReadyToRun>
+ <TieredCompilation>false</TieredCompilation>
+ <RootNamespace>Q1.Emulator</RootNamespace>
+ <Nullable>enable</Nullable>
+ </PropertyGroup>
+ <ItemGroup>
+ <None Remove="Icon.ico"/>
+ <None Remove="Icon.bmp"/>
+ </ItemGroup>
+ <ItemGroup>
+ <EmbeddedResource Include="Icon.ico">
+ <LogicalName>Icon.ico</LogicalName>
+ </EmbeddedResource>
+ <EmbeddedResource Include="Icon.bmp">
+ <LogicalName>Icon.bmp</LogicalName>
+ </EmbeddedResource>
+ </ItemGroup>
+ <ItemGroup>
+ <PackageReference Include="CommandLineParser" Version="2.9.1" />
+ <PackageReference Include="MonoGame.Framework.DesktopGL" Version="3.8.2.1105"/>
+ <PackageReference Include="MonoGame.Content.Builder.Task" Version="3.8.2.1105"/>
+ </ItemGroup>
+ <Target Name="RestoreDotnetTools" BeforeTargets="Restore">
+ <Message Text="Restoring dotnet tools" Importance="High"/>
+ <Exec Command="dotnet tool restore"/>
+ </Target>
+</Project> \ No newline at end of file
diff --git a/Emulator/Extensions.cs b/Emulator/Extensions.cs
new file mode 100644
index 0000000..3cc980d
--- /dev/null
+++ b/Emulator/Extensions.cs
@@ -0,0 +1,23 @@
+namespace Q1.Emulator;
+
+using System.Collections.Generic;
+
+public static class Extensions
+{
+ public static IEnumerable<int> AllIndexesOf<T>(this IEnumerable<T> arr, T q)
+ {
+ var indexes = new List<int>();
+ int index = 0;
+
+ foreach (var item in arr)
+ {
+ if (EqualityComparer<T>.Default.Equals(item, q))
+ {
+ indexes.Add(index);
+ }
+ index++;
+ }
+
+ return indexes;
+ }
+} \ No newline at end of file
diff --git a/Emulator/GlobalUsings.cs b/Emulator/GlobalUsings.cs
new file mode 100644
index 0000000..ff38a75
--- /dev/null
+++ b/Emulator/GlobalUsings.cs
@@ -0,0 +1,12 @@
+// Integer type aliases
+global using i8 = sbyte; // -128 to 127
+global using u8 = byte; // 0 to 255
+global using i16 = short; // -32,768 to 32,767
+global using u16 = ushort; // 0 to 65,535
+global using i32 = int; // -2,147,483,648 to 2,147,483,647
+global using u32 = uint; // 0 to 4,294,967,295
+global using i64 = long; // -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
+global using u64 = ulong; // 0 to 18,446,744,073,709,551,615
+
+global using ref8 = System.Span<byte>;
+global using data8 = byte[];
diff --git a/Emulator/Icon.bmp b/Emulator/Icon.bmp
new file mode 100644
index 0000000..2b48165
--- /dev/null
+++ b/Emulator/Icon.bmp
Binary files differ
diff --git a/Emulator/Icon.ico b/Emulator/Icon.ico
new file mode 100644
index 0000000..7d9dec1
--- /dev/null
+++ b/Emulator/Icon.ico
Binary files differ
diff --git a/Emulator/Make.cs b/Emulator/Make.cs
new file mode 100644
index 0000000..aad9644
--- /dev/null
+++ b/Emulator/Make.cs
@@ -0,0 +1,58 @@
+namespace Q1.Emulator;
+
+using System;
+using System.Buffers.Binary;
+
+public static class Make
+{
+ public static u16 u16(u8 high, u8 low)
+ {
+ return (u16) ((high << 8) | low);
+ }
+
+ public static u16 u16(ref8 data)
+ {
+ if (data.Length < 2)
+ throw new ArgumentException("Data must contain at least 2 bytes to form a u16.");
+
+ return Make.u16(data[0], data[1]);
+ }
+
+ public static u32 u32(u8 b1, u8 b2, u8 b3, u8 b4)
+ {
+ return (u32) ((b1 << 24) | (b2 << 16) | (b3 << 8) | b4);
+ }
+
+ public static u32 u32(ref8 data)
+ {
+ if (data.Length < 4)
+ throw new ArgumentException("Data must contain at least 4 bytes to form a u32.");
+
+ return Make.u32(data[0], data[1], data[2], data[3]);
+ }
+
+ public static ref8 ref8(u16 value)
+ {
+ u8 high = (u8) (value >> 8);
+ u8 low = (u8) (value & 0xFF);
+ return new ref8([high, low], 0, 2);
+ }
+
+ public static ref8 ref8(u32 value)
+ {
+ u8 b1 = (u8) (value >> 24);
+ u8 b2 = (u8) (value >> 16);
+ u8 b3 = (u8) (value >> 8);
+ u8 b4 = (u8) (value & 0xFF);
+ return new ref8([b1, b2, b3, b4], 0, 4);
+ }
+ public static i16 i16(ref8 value)
+ {
+ return BinaryPrimitives.ReadInt16BigEndian(value);
+ }
+
+ public static i16 i16(u8 high, u8 low)
+ {
+ return BinaryPrimitives.ReadInt16BigEndian(new ReadOnlySpan<u8>([high, low]));
+ }
+} \ No newline at end of file
diff --git a/Emulator/Options.cs b/Emulator/Options.cs
new file mode 100644
index 0000000..a42b560
--- /dev/null
+++ b/Emulator/Options.cs
@@ -0,0 +1,7 @@
+namespace Q1.Emulator;
+
+public class Options
+{
+ [CommandLine.Option('i', "input", Required = true, HelpText = "Input file to run.")]
+ public string InputFile { get; set; }
+} \ No newline at end of file
diff --git a/Emulator/Program.cs b/Emulator/Program.cs
new file mode 100644
index 0000000..cd6a8c0
--- /dev/null
+++ b/Emulator/Program.cs
@@ -0,0 +1,82 @@
+namespace Q1.Emulator;
+
+using System;
+using System.IO;
+using System.Threading;
+using Chip;
+using CommandLine;
+using Microsoft.Xna.Framework;
+
+internal class Program
+{
+ public static void Main(string[] args)
+ {
+ Parser.Default.ParseArguments<Options>(args).WithParsed(Program.Main);
+ }
+
+ static void Main(Options options)
+ {
+ Q1Cpu cpu = new();
+ Bus bus = new(u16.MinValue, u16.MaxValue);
+ RamDevice ram = new(0x1FFF, 1024 * 8);
+ File.ReadAllBytes(options.InputFile).CopyTo(ram.Memory, 0);
+
+ cpu.PC = ram.AddressableStart;
+
+ DisplayDevice display = new(16, 64, 32, 0x3FFF);
+ display.SetPalette([
+ Color.Red,
+ Color.Green,
+ Color.Blue,
+ Color.Yellow,
+ Color.Cyan,
+ Color.Magenta,
+ Color.White,
+ Color.Black,
+ Color.Gray,
+ Color.Orange,
+ Color.Purple,
+ Color.Brown,
+ Color.LightGray,
+ Color.DarkGray,
+ Color.LightBlue,
+ Color.LightGreen
+ ]);
+
+ DebugDevice debug = new(0xEFFF);
+
+ cpu.Bus = bus;
+ ram.AttachToBus(bus);
+ display.AttachToBus(bus);
+ debug.AttachToBus(bus);
+
+ Thread t = new(() =>
+ {
+ cpu.Reset();
+ while (!cpu.AbortRequested)
+ {
+ for (int i = 0; i < 64; i++)
+ cpu.Clock();
+
+ Thread.Sleep(1);
+ //
+ // cpu.Clock();
+ // Thread.Sleep(1000);
+ }
+ Console.WriteLine($"Exit code: 0x{cpu.V[0]:X4}");
+ });
+ t.IsBackground = true;
+ t.Start();
+
+ using DisplayEngine game = new(64, 32, 10,
+ tex =>
+ {
+ display.OutputTexture = tex;
+ Console.WriteLine("Display surface initialized.");
+ }, () => display.Clock(), () => cpu.AbortRequested);
+ game.Run();
+
+ Console.WriteLine("Display surface closed. Waiting for CPU thread to finish...");
+ t.Join();
+ }
+} \ No newline at end of file
generated by cgit v1.3.1 (git 2.54.0) at 2026-10-31 19:24:09 +0000