Bytecode-Compiler, Cpu6809-Emulator, BASIC-Interpreter-Optimierungen
- Expression-Bytecode-Compiler für den BASIC-Interpreter: Ausdrücke werden beim Eintippen in ein kompaktes int[]-Bytecode übersetzt und per stackalloc-Stack ohne Heap-Allokation ausgewertet - Variablen-Dictionary durch int[26]-Array ersetzt (A=0…Z=25), Bytecode emittiert jetzt direkte 0-basierte Indizes - GOTO/GOSUB: _lineIndex-Dictionary entfernt, stattdessen Array.BinarySearch auf dem sortierten _lines-Array - Debug-Print in Execute() entfernt - REG_MODE=0 (Textmodus) bei END und Programmende; Ctrl+Pause: Textmodus nur wenn kein Programm lief, sonst Bild stehen lassen - Cpu6809: vollständiger Motorola-6809-Emulator (alle Opcodes, Adressierungsarten, ALU, Stack, SWI-Halt) Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
This commit is contained in:
parent
45ff3d2ff2
commit
c13f25ab08
3 changed files with 1718 additions and 369 deletions
918
Cpu6809.cs
Normal file
918
Cpu6809.cs
Normal file
|
|
@ -0,0 +1,918 @@
|
|||
using System.Runtime.CompilerServices;
|
||||
|
||||
/// <summary>
|
||||
/// 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.
|
||||
/// </summary>
|
||||
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);
|
||||
}
|
||||
}
|
||||
1045
InputInterpreter.cs
1045
InputInterpreter.cs
File diff suppressed because it is too large
Load diff
108
Program.cs
108
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 <file>: 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);
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue