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:
Hans-Jörg Meyer 2026-04-16 12:26:52 +02:00
parent 45ff3d2ff2
commit c13f25ab08
3 changed files with 1718 additions and 369 deletions

918
Cpu6809.cs Normal file
View 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);
}
}

File diff suppressed because it is too large Load diff

View file

@ -7,6 +7,10 @@ const int ScreenHeight = 180;
const string Title = "Micronona"; const string Title = "Micronona";
const int Scale = 3; 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 // Memory
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
@ -28,8 +32,9 @@ var diskManager = new DiskManager();
var micrononaRenderer = new MicrononaRenderer(mem); var micrononaRenderer = new MicrononaRenderer(mem);
var consoleHelper = new ConsoleHelper(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 // Unit Separator (ASCII 31) für Eingabeaufforderung
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 31 * MemoryModel.FontGlyphHeight, 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 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, mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 36 * MemoryModel.FontGlyphHeight,
// 0x00, 0x18, 0x3E, 0x68, 0x3C, 0x16, 0x7C, 0x18, 0x00, 0x00 // 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 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 // 0
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 48 * MemoryModel.FontGlyphHeight, 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 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 // G
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 71 * MemoryModel.FontGlyphHeight, mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 71 * MemoryModel.FontGlyphHeight,
0x00, 0x3C, 0x66, 0x60, 0x6E, 0x66, 0x66, 0x3C, 0x00, 0x00 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 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 // K
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 75 * MemoryModel.FontGlyphHeight, mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 75 * MemoryModel.FontGlyphHeight,
0x00, 0x66, 0x6C, 0x78, 0x70, 0x78, 0x6C, 0x66, 0x00, 0x00 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 // 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 // R
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 82 * MemoryModel.FontGlyphHeight, mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 82 * MemoryModel.FontGlyphHeight,
0x00, 0x7C, 0x66, 0x66, 0x7C, 0x78, 0x6C, 0x66, 0x00, 0x00 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 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 // W
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 87 * MemoryModel.FontGlyphHeight, 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 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 // a
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 97 * MemoryModel.FontGlyphHeight, mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 97 * MemoryModel.FontGlyphHeight,
0x00, 0x00, 0x3C, 0x06, 0x3E, 0x66, 0x66, 0x3E, 0x00, 0x00 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 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 // h
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 104 * MemoryModel.FontGlyphHeight, mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 104 * MemoryModel.FontGlyphHeight,
0x00, 0x60, 0x60, 0x60, 0x7C, 0x66, 0x66, 0x66, 0x00, 0x00 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 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 // k
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 107 * MemoryModel.FontGlyphHeight, mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 107 * MemoryModel.FontGlyphHeight,
0x00, 0x60, 0x60, 0x66, 0x6C, 0x78, 0x6C, 0x66, 0x00, 0x00 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.OnMicrononaStickInserted += path => { Console.WriteLine($"Ready: {path}"); scrollLock.Set(true); };
diskManager.OnStickRemoved += () => { Console.WriteLine("Stick removed"); scrollLock.Set(false); }; diskManager.OnStickRemoved += () => { Console.WriteLine("Stick removed"); scrollLock.Set(false); };
diskManager.Start(); diskManager.Start();
cpu.StartThread();
inputInterpreter.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 // 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_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: case SDL.SDL_Keycode.SDLK_PAUSE when (e.key.keysym.mod & SDL.SDL_Keymod.KMOD_CTRL) != 0:
inputInterpreter.Stop(); inputInterpreter.Stop();
cpu.Stop();
break; break;
} }
@ -543,6 +641,11 @@ while (running)
SDL.SDL_RenderClear(renderer); SDL.SDL_RenderClear(renderer);
SDL.SDL_RenderCopy(renderer, texture, IntPtr.Zero, IntPtr.Zero); SDL.SDL_RenderCopy(renderer, texture, IntPtr.Zero, IntPtr.Zero);
SDL.SDL_RenderPresent(renderer); SDL.SDL_RenderPresent(renderer);
mem.TickFrame();
if (runStartTick > 0 && Environment.TickCount64 - runStartTick >= 5000)
running = false;
} }
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
@ -550,6 +653,7 @@ while (running)
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
inputInterpreter.StopThread(); inputInterpreter.StopThread();
cpu.StopThread();
SDL.SDL_DestroyTexture(texture); SDL.SDL_DestroyTexture(texture);
SDL.SDL_DestroyRenderer(renderer); SDL.SDL_DestroyRenderer(renderer);
SDL.SDL_DestroyWindow(window); SDL.SDL_DestroyWindow(window);