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);