diff --git a/.claude/settings.local.json b/.claude/settings.local.json
index 0cc3d41..4c6bcac 100644
--- a/.claude/settings.local.json
+++ b/.claude/settings.local.json
@@ -4,7 +4,44 @@
"Bash(dotnet remove:*)",
"Bash(dotnet add:*)",
"Bash(dotnet build:*)",
- "Bash(dotnet run:*)"
+ "Bash(dotnet run:*)",
+ "Bash(dotnet restore:*)",
+ "Bash(curl:*)",
+ "Bash(sudo tee:*)",
+ "Bash(sudo udevadm:*)",
+ "Bash(sudo chmod:*)",
+ "Bash(git add:*)",
+ "Bash(git commit:*)",
+ "Bash(git -C /home/hajo/Homework/Micronona status)",
+ "Bash(git -C /home/hajo/Homework/Micronona diff --stat)",
+ "Bash(git -C /home/hajo/Homework/Micronona add InputInterpreter.cs MemoryModel.cs MicrononaRenderer.cs Program.cs)",
+ "Bash(git -C /home/hajo/Homework/Micronona commit -m ':*)",
+ "Bash(git:*)",
+ "Bash(kill %1)",
+ "Bash(wait)",
+ "Read(//tmp/**)",
+ "Bash(sync)",
+ "Bash(dpkg -L kbd)",
+ "Bash(dpkg -L console-data)",
+ "Bash(apt list *)",
+ "Bash(apt-cache search *)",
+ "Bash(loadkeys -V)",
+ "Bash(dpkg -L console-setup-linux)",
+ "Bash(zcat /etc/console-setup/cached_UTF-8_del.kmap.gz)",
+ "Bash(apt-cache policy *)",
+ "Bash(dpkg -l)",
+ "Bash(sudo apt *)",
+ "Bash(xargs -I {} sh -c 'echo \"{}: $\\(zcat \"{}\" 2>/dev/null | head -5 | tail -3\\)\"')",
+ "Bash(zcat /usr/share/keymaps/i386/include/linux-keys-bare.inc.gz)",
+ "Bash(zcat /usr/share/keymaps/i386/qwertz/de-latin1-nodeadkeys.kmap.gz)",
+ "Bash(zcat /usr/share/keymaps/i386/qwertz/de.kmap.gz)",
+ "Bash(zcat /usr/share/keymaps/i386/qwertz/croat.kmap.gz)",
+ "Bash(zcat /usr/share/keymaps/i386/qwertz/de-latin1.kmap.gz)",
+ "Bash(zcat /usr/share/keymaps/i386/include/qwertz-layout.inc.gz)",
+ "Bash(zcat /usr/share/keymaps/i386/qwerty/ar.kmap.gz)",
+ "Bash(zcat /usr/share/keymaps/i386/qwerty/fa.kmap.gz)",
+ "Bash(zcat /usr/share/keymaps/i386/include/linux-with-modeshift-altgr.inc.gz)",
+ "Bash(zcat /usr/share/keymaps/i386/qwerty/lv-latin7.kmap.gz)"
]
}
}
diff --git a/ConsoleHelper.cs b/ConsoleHelper.cs
index 059eb9d..5ddad75 100644
--- a/ConsoleHelper.cs
+++ b/ConsoleHelper.cs
@@ -2,9 +2,17 @@ public class ConsoleHelper
{
private readonly MemoryModel _mem;
+ public const byte DefaultFg = 0x1C; // Bright green: R=0, G=224, B=0
+ public const byte DefaultBg = 0x08; // Dark green: R=0, G=64, B=0
+
+ public byte CurrentFg { get; set; }
+ public byte CurrentBg { get; set; }
+
public ConsoleHelper(MemoryModel mem)
{
_mem = mem;
+ CurrentFg = DefaultFg;
+ CurrentBg = DefaultBg;
}
static byte Rgb332Mid(byte a, byte b)
@@ -32,10 +40,9 @@ public class ConsoleHelper
_mem.ReadFlat(textBase + i + MemoryModel.TextCellSize + 2));
}
- _mem.WriteFlat(textBase + rowEnd, 0x20, MemoryModel.DefaultFg, MemoryModel.DefaultBg);
+ _mem.WriteFlat(textBase + rowEnd, 0x20, CurrentFg, CurrentBg);
}
-
public void Backspace()
{
int col = _mem.Read(MemoryModel.IoBase + MemoryModel.REG_CURSOR_COL);
@@ -44,7 +51,6 @@ public class ConsoleHelper
if (col == 0) { col = MemoryModel.TextCols - 1; row--; }
else col--;
- // Rest der Zeile nach links ziehen
int textBase = MemoryModel.TextBankIndex * MemoryModel.BankSize;
int rowEnd = (row * MemoryModel.TextCols + MemoryModel.TextCols - 1) * MemoryModel.TextCellSize;
int startOffset = (row * MemoryModel.TextCols + col) * MemoryModel.TextCellSize;
@@ -57,8 +63,7 @@ public class ConsoleHelper
_mem.ReadFlat(textBase + i + MemoryModel.TextCellSize + 2));
}
- // Letztes Zeichen der Zeile löschen
- _mem.WriteFlat(textBase + rowEnd, 0x20, MemoryModel.DefaultFg, MemoryModel.DefaultBg);
+ _mem.WriteFlat(textBase + rowEnd, 0x20, CurrentFg, CurrentBg);
_mem.Write(MemoryModel.IoBase + MemoryModel.REG_CURSOR_COL, (byte)col);
_mem.Write(MemoryModel.IoBase + MemoryModel.REG_CURSOR_ROW, (byte)row);
@@ -66,18 +71,15 @@ public class ConsoleHelper
public void NewLine()
{
- ReadLine(); // Optional: Aktuelle Zeile lesen und verarbeiten
+ ReadLine();
int row = _mem.Read(MemoryModel.IoBase + MemoryModel.REG_CURSOR_ROW);
if (row + 1 >= MemoryModel.TextRows)
- {
ScrollUp();
- }
else
- {
row++;
- }
SetCursor(0, (byte)row);
}
+
public void MoveCursor(int dx, int dy)
{
int col = _mem.Read(MemoryModel.IoBase + MemoryModel.REG_CURSOR_COL);
@@ -93,7 +95,6 @@ public class ConsoleHelper
int textBase = MemoryModel.TextBankIndex * MemoryModel.BankSize;
int rowSize = MemoryModel.TextCols * MemoryModel.TextCellSize;
- // Zeilen 1–17 nach oben kopieren
for (int row = 0; row < MemoryModel.TextRows - 1; row++)
{
for (int i = 0; i < rowSize; i++)
@@ -103,13 +104,14 @@ public class ConsoleHelper
}
}
- // Letzte Zeile mit Leerzeichen und Defaultfarben füllen
int lastRow = (MemoryModel.TextRows - 1) * rowSize;
for (int col = 0; col < MemoryModel.TextCols; col++)
{
- _mem.WriteFlat(textBase + lastRow + col * MemoryModel.TextCellSize, 0x20, MemoryModel.DefaultFg, MemoryModel.DefaultBg);
+ _mem.WriteFlat(textBase + lastRow + col * MemoryModel.TextCellSize,
+ 0x20, CurrentFg, CurrentBg);
}
}
+
public string ReadLine()
{
int col = _mem.Read(MemoryModel.IoBase + MemoryModel.REG_CURSOR_COL);
@@ -117,8 +119,6 @@ public class ConsoleHelper
int textBase = MemoryModel.TextBankIndex * MemoryModel.BankSize;
- // Erste Zeile der logischen Zeile finden:
- // Solange Spalte 0 der aktuellen Zeile ASCII 31 enthält, ist sie eine Folgezeile.
int startRow = row;
while (startRow > 0)
{
@@ -138,7 +138,7 @@ public class ConsoleHelper
{
int offset = (r * MemoryModel.TextCols + c) * MemoryModel.TextCellSize;
byte ch = _mem.ReadFlat(textBase + offset);
- if (ch == 31) continue; // Umbruch-Marker überspringen
+ if (ch == 31) continue;
sb.Append((char)ch);
}
}
@@ -153,6 +153,23 @@ public class ConsoleHelper
_mem.Write(MemoryModel.IoBase + MemoryModel.REG_CURSOR_COL, x);
_mem.Write(MemoryModel.IoBase + MemoryModel.REG_CURSOR_ROW, y);
}
+
+ public void Cls()
+ {
+ int textBase = MemoryModel.TextBankIndex * MemoryModel.BankSize;
+ for (int i = 0; i < MemoryModel.TextCols * MemoryModel.TextRows; i++)
+ _mem.WriteFlat(textBase + i * MemoryModel.TextCellSize, 0x20, CurrentFg, CurrentBg);
+ SetCursor(0, 0);
+ }
+
+ public void SetChar(int x, int y, byte ascii, byte fg, byte bg)
+ {
+ if (x < 0 || x >= MemoryModel.TextCols || y < 0 || y >= MemoryModel.TextRows) return;
+ int textBase = MemoryModel.TextBankIndex * MemoryModel.BankSize;
+ int offset = (y * MemoryModel.TextCols + x) * MemoryModel.TextCellSize;
+ _mem.WriteFlat(textBase + offset, ascii, fg, bg);
+ }
+
public void WriteText(string text)
{
if (_mem.Read(MemoryModel.IoBase + MemoryModel.REG_MODE) != 0) return;
@@ -160,24 +177,25 @@ public class ConsoleHelper
var y = _mem.Read(MemoryModel.IoBase + MemoryModel.REG_CURSOR_ROW);
var offset = (y * MemoryModel.TextCols + x) * MemoryModel.TextCellSize;
- foreach (char c in text.ToArray())
+ foreach (char c in text)
{
var ascii = (byte)c;
- _mem.WriteFlat(MemoryModel.TextBankIndex * MemoryModel.BankSize + offset, ascii, MemoryModel.DefaultFg, MemoryModel.DefaultBg);
+ _mem.WriteFlat(MemoryModel.TextBankIndex * MemoryModel.BankSize + offset,
+ ascii, CurrentFg, CurrentBg);
offset += MemoryModel.TextCellSize;
byte column = (byte)(offset % MemoryModel.TextCols);
if (column == 0)
{
- byte color = Rgb332Mid(MemoryModel.DefaultBg,MemoryModel.DefaultFg);
- _mem.WriteFlat(MemoryModel.TextBankIndex * MemoryModel.BankSize + offset, 31, color, MemoryModel.DefaultBg);
+ byte color = Rgb332Mid(CurrentBg, CurrentFg);
+ _mem.WriteFlat(MemoryModel.TextBankIndex * MemoryModel.BankSize + offset,
+ 31, color, CurrentBg);
offset += MemoryModel.TextCellSize;
}
while (offset >= MemoryModel.TextCellSize * MemoryModel.TextCols * MemoryModel.TextRows)
{
ScrollUp();
- offset -= (MemoryModel.TextCellSize * MemoryModel.TextCols);
+ offset -= MemoryModel.TextCellSize * MemoryModel.TextCols;
}
-
}
offset /= MemoryModel.TextCellSize;
_mem.Write(MemoryModel.IoBase + MemoryModel.REG_CURSOR_COL, (byte)(offset % MemoryModel.TextCols));
diff --git a/DiskManager.cs b/DiskManager.cs
index 88c07fe..a08f993 100644
--- a/DiskManager.cs
+++ b/DiskManager.cs
@@ -28,7 +28,7 @@ public class DiskManager : IDisposable
private string? _mountedDevice; // e.g. "/dev/sda1"
private string? _mountPath; // e.g. "/mnt/micronona"
- private const string MarkerFile = ".micronona";
+ public const string MarkerFile = ".micronona";
// -------------------------------------------------------------------------
// Netlink socket
@@ -233,6 +233,50 @@ public class DiskManager : IDisposable
Console.WriteLine($"[DiskManager] Written {markerPath}");
}
+ // -------------------------------------------------------------------------
+ // Stick discovery and config update (CLI use)
+ // -------------------------------------------------------------------------
+
+ ///
+ /// Scan standard udisks mount roots for a currently-mounted Micronona stick.
+ /// Returns the mount path of the first stick whose root contains the marker
+ /// file, or null if none is found. Independent of the netlink watcher.
+ ///
+ public static string? FindMicrononaMount()
+ {
+ foreach (string root in new[] { "/run/media", "/media" })
+ {
+ if (!Directory.Exists(root)) continue;
+ foreach (string userDir in Directory.EnumerateDirectories(root))
+ foreach (string mount in Directory.EnumerateDirectories(userDir))
+ if (File.Exists(Path.Combine(mount, MarkerFile)))
+ return mount;
+ }
+ return null;
+ }
+
+ ///
+ /// Write or update the [keyboard] layout entry in the stick's .micronona file.
+ /// Preserves all other existing keys.
+ ///
+ public static void SaveKeyboardLayout(string mountPath, string layout)
+ {
+ string markerPath = Path.Combine(mountPath, MarkerFile);
+ Tomlyn.Model.TomlTable model = File.Exists(markerPath)
+ ? Tomlyn.Toml.ToModel(File.ReadAllText(markerPath))
+ : new Tomlyn.Model.TomlTable();
+
+ if (!model.TryGetValue("keyboard", out object? kbObj)
+ || kbObj is not Tomlyn.Model.TomlTable kb)
+ {
+ kb = new Tomlyn.Model.TomlTable();
+ model["keyboard"] = kb;
+ }
+ kb["layout"] = layout;
+
+ File.WriteAllText(markerPath, Tomlyn.Toml.FromModel(model));
+ }
+
// -------------------------------------------------------------------------
// Mount helpers (udisksctl — no root required)
// -------------------------------------------------------------------------
diff --git a/InputInterpreter.cs b/InputInterpreter.cs
index 53b8262..671a316 100644
--- a/InputInterpreter.cs
+++ b/InputInterpreter.cs
@@ -9,7 +9,7 @@ internal enum Op
{
PushConst, PushVar,
Add, Sub, Mul, Div, Mod, Negate,
- CallRnd, CallPeek, CallPeekX,
+ CallRnd, CallPeek, CallPeekX, CallGetPixel,
CmpEq, CmpLt, CmpGt, CmpLe, CmpGe, CmpNe
}
@@ -27,7 +27,9 @@ internal sealed class CompiledExpr
internal enum Keyword
{
Unknown, Print, Let, Goto, Gosub, Return, If, Input,
- Poke, PokeX, Rem, End
+ Poke, PokeX, Rem, End,
+ Cls, Locate, Color, Mode, SetChar, Inkey, Vsync,
+ Clear, PutPixel, For, Next
}
internal sealed class TokenizedLine
@@ -39,8 +41,11 @@ internal sealed class TokenizedLine
public CompiledExpr? E0; // primary expression
public CompiledExpr? E1; // secondary expression
- public CompiledExpr? E2; // tertiary expression (POKEX)
+ 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
}
// ---------------------------------------------------------------------------
@@ -55,6 +60,7 @@ internal class InputInterpreter
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();
@@ -67,12 +73,20 @@ internal class InputInterpreter
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;
@@ -97,10 +111,17 @@ internal class InputInterpreter
this.consoleHelper = consoleHelper;
this.diskManager = diskManager;
this.cpu = cpu;
+ _editor = new TextEditor(consoleHelper);
}
- public bool IsRunning => _running;
- public bool IsWaitingForInput => _waitingForInput;
+ 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
@@ -118,6 +139,7 @@ internal class InputInterpreter
_cts.Cancel();
try { _runSignal.Set(); } catch { }
try { _inputSignal.Release(); } catch { }
+ try { _kmapSignal.Release(); } catch { }
_thread?.Join();
}
@@ -164,8 +186,10 @@ internal class InputInterpreter
{
bool wasRunning = _running;
_running = false;
+ _forStack.Clear();
+ mem.Write(MemoryModel.IoBase + MemoryModel.REG_MODE, 0);
if (!wasRunning)
- mem.Write(MemoryModel.IoBase + MemoryModel.REG_MODE, 0);
+ consoleHelper.Cls();
if (_waitingForInput)
{
_waitingForInput = false;
@@ -187,7 +211,6 @@ internal class InputInterpreter
if (_programCounter >= _lines.Length)
{
_running = false;
- mem.Write(MemoryModel.IoBase + MemoryModel.REG_MODE, 0);
return;
}
@@ -276,6 +299,7 @@ internal class InputInterpreter
_lines = _program.Keys.ToArray();
_programCounter = 0;
_callStack.Clear();
+ _forStack.Clear();
_running = true;
_runSignal.Set();
return;
@@ -286,6 +310,7 @@ internal class InputInterpreter
_program.Clear(); _tokenized.Clear();
_lines = [];
_callStack.Clear();
+ _forStack.Clear();
_running = false;
consoleHelper.WriteText("OK"); consoleHelper.NewLine();
return;
@@ -311,6 +336,8 @@ internal class InputInterpreter
{ 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")
{
@@ -323,10 +350,95 @@ internal class InputInterpreter
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
// -----------------------------------------------------------------------
@@ -346,6 +458,7 @@ internal class InputInterpreter
{
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('"');
@@ -451,6 +564,148 @@ internal class InputInterpreter
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
}
@@ -623,6 +878,33 @@ internal class InputInterpreter
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]))
{
@@ -732,6 +1014,14 @@ internal class InputInterpreter
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; }
@@ -756,19 +1046,18 @@ internal class InputInterpreter
if (t.PrintLiteral != null)
{
consoleHelper.WriteText(t.PrintLiteral);
- consoleHelper.NewLine();
+ if (!t.SuppressNewLine) consoleHelper.NewLine();
}
else if (t.E0 != null)
{
try { consoleHelper.WriteText(EvalExpr(t.E0).ToString()); }
catch { SyntaxError(); break; }
- if (_running) consoleHelper.NewLine();
+ if (_running && !t.SuppressNewLine) consoleHelper.NewLine();
}
break;
case Keyword.End:
_running = false;
- mem.Write(MemoryModel.IoBase + MemoryModel.REG_MODE, 0);
break;
case Keyword.Rem:
@@ -850,6 +1139,140 @@ internal class InputInterpreter
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;
@@ -860,6 +1283,38 @@ internal class InputInterpreter
// 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++;
@@ -929,39 +1384,81 @@ internal class InputInterpreter
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; }
- string name = args.Substring(1, close - 1).ToUpperInvariant();
- string rest = args.Substring(close + 1).TrimStart();
- if (!rest.StartsWith(",")) { SyntaxError(); return; }
- int addr;
- try { addr = EvalExpr(CompileExpr(rest.Substring(1).Trim())); }
- catch { SyntaxError(); return; }
- if (!_running) return;
-
- if (diskManager.MountPath == null)
- { consoleHelper.WriteText("?NO DISK"); consoleHelper.NewLine(); return; }
- var path = Path.Combine(diskManager.MountPath, name);
- if (!File.Exists(path))
- { consoleHelper.WriteText("?FILE NOT FOUND"); consoleHelper.NewLine(); return; }
-
- byte[] data = File.ReadAllBytes(path);
- int start = (data.Length > 0 && data[0] == 0x01) ? 1 : 0;
- for (int i = start; i < data.Length; i++)
- mem.Write((ushort)(addr + i - start), data[i]);
- cpu.Run((ushort)addr);
+ 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)
@@ -995,7 +1492,7 @@ internal class InputInterpreter
{
var psi = new System.Diagnostics.ProcessStartInfo
{ FileName = "lwasm", RedirectStandardError = true };
- psi.ArgumentList.Add("--format=raw");
+ psi.ArgumentList.Add("--format=decb");
psi.ArgumentList.Add("-9");
psi.ArgumentList.Add("-o");
psi.ArgumentList.Add(tmpFile);
@@ -1012,11 +1509,9 @@ internal class InputInterpreter
return;
}
- byte[] raw = File.ReadAllBytes(tmpFile);
- byte[] output = new byte[raw.Length + 1];
- output[0] = 0x01;
- raw.CopyTo(output, 1);
- File.WriteAllBytes(outputPath, output);
+ byte[] decb = File.ReadAllBytes(tmpFile);
+ decb[0] = 0x01;
+ File.WriteAllBytes(outputPath, decb);
}
finally { try { File.Delete(tmpFile); } catch { } }
}
diff --git a/KeyboardLayoutDetector.cs b/KeyboardLayoutDetector.cs
new file mode 100644
index 0000000..7513e83
--- /dev/null
+++ b/KeyboardLayoutDetector.cs
@@ -0,0 +1,529 @@
+using System.Globalization;
+using System.IO.Compression;
+using System.Text.RegularExpressions;
+using SDL2;
+
+///
+/// Phase 1 (CLI only): parses Linux loadkeys keymap files, derives the
+/// discriminating keycodes in the printable ASCII range, and prompts the user
+/// to press specific keys via SDL2 until one layout candidate remains.
+///
+/// No Micronona display integration — output via Console, input via SDL_KEYDOWN.
+///
+public static class KeyboardLayoutDetector
+{
+ private static readonly Regex KeycodeLine = new(
+ @"^\s*(?:plain\s+)?keycode\s+(\d+)\s*=\s*(.+)$",
+ RegexOptions.Compiled | RegexOptions.IgnoreCase);
+
+ private static readonly Regex IncludeLine = new(
+ @"^\s*include\s+""([^""]+)""\s*$",
+ RegexOptions.Compiled | RegexOptions.IgnoreCase);
+
+ // loadkeys symbolic names that map to printable ASCII.
+ private static readonly Dictionary NamedSymbol = new(StringComparer.Ordinal)
+ {
+ {"space", ' '},
+ {"exclam", '!'}, {"quotedbl", '"'}, {"numbersign", '#'},
+ {"dollar", '$'}, {"percent", '%'}, {"ampersand", '&'},
+ {"apostrophe", '\''},
+ {"parenleft", '('}, {"parenright", ')'},
+ {"asterisk", '*'}, {"plus", '+'},
+ {"comma", ','}, {"minus", '-'},
+ {"period", '.'}, {"slash", '/'},
+ {"zero", '0'}, {"one", '1'}, {"two", '2'}, {"three", '3'}, {"four", '4'},
+ {"five", '5'}, {"six", '6'}, {"seven", '7'}, {"eight", '8'}, {"nine", '9'},
+ {"colon", ':'}, {"semicolon", ';'},
+ {"less", '<'}, {"equal", '='}, {"greater", '>'},
+ {"question", '?'}, {"at", '@'},
+ {"bracketleft", '['}, {"backslash", '\\'}, {"bracketright", ']'},
+ {"asciicircum", '^'}, {"underscore", '_'}, {"grave", '`'},
+ {"braceleft", '{'}, {"bar", '|'}, {"braceright", '}'},
+ {"asciitilde", '~'},
+ };
+
+
+ // ------------------------------------------------------------------------
+ // Public entry points
+ // ------------------------------------------------------------------------
+
+ ///
+ /// Pure detection logic — I/O is delegated to callbacks so the same routine
+ /// drives both the CLI flag (own SDL window + Console) and the in-app KMAP
+ /// command (Micronona screen + main SDL event loop).
+ ///
+ /// writes an informational line (no trailing newline expected).
+ /// shows a prompt, waits for a keypress, returns
+ /// the Linux keycode (KEY_*) or null on cancel.
+ ///
+ public static string? Detect(
+ string keymapDir,
+ Action log,
+ Func waitForKey)
+ {
+ var layouts = ParseKeymaps(keymapDir);
+ if (layouts.Count == 0)
+ {
+ log("No keymaps available.");
+ return null;
+ }
+ log("Keyboard detection");
+
+ var candidates = new HashSet(layouts.Keys, StringComparer.Ordinal);
+ // Positive proofs: how many rounds each candidate matched a keypress
+ // positively (rather than just surviving as "X is unreachable here").
+ // Used as a tiebreaker at the end so concrete matches beat ghosts.
+ var proofs = candidates.ToDictionary(n => n, _ => 0, StringComparer.Ordinal);
+
+ while (candidates.Count > 1)
+ {
+ // Build per-candidate inverse map: char → keycodes that plain-produce it.
+ var inverse = new Dictionary>>(StringComparer.Ordinal);
+ foreach (string name in candidates)
+ {
+ var inv = new Dictionary>();
+ foreach (var kv in layouts[name])
+ {
+ char ch = kv.Value;
+ if (!inv.TryGetValue(ch, out var set))
+ inv[ch] = set = new HashSet();
+ set.Add(kv.Key);
+ }
+ inverse[name] = inv;
+ }
+
+ // Pick the target char that splits the candidate set most. The
+ // target need not be reachable in every candidate — candidates
+ // without it survive the round as "neutral", but candidates that
+ // do have it get sorted into keycode-equivalence classes and all
+ // but the user's class are eliminated.
+ //
+ // Two passes to avoid Shift-only prompts: first only consider
+ // characters whose plain-row coverage spans at least half of the
+ // remaining candidates (likely directly typeable on the user's
+ // layout). Only if no such character discriminates do we fall back
+ // to rarer chars like an apostrophe that may require Shift.
+ char? bestTarget = null;
+ int bestScore = 0;
+ int[] minCoverages = { Math.Max(2, candidates.Count / 2), 2 };
+ foreach (int minCoverage in minCoverages)
+ {
+ for (int c = 32; c <= 126; c++)
+ {
+ char ch = (char)c;
+ var withX = candidates.Where(n => inverse[n].ContainsKey(ch)).ToList();
+ if (withX.Count < minCoverage) continue;
+
+ var groups = withX
+ .GroupBy(n => CanonicalKeycodeSet(inverse[n][ch]), StringComparer.Ordinal)
+ .ToList();
+ if (groups.Count < 2) continue;
+
+ // Worst case: user is in the largest keycode group. Everyone
+ // else in withX gets eliminated.
+ int largest = groups.Max(g => g.Count());
+ int eliminated = withX.Count - largest;
+ if (eliminated < 1) continue;
+ int score = eliminated * 2 + withX.Count;
+ if (score > bestScore)
+ {
+ bestScore = score;
+ bestTarget = ch;
+ }
+ }
+ if (bestTarget is not null) break;
+ }
+
+ if (bestTarget is null) break; // can't discriminate further
+
+ int? pressed = waitForKey($"Press {Describe(bestTarget.Value)} ({candidates.Count} remaining)");
+ if (pressed is null)
+ {
+ log("(cancelled)");
+ return null;
+ }
+
+ var survivors = new HashSet(StringComparer.Ordinal);
+ foreach (string name in candidates)
+ {
+ if (!inverse[name].TryGetValue(bestTarget.Value, out var kcs))
+ {
+ // Layout doesn't have this char plain — stay neutral.
+ survivors.Add(name);
+ }
+ else if (kcs.Contains(pressed.Value))
+ {
+ survivors.Add(name);
+ proofs[name]++;
+ }
+ // else: keycode mismatch among layouts that DO have X → eliminate.
+ }
+
+ if (survivors.Count == 0)
+ {
+ log("No candidate is consistent with that keypress.");
+ return null;
+ }
+ candidates = survivors;
+ }
+
+ if (candidates.Count == 1) return candidates.First();
+
+ // Tiebreaker: candidates that positively matched the most keypresses win
+ // over ghosts that only ever survived as neutrals. If still tied, prefer
+ // the shortest name (base layout over variant), then alphabetical.
+ int maxProof = candidates.Max(n => proofs[n]);
+ var winners = candidates.Where(n => proofs[n] == maxProof).ToList();
+ if (winners.Count == 1) return winners[0];
+
+ var picked = winners
+ .OrderBy(n => n.Length)
+ .ThenBy(n => n, StringComparer.Ordinal)
+ .First();
+ // Diagnostic — Console only; Micronona display stays clean.
+ Console.Error.WriteLine(
+ $"Narrowed to: {string.Join(", ", winners.OrderBy(n => n, StringComparer.Ordinal))} (picking '{picked}')");
+ return picked;
+ }
+
+ ///
+ /// CLI entry: opens a small SDL window of its own (so the OS routes key
+ /// events to it) and prints to Console.
+ ///
+ public static string? DetectInteractive(string keymapDir)
+ {
+ if (SDL.SDL_Init(SDL.SDL_INIT_VIDEO) < 0)
+ {
+ Console.Error.WriteLine($"SDL_Init failed: {SDL.SDL_GetError()}");
+ return null;
+ }
+
+ IntPtr window = SDL.SDL_CreateWindow(
+ "Micronona — Keyboard Layout Detection",
+ SDL.SDL_WINDOWPOS_CENTERED, SDL.SDL_WINDOWPOS_CENTERED,
+ 480, 120,
+ SDL.SDL_WindowFlags.SDL_WINDOW_SHOWN);
+ if (window == IntPtr.Zero)
+ {
+ Console.Error.WriteLine($"SDL_CreateWindow failed: {SDL.SDL_GetError()}");
+ SDL.SDL_Quit();
+ return null;
+ }
+ SDL.SDL_RaiseWindow(window);
+
+ try
+ {
+ return Detect(
+ keymapDir,
+ Console.WriteLine,
+ prompt =>
+ {
+ Console.Write(prompt + ": ");
+ int? kc = WaitForKey();
+ Console.WriteLine(kc is null ? "(cancelled)" : $"(keycode {kc})");
+ return kc;
+ });
+ }
+ finally
+ {
+ SDL.SDL_DestroyWindow(window);
+ SDL.SDL_Quit();
+ }
+ }
+
+ ///
+ /// Best-effort `loadkeys <layout>` invocation. Used on the Pi target
+ /// to apply the detected/stored layout system-wide; silently no-ops on
+ /// dev machines where loadkeys is missing or we lack permissions.
+ ///
+ public static void ApplyLoadkeys(string layout)
+ {
+ try
+ {
+ var psi = new System.Diagnostics.ProcessStartInfo
+ {
+ FileName = "loadkeys",
+ RedirectStandardOutput = true,
+ RedirectStandardError = true,
+ };
+ psi.ArgumentList.Add(layout);
+ var p = System.Diagnostics.Process.Start(psi);
+ p?.WaitForExit();
+ }
+ catch
+ {
+ // loadkeys missing or unprivileged — nothing to do on dev.
+ }
+ }
+
+ private static string CanonicalKeycodeSet(HashSet set)
+ {
+ var arr = set.ToArray();
+ Array.Sort(arr);
+ return string.Join(",", arr);
+ }
+
+ // Spell out characters that are visually confusable with letters/digits so the
+ // user knows whether to press a digit row key or a letter key.
+ private static string Describe(char c) => c switch
+ {
+ '0' => "'0' (digit zero)",
+ '1' => "'1' (digit one)",
+ 'O' => "'O' (capital letter O)",
+ 'o' => "'o' (small letter o)",
+ 'l' => "'l' (small letter L)",
+ 'I' => "'I' (capital letter I)",
+ _ => $"'{c}'",
+ };
+
+ // ------------------------------------------------------------------------
+ // Step 1: parse keymap files
+ // ------------------------------------------------------------------------
+
+ public static Dictionary> ParseKeymaps(string dir)
+ {
+ var result = new Dictionary>(StringComparer.Ordinal);
+ if (!Directory.Exists(dir)) return result;
+
+ // Target hardware is USB-HID on Raspberry Pi — only PC keycode layouts apply.
+ string i386 = Path.Combine(dir, "i386");
+ if (!Directory.Exists(i386)) return result;
+
+ // Layout files use .map / .map.gz (older) or .kmap / .kmap.gz (current kbd/console-data).
+ // .inc / .inc.gz are include fragments — skipped as top-level layouts.
+ string[] suffixes = { ".kmap.gz", ".kmap", ".map.gz", ".map" };
+
+ var searchPaths = new List { Path.Combine(i386, "include") };
+
+ foreach (string path in Directory.EnumerateFiles(i386, "*", SearchOption.AllDirectories))
+ {
+ string file = Path.GetFileName(path);
+ string? matched = null;
+ foreach (var s in suffixes)
+ if (file.EndsWith(s, StringComparison.OrdinalIgnoreCase)) { matched = s; break; }
+ if (matched is null) continue;
+
+ // Files inside any include/ directory are fragments, not standalone layouts.
+ string sep = Path.DirectorySeparatorChar.ToString();
+ if (path.Contains($"{sep}include{sep}", StringComparison.Ordinal)) continue;
+
+ string layoutName = file[..^matched.Length];
+
+ try
+ {
+ var visited = new HashSet(StringComparer.Ordinal);
+ var map = new Dictionary();
+ ParseFile(path, map, visited, searchPaths);
+ // Need a near-complete Latin alphabet for press-a-char detection
+ // to have any chance of working. Layouts like ar/fa/lv-latin*
+ // only override AltGr/shift positions and rely on the kernel's
+ // compiled-in defkeymap for plain letters — we can't see that.
+ if (HasUsableAlphabet(map))
+ result[layoutName] = map;
+ }
+ catch (Exception ex)
+ {
+ Console.Error.WriteLine($" warning: failed to parse '{path}': {ex.Message}");
+ }
+ }
+ return result;
+ }
+
+ private static void ParseFile(
+ string path,
+ Dictionary dict,
+ HashSet visited,
+ List searchPaths)
+ {
+ string canonical;
+ try { canonical = Path.GetFullPath(path); }
+ catch { canonical = path; }
+ if (!visited.Add(canonical)) return; // cycle / already included
+
+ bool gz = path.EndsWith(".gz", StringComparison.OrdinalIgnoreCase);
+ using var fs = File.OpenRead(path);
+ using Stream s = gz ? new GZipStream(fs, CompressionMode.Decompress) : (Stream)fs;
+ using var reader = new StreamReader(s);
+
+ string currentDir = Path.GetDirectoryName(path) ?? ".";
+
+ string? raw;
+ while ((raw = reader.ReadLine()) != null)
+ {
+ int hash = raw.IndexOf('#');
+ string line = (hash >= 0 ? raw[..hash] : raw).Trim();
+ if (line.Length == 0) continue;
+
+ var inc = IncludeLine.Match(line);
+ if (inc.Success)
+ {
+ // Included file's keycodes go in first; any later keycode line in the
+ // parent file overrides them via the dict[kc] = ... assignment below.
+ string? resolved = ResolveInclude(inc.Groups[1].Value, currentDir, searchPaths);
+ if (resolved is not null)
+ ParseFile(resolved, dict, visited, searchPaths);
+ continue;
+ }
+
+ var m = KeycodeLine.Match(line);
+ if (!m.Success) continue;
+ if (!int.TryParse(m.Groups[1].Value, out int kc)) continue;
+
+ string rhs = m.Groups[2].Value.Trim();
+ // String macros like keycode N = "foo" — first token starts with " — skip.
+ if (rhs.Length > 0 && rhs[0] == '"') continue;
+
+ string first = rhs.Split(new[] { ' ', '\t' }, 2, StringSplitOptions.RemoveEmptyEntries)[0];
+ char? c = ResolveSymbol(first);
+ if (c is null) continue;
+ if (c < (char)32 || c > (char)126) continue;
+ dict[kc] = c.Value;
+ }
+ }
+
+ private static string? ResolveInclude(string name, string currentDir, List searchPaths)
+ {
+ // Always try a ".gz" sibling even when the name carries an explicit
+ // extension — kbd installs the keymaps gzipped while the include
+ // directives still spell them out bare (e.g. include "de-latin1.kmap"
+ // resolves to de-latin1.kmap.gz on disk).
+ string[] suffixes = HasKeymapExtension(name)
+ ? new[] { "", ".gz" }
+ : new[] { ".inc", ".inc.gz", ".kmap", ".kmap.gz", ".map", ".map.gz", "" };
+
+ foreach (string d in new[] { currentDir }.Concat(searchPaths))
+ {
+ foreach (string ext in suffixes)
+ {
+ string full = Path.Combine(d, name + ext);
+ if (File.Exists(full)) return full;
+ }
+ }
+ return null;
+ }
+
+ private static bool HasUsableAlphabet(Dictionary map)
+ {
+ var letters = new HashSet();
+ foreach (char c in map.Values)
+ if (c >= 'a' && c <= 'z') letters.Add(c);
+ return letters.Count >= 20;
+ }
+
+ private static bool HasKeymapExtension(string name) =>
+ name.EndsWith(".inc", StringComparison.OrdinalIgnoreCase) ||
+ name.EndsWith(".inc.gz", StringComparison.OrdinalIgnoreCase) ||
+ name.EndsWith(".kmap", StringComparison.OrdinalIgnoreCase) ||
+ name.EndsWith(".kmap.gz", StringComparison.OrdinalIgnoreCase) ||
+ name.EndsWith(".map", StringComparison.OrdinalIgnoreCase) ||
+ name.EndsWith(".map.gz", StringComparison.OrdinalIgnoreCase);
+
+ private static char? ResolveSymbol(string sym)
+ {
+ if (string.IsNullOrEmpty(sym)) return null;
+ if (sym[0] == '+') sym = sym[1..];
+ if (sym.Length == 0) return null;
+
+ // Single-character literal (handles letters, digits, punctuation directly written).
+ if (sym.Length == 1) return sym[0];
+
+ if (NamedSymbol.TryGetValue(sym, out char c)) return c;
+
+ // U+NNNN / +U+NNNN
+ if ((sym.StartsWith("U+", StringComparison.OrdinalIgnoreCase)) &&
+ int.TryParse(sym.AsSpan(2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out int u))
+ return (char)u;
+
+ // 0xNN
+ if (sym.StartsWith("0x", StringComparison.OrdinalIgnoreCase) &&
+ int.TryParse(sym.AsSpan(2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out int h))
+ return (char)h;
+
+ // Decimal
+ if (int.TryParse(sym, NumberStyles.Integer, CultureInfo.InvariantCulture, out int d))
+ return (char)d;
+
+ return null;
+ }
+
+ // ------------------------------------------------------------------------
+ // SDL key-press input
+ // ------------------------------------------------------------------------
+
+ private static int? WaitForKey()
+ {
+ // Drop any leftover events from the previous round (key-up, queued repeats,
+ // window focus changes) so we start clean.
+ while (SDL.SDL_PollEvent(out _) != 0) { }
+
+ while (true)
+ {
+ if (SDL.SDL_WaitEvent(out SDL.SDL_Event ev) == 0) return null;
+ if (ev.type == SDL.SDL_EventType.SDL_QUIT) return null;
+ if (ev.type != SDL.SDL_EventType.SDL_KEYDOWN) continue;
+ if (ev.key.repeat != 0) continue; // ignore auto-repeat
+ if (ev.key.keysym.sym == SDL.SDL_Keycode.SDLK_ESCAPE) return null;
+
+ int? kc = SdlScancodeToLinuxKeycode(ev.key.keysym.scancode);
+ if (kc is not null) return kc;
+ // Unsupported physical key (e.g. F-key, arrow) — keep waiting.
+ }
+ }
+
+ // SDL_Scancode (USB-HID derived) → Linux input-event-codes.h keycode.
+ // Covers only the keys that can produce printable ASCII; everything else
+ // returns null and gets ignored upstream.
+ public static int? SdlScancodeToLinuxKeycode(SDL.SDL_Scancode sc) => sc switch
+ {
+ SDL.SDL_Scancode.SDL_SCANCODE_A => 30,
+ SDL.SDL_Scancode.SDL_SCANCODE_B => 48,
+ SDL.SDL_Scancode.SDL_SCANCODE_C => 46,
+ SDL.SDL_Scancode.SDL_SCANCODE_D => 32,
+ SDL.SDL_Scancode.SDL_SCANCODE_E => 18,
+ SDL.SDL_Scancode.SDL_SCANCODE_F => 33,
+ SDL.SDL_Scancode.SDL_SCANCODE_G => 34,
+ SDL.SDL_Scancode.SDL_SCANCODE_H => 35,
+ SDL.SDL_Scancode.SDL_SCANCODE_I => 23,
+ SDL.SDL_Scancode.SDL_SCANCODE_J => 36,
+ SDL.SDL_Scancode.SDL_SCANCODE_K => 37,
+ SDL.SDL_Scancode.SDL_SCANCODE_L => 38,
+ SDL.SDL_Scancode.SDL_SCANCODE_M => 50,
+ SDL.SDL_Scancode.SDL_SCANCODE_N => 49,
+ SDL.SDL_Scancode.SDL_SCANCODE_O => 24,
+ SDL.SDL_Scancode.SDL_SCANCODE_P => 25,
+ SDL.SDL_Scancode.SDL_SCANCODE_Q => 16,
+ SDL.SDL_Scancode.SDL_SCANCODE_R => 19,
+ SDL.SDL_Scancode.SDL_SCANCODE_S => 31,
+ SDL.SDL_Scancode.SDL_SCANCODE_T => 20,
+ SDL.SDL_Scancode.SDL_SCANCODE_U => 22,
+ SDL.SDL_Scancode.SDL_SCANCODE_V => 47,
+ SDL.SDL_Scancode.SDL_SCANCODE_W => 17,
+ SDL.SDL_Scancode.SDL_SCANCODE_X => 45,
+ SDL.SDL_Scancode.SDL_SCANCODE_Y => 21,
+ SDL.SDL_Scancode.SDL_SCANCODE_Z => 44,
+ SDL.SDL_Scancode.SDL_SCANCODE_1 => 2,
+ SDL.SDL_Scancode.SDL_SCANCODE_2 => 3,
+ SDL.SDL_Scancode.SDL_SCANCODE_3 => 4,
+ SDL.SDL_Scancode.SDL_SCANCODE_4 => 5,
+ SDL.SDL_Scancode.SDL_SCANCODE_5 => 6,
+ SDL.SDL_Scancode.SDL_SCANCODE_6 => 7,
+ SDL.SDL_Scancode.SDL_SCANCODE_7 => 8,
+ SDL.SDL_Scancode.SDL_SCANCODE_8 => 9,
+ SDL.SDL_Scancode.SDL_SCANCODE_9 => 10,
+ SDL.SDL_Scancode.SDL_SCANCODE_0 => 11,
+ SDL.SDL_Scancode.SDL_SCANCODE_MINUS => 12,
+ SDL.SDL_Scancode.SDL_SCANCODE_EQUALS => 13,
+ SDL.SDL_Scancode.SDL_SCANCODE_LEFTBRACKET => 26,
+ SDL.SDL_Scancode.SDL_SCANCODE_RIGHTBRACKET => 27,
+ SDL.SDL_Scancode.SDL_SCANCODE_BACKSLASH => 43,
+ SDL.SDL_Scancode.SDL_SCANCODE_SEMICOLON => 39,
+ SDL.SDL_Scancode.SDL_SCANCODE_APOSTROPHE => 40,
+ SDL.SDL_Scancode.SDL_SCANCODE_GRAVE => 41,
+ SDL.SDL_Scancode.SDL_SCANCODE_COMMA => 51,
+ SDL.SDL_Scancode.SDL_SCANCODE_PERIOD => 52,
+ SDL.SDL_Scancode.SDL_SCANCODE_SLASH => 53,
+ SDL.SDL_Scancode.SDL_SCANCODE_SPACE => 57,
+ SDL.SDL_Scancode.SDL_SCANCODE_NONUSBACKSLASH => 86, // KEY_102ND (DE: < > |)
+ _ => null,
+ };
+}
diff --git a/MemoryModel.cs b/MemoryModel.cs
index c8d3dd2..27f78bf 100644
--- a/MemoryModel.cs
+++ b/MemoryModel.cs
@@ -1,19 +1,20 @@
///
-/// Memory model for Micronona 256.
+/// Memory model for Micronona.
///
-/// Address space as seen by the CPU and all high-level layers (Lua, TinyBasic, host):
+/// Address space as seen by the 6809 CPU and all high-level layers (BASIC, host):
///
/// 0x0000 – 0xDEFF Fixed RAM (56,832 bytes, general purpose)
/// 0xDF00 – 0xDFFF Hardware registers (256 bytes, I/O)
/// 0xE000 – 0xFFFF Bank window (8KB, switchable via REG_BANK)
///
-/// Extended RAM: 256 banks × 8KB = 2MB total.
+/// Extended RAM: 25 banks × 8KB = 200KB total.
/// The bank window at 0xE000 maps to one 8KB slice of extended RAM at a time.
/// Bank switching is done by writing the desired bank number to REG_BANK (0xDF01).
///
/// Bank layout conventions:
-/// Bank 0 Text buffer (40×18×3 bytes: char, fg, bg) starts at offset 0
-/// Bank 255 Font bitmaps (256 glyphs × 8×10 bytes) at end of extended RAM
+/// Bank 0 Text buffer (40×18×3 bytes: char, fg, bg) starts at offset 0,
+/// or 320×180 RGB332 framebuffer when REG_MODE = 1 (graphics)
+/// Bank 24 Font bitmaps (256 glyphs × 8×10 bytes) — FontBankIndex = BankCount-1
///
/// The CPU and all high-level layers use Read(address)/Write(address) exclusively.
/// Bank switching is transparent — callers set REG_BANK and then access 0xE000–0xFFFF.
@@ -42,10 +43,12 @@ public class MemoryModel
public const int REG_BANK = 0x01; // Active bank in the 0xE000 window (0–255)
public const int REG_KEY_CHAR = 0x02; // Next keypress character (0 = none)
public const int REG_KEY_FLAGS = 0x03; // Modifier flags (Shift, Ctrl, …)
- public const int REG_TIMER = 0x04; // Auto-incrementing timer; saturates at 255; resets on read
+ public const int REG_TIMER = 0x04; // Frame counter: incremented once per frame (60 Hz), saturates at 255, resets to 0 on read
public const int REG_VSYNC = 0x05; // VSync flag; set by host each frame
public const int REG_CURSOR_COL = 0x06; // Text cursor position horizontally
public const int REG_CURSOR_ROW = 0x07; // Text cursor position vertically
+ public const int REG_RANDOM = 0x08; // Read-only: returns a new random byte on every read
+ public const int REG_SOUND = 0x10; // Write-only: SN76489 PSG data port
// -------------------------------------------------------------------------
// Text mode layout (Bank 0, starting at offset 0)
@@ -58,9 +61,7 @@ public class MemoryModel
public const int TextBankIndex = 0; // Text buffer lives in bank 0
public const int TextBufferSize = TextCols * TextRows * TextCellSize; // 2160 bytes
- // Default terminal colors (RGB332)
- public const byte DefaultFg = 0x1C; // Bright green: R=0, G=224, B=0
- public const byte DefaultBg = 0x08; // Dark green: R=0, G=64, B=0
+
// -------------------------------------------------------------------------
// Font layout (Bank 255, starting at offset 0)
@@ -85,6 +86,17 @@ public class MemoryModel
///
public readonly object Lock = new();
+ ///
+ /// Invoked whenever the CPU (or any writer) stores to REG_SOUND. The host
+ /// wires this to the SN76489 emulator. May be called from multiple threads.
+ ///
+ public Action? OnSoundWrite;
+
+ // VSync: semaphore signals each frame; _totalFrames counts them for elapsed measurement.
+ private readonly SemaphoreSlim _vsyncSem = new(0, 1);
+ private long _totalFrames = 0;
+ private long _lastVsyncFrame = 0;
+
// -------------------------------------------------------------------------
// Internal storage
// -------------------------------------------------------------------------
@@ -102,7 +114,7 @@ public class MemoryModel
// Constructor
// -------------------------------------------------------------------------
- public MemoryModel()
+ public MemoryModel(byte defaultFg, byte defaultBg)
{
// Bank 0 active by default
_io[REG_BANK] = TextBankIndex;
@@ -112,8 +124,8 @@ public class MemoryModel
for (int i = 0; i < TextCols * TextRows; i++)
{
_extendedRam[textBase + i * TextCellSize + 0] = 0x20; // Space
- _extendedRam[textBase + i * TextCellSize + 1] = DefaultFg;
- _extendedRam[textBase + i * TextCellSize + 2] = DefaultBg;
+ _extendedRam[textBase + i * TextCellSize + 1] = defaultFg;
+ _extendedRam[textBase + i * TextCellSize + 2] = defaultBg;
}
}
@@ -127,14 +139,11 @@ public class MemoryModel
///
public byte Read(ushort address)
{
- lock (Lock)
- {
- if (address >= IoBase && address < IoBase + IoSize)
- return ReadIo(address - IoBase);
- if (address >= BankWindowBase)
- return ReadBank(address - BankWindowBase);
- return _fixedRam[address];
- }
+ if (address >= IoBase && address < IoBase + IoSize)
+ return ReadIo(address - IoBase);
+ if (address >= BankWindowBase)
+ return ReadBank(address - BankWindowBase);
+ return _fixedRam[address];
}
///
@@ -142,15 +151,12 @@ public class MemoryModel
///
public void Write(ushort address, byte value)
{
- lock (Lock)
- {
- if (address >= IoBase && address < IoBase + IoSize)
- WriteIo(address - IoBase, value);
- else if (address >= BankWindowBase)
- WriteBank(address - BankWindowBase, value);
- else
- _fixedRam[address] = value;
- }
+ if (address >= IoBase && address < IoBase + IoSize)
+ WriteIo(address - IoBase, value);
+ else if (address >= BankWindowBase)
+ WriteBank(address - BankWindowBase, value);
+ else
+ _fixedRam[address] = value;
}
///
@@ -189,7 +195,7 @@ public class MemoryModel
///
public byte ReadFlat(int address)
{
- lock (Lock) return _extendedRam[address];
+ return _extendedRam[address];
}
///
@@ -205,6 +211,14 @@ public class MemoryModel
}
}
+ public void FillFlat(int address, int length, byte value)
+ {
+ lock (Lock)
+ {
+ _extendedRam.AsSpan(address, length).Fill(value);
+ }
+ }
+
///
/// Return a Span over one full bank in extended RAM.
/// Useful for bulk operations like SDL texture uploads.
@@ -216,24 +230,66 @@ public class MemoryModel
// Internal helpers
// -------------------------------------------------------------------------
+ ///
+ /// Called once per rendered frame by the host. Increments REG_TIMER, saturating at 255.
+ ///
+ public void TickFrame()
+ {
+ if (_io[REG_TIMER] < 255)
+ _io[REG_TIMER]++;
+ }
+
private byte ReadIo(int reg)
{
if (reg == REG_TIMER)
{
- // Timer resets to 0 on read (after returning current value)
+ // Returns frames elapsed since last read, then resets to 0
byte val = _io[REG_TIMER];
_io[REG_TIMER] = 0;
return val;
}
+ if (reg == REG_RANDOM)
+ return (byte)Random.Shared.Next(256);
return _io[reg];
}
private void WriteIo(int reg, byte value)
{
- // All register writes are simple stores; bank switch takes effect immediately
+ if (reg == REG_VSYNC)
+ {
+ WaitVSync();
+ return;
+ }
+ if (reg == REG_SOUND)
+ {
+ _io[reg] = value;
+ OnSoundWrite?.Invoke(value);
+ return;
+ }
+ // All other register writes are simple stores.
_io[reg] = value;
}
+ private void WaitVSync()
+ {
+ _vsyncSem.Wait();
+ long now = Volatile.Read(ref _totalFrames);
+ int elapsed = (int)(now - _lastVsyncFrame);
+ _lastVsyncFrame = now;
+ _io[REG_TIMER] = (byte)Math.Min(elapsed, 255);
+ }
+
+ ///
+ /// Called by the SDL render loop after SDL_RenderPresent.
+ /// Increments the frame counter and unblocks any thread waiting on REG_VSYNC.
+ ///
+ public void SignalVSync()
+ {
+ Interlocked.Increment(ref _totalFrames);
+ if (_vsyncSem.CurrentCount == 0)
+ _vsyncSem.Release();
+ }
+
private byte ReadBank(int offset)
{
int bank = _io[REG_BANK];
diff --git a/MicrononaRenderer.cs b/MicrononaRenderer.cs
index 8660cb4..b37d87d 100644
--- a/MicrononaRenderer.cs
+++ b/MicrononaRenderer.cs
@@ -11,7 +11,8 @@
/// Expands RGB332 to RGB24 for each pixel.
///
/// Graphics mode:
-/// Not yet implemented.
+/// Reads 320×180 bytes from extended RAM starting at bank 0 offset 0.
+/// Each byte is one pixel in RGB332 format, expanded to RGB24.
///
public class MicrononaRenderer
{
@@ -103,7 +104,13 @@ public class MicrononaRenderer
private void RenderGraphics()
{
- // TODO: read framebuffer from extended RAM, expand RGB332 → RGB24
+ int pixelBase = MemoryModel.TextBankIndex * MemoryModel.BankSize;
+
+ for (int i = 0; i < 320 * 180; i++)
+ {
+ byte color332 = _mem.ReadFlat(pixelBase + i);
+ Expand332(_rgb24, i * 3, color332);
+ }
}
// -------------------------------------------------------------------------
diff --git a/Program.cs b/Program.cs
index a775b19..58c1299 100644
--- a/Program.cs
+++ b/Program.cs
@@ -2,6 +2,23 @@
using Tomlyn;
using Tomlyn.Model;
+if (args.Length > 0 && args[0] == "--detect-keyboard")
+{
+ string keymapDir = args.Length > 1 ? args[1] : "/usr/share/keymaps";
+ string? layout = KeyboardLayoutDetector.DetectInteractive(keymapDir);
+ if (layout is null) { Console.WriteLine("(undecidable)"); return 0; }
+
+ string? stickPath = DiskManager.FindMicrononaMount();
+ if (stickPath is null)
+ Console.WriteLine($"{layout} (no Micronona stick mounted — not saved)");
+ else
+ {
+ DiskManager.SaveKeyboardLayout(stickPath, layout);
+ Console.WriteLine($"{layout} (saved to {Path.Combine(stickPath, DiskManager.MarkerFile)})");
+ }
+ return 0;
+}
+
const int ScreenWidth = 320;
const int ScreenHeight = 180;
const string Title = "Micronona";
@@ -27,7 +44,8 @@ else
Console.WriteLine("Running in developer mode");
}
-var mem = new MemoryModel();
+var mem = new MemoryModel(ConsoleHelper.DefaultFg, ConsoleHelper.DefaultBg);
+var console = new ConsoleHelper(mem);
var diskManager = new DiskManager();
var micrononaRenderer = new MicrononaRenderer(mem);
@@ -63,6 +81,12 @@ mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 36 * MemoryMode
0x00, 0x08, 0x3E, 0x68, 0x3C, 0x16, 0x7C, 0x10, 0x00, 0x00
);
+// '
+mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 39 * MemoryModel.FontGlyphHeight,
+ // 0x00, 0x18, 0x3E, 0x68, 0x3C, 0x16, 0x7C, 0x18, 0x00, 0x00
+ 0x00, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+);
+
// (
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 40 * MemoryModel.FontGlyphHeight,
// 0x00, 0x08, 0x18, 0x30, 0x20, 0x20, 0x30, 0x18, 0x08, 0x00
@@ -325,6 +349,11 @@ mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 90 * MemoryMode
0x00, 0x7E, 0x06, 0x0C, 0x18, 0x30, 0x60, 0x7E, 0x00, 0x00
);
+// ^
+mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 94 * MemoryModel.FontGlyphHeight,
+ 0x00, 0x18, 0x3C, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+);
+
// _
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 95 * MemoryModel.FontGlyphHeight,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00
@@ -360,6 +389,11 @@ mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 102 * MemoryMod
0x00, 0x0C, 0x18, 0x18, 0x3C, 0x18, 0x18, 0x18, 0x18, 0x00
);
+// g
+mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 103 * MemoryModel.FontGlyphHeight,
+ 0x00, 0x00, 0x3C, 0x66, 0x66, 0x66, 0x3E, 0x06, 0x3C, 0x00
+);
+
// h
mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 104 * MemoryModel.FontGlyphHeight,
0x00, 0x60, 0x60, 0x60, 0x7C, 0x66, 0x66, 0x66, 0x00, 0x00
@@ -445,11 +479,16 @@ mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 121 * MemoryMod
0x00, 0x00, 0x66, 0x66, 0x66, 0x3C, 0x18, 0x18, 0x30, 0x00
);
+// z
+mem.WriteFlat(MemoryModel.FontBankIndex * MemoryModel.BankSize + 122 * MemoryModel.FontGlyphHeight,
+ 0x00, 0x00, 0x7E, 0x0C, 0x38,0x1C, 0x30, 0x7E, 0x00, 0x00
+);
+
// -------------------------------------------------------------------------
// SDL init
// -------------------------------------------------------------------------
-if (SDL.SDL_Init(SDL.SDL_INIT_VIDEO) < 0)
+if (SDL.SDL_Init(SDL.SDL_INIT_VIDEO | SDL.SDL_INIT_AUDIO) < 0)
{
Console.Error.WriteLine($"SDL_Init failed: {SDL.SDL_GetError()}");
return 1;
@@ -498,6 +537,37 @@ var texture = SDL.SDL_CreateTexture(
// RGB24 output buffer for SDL (expanded from memory each frame)
byte[] rgb24 = new byte[ScreenWidth * ScreenHeight * 3];
+// -------------------------------------------------------------------------
+// SN76489 PSG — one-byte write port at REG_SOUND ($DF10)
+// -------------------------------------------------------------------------
+
+var audioDesired = new SDL.SDL_AudioSpec
+{
+ freq = 44100,
+ format = SDL.AUDIO_S16SYS,
+ channels = 1,
+ samples = 1024,
+};
+
+// ppy.SDL2-CS cannot marshal a null device name to SDL_OpenAudioDevice, and
+// passing "" is treated as a literal device name. Use the legacy SDL_OpenAudio
+// which always targets the default device (device ID 1).
+int audioOpenResult = SDL.SDL_OpenAudio(ref audioDesired, out var audioObtained);
+uint audioDev = audioOpenResult == 0 ? 1u : 0u;
+if (audioDev == 0)
+ Console.Error.WriteLine($"SDL_OpenAudio failed: {SDL.SDL_GetError()} (continuing without sound)");
+
+int audioSampleRate = audioDev != 0 ? audioObtained.freq : 44100;
+var sn = new Sn76489(audioSampleRate);
+mem.OnSoundWrite = sn.Write;
+
+int samplesPerFrame = audioSampleRate / 60;
+int audioTarget = samplesPerFrame * 3; // keep ~3 frames (~50 ms) queued
+short[] audioBuf = new short[audioTarget]; // room for a full top-up in one call
+
+if (audioDev != 0)
+ SDL.SDL_PauseAudio(0);
+
var top = "*** MICRONONA 256 ***";
var tab = (byte)((MemoryModel.TextCols - top.Length) / 2);
@@ -509,13 +579,50 @@ consoleHelper.WriteText("MICRONONA");
consoleHelper.SetCursor(5, 1);
-SDL.SDL_SetWindowFullscreen(window, (uint)SDL.SDL_WindowFlags.SDL_WINDOW_FULLSCREEN_DESKTOP);
+//SDL.SDL_SetWindowFullscreen(window, (uint)SDL.SDL_WindowFlags.SDL_WINDOW_FULLSCREEN_DESKTOP);
var scrollLock = new ScrollLockLed();
scrollLock.Set(false);
-diskManager.OnMicrononaStickInserted += path => { Console.WriteLine($"Ready: {path}"); scrollLock.Set(true); };
+// Start from a known baseline so the subsequent loadkeys switch (from marker
+// or KMAP result) is visibly distinct on the Pi target.
+KeyboardLayoutDetector.ApplyLoadkeys("us");
+
+bool firstStickInsert = true;
+diskManager.OnMicrononaStickInserted += path =>
+{
+ Console.WriteLine($"Ready: {path}");
+ scrollLock.Set(true);
+
+ // Only on the first stick after app start: apply the stored layout via
+ // loadkeys, or auto-run KMAP if the marker has no [keyboard] entry yet.
+ // Later inserts stay quiet so they can't interrupt a running BASIC session.
+ if (!firstStickInsert) return;
+ firstStickInsert = false;
+
+ string markerPath = Path.Combine(path, DiskManager.MarkerFile);
+ try
+ {
+ TomlTable model = Toml.ToModel(File.ReadAllText(markerPath));
+ if (model.TryGetValue("keyboard", out object? kbObj)
+ && kbObj is TomlTable kb
+ && kb.TryGetValue("layout", out object? layoutObj)
+ && layoutObj is string layout
+ && !string.IsNullOrWhiteSpace(layout))
+ {
+ KeyboardLayoutDetector.ApplyLoadkeys(layout);
+ }
+ else
+ {
+ inputInterpreter.InterpretInput("KMAP");
+ }
+ }
+ catch (Exception ex)
+ {
+ Console.WriteLine($"[keyboard] could not read marker: {ex.Message}");
+ }
+};
diskManager.OnStickRemoved += () => { Console.WriteLine("Stick removed"); scrollLock.Set(false); };
diskManager.Start();
cpu.StartThread();
@@ -538,6 +645,7 @@ if (runFile != null)
Console.Error.WriteLine($"--run: no Micronona stick mounted");
inputInterpreter.StopThread();
cpu.StopThread();
+ if (audioDev != 0) SDL.SDL_CloseAudio();
SDL.SDL_DestroyTexture(texture);
SDL.SDL_DestroyRenderer(renderer);
SDL.SDL_DestroyWindow(window);
@@ -551,6 +659,7 @@ if (runFile != null)
Console.Error.WriteLine($"--run: file not found on stick: {runFile}");
inputInterpreter.StopThread();
cpu.StopThread();
+ if (audioDev != 0) SDL.SDL_CloseAudio();
SDL.SDL_DestroyTexture(texture);
SDL.SDL_DestroyRenderer(renderer);
SDL.SDL_DestroyWindow(window);
@@ -580,6 +689,34 @@ while (running)
if (e.type == SDL.SDL_EventType.SDL_KEYDOWN)
{
+ // KMAP captures key events directly: ESC cancels, mapped scancodes
+ // get submitted; everything else is ignored until KMAP releases.
+ if (inputInterpreter.IsWaitingForKmapKey)
+ {
+ if (e.key.keysym.sym == SDL.SDL_Keycode.SDLK_ESCAPE)
+ {
+ inputInterpreter.SubmitKmapKey(null);
+ }
+ else
+ {
+ int? kc = KeyboardLayoutDetector.SdlScancodeToLinuxKeycode(e.key.keysym.scancode);
+ if (kc is not null)
+ {
+ int sym = (int)e.key.keysym.sym;
+ char display = (sym >= 32 && sym <= 126) ? (char)sym : '\0';
+ inputInterpreter.SubmitKmapKey(kc.Value, display);
+ }
+ }
+ continue;
+ }
+
+ if (inputInterpreter.IsEditorActive)
+ {
+ EditorAction? act = MapSdlToEditorAction(e.key);
+ if (act.HasValue) inputInterpreter.EditorAction(act.Value);
+ continue;
+ }
+
switch (e.key.keysym.sym)
{
case SDL.SDL_Keycode.SDLK_ESCAPE:
@@ -592,7 +729,8 @@ while (running)
break;
}
- if (!inputInterpreter.IsRunning || inputInterpreter.IsWaitingForInput)
+ if (!inputInterpreter.IsKmapActive
+ && (!inputInterpreter.IsRunning || inputInterpreter.IsWaitingForInput))
{
switch (e.key.keysym.sym)
{
@@ -613,21 +751,33 @@ while (running)
}
}
}
- if (e.type == SDL.SDL_EventType.SDL_TEXTINPUT && (!inputInterpreter.IsRunning || inputInterpreter.IsWaitingForInput))
+ if (e.type == SDL.SDL_EventType.SDL_TEXTINPUT)
{
- unsafe
+ if (inputInterpreter.IsEditorActive)
{
- byte ascii = e.text.text[0];
- if (ascii >= 32 && ascii < 127)
- consoleHelper.WriteText(((char)ascii).ToString());
+ unsafe
+ {
+ byte ascii = e.text.text[0];
+ if (ascii >= 32 && ascii < 127)
+ inputInterpreter.EditorChar((char)ascii);
+ }
+ continue;
+ }
+
+ if (!inputInterpreter.IsKmapActive
+ && (!inputInterpreter.IsRunning || inputInterpreter.IsWaitingForInput))
+ {
+ unsafe
+ {
+ byte ascii = e.text.text[0];
+ if (ascii >= 32 && ascii < 127)
+ consoleHelper.WriteText(((char)ascii).ToString());
+ }
}
}
}
scrollLock.Refresh();
- // --- VSync flag setzen (wird später vom 6809-Emulator gelesen) ---
- mem.Write(MemoryModel.IoBase + MemoryModel.REG_VSYNC, 1);
-
// --- Render ---
var span = micrononaRenderer.Render();
unsafe
@@ -641,19 +791,77 @@ while (running)
SDL.SDL_RenderClear(renderer);
SDL.SDL_RenderCopy(renderer, texture, IntPtr.Zero, IntPtr.Zero);
SDL.SDL_RenderPresent(renderer);
+ mem.SignalVSync();
mem.TickFrame();
+ if (audioDev != 0)
+ {
+ // Top up the audio queue to ~3 frames; absorbs vsync jitter without
+ // noticeable latency.
+ uint queuedBytes = SDL.SDL_GetQueuedAudioSize(audioDev);
+ int queuedSamples = (int)(queuedBytes / sizeof(short));
+ int need = audioTarget - queuedSamples;
+ if (need > 0)
+ {
+ if (need > audioBuf.Length) need = audioBuf.Length;
+ sn.GenerateSamples(audioBuf.AsSpan(0, need));
+ unsafe
+ {
+ fixed (short* p = audioBuf)
+ {
+ SDL.SDL_QueueAudio(audioDev, (IntPtr)p, (uint)(need * sizeof(short)));
+ }
+ }
+ }
+ }
+
if (runStartTick > 0 && Environment.TickCount64 - runStartTick >= 5000)
running = false;
}
+// -------------------------------------------------------------------------
+// Helpers
+// -------------------------------------------------------------------------
+
+static EditorAction? MapSdlToEditorAction(SDL.SDL_KeyboardEvent ke)
+{
+ bool ctrl = (ke.keysym.mod & SDL.SDL_Keymod.KMOD_CTRL) != 0;
+ return ke.keysym.sym switch
+ {
+ SDL.SDL_Keycode.SDLK_LEFT => EditorAction.Left,
+ SDL.SDL_Keycode.SDLK_RIGHT => EditorAction.Right,
+ SDL.SDL_Keycode.SDLK_UP => EditorAction.Up,
+ SDL.SDL_Keycode.SDLK_DOWN => EditorAction.Down,
+ SDL.SDL_Keycode.SDLK_HOME => EditorAction.Home,
+ SDL.SDL_Keycode.SDLK_END => EditorAction.End,
+ SDL.SDL_Keycode.SDLK_PAGEUP => EditorAction.PageUp,
+ SDL.SDL_Keycode.SDLK_PAGEDOWN => EditorAction.PageDown,
+ SDL.SDL_Keycode.SDLK_BACKSPACE => EditorAction.Backspace,
+ SDL.SDL_Keycode.SDLK_DELETE => EditorAction.Delete,
+ SDL.SDL_Keycode.SDLK_RETURN => EditorAction.Enter,
+ SDL.SDL_Keycode.SDLK_KP_ENTER => EditorAction.Enter,
+ SDL.SDL_Keycode.SDLK_ESCAPE => EditorAction.Quit,
+ SDL.SDL_Keycode.SDLK_s when ctrl => EditorAction.Save,
+ SDL.SDL_Keycode.SDLK_z when ctrl => EditorAction.Undo,
+ SDL.SDL_Keycode.SDLK_k when ctrl => EditorAction.CutLine,
+ SDL.SDL_Keycode.SDLK_u when ctrl => EditorAction.PasteLine,
+ SDL.SDL_Keycode.SDLK_q when ctrl => EditorAction.Quit,
+ _ => null
+ };
+}
+
// -------------------------------------------------------------------------
// Cleanup
// -------------------------------------------------------------------------
inputInterpreter.StopThread();
cpu.StopThread();
+if (audioDev != 0)
+{
+ SDL.SDL_PauseAudio(1);
+ SDL.SDL_CloseAudio();
+}
SDL.SDL_DestroyTexture(texture);
SDL.SDL_DestroyRenderer(renderer);
SDL.SDL_DestroyWindow(window);
diff --git a/Sn76489.cs b/Sn76489.cs
new file mode 100644
index 0000000..bc7686a
--- /dev/null
+++ b/Sn76489.cs
@@ -0,0 +1,197 @@
+///
+/// Texas Instruments SN76489 programmable sound generator.
+///
+/// Three square-wave tone channels plus one noise channel, mono output.
+/// Clock: 3.579545 MHz (NTSC). Internal /16 divider yields a ~223.7 kHz
+/// counter clock. Tone frequency = ChipClock / (32 * N) for 10-bit reload N.
+///
+/// Write protocol (single 8-bit port at REG_SOUND):
+/// LATCH/DATA byte (MSB=1): 1 R2 R1 R0 D3 D2 D1 D0
+/// R2..R0 selects register, D3..D0 is low 4 bits of payload.
+/// DATA byte (MSB=0): 0 x D5 D4 D3 D2 D1 D0
+/// Upper 6 bits of 10-bit tone reload; appended to the last latched
+/// tone register. Ignored for attenuation (kept for completeness).
+///
+/// Register map (R2 R1 R0):
+/// 000 Tone 1 freq 001 Tone 1 attenuation
+/// 010 Tone 2 freq 011 Tone 2 attenuation
+/// 100 Tone 3 freq 101 Tone 3 attenuation
+/// 110 Noise control 111 Noise attenuation
+///
+/// Attenuation: 0 = loudest, 15 = silent, 2 dB per step.
+/// Noise control bits: NF2 = white (1) / periodic (0); NF1 NF0 = shift rate
+/// 00 N/512, 01 N/1024, 10 N/2048, 11 = tone 3 rate.
+///
+public class Sn76489
+{
+ public const int ChipClock = 3579545;
+ public const int ToneDivider = 16;
+ public const double CounterClock = ChipClock / (double)ToneDivider;
+
+ private const int NoiseLfsrInit = 0x4000;
+ private const int NoiseLfsrMask = 0x7FFF;
+
+ private readonly int[] _toneReload = new int[3];
+ private readonly int[] _toneCounter = new int[3] { 1, 1, 1 };
+ private readonly int[] _toneOut = new int[3];
+
+ private readonly int[] _attenuation = new int[4] { 15, 15, 15, 15 };
+
+ private int _noiseCtrl;
+ private int _noiseCounter = 1;
+ private int _noiseShift = NoiseLfsrInit;
+ private int _noiseOut;
+
+ private int _latchedReg;
+
+ private readonly double _cyclesPerSample;
+ private double _cyclesAccum;
+
+ private static readonly short[] VolumeTable = BuildVolumeTable();
+
+ private readonly object _lock = new();
+
+ public Sn76489(int sampleRate)
+ {
+ _cyclesPerSample = CounterClock / sampleRate;
+ }
+
+ private static short[] BuildVolumeTable()
+ {
+ // Per-channel peak of 6000 keeps four channels summed within int16 range.
+ var t = new short[16];
+ for (int i = 0; i < 15; i++)
+ t[i] = (short)(6000.0 * System.Math.Pow(10.0, -i * 2.0 / 20.0));
+ t[15] = 0;
+ return t;
+ }
+
+ public void Write(byte value)
+ {
+ lock (_lock)
+ {
+ if ((value & 0x80) != 0)
+ {
+ int reg = (value >> 4) & 0x07;
+ int data4 = value & 0x0F;
+ _latchedReg = reg;
+ ApplyLatch(reg, data4);
+ }
+ else
+ {
+ int data6 = value & 0x3F;
+ ApplyContinuation(_latchedReg, data6);
+ }
+ }
+ }
+
+ private void ApplyLatch(int reg, int data4)
+ {
+ int channel = reg >> 1;
+ bool isAtt = (reg & 1) != 0;
+
+ if (isAtt)
+ {
+ _attenuation[channel] = data4;
+ }
+ else if (channel < 3)
+ {
+ _toneReload[channel] = (_toneReload[channel] & ~0x0F) | data4;
+ }
+ else
+ {
+ _noiseCtrl = data4 & 0x07;
+ _noiseShift = NoiseLfsrInit;
+ }
+ }
+
+ private void ApplyContinuation(int reg, int data6)
+ {
+ int channel = reg >> 1;
+ bool isAtt = (reg & 1) != 0;
+
+ if (isAtt)
+ {
+ _attenuation[channel] = data6 & 0x0F;
+ }
+ else if (channel < 3)
+ {
+ _toneReload[channel] = (_toneReload[channel] & 0x0F) | ((data6 & 0x3F) << 4);
+ }
+ else
+ {
+ _noiseCtrl = data6 & 0x07;
+ _noiseShift = NoiseLfsrInit;
+ }
+ }
+
+ /// Fill a mono 16-bit PCM buffer with freshly generated samples.
+ public void GenerateSamples(System.Span output)
+ {
+ lock (_lock)
+ {
+ for (int s = 0; s < output.Length; s++)
+ {
+ _cyclesAccum += _cyclesPerSample;
+ int cycles = (int)_cyclesAccum;
+ _cyclesAccum -= cycles;
+ if (cycles > 0) RunCycles(cycles);
+ output[s] = MixSample();
+ }
+ }
+ }
+
+ private void RunCycles(int cycles)
+ {
+ for (int c = 0; c < cycles; c++)
+ {
+ for (int ch = 0; ch < 3; ch++)
+ {
+ if (--_toneCounter[ch] <= 0)
+ {
+ int reload = _toneReload[ch];
+ // Reload of 0 is treated as 1 — at that rate the channel emits
+ // DC-ish, which is correct "silent carrier" behaviour on hardware.
+ _toneCounter[ch] = reload == 0 ? 1 : reload;
+ _toneOut[ch] ^= 1;
+ }
+ }
+
+ if (--_noiseCounter <= 0)
+ {
+ int rate = _noiseCtrl & 0x03;
+ int reload = rate switch
+ {
+ 0 => 32,
+ 1 => 64,
+ 2 => 128,
+ _ => _toneReload[2] == 0 ? 1 : _toneReload[2],
+ };
+ _noiseCounter = reload;
+
+ int fb = (_noiseCtrl & 0x04) != 0
+ ? ((_noiseShift & 1) ^ ((_noiseShift >> 3) & 1)) & 1
+ : _noiseShift & 1;
+
+ _noiseShift = ((_noiseShift >> 1) | (fb << 14)) & NoiseLfsrMask;
+ _noiseOut = _noiseShift & 1;
+ }
+ }
+ }
+
+ private short MixSample()
+ {
+ int sum = 0;
+ for (int ch = 0; ch < 3; ch++)
+ {
+ int v = VolumeTable[_attenuation[ch]];
+ sum += _toneOut[ch] != 0 ? v : -v;
+ }
+ int nv = VolumeTable[_attenuation[3]];
+ sum += _noiseOut != 0 ? nv : -nv;
+
+ if (sum > short.MaxValue) sum = short.MaxValue;
+ if (sum < short.MinValue) sum = short.MinValue;
+ return (short)sum;
+ }
+}
diff --git a/TextEditor.cs b/TextEditor.cs
new file mode 100644
index 0000000..c26f557
--- /dev/null
+++ b/TextEditor.cs
@@ -0,0 +1,433 @@
+using System.Collections.Concurrent;
+
+///
+/// Editor actions delivered from the SDL main loop. All non-printable input is
+/// expressed as one of these; printable characters arrive via OnChar.
+///
+public enum EditorAction
+{
+ Left, Right, Up, Down,
+ Home, End, PageUp, PageDown,
+ Backspace, Delete, Enter,
+ Save, Undo, CutLine, PasteLine, Quit
+}
+
+internal enum EditorOpType
+{
+ InsertChar, DeleteChar,
+ InsertLine, DeleteLine,
+ SplitLine, JoinLine,
+ ReplaceLine
+}
+
+internal readonly record struct EditorOp(EditorOpType Type, int Row, int Col, char Ch, string? Line);
+
+///
+/// Full-screen text editor for Micronona. Runs on its own thread, blocks on an
+/// event queue fed by the SDL main loop. Renders directly into the text-mode
+/// framebuffer via ConsoleHelper; the hardware cursor is positioned through
+/// REG_CURSOR_COL/ROW so the existing inverting render handles cursor display.
+///
+/// Layout (40×18):
+/// row 0 title bar (filename + [modified])
+/// rows 1..16 content (16 visible rows, horizontal scrolling)
+/// row 17 shortcut bar / quit-confirm prompt
+///
+public sealed class TextEditor
+{
+ private const int TitleRow = 0;
+ private const int ContentTop = 1;
+ private const int ShortcutRow = MemoryModel.TextRows - 1; // 17
+ private const int ContentRows = ShortcutRow - ContentTop; // 16
+ private const int Cols = MemoryModel.TextCols; // 40
+
+ private const byte ContentFg = ConsoleHelper.DefaultFg;
+ private const byte ContentBg = ConsoleHelper.DefaultBg;
+ private const byte BarFg = ConsoleHelper.DefaultBg; // inverted bars
+ private const byte BarBg = ConsoleHelper.DefaultFg;
+
+ private readonly ConsoleHelper _con;
+
+ private readonly List _lines = new();
+ private readonly Stack _undo = new();
+ private readonly BlockingCollection