diff --git a/Cpu6809.cs b/Cpu6809.cs
new file mode 100644
index 0000000..bce1c66
--- /dev/null
+++ b/Cpu6809.cs
@@ -0,0 +1,918 @@
+using System.Runtime.CompilerServices;
+
+///
+/// Motorola 6809 CPU emulator for Micronona 256.
+/// Runs on its own background thread; started via Run(address).
+/// SWI halts gracefully when the SWI vector (0xFFFA) is 0x0000.
+///
+public class Cpu6809
+{
+ // -------------------------------------------------------------------------
+ // Registers
+ // -------------------------------------------------------------------------
+ public byte A, B, DP, CC;
+ public ushort X, Y, U, S, PC;
+
+ public ushort D
+ {
+ get => (ushort)((A << 8) | B);
+ set { A = (byte)(value >> 8); B = (byte)value; }
+ }
+
+ // Condition code bits
+ private const byte CC_C = 0x01;
+ private const byte CC_V = 0x02;
+ private const byte CC_Z = 0x04;
+ private const byte CC_N = 0x08;
+ private const byte CC_I = 0x10;
+ private const byte CC_H = 0x20;
+ private const byte CC_F = 0x40;
+ private const byte CC_E = 0x80;
+
+ // -------------------------------------------------------------------------
+ // Dependencies
+ // -------------------------------------------------------------------------
+ private readonly MemoryModel _mem;
+ private readonly ConsoleHelper _console;
+
+ // -------------------------------------------------------------------------
+ // Threading
+ // -------------------------------------------------------------------------
+ private Thread? _thread;
+ private CancellationTokenSource _cts = new();
+ private readonly ManualResetEventSlim _runSignal = new(false);
+ private volatile bool _running;
+
+ public bool IsRunning => _running;
+
+ public Cpu6809(MemoryModel mem, ConsoleHelper console)
+ {
+ _mem = mem;
+ _console = console;
+ S = 0xDF00; // default stack at top of fixed RAM
+ }
+
+ // -------------------------------------------------------------------------
+ // Thread management
+ // -------------------------------------------------------------------------
+ public void StartThread()
+ {
+ _thread = new Thread(RunLoop) { IsBackground = true, Name = "Cpu6809" };
+ _thread.Start();
+ }
+
+ public void StopThread()
+ {
+ _running = false;
+ _cts.Cancel();
+ try { _runSignal.Set(); } catch { }
+ _thread?.Join();
+ }
+
+ public void Run(ushort address)
+ {
+ PC = address;
+ _running = true;
+ _runSignal.Set();
+ }
+
+ public void Stop()
+ {
+ _running = false;
+ }
+
+ private void RunLoop()
+ {
+ try
+ {
+ while (true)
+ {
+ _runSignal.Wait(_cts.Token);
+ _runSignal.Reset();
+ while (_running && !_cts.IsCancellationRequested)
+ Step();
+ }
+ }
+ catch (OperationCanceledException) { }
+ }
+
+ // -------------------------------------------------------------------------
+ // Memory
+ // -------------------------------------------------------------------------
+ private byte Read(ushort addr) => _mem.Read(addr);
+ private void Write(ushort addr, byte val) => _mem.Write(addr, val);
+
+ private ushort ReadWord(ushort addr)
+ => (ushort)((Read(addr) << 8) | Read((ushort)(addr + 1)));
+
+ private void WriteWord(ushort addr, ushort val)
+ {
+ Write(addr, (byte)(val >> 8));
+ Write((ushort)(addr + 1), (byte)val);
+ }
+
+ private byte Fetch() => Read(PC++);
+
+ private ushort FetchWord() { ushort v = ReadWord(PC); PC += 2; return v; }
+
+ // -------------------------------------------------------------------------
+ // CC helpers
+ // -------------------------------------------------------------------------
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ private bool GetFlag(byte f) => (CC & f) != 0;
+
+ [MethodImpl(MethodImplOptions.AggressiveInlining)]
+ private void SetFlag(byte f, bool v) { if (v) CC |= f; else CC &= (byte)~f; }
+
+ private void SetNZ8(byte v) { SetFlag(CC_N, (v & 0x80) != 0); SetFlag(CC_Z, v == 0); }
+ private void SetNZ16(ushort v) { SetFlag(CC_N, (v & 0x8000) != 0); SetFlag(CC_Z, v == 0); }
+
+ // -------------------------------------------------------------------------
+ // Addressing modes
+ // -------------------------------------------------------------------------
+ private ushort DirectAddr() => (ushort)((DP << 8) | Fetch());
+ private ushort ExtendedAddr() => FetchWord();
+
+ private ushort IndexedAddr()
+ {
+ byte pb = Fetch();
+ int rn = (pb >> 5) & 0x03;
+
+ ushort GetR() => rn switch { 0 => X, 1 => Y, 2 => U, _ => S };
+ void SetR(ushort v) { switch (rn) { case 0: X=v; break; case 1: Y=v; break; case 2: U=v; break; default: S=v; break; } }
+
+ if ((pb & 0x80) == 0)
+ {
+ // 5-bit signed offset
+ int off = pb & 0x1F;
+ if ((off & 0x10) != 0) off |= ~0x1F;
+ return (ushort)(GetR() + off);
+ }
+
+ bool indirect = (pb & 0x10) != 0;
+ ushort ea;
+
+ switch (pb & 0x0F)
+ {
+ case 0x00: { ushort r = GetR(); SetR((ushort)(r + 1)); ea = r; break; }
+ case 0x01: { ushort r = GetR(); SetR((ushort)(r + 2)); ea = r; break; }
+ case 0x02: { ushort r = (ushort)(GetR() - 1); SetR(r); ea = r; break; }
+ case 0x03: { ushort r = (ushort)(GetR() - 2); SetR(r); ea = r; break; }
+ case 0x04: ea = GetR(); break;
+ case 0x05: ea = (ushort)(GetR() + (sbyte)B); break;
+ case 0x06: ea = (ushort)(GetR() + (sbyte)A); break;
+ case 0x08: ea = (ushort)(GetR() + (sbyte)Fetch()); break;
+ case 0x09: ea = (ushort)(GetR() + (short)FetchWord()); break;
+ case 0x0B: ea = (ushort)(GetR() + (short)D); break;
+ case 0x0C: { sbyte o = (sbyte)Fetch(); ea = (ushort)(PC + o); break; }
+ case 0x0D: { short o = (short)FetchWord(); ea = (ushort)(PC + o); break; }
+ case 0x0F: ea = FetchWord(); indirect = true; break;
+ default: ea = 0; break;
+ }
+
+ if (indirect) ea = ReadWord(ea);
+ return ea;
+ }
+
+ // -------------------------------------------------------------------------
+ // Main dispatch
+ // -------------------------------------------------------------------------
+ public void Step()
+ {
+ byte op = Fetch();
+ switch (op)
+ {
+ // NEG
+ case 0x00: { var a = DirectAddr(); Write(a, Neg8(Read(a))); break; }
+ case 0x60: { var a = IndexedAddr(); Write(a, Neg8(Read(a))); break; }
+ case 0x70: { var a = ExtendedAddr(); Write(a, Neg8(Read(a))); break; }
+ case 0x40: A = Neg8(A); break;
+ case 0x50: B = Neg8(B); break;
+
+ // COM
+ case 0x03: { var a = DirectAddr(); Write(a, Com8(Read(a))); break; }
+ case 0x63: { var a = IndexedAddr(); Write(a, Com8(Read(a))); break; }
+ case 0x73: { var a = ExtendedAddr(); Write(a, Com8(Read(a))); break; }
+ case 0x43: A = Com8(A); break;
+ case 0x53: B = Com8(B); break;
+
+ // LSR
+ case 0x04: { var a = DirectAddr(); Write(a, Lsr8(Read(a))); break; }
+ case 0x64: { var a = IndexedAddr(); Write(a, Lsr8(Read(a))); break; }
+ case 0x74: { var a = ExtendedAddr(); Write(a, Lsr8(Read(a))); break; }
+ case 0x44: A = Lsr8(A); break;
+ case 0x54: B = Lsr8(B); break;
+
+ // ROR
+ case 0x06: { var a = DirectAddr(); Write(a, Ror8(Read(a))); break; }
+ case 0x66: { var a = IndexedAddr(); Write(a, Ror8(Read(a))); break; }
+ case 0x76: { var a = ExtendedAddr(); Write(a, Ror8(Read(a))); break; }
+ case 0x46: A = Ror8(A); break;
+ case 0x56: B = Ror8(B); break;
+
+ // ASR
+ case 0x07: { var a = DirectAddr(); Write(a, Asr8(Read(a))); break; }
+ case 0x67: { var a = IndexedAddr(); Write(a, Asr8(Read(a))); break; }
+ case 0x77: { var a = ExtendedAddr(); Write(a, Asr8(Read(a))); break; }
+ case 0x47: A = Asr8(A); break;
+ case 0x57: B = Asr8(B); break;
+
+ // LSL / ASL
+ case 0x08: { var a = DirectAddr(); Write(a, Lsl8(Read(a))); break; }
+ case 0x68: { var a = IndexedAddr(); Write(a, Lsl8(Read(a))); break; }
+ case 0x78: { var a = ExtendedAddr(); Write(a, Lsl8(Read(a))); break; }
+ case 0x48: A = Lsl8(A); break;
+ case 0x58: B = Lsl8(B); break;
+
+ // ROL
+ case 0x09: { var a = DirectAddr(); Write(a, Rol8(Read(a))); break; }
+ case 0x69: { var a = IndexedAddr(); Write(a, Rol8(Read(a))); break; }
+ case 0x79: { var a = ExtendedAddr(); Write(a, Rol8(Read(a))); break; }
+ case 0x49: A = Rol8(A); break;
+ case 0x59: B = Rol8(B); break;
+
+ // DEC
+ case 0x0A: { var a = DirectAddr(); Write(a, Dec8(Read(a))); break; }
+ case 0x6A: { var a = IndexedAddr(); Write(a, Dec8(Read(a))); break; }
+ case 0x7A: { var a = ExtendedAddr(); Write(a, Dec8(Read(a))); break; }
+ case 0x4A: A = Dec8(A); break;
+ case 0x5A: B = Dec8(B); break;
+
+ // INC
+ case 0x0C: { var a = DirectAddr(); Write(a, Inc8(Read(a))); break; }
+ case 0x6C: { var a = IndexedAddr(); Write(a, Inc8(Read(a))); break; }
+ case 0x7C: { var a = ExtendedAddr(); Write(a, Inc8(Read(a))); break; }
+ case 0x4C: A = Inc8(A); break;
+ case 0x5C: B = Inc8(B); break;
+
+ // TST
+ case 0x0D: { Tst8(Read(DirectAddr())); break; }
+ case 0x6D: { Tst8(Read(IndexedAddr())); break; }
+ case 0x7D: { Tst8(Read(ExtendedAddr())); break; }
+ case 0x4D: Tst8(A); break;
+ case 0x5D: Tst8(B); break;
+
+ // JMP
+ case 0x0E: PC = DirectAddr(); break;
+ case 0x6E: PC = IndexedAddr(); break;
+ case 0x7E: PC = ExtendedAddr(); break;
+
+ // CLR
+ case 0x0F: { Write(DirectAddr(), 0); ClrFlags(); break; }
+ case 0x6F: { Write(IndexedAddr(), 0); ClrFlags(); break; }
+ case 0x7F: { Write(ExtendedAddr(), 0); ClrFlags(); break; }
+ case 0x4F: A = 0; ClrFlags(); break;
+ case 0x5F: B = 0; ClrFlags(); break;
+
+ case 0x10: StepPage2(); break;
+ case 0x11: StepPage3(); break;
+
+ case 0x12: break; // NOP
+ case 0x13: _running = false; break; // SYNC — simplified halt
+
+ // LBRA
+ case 0x16: { short o = (short)FetchWord(); PC = (ushort)(PC + o); break; }
+
+ // LBSR
+ case 0x17: { short o = (short)FetchWord(); PushWord(ref S, PC); PC = (ushort)(PC + o); break; }
+
+ case 0x19: Daa(); break; // DAA
+ case 0x1A: CC |= Fetch(); break; // ORCC
+ case 0x1C: CC &= Fetch(); break; // ANDCC
+
+ // SEX
+ case 0x1D: A = (byte)((B & 0x80) != 0 ? 0xFF : 0x00); SetNZ16(D); break;
+
+ case 0x1E: ExgTfr(Fetch(), exg: true); break; // EXG
+ case 0x1F: ExgTfr(Fetch(), exg: false); break; // TFR
+
+ // Short branches
+ case 0x20: Branch8(true); break;
+ case 0x21: Branch8(false); break;
+ case 0x22: Branch8(!GetFlag(CC_C) && !GetFlag(CC_Z)); break;
+ case 0x23: Branch8(GetFlag(CC_C) || GetFlag(CC_Z)); break;
+ case 0x24: Branch8(!GetFlag(CC_C)); break;
+ case 0x25: Branch8(GetFlag(CC_C)); break;
+ case 0x26: Branch8(!GetFlag(CC_Z)); break;
+ case 0x27: Branch8(GetFlag(CC_Z)); break;
+ case 0x28: Branch8(!GetFlag(CC_V)); break;
+ case 0x29: Branch8(GetFlag(CC_V)); break;
+ case 0x2A: Branch8(!GetFlag(CC_N)); break;
+ case 0x2B: Branch8(GetFlag(CC_N)); break;
+ case 0x2C: Branch8(GetFlag(CC_N) == GetFlag(CC_V)); break;
+ case 0x2D: Branch8(GetFlag(CC_N) != GetFlag(CC_V)); break;
+ case 0x2E: Branch8(!GetFlag(CC_Z) && (GetFlag(CC_N) == GetFlag(CC_V))); break;
+ case 0x2F: Branch8(GetFlag(CC_Z) || (GetFlag(CC_N) != GetFlag(CC_V))); break;
+
+ // LEA
+ case 0x30: { X = IndexedAddr(); SetFlag(CC_Z, X == 0); break; }
+ case 0x31: { Y = IndexedAddr(); SetFlag(CC_Z, Y == 0); break; }
+ case 0x32: S = IndexedAddr(); break;
+ case 0x33: U = IndexedAddr(); break;
+
+ case 0x34: PushRegs(ref S, Fetch(), useU: false); break; // PSHS
+ case 0x35: PullRegs(ref S, Fetch(), useU: false); break; // PULS
+ case 0x36: PushRegs(ref U, Fetch(), useU: true); break; // PSHU
+ case 0x37: PullRegs(ref U, Fetch(), useU: true); break; // PULU
+
+ case 0x39: PC = PullWord(ref S); break; // RTS
+ case 0x3A: X = (ushort)(X + B); break; // ABX
+ case 0x3B: Rti(); break; // RTI
+
+ // CWAI
+ case 0x3C: CC &= Fetch(); PushAllState(ref S); _running = false; break;
+
+ // MUL
+ case 0x3D:
+ {
+ ushort r = (ushort)(A * B);
+ D = r;
+ SetFlag(CC_Z, r == 0);
+ SetFlag(CC_C, (r & 0x80) != 0);
+ break;
+ }
+
+ case 0x3F: Swi(0xFFFA); break; // SWI
+
+ // SUBA
+ case 0x80: A = Sub8(A, Fetch(), carry: false); break;
+ case 0x90: A = Sub8(A, Read(DirectAddr()), carry: false); break;
+ case 0xA0: A = Sub8(A, Read(IndexedAddr()), carry: false); break;
+ case 0xB0: A = Sub8(A, Read(ExtendedAddr()),carry: false); break;
+
+ // CMPA
+ case 0x81: Sub8(A, Fetch(), carry: false); break;
+ case 0x91: Sub8(A, Read(DirectAddr()), carry: false); break;
+ case 0xA1: Sub8(A, Read(IndexedAddr()), carry: false); break;
+ case 0xB1: Sub8(A, Read(ExtendedAddr()),carry: false); break;
+
+ // SBCA
+ case 0x82: A = Sub8(A, Fetch(), carry: true); break;
+ case 0x92: A = Sub8(A, Read(DirectAddr()), carry: true); break;
+ case 0xA2: A = Sub8(A, Read(IndexedAddr()), carry: true); break;
+ case 0xB2: A = Sub8(A, Read(ExtendedAddr()),carry: true); break;
+
+ // SUBD
+ case 0x83: D = Sub16(D, FetchWord()); break;
+ case 0x93: D = Sub16(D, ReadWord(DirectAddr())); break;
+ case 0xA3: D = Sub16(D, ReadWord(IndexedAddr())); break;
+ case 0xB3: D = Sub16(D, ReadWord(ExtendedAddr())); break;
+
+ // ANDA
+ case 0x84: A = And8(A, Fetch()); break;
+ case 0x94: A = And8(A, Read(DirectAddr())); break;
+ case 0xA4: A = And8(A, Read(IndexedAddr())); break;
+ case 0xB4: A = And8(A, Read(ExtendedAddr())); break;
+
+ // BITA
+ case 0x85: And8(A, Fetch()); break;
+ case 0x95: And8(A, Read(DirectAddr())); break;
+ case 0xA5: And8(A, Read(IndexedAddr())); break;
+ case 0xB5: And8(A, Read(ExtendedAddr())); break;
+
+ // LDA
+ case 0x86: A = Ld8(Fetch()); break;
+ case 0x96: A = Ld8(Read(DirectAddr())); break;
+ case 0xA6: A = Ld8(Read(IndexedAddr())); break;
+ case 0xB6: A = Ld8(Read(ExtendedAddr())); break;
+
+ // STA
+ case 0x97: Write(DirectAddr(), St8(A)); break;
+ case 0xA7: Write(IndexedAddr(), St8(A)); break;
+ case 0xB7: Write(ExtendedAddr(), St8(A)); break;
+
+ // EORA
+ case 0x88: A = Eor8(A, Fetch()); break;
+ case 0x98: A = Eor8(A, Read(DirectAddr())); break;
+ case 0xA8: A = Eor8(A, Read(IndexedAddr())); break;
+ case 0xB8: A = Eor8(A, Read(ExtendedAddr())); break;
+
+ // ADCA
+ case 0x89: A = Add8(A, Fetch(), carry: true); break;
+ case 0x99: A = Add8(A, Read(DirectAddr()), carry: true); break;
+ case 0xA9: A = Add8(A, Read(IndexedAddr()), carry: true); break;
+ case 0xB9: A = Add8(A, Read(ExtendedAddr()),carry: true); break;
+
+ // ORA
+ case 0x8A: A = Or8(A, Fetch()); break;
+ case 0x9A: A = Or8(A, Read(DirectAddr())); break;
+ case 0xAA: A = Or8(A, Read(IndexedAddr())); break;
+ case 0xBA: A = Or8(A, Read(ExtendedAddr())); break;
+
+ // ADDA
+ case 0x8B: A = Add8(A, Fetch(), carry: false); break;
+ case 0x9B: A = Add8(A, Read(DirectAddr()), carry: false); break;
+ case 0xAB: A = Add8(A, Read(IndexedAddr()), carry: false); break;
+ case 0xBB: A = Add8(A, Read(ExtendedAddr()),carry: false); break;
+
+ // CMPX
+ case 0x8C: Sub16(X, FetchWord()); break;
+ case 0x9C: Sub16(X, ReadWord(DirectAddr())); break;
+ case 0xAC: Sub16(X, ReadWord(IndexedAddr())); break;
+ case 0xBC: Sub16(X, ReadWord(ExtendedAddr())); break;
+
+ // BSR
+ case 0x8D: { sbyte o = (sbyte)Fetch(); PushWord(ref S, PC); PC = (ushort)(PC + o); break; }
+
+ // LDX
+ case 0x8E: X = Ld16(FetchWord()); break;
+ case 0x9E: X = Ld16(ReadWord(DirectAddr())); break;
+ case 0xAE: X = Ld16(ReadWord(IndexedAddr())); break;
+ case 0xBE: X = Ld16(ReadWord(ExtendedAddr())); break;
+
+ // STX
+ case 0x9F: WriteWord(DirectAddr(), St16(X)); break;
+ case 0xAF: WriteWord(IndexedAddr(), St16(X)); break;
+ case 0xBF: WriteWord(ExtendedAddr(), St16(X)); break;
+
+ // SUBB
+ case 0xC0: B = Sub8(B, Fetch(), carry: false); break;
+ case 0xD0: B = Sub8(B, Read(DirectAddr()), carry: false); break;
+ case 0xE0: B = Sub8(B, Read(IndexedAddr()), carry: false); break;
+ case 0xF0: B = Sub8(B, Read(ExtendedAddr()),carry: false); break;
+
+ // CMPB
+ case 0xC1: Sub8(B, Fetch(), carry: false); break;
+ case 0xD1: Sub8(B, Read(DirectAddr()), carry: false); break;
+ case 0xE1: Sub8(B, Read(IndexedAddr()), carry: false); break;
+ case 0xF1: Sub8(B, Read(ExtendedAddr()),carry: false); break;
+
+ // SBCB
+ case 0xC2: B = Sub8(B, Fetch(), carry: true); break;
+ case 0xD2: B = Sub8(B, Read(DirectAddr()), carry: true); break;
+ case 0xE2: B = Sub8(B, Read(IndexedAddr()), carry: true); break;
+ case 0xF2: B = Sub8(B, Read(ExtendedAddr()),carry: true); break;
+
+ // ADDD
+ case 0xC3: D = Add16(D, FetchWord()); break;
+ case 0xD3: D = Add16(D, ReadWord(DirectAddr())); break;
+ case 0xE3: D = Add16(D, ReadWord(IndexedAddr())); break;
+ case 0xF3: D = Add16(D, ReadWord(ExtendedAddr())); break;
+
+ // ANDB
+ case 0xC4: B = And8(B, Fetch()); break;
+ case 0xD4: B = And8(B, Read(DirectAddr())); break;
+ case 0xE4: B = And8(B, Read(IndexedAddr())); break;
+ case 0xF4: B = And8(B, Read(ExtendedAddr())); break;
+
+ // BITB
+ case 0xC5: And8(B, Fetch()); break;
+ case 0xD5: And8(B, Read(DirectAddr())); break;
+ case 0xE5: And8(B, Read(IndexedAddr())); break;
+ case 0xF5: And8(B, Read(ExtendedAddr())); break;
+
+ // LDB
+ case 0xC6: B = Ld8(Fetch()); break;
+ case 0xD6: B = Ld8(Read(DirectAddr())); break;
+ case 0xE6: B = Ld8(Read(IndexedAddr())); break;
+ case 0xF6: B = Ld8(Read(ExtendedAddr())); break;
+
+ // STB
+ case 0xD7: Write(DirectAddr(), St8(B)); break;
+ case 0xE7: Write(IndexedAddr(), St8(B)); break;
+ case 0xF7: Write(ExtendedAddr(), St8(B)); break;
+
+ // EORB
+ case 0xC8: B = Eor8(B, Fetch()); break;
+ case 0xD8: B = Eor8(B, Read(DirectAddr())); break;
+ case 0xE8: B = Eor8(B, Read(IndexedAddr())); break;
+ case 0xF8: B = Eor8(B, Read(ExtendedAddr())); break;
+
+ // ADCB
+ case 0xC9: B = Add8(B, Fetch(), carry: true); break;
+ case 0xD9: B = Add8(B, Read(DirectAddr()), carry: true); break;
+ case 0xE9: B = Add8(B, Read(IndexedAddr()), carry: true); break;
+ case 0xF9: B = Add8(B, Read(ExtendedAddr()),carry: true); break;
+
+ // ORB
+ case 0xCA: B = Or8(B, Fetch()); break;
+ case 0xDA: B = Or8(B, Read(DirectAddr())); break;
+ case 0xEA: B = Or8(B, Read(IndexedAddr())); break;
+ case 0xFA: B = Or8(B, Read(ExtendedAddr())); break;
+
+ // ADDB
+ case 0xCB: B = Add8(B, Fetch(), carry: false); break;
+ case 0xDB: B = Add8(B, Read(DirectAddr()), carry: false); break;
+ case 0xEB: B = Add8(B, Read(IndexedAddr()), carry: false); break;
+ case 0xFB: B = Add8(B, Read(ExtendedAddr()),carry: false); break;
+
+ // LDD
+ case 0xCC: D = Ld16(FetchWord()); break;
+ case 0xDC: D = Ld16(ReadWord(DirectAddr())); break;
+ case 0xEC: D = Ld16(ReadWord(IndexedAddr())); break;
+ case 0xFC: D = Ld16(ReadWord(ExtendedAddr())); break;
+
+ // STD
+ case 0xDD: WriteWord(DirectAddr(), St16(D)); break;
+ case 0xED: WriteWord(IndexedAddr(), St16(D)); break;
+ case 0xFD: WriteWord(ExtendedAddr(), St16(D)); break;
+
+ // LDU
+ case 0xCE: U = Ld16(FetchWord()); break;
+ case 0xDE: U = Ld16(ReadWord(DirectAddr())); break;
+ case 0xEE: U = Ld16(ReadWord(IndexedAddr())); break;
+ case 0xFE: U = Ld16(ReadWord(ExtendedAddr())); break;
+
+ // STU
+ case 0xDF: WriteWord(DirectAddr(), St16(U)); break;
+ case 0xEF: WriteWord(IndexedAddr(), St16(U)); break;
+ case 0xFF: WriteWord(ExtendedAddr(), St16(U)); break;
+
+ // JSR
+ case 0x9D: { var a = DirectAddr(); PushWord(ref S, PC); PC = a; break; }
+ case 0xAD: { var a = IndexedAddr(); PushWord(ref S, PC); PC = a; break; }
+ case 0xBD: { var a = ExtendedAddr(); PushWord(ref S, PC); PC = a; break; }
+
+ default:
+ _console.WriteText($"?ILL OP ${op:X2} @${(ushort)(PC - 1):X4}");
+ _console.NewLine();
+ _running = false;
+ break;
+ }
+ }
+
+ // -------------------------------------------------------------------------
+ // Page 2 (0x10 prefix)
+ // -------------------------------------------------------------------------
+ private void StepPage2()
+ {
+ byte op = Fetch();
+ switch (op)
+ {
+ // Long branches
+ case 0x21: Branch16(false); break;
+ case 0x22: Branch16(!GetFlag(CC_C) && !GetFlag(CC_Z)); break;
+ case 0x23: Branch16(GetFlag(CC_C) || GetFlag(CC_Z)); break;
+ case 0x24: Branch16(!GetFlag(CC_C)); break;
+ case 0x25: Branch16(GetFlag(CC_C)); break;
+ case 0x26: Branch16(!GetFlag(CC_Z)); break;
+ case 0x27: Branch16(GetFlag(CC_Z)); break;
+ case 0x28: Branch16(!GetFlag(CC_V)); break;
+ case 0x29: Branch16(GetFlag(CC_V)); break;
+ case 0x2A: Branch16(!GetFlag(CC_N)); break;
+ case 0x2B: Branch16(GetFlag(CC_N)); break;
+ case 0x2C: Branch16(GetFlag(CC_N) == GetFlag(CC_V)); break;
+ case 0x2D: Branch16(GetFlag(CC_N) != GetFlag(CC_V)); break;
+ case 0x2E: Branch16(!GetFlag(CC_Z) && (GetFlag(CC_N) == GetFlag(CC_V))); break;
+ case 0x2F: Branch16(GetFlag(CC_Z) || (GetFlag(CC_N) != GetFlag(CC_V))); break;
+
+ case 0x3F: Swi(0xFFF4); break; // SWI2
+
+ // CMPD
+ case 0x83: Sub16(D, FetchWord()); break;
+ case 0x93: Sub16(D, ReadWord(DirectAddr())); break;
+ case 0xA3: Sub16(D, ReadWord(IndexedAddr())); break;
+ case 0xB3: Sub16(D, ReadWord(ExtendedAddr())); break;
+
+ // CMPY
+ case 0x8C: Sub16(Y, FetchWord()); break;
+ case 0x9C: Sub16(Y, ReadWord(DirectAddr())); break;
+ case 0xAC: Sub16(Y, ReadWord(IndexedAddr())); break;
+ case 0xBC: Sub16(Y, ReadWord(ExtendedAddr())); break;
+
+ // LDY
+ case 0x8E: Y = Ld16(FetchWord()); break;
+ case 0x9E: Y = Ld16(ReadWord(DirectAddr())); break;
+ case 0xAE: Y = Ld16(ReadWord(IndexedAddr())); break;
+ case 0xBE: Y = Ld16(ReadWord(ExtendedAddr())); break;
+
+ // STY
+ case 0x9F: WriteWord(DirectAddr(), St16(Y)); break;
+ case 0xAF: WriteWord(IndexedAddr(), St16(Y)); break;
+ case 0xBF: WriteWord(ExtendedAddr(), St16(Y)); break;
+
+ // LDS
+ case 0xCE: S = Ld16(FetchWord()); break;
+ case 0xDE: S = Ld16(ReadWord(DirectAddr())); break;
+ case 0xEE: S = Ld16(ReadWord(IndexedAddr())); break;
+ case 0xFE: S = Ld16(ReadWord(ExtendedAddr())); break;
+
+ // STS
+ case 0xDF: WriteWord(DirectAddr(), St16(S)); break;
+ case 0xEF: WriteWord(IndexedAddr(), St16(S)); break;
+ case 0xFF: WriteWord(ExtendedAddr(), St16(S)); break;
+
+ default:
+ _console.WriteText($"?ILL OP $10{op:X2} @${(ushort)(PC - 2):X4}");
+ _console.NewLine();
+ _running = false;
+ break;
+ }
+ }
+
+ // -------------------------------------------------------------------------
+ // Page 3 (0x11 prefix)
+ // -------------------------------------------------------------------------
+ private void StepPage3()
+ {
+ byte op = Fetch();
+ switch (op)
+ {
+ case 0x3F: Swi(0xFFF2); break; // SWI3
+
+ // CMPU
+ case 0x83: Sub16(U, FetchWord()); break;
+ case 0x93: Sub16(U, ReadWord(DirectAddr())); break;
+ case 0xA3: Sub16(U, ReadWord(IndexedAddr())); break;
+ case 0xB3: Sub16(U, ReadWord(ExtendedAddr())); break;
+
+ // CMPS
+ case 0x8C: Sub16(S, FetchWord()); break;
+ case 0x9C: Sub16(S, ReadWord(DirectAddr())); break;
+ case 0xAC: Sub16(S, ReadWord(IndexedAddr())); break;
+ case 0xBC: Sub16(S, ReadWord(ExtendedAddr())); break;
+
+ default:
+ _console.WriteText($"?ILL OP $11{op:X2} @${(ushort)(PC - 2):X4}");
+ _console.NewLine();
+ _running = false;
+ break;
+ }
+ }
+
+ // -------------------------------------------------------------------------
+ // ALU
+ // -------------------------------------------------------------------------
+ private byte Neg8(byte v)
+ {
+ int r = -v;
+ SetFlag(CC_N, (r & 0x80) != 0);
+ SetFlag(CC_Z, (r & 0xFF) == 0);
+ SetFlag(CC_V, v == 0x80);
+ SetFlag(CC_C, v != 0);
+ return (byte)r;
+ }
+
+ private byte Com8(byte v)
+ {
+ byte r = (byte)~v;
+ SetNZ8(r);
+ SetFlag(CC_V, false);
+ SetFlag(CC_C, true);
+ return r;
+ }
+
+ private byte Lsr8(byte v)
+ {
+ SetFlag(CC_C, (v & 0x01) != 0);
+ byte r = (byte)(v >> 1);
+ SetFlag(CC_N, false);
+ SetFlag(CC_Z, r == 0);
+ return r;
+ }
+
+ private byte Ror8(byte v)
+ {
+ byte cin = (byte)(GetFlag(CC_C) ? 1 : 0);
+ SetFlag(CC_C, (v & 0x01) != 0);
+ byte r = (byte)((v >> 1) | (cin << 7));
+ SetNZ8(r);
+ return r;
+ }
+
+ private byte Asr8(byte v)
+ {
+ SetFlag(CC_C, (v & 0x01) != 0);
+ byte r = (byte)((sbyte)v >> 1);
+ SetNZ8(r);
+ return r;
+ }
+
+ private byte Lsl8(byte v)
+ {
+ SetFlag(CC_C, (v & 0x80) != 0);
+ SetFlag(CC_V, ((v ^ (v << 1)) & 0x80) != 0);
+ byte r = (byte)(v << 1);
+ SetNZ8(r);
+ return r;
+ }
+
+ private byte Rol8(byte v)
+ {
+ byte cin = (byte)(GetFlag(CC_C) ? 1 : 0);
+ SetFlag(CC_C, (v & 0x80) != 0);
+ SetFlag(CC_V, ((v ^ (v << 1)) & 0x80) != 0);
+ byte r = (byte)((v << 1) | cin);
+ SetNZ8(r);
+ return r;
+ }
+
+ private byte Dec8(byte v)
+ {
+ byte r = (byte)(v - 1);
+ SetFlag(CC_N, (r & 0x80) != 0);
+ SetFlag(CC_Z, r == 0);
+ SetFlag(CC_V, v == 0x80);
+ return r;
+ }
+
+ private byte Inc8(byte v)
+ {
+ byte r = (byte)(v + 1);
+ SetFlag(CC_N, (r & 0x80) != 0);
+ SetFlag(CC_Z, r == 0);
+ SetFlag(CC_V, v == 0x7F);
+ return r;
+ }
+
+ private void Tst8(byte v) { SetNZ8(v); SetFlag(CC_V, false); }
+
+ private void ClrFlags()
+ {
+ SetFlag(CC_N, false);
+ SetFlag(CC_Z, true);
+ SetFlag(CC_V, false);
+ SetFlag(CC_C, false);
+ }
+
+ private byte Add8(byte a, byte b, bool carry)
+ {
+ int c = carry && GetFlag(CC_C) ? 1 : 0;
+ int r = a + b + c;
+ SetFlag(CC_H, ((a ^ b ^ r) & 0x10) != 0);
+ SetFlag(CC_C, (r & 0x100) != 0);
+ SetFlag(CC_V, (~(a ^ b) & (a ^ r) & 0x80) != 0);
+ byte res = (byte)r;
+ SetNZ8(res);
+ return res;
+ }
+
+ private byte Sub8(byte a, byte b, bool carry)
+ {
+ int c = carry && GetFlag(CC_C) ? 1 : 0;
+ int r = a - b - c;
+ SetFlag(CC_C, (r & 0x100) != 0);
+ SetFlag(CC_V, ((a ^ b) & (a ^ r) & 0x80) != 0);
+ byte res = (byte)r;
+ SetNZ8(res);
+ return res;
+ }
+
+ private ushort Add16(ushort a, ushort b)
+ {
+ int r = a + b;
+ SetFlag(CC_C, (r & 0x10000) != 0);
+ SetFlag(CC_V, (~(a ^ b) & (a ^ r) & 0x8000) != 0);
+ ushort res = (ushort)r;
+ SetNZ16(res);
+ return res;
+ }
+
+ private ushort Sub16(ushort a, ushort b)
+ {
+ int r = a - b;
+ SetFlag(CC_C, (r & 0x10000) != 0);
+ SetFlag(CC_V, ((a ^ b) & (a ^ r) & 0x8000) != 0);
+ ushort res = (ushort)r;
+ SetNZ16(res);
+ return res;
+ }
+
+ private byte And8(byte a, byte b) { byte r = (byte)(a & b); SetNZ8(r); SetFlag(CC_V, false); return r; }
+ private byte Eor8(byte a, byte b) { byte r = (byte)(a ^ b); SetNZ8(r); SetFlag(CC_V, false); return r; }
+ private byte Or8 (byte a, byte b) { byte r = (byte)(a | b); SetNZ8(r); SetFlag(CC_V, false); return r; }
+
+ private byte Ld8 (byte v) { SetNZ8(v); SetFlag(CC_V, false); return v; }
+ private byte St8 (byte v) { SetNZ8(v); SetFlag(CC_V, false); return v; }
+ private ushort Ld16(ushort v) { SetNZ16(v); SetFlag(CC_V, false); return v; }
+ private ushort St16(ushort v) { SetNZ16(v); SetFlag(CC_V, false); return v; }
+
+ private void Branch8(bool cond) { sbyte o = (sbyte)Fetch(); if (cond) PC = (ushort)(PC + o); }
+ private void Branch16(bool cond) { short o = (short)FetchWord(); if (cond) PC = (ushort)(PC + o); }
+
+ private void Daa()
+ {
+ int a = A, cf = 0;
+ if (GetFlag(CC_H) || (a & 0x0F) > 9) cf += 6;
+ if (GetFlag(CC_C) || a > 0x99) { cf += 0x60; SetFlag(CC_C, true); }
+ A = (byte)(a + cf);
+ SetNZ8(A);
+ }
+
+ // -------------------------------------------------------------------------
+ // Stack
+ // -------------------------------------------------------------------------
+ private void PushByte(ref ushort sp, byte v) => Write(--sp, v);
+ private byte PullByte(ref ushort sp) => Read(sp++);
+
+ private void PushWord(ref ushort sp, ushort v)
+ {
+ PushByte(ref sp, (byte)v);
+ PushByte(ref sp, (byte)(v >> 8));
+ }
+
+ private ushort PullWord(ref ushort sp)
+ {
+ byte hi = PullByte(ref sp);
+ byte lo = PullByte(ref sp);
+ return (ushort)((hi << 8) | lo);
+ }
+
+ private void PushAllState(ref ushort sp)
+ {
+ PushWord(ref sp, PC);
+ PushWord(ref sp, U);
+ PushWord(ref sp, Y);
+ PushWord(ref sp, X);
+ PushByte(ref sp, DP);
+ PushByte(ref sp, B);
+ PushByte(ref sp, A);
+ PushByte(ref sp, CC);
+ }
+
+ // Register mask: bit7=PC, 6=U/S, 5=Y, 4=X, 3=DP, 2=B, 1=A, 0=CC
+ private void PushRegs(ref ushort sp, byte mask, bool useU)
+ {
+ if ((mask & 0x80) != 0) PushWord(ref sp, PC);
+ if ((mask & 0x40) != 0) PushWord(ref sp, useU ? S : U);
+ if ((mask & 0x20) != 0) PushWord(ref sp, Y);
+ if ((mask & 0x10) != 0) PushWord(ref sp, X);
+ if ((mask & 0x08) != 0) PushByte(ref sp, DP);
+ if ((mask & 0x04) != 0) PushByte(ref sp, B);
+ if ((mask & 0x02) != 0) PushByte(ref sp, A);
+ if ((mask & 0x01) != 0) PushByte(ref sp, CC);
+ }
+
+ private void PullRegs(ref ushort sp, byte mask, bool useU)
+ {
+ if ((mask & 0x01) != 0) CC = PullByte(ref sp);
+ if ((mask & 0x02) != 0) A = PullByte(ref sp);
+ if ((mask & 0x04) != 0) B = PullByte(ref sp);
+ if ((mask & 0x08) != 0) DP = PullByte(ref sp);
+ if ((mask & 0x10) != 0) X = PullWord(ref sp);
+ if ((mask & 0x20) != 0) Y = PullWord(ref sp);
+ if ((mask & 0x40) != 0) { if (useU) S = PullWord(ref sp); else U = PullWord(ref sp); }
+ if ((mask & 0x80) != 0) PC = PullWord(ref sp);
+ }
+
+ private void Rti()
+ {
+ CC = PullByte(ref S);
+ if (GetFlag(CC_E))
+ {
+ A = PullByte(ref S);
+ B = PullByte(ref S);
+ DP = PullByte(ref S);
+ X = PullWord(ref S);
+ Y = PullWord(ref S);
+ U = PullWord(ref S);
+ }
+ PC = PullWord(ref S);
+ }
+
+ // -------------------------------------------------------------------------
+ // SWI — halt gracefully if vector is uninitialized (0x0000)
+ // -------------------------------------------------------------------------
+ private void Swi(ushort vector)
+ {
+ ushort target = ReadWord(vector);
+ if (target == 0x0000)
+ {
+ _running = false;
+ return;
+ }
+ SetFlag(CC_E, true);
+ PushAllState(ref S);
+ SetFlag(CC_I, true);
+ SetFlag(CC_F, true);
+ PC = target;
+ }
+
+ // -------------------------------------------------------------------------
+ // EXG / TFR post-byte: high nibble = r1, low nibble = r2
+ // -------------------------------------------------------------------------
+ private void ExgTfr(byte pb, bool exg)
+ {
+ ushort Get(int r) => r switch
+ {
+ 0x0 => D, 0x1 => X, 0x2 => Y, 0x3 => U,
+ 0x4 => S, 0x5 => PC,
+ 0x8 => A, 0x9 => B, 0xA => CC, 0xB => DP,
+ _ => 0xFF
+ };
+
+ void Set(int r, ushort v)
+ {
+ switch (r)
+ {
+ case 0x0: D = v; break;
+ case 0x1: X = v; break;
+ case 0x2: Y = v; break;
+ case 0x3: U = v; break;
+ case 0x4: S = v; break;
+ case 0x5: PC = v; break;
+ case 0x8: A = (byte)v; break;
+ case 0x9: B = (byte)v; break;
+ case 0xA: CC = (byte)v; break;
+ case 0xB: DP = (byte)v; break;
+ }
+ }
+
+ int src = (pb >> 4) & 0x0F;
+ int dst = pb & 0x0F;
+ ushort sv = Get(src);
+ ushort dv = Get(dst);
+ Set(dst, sv);
+ if (exg) Set(src, dv);
+ }
+}
diff --git a/InputInterpreter.cs b/InputInterpreter.cs
index 9967790..53b8262 100644
--- a/InputInterpreter.cs
+++ b/InputInterpreter.cs
@@ -1,39 +1,111 @@
+using System.Diagnostics;
using System.Text.RegularExpressions;
+// ---------------------------------------------------------------------------
+// Expression bytecode
+// ---------------------------------------------------------------------------
+
+internal enum Op
+{
+ PushConst, PushVar,
+ Add, Sub, Mul, Div, Mod, Negate,
+ CallRnd, CallPeek, CallPeekX,
+ CmpEq, CmpLt, CmpGt, CmpLe, CmpGe, CmpNe
+}
+
+internal sealed class CompiledExpr
+{
+ public readonly int[] Code;
+ public readonly string Source;
+ public CompiledExpr(int[] code, string source) { Code = code; Source = source; }
+}
+
+// ---------------------------------------------------------------------------
+// Token types for pre-compiled BASIC lines
+// ---------------------------------------------------------------------------
+
+internal enum Keyword
+{
+ Unknown, Print, Let, Goto, Gosub, Return, If, Input,
+ Poke, PokeX, Rem, End
+}
+
+internal sealed class TokenizedLine
+{
+ public Keyword Kw;
+ public char Var;
+ public int LineTarget;
+ public TokenizedLine? ThenLine;
+
+ public CompiledExpr? E0; // primary expression
+ public CompiledExpr? E1; // secondary expression
+ public CompiledExpr? E2; // tertiary expression (POKEX)
+ public string? PrintLiteral; // PRINT "text" — pre-extracted, no quotes
+}
+
+// ---------------------------------------------------------------------------
+// Interpreter
+// ---------------------------------------------------------------------------
+
internal class InputInterpreter
{
private static readonly Regex LineNumberPattern = new(@"^\s*(\d+)\s+(.*)$");
- private readonly MemoryModel mem;
- private readonly ConsoleHelper consoleHelper;
- private readonly DiskManager diskManager;
- private readonly SortedDictionary _program = new();
- private readonly Dictionary _variables = new();
+ private readonly MemoryModel mem;
+ private readonly ConsoleHelper consoleHelper;
+ private readonly DiskManager diskManager;
+ private readonly Cpu6809 cpu;
- private List _lines = new();
- private int _programCounter;
+ private readonly SortedDictionary _program = new();
+ private readonly Dictionary _tokenized = new();
+ private readonly int[] _variables = new int[26]; // A=0 … Z=25
+
+ private int[] _lines = [];
+ private int _programCounter;
private volatile bool _running;
private volatile bool _waitingForInput;
- private char _inputVariable;
- private bool _skipIncrement;
+ private char _inputVariable;
+ private bool _skipIncrement;
private readonly Stack _callStack = new();
- // Threading
- private Thread? _thread;
- private CancellationTokenSource _cts = new();
- private readonly ManualResetEventSlim _runSignal = new(false);
- private readonly SemaphoreSlim _inputSignal = new(0, 1);
+ private Thread? _thread;
+ private CancellationTokenSource _cts = new();
+ private readonly ManualResetEventSlim _runSignal = new(false);
+ private readonly SemaphoreSlim _inputSignal = new(0, 1);
- public InputInterpreter(MemoryModel mem, ConsoleHelper consoleHelper, DiskManager diskManager)
+ // Perf measurement
+ private long _perfExecute;
+ private long _perfGoto;
+ private long _perfCount;
+ private const long PerfInterval = 100_000;
+
+ // XorShift32 RNG
+ private uint _rng = (uint)Environment.TickCount;
+
+ private int FastRnd(int n)
{
- this.mem = mem;
- this.consoleHelper = consoleHelper;
- this.diskManager = diskManager;
+ _rng ^= _rng << 13;
+ _rng ^= _rng >> 17;
+ _rng ^= _rng << 5;
+ return (int)((_rng & 0x7FFFFFFFu) % (uint)n);
}
- public bool IsRunning => _running;
+ public InputInterpreter(MemoryModel mem, ConsoleHelper consoleHelper,
+ DiskManager diskManager, Cpu6809 cpu)
+ {
+ this.mem = mem;
+ this.consoleHelper = consoleHelper;
+ this.diskManager = diskManager;
+ this.cpu = cpu;
+ }
+
+ public bool IsRunning => _running;
public bool IsWaitingForInput => _waitingForInput;
+ // -----------------------------------------------------------------------
+ // Thread management
+ // -----------------------------------------------------------------------
+
public void StartThread()
{
_thread = new Thread(RunLoop) { IsBackground = true, Name = "BasicInterpreter" };
@@ -44,8 +116,7 @@ internal class InputInterpreter
{
_running = false;
_cts.Cancel();
- // Unblock any pending Wait calls
- try { _runSignal.Set(); } catch { }
+ try { _runSignal.Set(); } catch { }
try { _inputSignal.Release(); } catch { }
_thread?.Join();
}
@@ -58,14 +129,9 @@ internal class InputInterpreter
{
_runSignal.Wait(_cts.Token);
_runSignal.Reset();
-
while (_running && !_cts.IsCancellationRequested)
{
- if (_waitingForInput)
- {
- _inputSignal.Wait(_cts.Token);
- continue;
- }
+ if (_waitingForInput) { _inputSignal.Wait(_cts.Token); continue; }
Tick();
}
}
@@ -73,12 +139,16 @@ internal class InputInterpreter
catch (OperationCanceledException) { }
}
+ // -----------------------------------------------------------------------
+ // Input handling
+ // -----------------------------------------------------------------------
+
public void SubmitInput(string line)
{
if (!_waitingForInput) return;
if (int.TryParse(line.Trim(), out int val))
{
- _variables[_inputVariable] = val;
+ _variables[_inputVariable - 'A'] = val;
_waitingForInput = false;
_programCounter++;
_inputSignal.Release();
@@ -92,7 +162,10 @@ internal class InputInterpreter
public void Stop()
{
+ bool wasRunning = _running;
_running = false;
+ if (!wasRunning)
+ mem.Write(MemoryModel.IoBase + MemoryModel.REG_MODE, 0);
if (_waitingForInput)
{
_waitingForInput = false;
@@ -103,27 +176,35 @@ internal class InputInterpreter
consoleHelper.NewLine();
}
+ // -----------------------------------------------------------------------
+ // Execution tick
+ // -----------------------------------------------------------------------
+
private void Tick()
{
if (!_running) return;
- if (_programCounter >= _lines.Count)
+ if (_programCounter >= _lines.Length)
{
_running = false;
+ mem.Write(MemoryModel.IoBase + MemoryModel.REG_MODE, 0);
return;
}
int lineNr = _lines[_programCounter];
int? gotoTarget = null;
_skipIncrement = false;
- ExecuteStatement(_program[lineNr], ref gotoTarget);
+
+ long t0 = Stopwatch.GetTimestamp();
+ ExecuteTokenized(_tokenized[lineNr], ref gotoTarget);
+ long t1 = Stopwatch.GetTimestamp();
if (_waitingForInput || _skipIncrement) return;
if (gotoTarget.HasValue)
{
- int idx = _lines.IndexOf(gotoTarget.Value);
- if (idx == -1)
+ int idx = Array.BinarySearch(_lines, gotoTarget.Value);
+ if (idx < 0)
{
consoleHelper.WriteText($"?UNDEF'D LINE {gotoTarget.Value}");
consoleHelper.NewLine();
@@ -138,8 +219,26 @@ internal class InputInterpreter
{
_programCounter++;
}
+ long t2 = Stopwatch.GetTimestamp();
+
+ _perfExecute += t1 - t0;
+ _perfGoto += t2 - t1;
+ _perfCount++;
+ if (_perfCount == PerfInterval)
+ {
+ double f = Stopwatch.Frequency / 1e9;
+ double exec = _perfExecute / f / PerfInterval;
+ double gotol = _perfGoto / f / PerfInterval;
+ double totalSec = (_perfExecute + _perfGoto) / (double)Stopwatch.Frequency;
+ Console.WriteLine($"[PERF] exec={exec:F1}ns goto={gotol:F1}ns total={exec+gotol:F1}ns ({PerfInterval/totalSec:N0} ticks/s)");
+ _perfExecute = _perfGoto = _perfCount = 0;
+ }
}
+ // -----------------------------------------------------------------------
+ // Direct-mode dispatcher
+ // -----------------------------------------------------------------------
+
public void InterpretInput(string input)
{
input = input.Trim();
@@ -148,13 +247,19 @@ internal class InputInterpreter
var match = LineNumberPattern.Match(input);
if (match.Success)
{
- int lineNumber = int.Parse(match.Groups[1].Value);
- string statement = match.Groups[2].Value.Trim();
+ int lineNumber = int.Parse(match.Groups[1].Value);
+ string statement = match.Groups[2].Value.Trim();
if (string.IsNullOrWhiteSpace(statement))
+ {
_program.Remove(lineNumber);
+ _tokenized.Remove(lineNumber);
+ }
else
- _program[lineNumber] = statement;
+ {
+ _program[lineNumber] = statement;
+ _tokenized[lineNumber] = Tokenize(statement);
+ }
}
else
{
@@ -162,15 +267,13 @@ internal class InputInterpreter
}
}
- // Direktmodus: RUN, LIST, DIR und alle Statements
private void Execute(string input)
{
- Console.WriteLine("input: " + input.ToLowerInvariant());
var cmd = input.ToLowerInvariant();
if (cmd == "run")
{
- _lines = _program.Keys.ToList();
+ _lines = _program.Keys.ToArray();
_programCounter = 0;
_callStack.Clear();
_running = true;
@@ -180,306 +283,263 @@ internal class InputInterpreter
if (cmd == "new")
{
- _program.Clear();
- _lines.Clear();
+ _program.Clear(); _tokenized.Clear();
+ _lines = [];
_callStack.Clear();
_running = false;
+ consoleHelper.WriteText("OK"); consoleHelper.NewLine();
return;
}
if (cmd == "list")
{
- if (_program.Count == 0)
+ foreach (var (lineNumber, statement) in _program)
{
- consoleHelper.WriteText("(empty)");
+ consoleHelper.WriteText($"{lineNumber} {statement}");
consoleHelper.NewLine();
}
- else
- {
- foreach (var (lineNumber, statement) in _program)
- {
- consoleHelper.WriteText($"{lineNumber} {statement}");
- consoleHelper.NewLine();
- }
- }
return;
}
if (cmd.StartsWith("save ") || cmd.StartsWith("save\""))
- {
- ExecuteSave(input.Substring("save".Length).Trim());
- return;
- }
-
+ { ExecuteSave(input.Substring("save".Length).Trim()); return; }
if (cmd.StartsWith("load ") || cmd.StartsWith("load\""))
- {
- ExecuteLoad(input.Substring("load".Length).Trim());
- return;
- }
+ { ExecuteLoad(input.Substring("load".Length).Trim()); return; }
+ if (cmd.StartsWith("exec ") || cmd.StartsWith("exec\""))
+ { ExecuteExec(input.Substring("exec".Length).Trim()); return; }
+ if (cmd.StartsWith("asm ") || cmd.StartsWith("asm\""))
+ { ExecuteAsm(input.Substring("asm".Length).Trim()); return; }
+ if (cmd.StartsWith("del ") || cmd.StartsWith("del\""))
+ { ExecuteDelFile(input.Substring("del".Length).Trim()); return; }
if (cmd == "dir")
{
var (error, files) = diskManager.Dir();
if (error != null)
- {
- consoleHelper.WriteText($"Error: {error}");
- consoleHelper.NewLine();
- }
+ { consoleHelper.WriteText($"Error: {error}"); consoleHelper.NewLine(); }
else if (files is not null)
- {
foreach (var file in files)
- {
- consoleHelper.WriteText(file.Name);
- consoleHelper.NewLine();
- }
- }
+ { consoleHelper.WriteText(file.Name); consoleHelper.NewLine(); }
return;
}
int? unused = null;
- ExecuteStatement(input, ref unused);
+ ExecuteTokenized(Tokenize(input), ref unused);
}
- // Ausführung eines einzelnen Statements
- private void ExecuteStatement(string input, ref int? gotoTarget)
+ // -----------------------------------------------------------------------
+ // Tokenizer — runs once at line entry; compiles expressions to bytecode
+ // -----------------------------------------------------------------------
+
+ private static TokenizedLine Tokenize(string raw)
{
- var cmd = input.ToLowerInvariant();
+ var t = new TokenizedLine();
+ var s = raw.Trim();
+ if (s.Length == 0) return t;
+ var lo = s.ToLowerInvariant();
- if (cmd.StartsWith("print ") || cmd == "print")
- {
- ExecutePrint(input.Substring("print".Length).Trim());
- return;
- }
+ if (lo == "end") { t.Kw = Keyword.End; return t; }
+ if (lo == "return") { t.Kw = Keyword.Return; return t; }
+ if (lo.StartsWith("rem")) { t.Kw = Keyword.Rem; return t; }
- if (cmd == "end")
+ if (lo == "print" || lo.StartsWith("print "))
{
- _running = false;
- return;
- }
-
- if (cmd.StartsWith("if "))
- {
- ExecuteIf(input.Substring("if ".Length).Trim(), ref gotoTarget);
- return;
- }
-
- if (cmd.StartsWith("input "))
- {
- string arg = input.Substring("input ".Length).Trim();
- if (arg.Length != 1 || !char.IsUpper(arg[0]))
+ t.Kw = Keyword.Print;
+ string a = s.Length > 5 ? s.Substring(5).Trim() : "";
+ if (a.StartsWith("\""))
{
- SyntaxError();
- return;
+ int last = a.LastIndexOf('"');
+ if (last <= 0) { t.Kw = Keyword.Unknown; return t; }
+ t.PrintLiteral = a.Substring(1, last - 1);
}
- _inputVariable = arg[0];
- _waitingForInput = true;
- consoleHelper.WriteText("?");
- consoleHelper.NewLine();
- return;
- }
-
- if (cmd.StartsWith("let "))
- {
- ExecuteLet(input.Substring("let ".Length).Trim());
- return;
- }
-
- if (cmd.StartsWith("rem")) return;
-
- if (cmd.StartsWith("poke "))
- {
- ExecutePoke(input.Substring("poke ".Length).Trim());
- return;
- }
-
- if (cmd.StartsWith("pokex "))
- {
- ExecutePokeX(input.Substring("pokex ".Length).Trim());
- return;
- }
-
- if (cmd.StartsWith("gosub "))
- {
- string arg = cmd.Substring("gosub ".Length).Trim();
- if (!int.TryParse(arg, out int target)) { SyntaxError(); return; }
- int idx = _lines.IndexOf(target);
- if (idx == -1)
+ else if (a.Length > 0)
{
- consoleHelper.WriteText($"?UNDEF'D LINE {target}");
- consoleHelper.NewLine();
- _running = false;
- return;
+ try { t.E0 = CompileExpr(a); }
+ catch { t.Kw = Keyword.Unknown; }
}
- _callStack.Push(_programCounter);
- gotoTarget = target;
- return;
+ return t;
}
- if (cmd == "return")
+ if (lo.StartsWith("let "))
{
- if (_callStack.Count == 0)
+ t.Kw = Keyword.Let;
+ var args = s.Substring(4).Trim();
+ if (args.Length >= 1 && char.IsUpper(args[0]))
{
- consoleHelper.WriteText("?RETURN WITHOUT GOSUB");
- consoleHelper.NewLine();
- _running = false;
- return;
+ t.Var = args[0];
+ var rest = args.Substring(1).TrimStart();
+ if (rest.StartsWith("="))
+ try { t.E0 = CompileExpr(rest.Substring(1).Trim()); }
+ catch { t.Kw = Keyword.Unknown; }
+ else
+ t.Kw = Keyword.Unknown;
}
- _programCounter = _callStack.Pop() + 1;
- _skipIncrement = true;
- return;
+ else t.Kw = Keyword.Unknown;
+ return t;
}
- if (cmd.StartsWith("goto "))
+ if (lo.StartsWith("pokex "))
{
- string arg = cmd.Substring("goto ".Length).Trim();
- if (int.TryParse(arg, out int target))
- gotoTarget = target;
- else
- SyntaxError();
- return;
- }
-
- SyntaxError();
- }
-
- private void ExecuteIf(string args, ref int? gotoTarget)
- {
- int thenIdx = args.ToUpperInvariant().IndexOf(" THEN ");
- if (thenIdx == -1) { SyntaxError(); return; }
-
- string condition = args.Substring(0, thenIdx).Trim();
- string stmt = args.Substring(thenIdx + " THEN ".Length).Trim();
-
- if (!TryEvaluateCondition(condition, out bool result)) { SyntaxError(); return; }
-
- if (result)
- ExecuteStatement(stmt, ref gotoTarget);
- }
-
- private static readonly string[] ComparisonOps = { "<=", ">=", "<>", "<", ">", "=" };
- private static readonly Random Rng = new();
-
- private bool TryEvaluateCondition(string condition, out bool result)
- {
- result = false;
- foreach (var op in ComparisonOps)
- {
- int idx = condition.IndexOf(op);
- if (idx == -1) continue;
-
- string leftStr = condition.Substring(0, idx).Trim();
- string rightStr = condition.Substring(idx + op.Length).Trim();
-
- if (!TryEvaluate(leftStr, out int left)) return false;
- if (!TryEvaluate(rightStr, out int right)) return false;
-
- result = op switch
+ t.Kw = Keyword.PokeX;
+ var args = s.Substring(6).Trim();
+ int c1 = args.IndexOf(',');
+ if (c1 < 0) { t.Kw = Keyword.Unknown; return t; }
+ int c2 = args.IndexOf(',', c1 + 1);
+ if (c2 < 0) { t.Kw = Keyword.Unknown; return t; }
+ try
{
- "=" => left == right,
- "<" => left < right,
- ">" => left > right,
- "<=" => left <= right,
- ">=" => left >= right,
- "<>" => left != right,
- _ => false
- };
- return true;
+ t.E0 = CompileExpr(args.Substring(0, c1 ).Trim());
+ t.E1 = CompileExpr(args.Substring(c1 + 1, c2 - c1 - 1).Trim());
+ t.E2 = CompileExpr(args.Substring(c2 + 1 ).Trim());
+ }
+ catch { t.Kw = Keyword.Unknown; }
+ return t;
}
- return false;
+
+ if (lo.StartsWith("poke "))
+ {
+ t.Kw = Keyword.Poke;
+ var args = s.Substring(5).Trim();
+ int comma = args.IndexOf(',');
+ if (comma < 0) { t.Kw = Keyword.Unknown; return t; }
+ try
+ {
+ t.E0 = CompileExpr(args.Substring(0, comma ).Trim());
+ t.E1 = CompileExpr(args.Substring(comma + 1 ).Trim());
+ }
+ catch { t.Kw = Keyword.Unknown; }
+ return t;
+ }
+
+ if (lo.StartsWith("goto "))
+ {
+ t.Kw = Keyword.Goto;
+ if (int.TryParse(lo.Substring(5).Trim(), out int target)) t.LineTarget = target;
+ else t.Kw = Keyword.Unknown;
+ return t;
+ }
+
+ if (lo.StartsWith("gosub "))
+ {
+ t.Kw = Keyword.Gosub;
+ if (int.TryParse(lo.Substring(6).Trim(), out int target)) t.LineTarget = target;
+ else t.Kw = Keyword.Unknown;
+ return t;
+ }
+
+ if (lo.StartsWith("input "))
+ {
+ t.Kw = Keyword.Input;
+ var arg = s.Substring(6).Trim();
+ if (arg.Length == 1 && char.IsUpper(arg[0])) t.Var = arg[0];
+ else t.Kw = Keyword.Unknown;
+ return t;
+ }
+
+ if (lo.StartsWith("if "))
+ {
+ t.Kw = Keyword.If;
+ var args = s.Substring(3).Trim();
+ int thenIdx = args.ToUpperInvariant().IndexOf(" THEN ");
+ if (thenIdx >= 0)
+ {
+ try { t.E0 = CompileCondition(args.Substring(0, thenIdx).Trim()); }
+ catch { t.Kw = Keyword.Unknown; return t; }
+ t.ThenLine = Tokenize(args.Substring(thenIdx + 6).Trim());
+ }
+ else t.Kw = Keyword.Unknown;
+ return t;
+ }
+
+ return t; // Unknown → SyntaxError at runtime
}
- private void ExecuteLet(string args)
+ // -----------------------------------------------------------------------
+ // Expression compiler
+ // -----------------------------------------------------------------------
+
+ private static CompiledExpr CompileExpr(string expr)
{
- if (args.Length < 1 || !char.IsUpper(args[0]))
- {
- SyntaxError();
- return;
- }
- char varName = args[0];
- var rest = args.Substring(1).TrimStart();
- if (!rest.StartsWith("="))
- {
- SyntaxError();
- return;
- }
- string exprStr = rest.Substring(1).Trim();
- if (!TryEvaluate(exprStr, out int value))
- {
- SyntaxError();
- return;
- }
- _variables[varName] = value;
+ var code = new List();
+ int pos = 0;
+ CompileExprInto(expr, ref pos, code);
+ SkipSpaces(expr, ref pos);
+ if (pos != expr.Length) throw new InvalidOperationException($"Trailing chars in: {expr}");
+ return new CompiledExpr(code.ToArray(), expr);
}
- private bool TryEvaluate(string expr, out int result)
+ private static CompiledExpr CompileCondition(string cond)
{
- try
+ // Two-char operators must precede their single-char prefixes in the list.
+ string[] ops = { "<=", ">=", "<>", "<", ">", "=" };
+ foreach (var op in ops)
{
- int pos = 0;
- result = ParseExpr(expr, ref pos);
- SkipSpaces(expr, ref pos);
- return pos == expr.Length;
- }
- catch (DivideByZeroException)
- {
- consoleHelper.WriteText("?DIVISION BY ZERO");
- consoleHelper.NewLine();
- _running = false;
- result = 0;
- return true; // Fehlermeldung bereits ausgegeben, kein ?SYNTAX ERROR
- }
- catch
- {
- result = 0;
- return false;
+ int idx = cond.IndexOf(op);
+ if (idx < 0) continue;
+
+ string left = cond.Substring(0, idx).Trim();
+ string right = cond.Substring(idx + op.Length).Trim();
+
+ var code = new List();
+ int lp = 0, rp = 0;
+ CompileExprInto(left, ref lp, code);
+ CompileExprInto(right, ref rp, code);
+
+ code.Add((int)(op switch
+ {
+ "=" => Op.CmpEq,
+ "<" => Op.CmpLt,
+ ">" => Op.CmpGt,
+ "<=" => Op.CmpLe,
+ ">=" => Op.CmpGe,
+ "<>" => Op.CmpNe,
+ _ => Op.CmpEq
+ }));
+
+ return new CompiledExpr(code.ToArray(), cond);
}
+ throw new InvalidOperationException($"No comparison operator in: {cond}");
}
- private int ParseExpr(string s, ref int pos)
+ private static void CompileExprInto(string s, ref int pos, List code)
{
- int left = ParseTerm(s, ref pos);
+ CompileTermInto(s, ref pos, code);
while (true)
{
SkipSpaces(s, ref pos);
- if (pos < s.Length && s[pos] == '+') { pos++; left += ParseTerm(s, ref pos); }
- else if (pos < s.Length && s[pos] == '-') { pos++; left -= ParseTerm(s, ref pos); }
+ if (pos < s.Length && s[pos] == '+') { pos++; CompileTermInto(s, ref pos, code); code.Add((int)Op.Add); }
+ else if (pos < s.Length && s[pos] == '-') { pos++; CompileTermInto(s, ref pos, code); code.Add((int)Op.Sub); }
else break;
}
- return left;
}
- private int ParseTerm(string s, ref int pos)
+ private static void CompileTermInto(string s, ref int pos, List code)
{
- int left = ParseFactor(s, ref pos);
+ CompileFactorInto(s, ref pos, code);
while (true)
{
SkipSpaces(s, ref pos);
if (pos < s.Length && s[pos] == '*')
{
- pos++; left *= ParseFactor(s, ref pos);
+ pos++; CompileFactorInto(s, ref pos, code); code.Add((int)Op.Mul);
}
else if (pos < s.Length && s[pos] == '/')
{
- pos++;
- int divisor = ParseFactor(s, ref pos);
- if (divisor == 0) throw new DivideByZeroException();
- left /= divisor;
+ pos++; CompileFactorInto(s, ref pos, code); code.Add((int)Op.Div);
}
else if (pos + 3 <= s.Length
- && s.Substring(pos, 3).ToUpperInvariant() == "MOD"
- && (pos + 3 >= s.Length || !char.IsLetterOrDigit(s[pos + 3])))
+ && (s[pos] | 0x20) == 'm'
+ && (s[pos+1] | 0x20) == 'o'
+ && (s[pos+2] | 0x20) == 'd'
+ && (pos + 3 >= s.Length || !char.IsLetterOrDigit(s[pos+3])))
{
- pos += 3;
- int divisor = ParseFactor(s, ref pos);
- if (divisor == 0) throw new DivideByZeroException();
- left %= divisor;
+ pos += 3; CompileFactorInto(s, ref pos, code); code.Add((int)Op.Mod);
}
else break;
}
- return left;
}
- private int ParseFactor(string s, ref int pos)
+ private static void CompileFactorInto(string s, ref int pos, List code)
{
SkipSpaces(s, ref pos);
if (pos >= s.Length) throw new InvalidOperationException();
@@ -487,129 +547,333 @@ internal class InputInterpreter
if (s[pos] == '(')
{
pos++;
- int val = ParseExpr(s, ref pos);
+ CompileExprInto(s, ref pos, code);
SkipSpaces(s, ref pos);
if (pos >= s.Length || s[pos] != ')') throw new InvalidOperationException();
pos++;
- return val;
+ return;
}
if (s[pos] == '-')
{
pos++;
- return -ParseFactor(s, ref pos);
+ CompileFactorInto(s, ref pos, code);
+ code.Add((int)Op.Negate);
+ return;
}
- if (pos + 3 <= s.Length && s.Substring(pos, 3).ToUpperInvariant() == "RND")
+ // RND(n)
+ if (pos + 3 <= s.Length
+ && (s[pos] | 0x20) == 'r'
+ && (s[pos+1] | 0x20) == 'n'
+ && (s[pos+2] | 0x20) == 'd')
{
pos += 3;
SkipSpaces(s, ref pos);
if (pos >= s.Length || s[pos] != '(') throw new InvalidOperationException();
pos++;
- int n = ParseExpr(s, ref pos);
+ CompileExprInto(s, ref pos, code);
SkipSpaces(s, ref pos);
if (pos >= s.Length || s[pos] != ')') throw new InvalidOperationException();
pos++;
- if (n <= 0) throw new InvalidOperationException();
- return Rng.Next(n);
+ code.Add((int)Op.CallRnd);
+ return;
}
- if (pos + 5 <= s.Length && s.Substring(pos, 5).ToUpperInvariant() == "PEEKX")
+ // PEEKX(bank, addr) — must precede PEEK
+ if (pos + 5 <= s.Length
+ && (s[pos] | 0x20) == 'p'
+ && (s[pos+1] | 0x20) == 'e'
+ && (s[pos+2] | 0x20) == 'e'
+ && (s[pos+3] | 0x20) == 'k'
+ && (s[pos+4] | 0x20) == 'x')
{
pos += 5;
SkipSpaces(s, ref pos);
if (pos >= s.Length || s[pos] != '(') throw new InvalidOperationException();
pos++;
- int bank = ParseExpr(s, ref pos);
+ CompileExprInto(s, ref pos, code); // bank
SkipSpaces(s, ref pos);
if (pos >= s.Length || s[pos] != ',') throw new InvalidOperationException();
pos++;
- int addr = ParseExpr(s, ref pos);
+ CompileExprInto(s, ref pos, code); // addr
SkipSpaces(s, ref pos);
if (pos >= s.Length || s[pos] != ')') throw new InvalidOperationException();
pos++;
- if (bank < 0 || bank >= MemoryModel.BankCount || addr < 0 || addr >= MemoryModel.BankSize)
- throw new InvalidOperationException();
- return mem.ReadFlat(bank * MemoryModel.BankSize + addr);
+ code.Add((int)Op.CallPeekX);
+ return;
}
- if (pos + 4 <= s.Length && s.Substring(pos, 4).ToUpperInvariant() == "PEEK")
+ // PEEK(addr)
+ if (pos + 4 <= s.Length
+ && (s[pos] | 0x20) == 'p'
+ && (s[pos+1] | 0x20) == 'e'
+ && (s[pos+2] | 0x20) == 'e'
+ && (s[pos+3] | 0x20) == 'k')
{
pos += 4;
SkipSpaces(s, ref pos);
if (pos >= s.Length || s[pos] != '(') throw new InvalidOperationException();
pos++;
- int addr = ParseExpr(s, ref pos);
+ CompileExprInto(s, ref pos, code);
SkipSpaces(s, ref pos);
if (pos >= s.Length || s[pos] != ')') throw new InvalidOperationException();
pos++;
- if (addr < 0 || addr > 0xFFFF) throw new InvalidOperationException();
- return mem.Read((ushort)addr);
+ code.Add((int)Op.CallPeek);
+ return;
}
+ // Variable (single uppercase letter) — emit 0-based index (A=0 … Z=25)
if (char.IsUpper(s[pos]))
{
- char v = s[pos++];
- if (!_variables.TryGetValue(v, out int val)) throw new InvalidOperationException();
- return val;
+ code.Add((int)Op.PushVar);
+ code.Add(s[pos++] - 'A');
+ return;
}
+ // Hex literal $XX
if (s[pos] == '$')
{
pos++;
- int start = pos;
- while (pos < s.Length && Uri.IsHexDigit(s[pos])) pos++;
- if (pos == start) throw new InvalidOperationException();
- return Convert.ToInt32(s.Substring(start, pos - start), 16);
+ if (pos >= s.Length || !IsHexChar(s[pos])) throw new InvalidOperationException();
+ int val = 0;
+ while (pos < s.Length && IsHexChar(s[pos]))
+ val = val * 16 + HexVal(s[pos++]);
+ code.Add((int)Op.PushConst);
+ code.Add(val);
+ return;
}
+ // Decimal literal
if (char.IsDigit(s[pos]))
{
- int start = pos;
- while (pos < s.Length && char.IsDigit(s[pos])) pos++;
- return int.Parse(s.Substring(start, pos - start));
+ int val = 0;
+ while (pos < s.Length && char.IsDigit(s[pos]))
+ val = val * 10 + (s[pos++] - '0');
+ code.Add((int)Op.PushConst);
+ code.Add(val);
+ return;
}
- throw new InvalidOperationException();
+ throw new InvalidOperationException($"Unexpected char '{s[pos]}' in: {s}");
}
+ // -----------------------------------------------------------------------
+ // Stack-based evaluator — no heap allocations, no string operations
+ // -----------------------------------------------------------------------
+
+ private int EvalExpr(CompiledExpr expr)
+ {
+ Span stack = stackalloc int[32];
+ int sp = 0;
+ int[] code = expr.Code;
+ int pc = 0;
+
+ while (pc < code.Length)
+ {
+ switch ((Op)code[pc++])
+ {
+ case Op.PushConst:
+ stack[sp++] = code[pc++];
+ break;
+ case Op.PushVar:
+ stack[sp++] = _variables[code[pc++]];
+ break;
+ case Op.Add: { int b = stack[--sp]; stack[sp-1] += b; break; }
+ case Op.Sub: { int b = stack[--sp]; stack[sp-1] -= b; break; }
+ case Op.Mul: { int b = stack[--sp]; stack[sp-1] *= b; break; }
+ case Op.Div:
+ {
+ int b = stack[--sp];
+ if (b == 0)
+ {
+ consoleHelper.WriteText("?DIVISION BY ZERO");
+ consoleHelper.NewLine();
+ _running = false;
+ return 0;
+ }
+ stack[sp-1] /= b;
+ break;
+ }
+ case Op.Mod:
+ {
+ int b = stack[--sp];
+ if (b == 0)
+ {
+ consoleHelper.WriteText("?DIVISION BY ZERO");
+ consoleHelper.NewLine();
+ _running = false;
+ return 0;
+ }
+ stack[sp-1] %= b;
+ break;
+ }
+ case Op.Negate:
+ stack[sp-1] = -stack[sp-1];
+ break;
+ case Op.CallRnd:
+ stack[sp-1] = FastRnd(stack[sp-1]);
+ break;
+ case Op.CallPeek:
+ stack[sp-1] = mem.Read((ushort)stack[sp-1]);
+ break;
+ case Op.CallPeekX:
+ {
+ int addr = stack[--sp];
+ int bank = stack[--sp];
+ if (bank < 0 || bank >= MemoryModel.BankCount ||
+ addr < 0 || addr >= MemoryModel.BankSize)
+ {
+ consoleHelper.WriteText($"?RANGE ERROR in {expr.Source}");
+ consoleHelper.NewLine();
+ _running = false;
+ return 0;
+ }
+ stack[sp++] = mem.ReadFlat(bank * MemoryModel.BankSize + addr);
+ break;
+ }
+ case Op.CmpEq: { int b = stack[--sp]; stack[sp-1] = stack[sp-1] == b ? 1 : 0; break; }
+ case Op.CmpLt: { int b = stack[--sp]; stack[sp-1] = stack[sp-1] < b ? 1 : 0; break; }
+ case Op.CmpGt: { int b = stack[--sp]; stack[sp-1] = stack[sp-1] > b ? 1 : 0; break; }
+ case Op.CmpLe: { int b = stack[--sp]; stack[sp-1] = stack[sp-1] <= b ? 1 : 0; break; }
+ case Op.CmpGe: { int b = stack[--sp]; stack[sp-1] = stack[sp-1] >= b ? 1 : 0; break; }
+ case Op.CmpNe: { int b = stack[--sp]; stack[sp-1] = stack[sp-1] != b ? 1 : 0; break; }
+ }
+ }
+
+ return sp > 0 ? stack[sp - 1] : 0;
+ }
+
+ // -----------------------------------------------------------------------
+ // Statement executor — switch on pre-compiled keyword, EvalExpr for exprs
+ // -----------------------------------------------------------------------
+
+ private void ExecuteTokenized(TokenizedLine t, ref int? gotoTarget)
+ {
+ switch (t.Kw)
+ {
+ case Keyword.Print:
+ if (t.PrintLiteral != null)
+ {
+ consoleHelper.WriteText(t.PrintLiteral);
+ consoleHelper.NewLine();
+ }
+ else if (t.E0 != null)
+ {
+ try { consoleHelper.WriteText(EvalExpr(t.E0).ToString()); }
+ catch { SyntaxError(); break; }
+ if (_running) consoleHelper.NewLine();
+ }
+ break;
+
+ case Keyword.End:
+ _running = false;
+ mem.Write(MemoryModel.IoBase + MemoryModel.REG_MODE, 0);
+ break;
+
+ case Keyword.Rem:
+ break;
+
+ case Keyword.Let:
+ try { _variables[t.Var - 'A'] = EvalExpr(t.E0!); }
+ catch { SyntaxError(); }
+ break;
+
+ case Keyword.Poke:
+ try
+ {
+ int addr = EvalExpr(t.E0!); if (!_running) break;
+ int val = EvalExpr(t.E1!); if (!_running) break;
+ if (addr < 0 || addr > 0xFFFF || val < 0 || val > 255)
+ { consoleHelper.WriteText("?RANGE ERROR"); consoleHelper.NewLine(); break; }
+ mem.Write((ushort)addr, (byte)val);
+ }
+ catch { SyntaxError(); }
+ break;
+
+ case Keyword.PokeX:
+ try
+ {
+ int bank = EvalExpr(t.E0!); if (!_running) break;
+ int addr = EvalExpr(t.E1!); if (!_running) break;
+ int val = EvalExpr(t.E2!); if (!_running) break;
+ if (bank < 0 || bank >= MemoryModel.BankCount ||
+ addr < 0 || addr >= MemoryModel.BankSize ||
+ val < 0 || val > 255)
+ { consoleHelper.WriteText("?RANGE ERROR"); consoleHelper.NewLine(); break; }
+ mem.WriteFlat(bank * MemoryModel.BankSize + addr, (byte)val);
+ }
+ catch { SyntaxError(); }
+ break;
+
+ case Keyword.Goto:
+ gotoTarget = t.LineTarget;
+ break;
+
+ case Keyword.Gosub:
+ if (Array.BinarySearch(_lines, t.LineTarget) < 0)
+ {
+ consoleHelper.WriteText($"?UNDEF'D LINE {t.LineTarget}");
+ consoleHelper.NewLine();
+ _running = false;
+ break;
+ }
+ _callStack.Push(_programCounter);
+ gotoTarget = t.LineTarget;
+ break;
+
+ case Keyword.Return:
+ if (_callStack.Count == 0)
+ {
+ consoleHelper.WriteText("?RETURN WITHOUT GOSUB");
+ consoleHelper.NewLine();
+ _running = false;
+ break;
+ }
+ _programCounter = _callStack.Pop() + 1;
+ _skipIncrement = true;
+ break;
+
+ case Keyword.Input:
+ _inputVariable = t.Var;
+ _waitingForInput = true;
+ consoleHelper.WriteText("?");
+ consoleHelper.NewLine();
+ break;
+
+ case Keyword.If:
+ try
+ {
+ if (EvalExpr(t.E0!) != 0 && t.ThenLine != null)
+ ExecuteTokenized(t.ThenLine, ref gotoTarget);
+ }
+ catch { SyntaxError(); }
+ break;
+
+ default:
+ SyntaxError();
+ break;
+ }
+ }
+
+ // -----------------------------------------------------------------------
+ // Helpers
+ // -----------------------------------------------------------------------
+
private static void SkipSpaces(string s, ref int pos)
{
while (pos < s.Length && s[pos] == ' ') pos++;
}
- private void ExecutePoke(string args)
- {
- int comma = args.IndexOf(',');
- if (comma == -1) { SyntaxError(); return; }
- if (!TryEvaluate(args.Substring(0, comma).Trim(), out int addr)) { SyntaxError(); return; }
- if (!TryEvaluate(args.Substring(comma + 1).Trim(), out int value)) { SyntaxError(); return; }
- if (addr < 0 || addr > 0xFFFF || value < 0 || value > 255)
- {
- consoleHelper.WriteText("?RANGE ERROR");
- consoleHelper.NewLine();
- return;
- }
- mem.Write((ushort)addr, (byte)value);
- }
+ private static bool IsHexChar(char c) =>
+ (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
- private void ExecutePokeX(string args)
- {
- var parts = args.Split(',');
- if (parts.Length != 3) { SyntaxError(); return; }
- if (!TryEvaluate(parts[0].Trim(), out int bank)) { SyntaxError(); return; }
- if (!TryEvaluate(parts[1].Trim(), out int addr)) { SyntaxError(); return; }
- if (!TryEvaluate(parts[2].Trim(), out int value)) { SyntaxError(); return; }
- if (bank < 0 || bank >= MemoryModel.BankCount ||
- addr < 0 || addr >= MemoryModel.BankSize ||
- value < 0 || value > 255)
- {
- consoleHelper.WriteText("?RANGE ERROR");
- consoleHelper.NewLine();
- return;
- }
- mem.WriteFlat(bank * MemoryModel.BankSize + addr, (byte)value);
- }
+ private static int HexVal(char c) =>
+ c <= '9' ? c - '0' : (c | 0x20) - 'a' + 10;
+
+ // -----------------------------------------------------------------------
+ // Disk / file commands
+ // -----------------------------------------------------------------------
private string? ParseFilename(string args)
{
@@ -623,16 +887,11 @@ internal class InputInterpreter
{
string? name = ParseFilename(args);
if (name == null) { SyntaxError(); return; }
-
if (diskManager.MountPath == null)
- {
- consoleHelper.WriteText("?NO DISK");
- consoleHelper.NewLine();
- return;
- }
-
- var path = Path.Combine(diskManager.MountPath, name);
- File.WriteAllLines(path, _program.Select(kv => $"{kv.Key} {kv.Value}"));
+ { consoleHelper.WriteText("?NO DISK"); consoleHelper.NewLine(); return; }
+ File.WriteAllLines(Path.Combine(diskManager.MountPath, name),
+ _program.Select(kv => $"{kv.Key} {kv.Value}"));
+ consoleHelper.WriteText("OK"); consoleHelper.NewLine();
}
private void ExecuteLoad(string args)
@@ -640,28 +899,126 @@ internal class InputInterpreter
string? name = ParseFilename(args);
if (name == null) { SyntaxError(); return; }
- _program.Clear();
- _lines.Clear();
+ _program.Clear(); _tokenized.Clear();
+ _lines = [];
_callStack.Clear();
_running = false;
if (diskManager.MountPath == null)
- {
- consoleHelper.WriteText("?NO DISK");
- consoleHelper.NewLine();
- return;
- }
+ { consoleHelper.WriteText("?NO DISK"); consoleHelper.NewLine(); return; }
var path = Path.Combine(diskManager.MountPath, name);
if (!File.Exists(path))
- {
- consoleHelper.WriteText("?FILE NOT FOUND");
- consoleHelper.NewLine();
- return;
- }
+ { consoleHelper.WriteText("?FILE NOT FOUND"); consoleHelper.NewLine(); return; }
foreach (var line in File.ReadAllLines(path))
InterpretInput(line);
+ consoleHelper.WriteText("OK"); consoleHelper.NewLine();
+ }
+
+ private void ExecuteDelFile(string args)
+ {
+ string? name = ParseFilename(args);
+ if (name == null) { SyntaxError(); return; }
+ if (diskManager.MountPath == null)
+ { consoleHelper.WriteText("?NO DISK"); consoleHelper.NewLine(); return; }
+ var path = Path.Combine(diskManager.MountPath, name);
+ if (!File.Exists(path))
+ { consoleHelper.WriteText("?FILE NOT FOUND"); consoleHelper.NewLine(); return; }
+ File.Delete(path);
+ consoleHelper.WriteText("OK"); consoleHelper.NewLine();
+ }
+
+ private void ExecuteExec(string args)
+ {
+ if (args.StartsWith("\""))
+ {
+ int close = args.IndexOf('"', 1);
+ if (close < 0) { SyntaxError(); return; }
+ string name = args.Substring(1, close - 1).ToUpperInvariant();
+ string rest = args.Substring(close + 1).TrimStart();
+ if (!rest.StartsWith(",")) { SyntaxError(); return; }
+ int addr;
+ try { addr = EvalExpr(CompileExpr(rest.Substring(1).Trim())); }
+ catch { SyntaxError(); return; }
+ if (!_running) return;
+
+ if (diskManager.MountPath == null)
+ { consoleHelper.WriteText("?NO DISK"); consoleHelper.NewLine(); return; }
+ var path = Path.Combine(diskManager.MountPath, name);
+ if (!File.Exists(path))
+ { consoleHelper.WriteText("?FILE NOT FOUND"); consoleHelper.NewLine(); return; }
+
+ byte[] data = File.ReadAllBytes(path);
+ int start = (data.Length > 0 && data[0] == 0x01) ? 1 : 0;
+ for (int i = start; i < data.Length; i++)
+ mem.Write((ushort)(addr + i - start), data[i]);
+ cpu.Run((ushort)addr);
+ }
+ else
+ {
+ int addr;
+ try { addr = EvalExpr(CompileExpr(args)); }
+ catch { SyntaxError(); return; }
+ if (_running) cpu.Run((ushort)addr);
+ }
+ }
+
+ private void ExecuteAsm(string args)
+ {
+ string? name = ParseFilename(args);
+ if (name == null) { SyntaxError(); return; }
+ if (diskManager.MountPath == null)
+ { consoleHelper.WriteText("?NO DISK"); consoleHelper.NewLine(); return; }
+
+ {
+ var psi = new System.Diagnostics.ProcessStartInfo
+ { FileName = "which", Arguments = "lwasm",
+ RedirectStandardOutput = true, RedirectStandardError = true };
+ var p = System.Diagnostics.Process.Start(psi)!;
+ p.WaitForExit();
+ if (p.ExitCode != 0)
+ { consoleHelper.WriteText("?LWASM NOT FOUND"); consoleHelper.NewLine(); return; }
+ }
+
+ var inputPath = Path.Combine(diskManager.MountPath, name);
+ if (!File.Exists(inputPath))
+ { consoleHelper.WriteText("?FILE NOT FOUND"); consoleHelper.NewLine(); return; }
+
+ string baseName = Path.GetFileNameWithoutExtension(name);
+ if (baseName.Length + 4 > 12) baseName = baseName[..(12 - 4)];
+ string outputName = baseName + ".BIN";
+ var outputPath = Path.Combine(diskManager.MountPath, outputName);
+ string tmpFile = Path.GetTempFileName();
+
+ try
+ {
+ var psi = new System.Diagnostics.ProcessStartInfo
+ { FileName = "lwasm", RedirectStandardError = true };
+ psi.ArgumentList.Add("--format=raw");
+ psi.ArgumentList.Add("-9");
+ psi.ArgumentList.Add("-o");
+ psi.ArgumentList.Add(tmpFile);
+ psi.ArgumentList.Add(inputPath);
+
+ var p = System.Diagnostics.Process.Start(psi)!;
+ string stderr = p.StandardError.ReadToEnd();
+ p.WaitForExit();
+
+ if (p.ExitCode != 0)
+ {
+ foreach (var line in stderr.Split('\n', StringSplitOptions.RemoveEmptyEntries))
+ { consoleHelper.WriteText(line); consoleHelper.NewLine(); }
+ return;
+ }
+
+ byte[] raw = File.ReadAllBytes(tmpFile);
+ byte[] output = new byte[raw.Length + 1];
+ output[0] = 0x01;
+ raw.CopyTo(output, 1);
+ File.WriteAllBytes(outputPath, output);
+ }
+ finally { try { File.Delete(tmpFile); } catch { } }
}
private void SyntaxError()
@@ -669,34 +1026,4 @@ internal class InputInterpreter
consoleHelper.WriteText("?SYNTAX ERROR");
consoleHelper.NewLine();
}
-
- private void ExecutePrint(string args)
- {
- if (args.StartsWith("\""))
- {
- int last = args.LastIndexOf('"');
- if (last == 0)
- {
- SyntaxError();
- return;
- }
- consoleHelper.WriteText(args.Substring(1, last - 1));
- consoleHelper.NewLine();
- return;
- }
-
- if (args.Length == 1 && char.IsUpper(args[0]))
- {
- if (!_variables.TryGetValue(args[0], out int val))
- {
- SyntaxError();
- return;
- }
- consoleHelper.WriteText(val.ToString());
- consoleHelper.NewLine();
- return;
- }
-
- SyntaxError();
- }
}
diff --git a/Program.cs b/Program.cs
index 8f44adb..a775b19 100644
--- a/Program.cs
+++ b/Program.cs
@@ -7,6 +7,10 @@ const int ScreenHeight = 180;
const string Title = "Micronona";
const int Scale = 3;
+string? runFile = null;
+for (int i = 0; i < args.Length - 1; i++)
+ if (args[i] == "--run") { runFile = args[i + 1]; break; }
+
// -------------------------------------------------------------------------
// Memory
// -------------------------------------------------------------------------
@@ -28,8 +32,9 @@ var diskManager = new DiskManager();
var micrononaRenderer = new MicrononaRenderer(mem);
var consoleHelper = new ConsoleHelper(mem);
+var cpu = new Cpu6809(mem, consoleHelper);
-var inputInterpreter = new InputInterpreter(mem, consoleHelper, diskManager);
+var inputInterpreter = new InputInterpreter(mem, consoleHelper, diskManager, cpu);
// Unit Separator (ASCII 31) für Eingabeaufforderung
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 31 * MemoryModel.FontGlyphHeight,
@@ -47,6 +52,11 @@ mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 34 * MemoryMode
0x00, 0x36, 0x66, 0x6C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
);
+// #
+mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 35 * MemoryModel.FontGlyphHeight,
+ 0x00, 0x034, 0x34, 0x7E, 0x34, 0x7E, 0x34, 0x34, 0x00, 0x00
+);
+
// $
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 36 * MemoryModel.FontGlyphHeight,
// 0x00, 0x18, 0x3E, 0x68, 0x3C, 0x16, 0x7C, 0x18, 0x00, 0x00
@@ -90,6 +100,11 @@ mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 46 * MemoryMode
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00
);
+// /
+mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 47 * MemoryModel.FontGlyphHeight,
+ 0x00, 0x04, 0x0C, 0x08, 0x18, 0x10, 0x30, 0x20, 0x00, 0x00
+);
+
// 0
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 48 * MemoryModel.FontGlyphHeight,
@@ -196,6 +211,11 @@ mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 69 * MemoryMode
0x00, 0x7E, 0x60, 0x60, 0x7C, 0x60, 0x60, 0x7E, 0x00, 0x00
);
+// F
+mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 70 * MemoryModel.FontGlyphHeight,
+ 0x00, 0x7E, 0x60, 0x60, 0x7C, 0x60, 0x60, 0x60, 0x00, 0x00
+);
+
// G
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 71 * MemoryModel.FontGlyphHeight,
0x00, 0x3C, 0x66, 0x60, 0x6E, 0x66, 0x66, 0x3C, 0x00, 0x00
@@ -211,6 +231,11 @@ mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 73 * MemoryMode
0x00, 0x3C, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00
);
+// J
+mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 74 * MemoryModel.FontGlyphHeight,
+ 0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 0x66, 0x3C, 0x00, 0x00
+);
+
// K
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 75 * MemoryModel.FontGlyphHeight,
0x00, 0x66, 0x6C, 0x78, 0x70, 0x78, 0x6C, 0x66, 0x00, 0x00
@@ -245,6 +270,12 @@ mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 80 * MemoryMode
// 0x00, 0x62, 0x76, 0x7E, 0x6A, 0x62, 0x62, 0x66, 0x00, 0x00
);
+// Q
+mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 81 * MemoryModel.FontGlyphHeight,
+ 0x00, 0x3C, 0x66, 0x66, 0x66, 0x66, 0x6E, 0x3C, 0x06, 0x00
+
+);
+
// R
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 82 * MemoryModel.FontGlyphHeight,
0x00, 0x7C, 0x66, 0x66, 0x7C, 0x78, 0x6C, 0x66, 0x00, 0x00
@@ -269,7 +300,10 @@ mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 85 * MemoryMode
0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x00, 0x00
);
-
+// V
+mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 86 * MemoryModel.FontGlyphHeight,
+ 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x18, 0x00, 0x00
+);
// W
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 87 * MemoryModel.FontGlyphHeight,
@@ -286,6 +320,16 @@ mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 89 * MemoryMode
0x00, 0x66, 0x66, 0x3C, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00
);
+// Z
+mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 90 * MemoryModel.FontGlyphHeight,
+ 0x00, 0x7E, 0x06, 0x0C, 0x18, 0x30, 0x60, 0x7E, 0x00, 0x00
+);
+
+// _
+mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 95 * MemoryModel.FontGlyphHeight,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00
+);
+
// a
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 97 * MemoryModel.FontGlyphHeight,
0x00, 0x00, 0x3C, 0x06, 0x3E, 0x66, 0x66, 0x3E, 0x00, 0x00
@@ -311,6 +355,11 @@ mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 101 * MemoryMod
0x00, 0x00, 0x3C, 0x66, 0x7E, 0x60, 0x66, 0x3C, 0x00, 0x00
);
+// f
+mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 102 * MemoryModel.FontGlyphHeight,
+ 0x00, 0x0C, 0x18, 0x18, 0x3C, 0x18, 0x18, 0x18, 0x18, 0x00
+);
+
// h
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 104 * MemoryModel.FontGlyphHeight,
0x00, 0x60, 0x60, 0x60, 0x7C, 0x66, 0x66, 0x66, 0x00, 0x00
@@ -323,6 +372,11 @@ mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 105 * MemoryMod
0x00, 0x18, 0x00, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, 0x00
);
+// j
+mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 106 * MemoryModel.FontGlyphHeight,
+ 0x00, 0x18, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x30, 0x00
+);
+
// k
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 107 * MemoryModel.FontGlyphHeight,
0x00, 0x60, 0x60, 0x66, 0x6C, 0x78, 0x6C, 0x66, 0x00, 0x00
@@ -464,8 +518,51 @@ scrollLock.Set(false);
diskManager.OnMicrononaStickInserted += path => { Console.WriteLine($"Ready: {path}"); scrollLock.Set(true); };
diskManager.OnStickRemoved += () => { Console.WriteLine("Stick removed"); scrollLock.Set(false); };
diskManager.Start();
+cpu.StartThread();
inputInterpreter.StartThread();
+// -------------------------------------------------------------------------
+// --run : load and execute file from stick, quit after 5 seconds
+// -------------------------------------------------------------------------
+
+long runStartTick = 0;
+
+if (runFile != null)
+{
+ var deadline = Environment.TickCount64 + 3000;
+ while (diskManager.MountPath == null && Environment.TickCount64 < deadline)
+ Thread.Sleep(50);
+
+ if (diskManager.MountPath == null)
+ {
+ Console.Error.WriteLine($"--run: no Micronona stick mounted");
+ inputInterpreter.StopThread();
+ cpu.StopThread();
+ SDL.SDL_DestroyTexture(texture);
+ SDL.SDL_DestroyRenderer(renderer);
+ SDL.SDL_DestroyWindow(window);
+ SDL.SDL_Quit();
+ return 1;
+ }
+
+ var filePath = Path.Combine(diskManager.MountPath, runFile.ToUpperInvariant());
+ if (!File.Exists(filePath))
+ {
+ Console.Error.WriteLine($"--run: file not found on stick: {runFile}");
+ inputInterpreter.StopThread();
+ cpu.StopThread();
+ SDL.SDL_DestroyTexture(texture);
+ SDL.SDL_DestroyRenderer(renderer);
+ SDL.SDL_DestroyWindow(window);
+ SDL.SDL_Quit();
+ return 1;
+ }
+
+ inputInterpreter.InterpretInput($"LOAD \"{runFile}\"");
+ inputInterpreter.InterpretInput("RUN");
+ runStartTick = Environment.TickCount64;
+}
+
// -------------------------------------------------------------------------
// Main loop
// -------------------------------------------------------------------------
@@ -491,6 +588,7 @@ while (running)
case SDL.SDL_Keycode.SDLK_c when (e.key.keysym.mod & SDL.SDL_Keymod.KMOD_CTRL) != 0:
case SDL.SDL_Keycode.SDLK_PAUSE when (e.key.keysym.mod & SDL.SDL_Keymod.KMOD_CTRL) != 0:
inputInterpreter.Stop();
+ cpu.Stop();
break;
}
@@ -543,6 +641,11 @@ while (running)
SDL.SDL_RenderClear(renderer);
SDL.SDL_RenderCopy(renderer, texture, IntPtr.Zero, IntPtr.Zero);
SDL.SDL_RenderPresent(renderer);
+
+ mem.TickFrame();
+
+ if (runStartTick > 0 && Environment.TickCount64 - runStartTick >= 5000)
+ running = false;
}
// -------------------------------------------------------------------------
@@ -550,6 +653,7 @@ while (running)
// -------------------------------------------------------------------------
inputInterpreter.StopThread();
+cpu.StopThread();
SDL.SDL_DestroyTexture(texture);
SDL.SDL_DestroyRenderer(renderer);
SDL.SDL_DestroyWindow(window);