fix: choice needs STI

Author: maximilien-noal

src/Spice86.Core/Emulator/InterruptHandlers/Common/MemoryWriter/MemoryAsmWriter.cs

@@ -111,6 +111,13 @@ public void WriteNop() {
         WriteUInt8(0x90);
     }
 
+    /// <summary>
+    /// Writes a STI instruction to memory. Re-enables hardware interrupts (IF=1).
+    /// </summary>
+    public void WriteSti() {
+        WriteUInt8(0xFB);
+    }
+
     /// <summary>
     /// Writes a far CALL instruction to the given inMemoryAddressSwitcher default address. <br/>
     /// Throws UnrecoverableException if DefaultAddressValue is not initialized. <br/>

src/Spice86.Core/Emulator/InterruptHandlers/Dos/DosInt21Handler.cs

@@ -234,7 +234,7 @@ public override SegmentedAddress WriteAssemblyInRam(MemoryAsmWriter memoryAsmWri
 
         // Block sizes for jump offset calculation:
         // L_DEFAULT:          callback(4) + IRET(1) = 5 bytes
-        // L_WAIT_FOR_STDIN:   callback(4) + CMP(6) + JNZ(2) + INT(2) + JMP(2) = 16 bytes
+        // L_WAIT_FOR_STDIN:   STI(1) + callback(4) + CMP(6) + JNZ(2) + INT(2) + JMP(2) = 17 bytes
         // L_DISPATCH:         callback(4) + IRET(1) = 5 bytes
 
         SegmentedAddress handlerAddress = memoryAsmWriter.CurrentAddress;
@@ -265,6 +265,11 @@ public override SegmentedAddress WriteAssemblyInRam(MemoryAsmWriter memoryAsmWri
         memoryAsmWriter.WriteIret();
 
         // L_WAIT_FOR_STDIN: poll STDIN readiness in a loop with INT 28h idle
+        // STI — re-enable hardware interrupts so IRQ1 (keyboard) can fire.
+        // INT 21h clears IF per x86 spec; without STI the polling loop would
+        // spin forever because keyboard scancodes never reach BiosKeyboardBuffer.
+        // This matches FreeDOS (INT 21h starts with STI) and DOSBox (idle uses STI+HLT).
+        memoryAsmWriter.WriteSti();
         // callback(CheckStdinReady) — writes flag byte, 4 bytes
         memoryAsmWriter.RegisterAndWriteCallback(CallbackCheckStdinReady);
         // CMP byte CS:[flagOffset], 0 — 6 bytes
@@ -277,8 +282,8 @@ public override SegmentedAddress WriteAssemblyInRam(MemoryAsmWriter memoryAsmWri
         memoryAsmWriter.WriteJnz(4);
         // INT 28h (DOS idle)
         memoryAsmWriter.WriteInt(0x28);
-        // JMP short back to callback(CheckStdinReady): -(4+6+2+2+2) = -16
-        memoryAsmWriter.WriteJumpShort(-16);
+        // JMP short back to STI: -(4+6+2+2+2+1) = -17
+        memoryAsmWriter.WriteJumpShort(-17);
 
         // L_DISPATCH: dispatch to C# handler for AH=07h/08h/0Ah
         memoryAsmWriter.RegisterAndWriteCallback(Run);

tests/Spice86.Tests/Dos/DosInt21IntegrationTests.cs

@@ -1274,6 +1274,73 @@ public void CheckStandardInputStatus_WithBreakEnabled_DetectsCtrlCAndInvokesInt2
         testHandler.Results.Should().NotContain((byte)TestResult.Failure);
     }
 
+    // ──────────────────────────────────────────────────────────────────────
+    // Phase 1 — Full hardware keyboard stack → AH=08h polling loop
+    // Reproduces the keyboard bug: INT 21h clears IF, so hardware IRQ1
+    // (keyboard) can never fire while the WriteAssemblyInRam polling loop
+    // is running. Keys injected through the full hardware stack never reach
+    // the BiosKeyboardBuffer.
+    // ──────────────────────────────────────────────────────────────────────
+
+    /// <summary>
+    /// Reproduces the live-emulation keyboard bug: a key pressed DURING the
+    /// AH=08h WriteAssemblyInRam polling loop never reaches BiosKeyboardBuffer
+    /// because INT 21h clears IF and the loop never re-enables interrupts (STI).
+    /// Full keyboard stack: HeadlessGui → InputEventHub → PS2Keyboard
+    /// → Intel8042Controller → IRQ1 (blocked by IF=0) → BiosKeyboardInt9Handler
+    /// → BiosKeyboardBuffer → ConsoleDevice → AH=08h.
+    /// </summary>
+    [Fact]
+    public void AH08h_ReadsKeyFromHardwareStack_WhenKeyInjectedDuringPolling() {
+        // Arrange: COM calls AH=08h immediately. The key arrives while the
+        // WriteAssemblyInRam polling loop is running with IF=0.
+        byte[] program = new byte[] {
+            // Call AH=08h (Character Input Without Echo) — enters polling loop
+            0xB4, 0x08,             // mov ah, 08h
+            0xCD, 0x21,             // int 21h
+
+            // Write AL to details port for diagnostics
+            0xBA, 0x98, 0x09,       // mov dx, DetailsPort (0x998)
+            0xEE,                   // out dx, al
+
+            // Check AL == 0x31 ('1')
+            0x3C, 0x31,             // cmp al, 31h
+            0x75, 0x04,             // jne failed
+
+            // Success
+            0xB0, 0x00,             // mov al, TestResult.Success
+            0xEB, 0x02,             // jmp writeResult
+
+            // failed:
+            0xB0, 0xFF,             // mov al, TestResult.Failure
+
+            // writeResult:
+            0xBA, 0x99, 0x09,       // mov dx, ResultPort
+            0xEE,                   // out dx, al
+            0xF4                    // hlt
+        };
+
+        // Act — inject '1' through the full hardware keyboard stack at cycle 50.
+        // The key arrives while AH=08h is in its polling loop with IF=0.
+        DosTestHandler testHandler = RunDosTest(program, keyInjectionAction: SimulateDigit1);
+
+        // Assert
+        testHandler.Details.Should().NotBeEmpty("AH=08h should write AL to details port");
+        byte actualAl = testHandler.Details[0];
+        actualAl.Should().Be(0x31,
+            "AH=08h should read '1' (0x31) from the hardware keyboard stack during polling");
+        testHandler.Results.Should().Contain((byte)TestResult.Success);
+        testHandler.Results.Should().NotContain((byte)TestResult.Failure);
+    }
+
+    /// <summary>
+    /// Simulates pressing the '1' key through the full UI → hardware keyboard stack.
+    /// </summary>
+    private static void SimulateDigit1(HeadlessGui gui) {
+        gui.SimulateKeyPress(PhysicalKey.Digit1);
+        gui.SimulateKeyRelease(PhysicalKey.Digit1);
+    }
+
     // ──────────────────────────────────────────────────────────────────────
     // Phase 0 — STDIN/STDOUT handle routing tests
     // These tests redirect STDIN (handle 0) to a file stream and verify that