using System.Diagnostics; using System.Text.RegularExpressions; // --------------------------------------------------------------------------- // Expression bytecode // --------------------------------------------------------------------------- internal enum Op { PushConst, PushVar, Add, Sub, Mul, Div, Mod, Negate, CallRnd, CallPeek, CallPeekX, CallGetPixel, 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, Cls, Locate, Color, Mode, SetChar, Inkey, Vsync, Clear, PutPixel, For, Next } 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 / SETCHAR) public CompiledExpr? E3; // quaternary expression (SETCHAR) public CompiledExpr? E4; // quinary expression (SETCHAR) public string? PrintLiteral; // PRINT "text" — pre-extracted, no quotes public bool SuppressNewLine; // PRINT "..."; — trailing semicolon } // --------------------------------------------------------------------------- // 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 Cpu6809 cpu; private readonly TextEditor _editor; 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 readonly Stack _callStack = new(); private readonly Stack<(char var, int to, int step, int bodyPc)> _forStack = new(); private Thread? _thread; private CancellationTokenSource _cts = new(); private readonly ManualResetEventSlim _runSignal = new(false); private readonly SemaphoreSlim _inputSignal = new(0, 1); // KMAP state — feeding the keyboard-layout detector from the main SDL loop. private volatile bool _kmapActive; private volatile bool _waitingForKmapKey; private int? _kmapKeycode; private char _kmapDisplayChar; private readonly SemaphoreSlim _kmapSignal = new(0, 1); // 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) { _rng ^= _rng << 13; _rng ^= _rng >> 17; _rng ^= _rng << 5; return (int)((_rng & 0x7FFFFFFFu) % (uint)n); } public InputInterpreter(MemoryModel mem, ConsoleHelper consoleHelper, DiskManager diskManager, Cpu6809 cpu) { this.mem = mem; this.consoleHelper = consoleHelper; this.diskManager = diskManager; this.cpu = cpu; _editor = new TextEditor(consoleHelper); } public bool IsRunning => _running; public bool IsWaitingForInput => _waitingForInput; public bool IsKmapActive => _kmapActive; public bool IsWaitingForKmapKey => _waitingForKmapKey; public bool IsEditorActive => _editor.IsActive; public void EditorChar(char c) => _editor.OnChar(c); public void EditorAction(EditorAction a) => _editor.OnAction(a); // ----------------------------------------------------------------------- // Thread management // ----------------------------------------------------------------------- public void StartThread() { _thread = new Thread(RunLoop) { IsBackground = true, Name = "BasicInterpreter" }; _thread.Start(); } public void StopThread() { _running = false; _cts.Cancel(); try { _runSignal.Set(); } catch { } try { _inputSignal.Release(); } catch { } try { _kmapSignal.Release(); } catch { } _thread?.Join(); } private void RunLoop() { try { while (true) { _runSignal.Wait(_cts.Token); _runSignal.Reset(); while (_running && !_cts.IsCancellationRequested) { if (_waitingForInput) { _inputSignal.Wait(_cts.Token); continue; } Tick(); } } } catch (OperationCanceledException) { } } // ----------------------------------------------------------------------- // Input handling // ----------------------------------------------------------------------- public void SubmitInput(string line) { if (!_waitingForInput) return; if (int.TryParse(line.Trim(), out int val)) { _variables[_inputVariable - 'A'] = val; _waitingForInput = false; _programCounter++; _inputSignal.Release(); } else { consoleHelper.WriteText("?"); consoleHelper.NewLine(); } } public void Stop() { bool wasRunning = _running; _running = false; _forStack.Clear(); mem.Write(MemoryModel.IoBase + MemoryModel.REG_MODE, 0); if (!wasRunning) consoleHelper.Cls(); if (_waitingForInput) { _waitingForInput = false; try { _inputSignal.Release(); } catch { } } consoleHelper.NewLine(); consoleHelper.WriteText("BREAK"); consoleHelper.NewLine(); } // ----------------------------------------------------------------------- // Execution tick // ----------------------------------------------------------------------- private void Tick() { if (!_running) return; if (_programCounter >= _lines.Length) { _running = false; return; } int lineNr = _lines[_programCounter]; int? gotoTarget = null; _skipIncrement = false; long t0 = Stopwatch.GetTimestamp(); ExecuteTokenized(_tokenized[lineNr], ref gotoTarget); long t1 = Stopwatch.GetTimestamp(); if (_waitingForInput || _skipIncrement) return; if (gotoTarget.HasValue) { int idx = Array.BinarySearch(_lines, gotoTarget.Value); if (idx < 0) { consoleHelper.WriteText($"?UNDEF'D LINE {gotoTarget.Value}"); consoleHelper.NewLine(); _running = false; } else { _programCounter = idx; } } else { _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(); if (string.IsNullOrEmpty(input)) return; var match = LineNumberPattern.Match(input); if (match.Success) { 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; _tokenized[lineNumber] = Tokenize(statement); } } else { Execute(input); } } private void Execute(string input) { var cmd = input.ToLowerInvariant(); if (cmd == "run") { _lines = _program.Keys.ToArray(); _programCounter = 0; _callStack.Clear(); _forStack.Clear(); _running = true; _runSignal.Set(); return; } if (cmd == "new") { _program.Clear(); _tokenized.Clear(); _lines = []; _callStack.Clear(); _forStack.Clear(); _running = false; consoleHelper.WriteText("OK"); consoleHelper.NewLine(); return; } if (cmd == "list") { 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; } if (cmd.StartsWith("load ") || cmd.StartsWith("load\"")) { 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.StartsWith("edit ") || cmd.StartsWith("edit\"")) { ExecuteEditor(input.Substring("edit".Length).Trim()); return; } if (cmd == "dir") { var (error, files) = diskManager.Dir(); if (error != null) { consoleHelper.WriteText($"Error: {error}"); consoleHelper.NewLine(); } else if (files is not null) foreach (var file in files) { consoleHelper.WriteText(file.Name); consoleHelper.NewLine(); } return; } if (cmd == "kmap") { StartKmap(); return; } int? unused = null; ExecuteTokenized(Tokenize(input), ref unused); } // ----------------------------------------------------------------------- // KMAP — keyboard-layout detection inside Micronona. // The actual work runs on a dedicated thread because the main SDL loop // (which drives key delivery) must keep ticking. // ----------------------------------------------------------------------- public void SubmitKmapKey(int? linuxKeycode, char displayChar = '\0') { if (!_waitingForKmapKey) return; _kmapKeycode = linuxKeycode; _kmapDisplayChar = displayChar; _waitingForKmapKey = false; try { _kmapSignal.Release(); } catch { } } private void StartKmap() { if (_kmapActive) { consoleHelper.WriteText("KMAP ALREADY RUNNING"); consoleHelper.NewLine(); return; } _kmapActive = true; new Thread(RunKmap) { IsBackground = true, Name = "Kmap" }.Start(); } private void RunKmap() { try { string? layout = KeyboardLayoutDetector.Detect( "/usr/share/keymaps", msg => { consoleHelper.WriteText(msg); consoleHelper.NewLine(); }, prompt => { consoleHelper.WriteText(prompt + ": "); _kmapKeycode = null; _kmapDisplayChar = '\0'; _waitingForKmapKey = true; try { _kmapSignal.Wait(_cts.Token); } catch (OperationCanceledException) { _waitingForKmapKey = false; return null; } if (_kmapDisplayChar != '\0') consoleHelper.WriteText(_kmapDisplayChar.ToString()); consoleHelper.NewLine(); return _kmapKeycode; }); if (layout == null) { consoleHelper.WriteText("KMAP CANCELLED"); consoleHelper.NewLine(); return; } if (diskManager.MountPath != null) { DiskManager.SaveKeyboardLayout(diskManager.MountPath, layout); consoleHelper.WriteText($"SAVED: {layout}"); } else { consoleHelper.WriteText($"DETECTED: {layout} (NO DISK)"); } consoleHelper.NewLine(); KeyboardLayoutDetector.ApplyLoadkeys(layout); } finally { _waitingForKmapKey = false; _kmapActive = false; } } // ----------------------------------------------------------------------- // Tokenizer — runs once at line entry; compiles expressions to bytecode // ----------------------------------------------------------------------- private static TokenizedLine Tokenize(string raw) { var t = new TokenizedLine(); var s = raw.Trim(); if (s.Length == 0) return t; var lo = s.ToLowerInvariant(); 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 (lo == "print" || lo.StartsWith("print ")) { t.Kw = Keyword.Print; string a = s.Length > 5 ? s.Substring(5).Trim() : ""; if (a.EndsWith(";")) { t.SuppressNewLine = true; a = a.Substring(0, a.Length - 1).TrimEnd(); } if (a.StartsWith("\"")) { int last = a.LastIndexOf('"'); if (last <= 0) { t.Kw = Keyword.Unknown; return t; } t.PrintLiteral = a.Substring(1, last - 1); } else if (a.Length > 0) { try { t.E0 = CompileExpr(a); } catch { t.Kw = Keyword.Unknown; } } return t; } if (lo.StartsWith("let ")) { t.Kw = Keyword.Let; var args = s.Substring(4).Trim(); if (args.Length >= 1 && char.IsUpper(args[0])) { 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; } else t.Kw = Keyword.Unknown; return t; } if (lo.StartsWith("pokex ")) { 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 { 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; } 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; } if (lo == "cls") { t.Kw = Keyword.Cls; return t; } if (lo.StartsWith("locate ")) { t.Kw = Keyword.Locate; var args = s.Substring(7).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("color ")) { t.Kw = Keyword.Color; var args = s.Substring(6).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("mode ")) { t.Kw = Keyword.Mode; try { t.E0 = CompileExpr(s.Substring(5).Trim()); } catch { t.Kw = Keyword.Unknown; } return t; } if (lo.StartsWith("setchar ")) { t.Kw = Keyword.SetChar; var args = s.Substring(8).Trim(); var parts = new string[5]; int start = 0; for (int i = 0; i < 4; i++) { int c = args.IndexOf(',', start); if (c < 0) { t.Kw = Keyword.Unknown; return t; } parts[i] = args.Substring(start, c - start).Trim(); start = c + 1; } parts[4] = args.Substring(start).Trim(); try { t.E0 = CompileExpr(parts[0]); t.E1 = CompileExpr(parts[1]); t.E2 = CompileExpr(parts[2]); t.E3 = CompileExpr(parts[3]); t.E4 = CompileExpr(parts[4]); } catch { t.Kw = Keyword.Unknown; } return t; } if (lo == "vsync") { t.Kw = Keyword.Vsync; return t; } if (lo.StartsWith("clear ")) { t.Kw = Keyword.Clear; try { t.E0 = CompileExpr(s.Substring(6).Trim()); } catch { t.Kw = Keyword.Unknown; } return t; } if (lo.StartsWith("putpixel ")) { t.Kw = Keyword.PutPixel; var args = s.Substring(9).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 { 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; } if (lo.StartsWith("for ")) { var args = s.Substring(4).Trim(); if (args.Length < 1 || !char.IsUpper(args[0])) { t.Kw = Keyword.Unknown; return t; } t.Kw = Keyword.For; t.Var = args[0]; var rest = args.Substring(1).TrimStart(); if (!rest.StartsWith("=")) { t.Kw = Keyword.Unknown; return t; } rest = rest.Substring(1).Trim(); int toIdx = FindWord(rest, "TO"); if (toIdx < 0) { t.Kw = Keyword.Unknown; return t; } string fromStr = rest.Substring(0, toIdx).Trim(); rest = rest.Substring(toIdx + 2).Trim(); int stepIdx = FindWord(rest, "STEP"); string toStr = stepIdx >= 0 ? rest.Substring(0, stepIdx).Trim() : rest.Trim(); string? stepStr = stepIdx >= 0 ? rest.Substring(stepIdx + 4).Trim() : null; try { t.E0 = CompileExpr(fromStr); t.E1 = CompileExpr(toStr); if (stepStr != null) t.E2 = CompileExpr(stepStr); } catch { t.Kw = Keyword.Unknown; } return t; } if (lo == "next" || lo.StartsWith("next ")) { t.Kw = Keyword.Next; if (lo.Length > 5) { var arg = s.Substring(5).Trim(); if (arg.Length == 1 && char.IsUpper(arg[0])) t.Var = arg[0]; else { t.Kw = Keyword.Unknown; return t; } } // bare NEXT: t.Var bleibt '\0' → passt auf obersten Frame return t; } if (lo.StartsWith("inkey ") || lo == "inkey") { t.Kw = Keyword.Inkey; var arg = s.Length > 6 ? s.Substring(6).Trim() : s.Substring(5).Trim(); if (arg.Length == 1 && char.IsUpper(arg[0])) t.Var = arg[0]; else t.Kw = Keyword.Unknown; return t; } return t; // Unknown → SyntaxError at runtime } // ----------------------------------------------------------------------- // Expression compiler // ----------------------------------------------------------------------- private static CompiledExpr CompileExpr(string expr) { 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 static CompiledExpr CompileCondition(string cond) { // Two-char operators must precede their single-char prefixes in the list. string[] ops = { "<=", ">=", "<>", "<", ">", "=" }; foreach (var op in ops) { 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 static void CompileExprInto(string s, ref int pos, List code) { CompileTermInto(s, ref pos, code); while (true) { SkipSpaces(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; } } private static void CompileTermInto(string s, ref int pos, List code) { CompileFactorInto(s, ref pos, code); while (true) { SkipSpaces(s, ref pos); if (pos < s.Length && s[pos] == '*') { pos++; CompileFactorInto(s, ref pos, code); code.Add((int)Op.Mul); } else if (pos < s.Length && s[pos] == '/') { pos++; CompileFactorInto(s, ref pos, code); code.Add((int)Op.Div); } else if (pos + 3 <= s.Length && (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; CompileFactorInto(s, ref pos, code); code.Add((int)Op.Mod); } else break; } } private static void CompileFactorInto(string s, ref int pos, List code) { SkipSpaces(s, ref pos); if (pos >= s.Length) throw new InvalidOperationException(); if (s[pos] == '(') { pos++; CompileExprInto(s, ref pos, code); SkipSpaces(s, ref pos); if (pos >= s.Length || s[pos] != ')') throw new InvalidOperationException(); pos++; return; } if (s[pos] == '-') { pos++; CompileFactorInto(s, ref pos, code); code.Add((int)Op.Negate); return; } // 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++; CompileExprInto(s, ref pos, code); SkipSpaces(s, ref pos); if (pos >= s.Length || s[pos] != ')') throw new InvalidOperationException(); pos++; code.Add((int)Op.CallRnd); return; } // 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++; CompileExprInto(s, ref pos, code); // bank SkipSpaces(s, ref pos); if (pos >= s.Length || s[pos] != ',') throw new InvalidOperationException(); pos++; CompileExprInto(s, ref pos, code); // addr SkipSpaces(s, ref pos); if (pos >= s.Length || s[pos] != ')') throw new InvalidOperationException(); pos++; code.Add((int)Op.CallPeekX); return; } // 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++; CompileExprInto(s, ref pos, code); SkipSpaces(s, ref pos); if (pos >= s.Length || s[pos] != ')') throw new InvalidOperationException(); pos++; code.Add((int)Op.CallPeek); return; } // GETPIXEL(x, y) if (pos + 8 <= s.Length && (s[pos] | 0x20) == 'g' && (s[pos+1] | 0x20) == 'e' && (s[pos+2] | 0x20) == 't' && (s[pos+3] | 0x20) == 'p' && (s[pos+4] | 0x20) == 'i' && (s[pos+5] | 0x20) == 'x' && (s[pos+6] | 0x20) == 'e' && (s[pos+7] | 0x20) == 'l') { pos += 8; SkipSpaces(s, ref pos); if (pos >= s.Length || s[pos] != '(') throw new InvalidOperationException(); pos++; CompileExprInto(s, ref pos, code); // x SkipSpaces(s, ref pos); if (pos >= s.Length || s[pos] != ',') throw new InvalidOperationException(); pos++; CompileExprInto(s, ref pos, code); // y SkipSpaces(s, ref pos); if (pos >= s.Length || s[pos] != ')') throw new InvalidOperationException(); pos++; code.Add((int)Op.CallGetPixel); return; } // Variable (single uppercase letter) — emit 0-based index (A=0 … Z=25) if (char.IsUpper(s[pos])) { code.Add((int)Op.PushVar); code.Add(s[pos++] - 'A'); return; } // Hex literal $XX if (s[pos] == '$') { pos++; 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 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($"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.CallGetPixel: { int y = stack[--sp]; int x = stack[--sp]; int offset = y * 320 + x; stack[sp++] = offset < 57600 ? mem.ReadFlat(offset) : 0; 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); if (!t.SuppressNewLine) consoleHelper.NewLine(); } else if (t.E0 != null) { try { consoleHelper.WriteText(EvalExpr(t.E0).ToString()); } catch { SyntaxError(); break; } if (_running && !t.SuppressNewLine) consoleHelper.NewLine(); } break; case Keyword.End: _running = false; 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; case Keyword.Cls: consoleHelper.Cls(); break; case Keyword.Locate: try { int x = EvalExpr(t.E0!); if (!_running) break; int y = EvalExpr(t.E1!); if (!_running) break; if (x < 0 || x >= MemoryModel.TextCols || y < 0 || y >= MemoryModel.TextRows) { consoleHelper.WriteText("?RANGE ERROR"); consoleHelper.NewLine(); break; } consoleHelper.SetCursor((byte)x, (byte)y); } catch { SyntaxError(); } break; case Keyword.Color: try { int fg = EvalExpr(t.E0!); if (!_running) break; int bg = EvalExpr(t.E1!); if (!_running) break; if (fg < 0 || fg > 255 || bg < 0 || bg > 255) { consoleHelper.WriteText("?RANGE ERROR"); consoleHelper.NewLine(); break; } consoleHelper.CurrentFg = (byte)fg; consoleHelper.CurrentBg = (byte)bg; } catch { SyntaxError(); } break; case Keyword.Mode: try { int mode = EvalExpr(t.E0!); if (!_running) break; mem.Write(MemoryModel.IoBase + MemoryModel.REG_MODE, (byte)mode); } catch { SyntaxError(); } break; case Keyword.SetChar: try { int x = EvalExpr(t.E0!); if (!_running) break; int y = EvalExpr(t.E1!); if (!_running) break; int asc = EvalExpr(t.E2!); if (!_running) break; int fg = EvalExpr(t.E3!); if (!_running) break; int bg = EvalExpr(t.E4!); if (!_running) break; if (x < 0 || x >= MemoryModel.TextCols || y < 0 || y >= MemoryModel.TextRows || asc < 0 || asc > 255 || fg < 0 || fg > 255 || bg < 0 || bg > 255) { consoleHelper.WriteText("?RANGE ERROR"); consoleHelper.NewLine(); break; } consoleHelper.SetChar(x, y, (byte)asc, (byte)fg, (byte)bg); } catch { SyntaxError(); } break; case Keyword.Inkey: { byte key = mem.Read(MemoryModel.IoBase + MemoryModel.REG_KEY_CHAR); _variables[t.Var - 'A'] = key; break; } case Keyword.Vsync: mem.Write(MemoryModel.IoBase + MemoryModel.REG_VSYNC, 1); break; case Keyword.Clear: try { int color = EvalExpr(t.E0!); if (!_running) break; mem.FillFlat(0, 57600, (byte)(color & 0xFF)); } catch { SyntaxError(); } break; case Keyword.PutPixel: try { int x = EvalExpr(t.E0!); if (!_running) break; int y = EvalExpr(t.E1!); if (!_running) break; int color = EvalExpr(t.E2!); if (!_running) break; int offset = y * 320 + x; if (offset < 57600) mem.WriteFlat(offset, (byte)(color & 0xFF)); } catch { SyntaxError(); } break; case Keyword.For: { int from = EvalExpr(t.E0!); if (!_running) break; int to = EvalExpr(t.E1!); if (!_running) break; int step = t.E2 != null ? EvalExpr(t.E2) : 1; if (!_running) break; _variables[t.Var - 'A'] = from; bool done = step > 0 ? from > to : from < to; if (done) { _programCounter = FindNextPc(t.Var, _programCounter); _skipIncrement = true; } else { _forStack.Push((t.Var, to, step, _programCounter + 1)); } break; } case Keyword.Next: { if (_forStack.Count == 0) { consoleHelper.WriteText("?NEXT WITHOUT FOR"); consoleHelper.NewLine(); _running = false; break; } var (fVar, to, step, bodyPc) = _forStack.Peek(); if (t.Var != '\0' && t.Var != fVar) { consoleHelper.WriteText("?NEXT WITHOUT FOR"); consoleHelper.NewLine(); _running = false; break; } _variables[fVar - 'A'] += step; bool cont = step > 0 ? _variables[fVar - 'A'] <= to : _variables[fVar - 'A'] >= to; if (cont) { _programCounter = bodyPc; _skipIncrement = true; } else { _forStack.Pop(); } break; } default: SyntaxError(); break; } } // ----------------------------------------------------------------------- // Helpers // ----------------------------------------------------------------------- private static int FindWord(string s, string word) { string up = s.ToUpperInvariant(); int i = 0; while (i + word.Length <= up.Length) { int found = up.IndexOf(word, i); if (found < 0) return -1; bool leftOk = found == 0 || !char.IsLetterOrDigit(up[found - 1]); bool rightOk = found + word.Length >= up.Length || !char.IsLetterOrDigit(up[found + word.Length]); if (leftOk && rightOk) return found; i = found + 1; } return -1; } private int FindNextPc(char var, int fromPc) { int depth = 0; for (int i = fromPc + 1; i < _lines.Length; i++) { var tok = _tokenized[_lines[i]]; if (tok.Kw == Keyword.For && tok.Var == var) depth++; if (tok.Kw == Keyword.Next && (tok.Var == '\0' || tok.Var == var)) { if (depth == 0) return i + 1; if (tok.Var == var) depth--; } } return _lines.Length; } private static void SkipSpaces(string s, ref int pos) { while (pos < s.Length && s[pos] == ' ') pos++; } private static bool IsHexChar(char c) => (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'); private static int HexVal(char c) => c <= '9' ? c - '0' : (c | 0x20) - 'a' + 10; // ----------------------------------------------------------------------- // Disk / file commands // ----------------------------------------------------------------------- private string? ParseFilename(string args) { string name = args.Trim('"', ' ').ToUpperInvariant(); if (name.Length == 0 || name.Length > 12 || name.Contains('/') || name.Contains('\\')) return null; return name; } private void ExecuteSave(string args) { string? name = ParseFilename(args); if (name == null) { SyntaxError(); return; } if (diskManager.MountPath == null) { 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) { string? name = ParseFilename(args); if (name == null) { SyntaxError(); return; } _program.Clear(); _tokenized.Clear(); _lines = []; _callStack.Clear(); _running = false; 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; } 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 ExecuteEditor(string args) { string? name = ParseFilename(args); if (name == null) { SyntaxError(); return; } if (diskManager.MountPath == null) { consoleHelper.WriteText("?NO DISK"); consoleHelper.NewLine(); return; } _editor.Run(Path.Combine(diskManager.MountPath, name)); } private void ExecuteExec(string args) { string name; if (args.StartsWith("\"")) { int close = args.IndexOf('"', 1); if (close < 0) { SyntaxError(); return; } name = args.Substring(1, close - 1).ToUpperInvariant(); } else if (args.Length > 0 && !char.IsDigit(args[0]) && args[0] != '$') { name = args.Trim().ToUpperInvariant(); } else { // Bare address: EXEC $1000 int addr; try { addr = EvalExpr(CompileExpr(args)); } catch { SyntaxError(); return; } if (_running) cpu.Run((ushort)addr); 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); if (ExecDecb(data, out ushort entry)) cpu.Run(entry); } private bool ExecDecb(byte[] data, out ushort entry) { entry = 0; int pos = 0; ushort firstLoadAddr = 0; bool hasFirstAddr = false; while (pos < data.Length) { byte type = data[pos++]; if (type == 0x01) // data block (Micronona binary marker) { if (pos + 4 > data.Length) break; int len = (data[pos] << 8) | data[pos + 1]; pos += 2; ushort addr = (ushort)((data[pos] << 8) | data[pos + 1]); pos += 2; if (!hasFirstAddr) { firstLoadAddr = addr; hasFirstAddr = true; } for (int i = 0; i < len && pos < data.Length; i++) mem.Write((ushort)(addr + i), data[pos++]); } else if (type == 0xFF) // end block — execution address { if (pos + 4 > data.Length) break; pos += 2; // skip length (always 0x0000) ushort execAddr = (ushort)((data[pos] << 8) | data[pos + 1]); // Fall back to first block's load address if no END addr in source. entry = execAddr != 0 ? execAddr : firstLoadAddr; return true; } else break; } consoleHelper.WriteText("?BAD FORMAT"); consoleHelper.NewLine(); return false; } 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=decb"); 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[] decb = File.ReadAllBytes(tmpFile); decb[0] = 0x01; File.WriteAllBytes(outputPath, decb); } finally { try { File.Delete(tmpFile); } catch { } } } private void SyntaxError() { consoleHelper.WriteText("?SYNTAX ERROR"); consoleHelper.NewLine(); } }