Phase 2 abgeschlossen: Bytecode, TBVM, Runtime-Scheibe, tbc run

- Sema zum Lowering-Pass umgebaut: typisiertes HIR (Slots, explizite Konvertierungsknoten) als Codegen-Eingabe; BYREF verlangt exakten Typ - Bytecode-Feindesign umgesetzt: monomorpher Opcode-Satz, .tbc-Container (Formatversion 1) mit eigenem Writer/Reader - Codegenerator HIR -> Bytecode (Fixup-Listen, keine globalen Passes) - TBVM-Interpreter: Kontrollfluss, GOSUB-Stack je Frame, BYREF/BYVAL, STATIC, DEF FN, DATA/READ/RESTORE, ON [LOCAL] ERROR/RESUME/ERR/ERL, Breakpoints/Einzelschritt/Inspektion, STOP fortsetzbar - Runtime-Scheibe: Host-Trait (Konsole/Capture), Builtin-Tabelle, Konvertierungsmatrix, PRINT-Formatierung/Druckzonen, Stringfunktionen - tbc run/build/check mit Exit-Codes nach Entscheidung D6 - Korpus-Harness (byte-genauer Vergleich) + 3 neue Korpusdateien (konvertierung, fehlerbehandlung, byref); 137 Tests gruen - Benchmarks: Einzelmodul 1,2 ms / Projekt 49.760 Zeilen 124 ms (Budgets eingehalten), VM ~5 Mio Schleifeniterationen/s - Doku fortgeschrieben (tbvm-design, sprachreferenz, PLAN); verlagerte Punkte als explizite Aufgaben in Phase 3 - OpenSpec-Change phase-2-bytecode-vm (27/27 Tasks) Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-09-02 11:28:07 +02:00
parent da23d52036
commit f7e57b0bd8
42 changed files with 9225 additions and 484 deletions
--- a/crates/tb-vm/tests/vm.rs
+++ b/crates/tb-vm/tests/vm.rs
@@ -0,0 +1,457 @@
+//! Interpreter-Tests: Spec-Szenarien aus vm-ausfuehrung und
+//! vm-fehlerbehandlung (Phase-2-Änderung).
+
+use tb_runtime::host::CaptureHost;
+use tb_runtime::value::Value;
+use tb_vm::interp::{RunEvent, Vm};
+
+fn run(src: &str) -> (RunEvent, String) {
+    run_with_input(src, &[])
+}
+
+fn run_with_input(src: &str, input: &[&str]) -> (RunEvent, String) {
+    let module = tb_vm::compile_source("TEST", src).unwrap_or_else(|d| {
+        panic!("Compile-Fehler: {d:?}");
+    });
+    let mut vm = Vm::new(module);
+    let mut host = CaptureHost::with_input(input);
+    let ev = vm.run(&mut host);
+    (ev, host.output)
+}
+
+fn out(src: &str) -> String {
+    let (ev, output) = run(src);
+    assert_eq!(ev, RunEvent::Ended, "unerwartetes Ende: {ev:?}\n{output}");
+    output
+}
+
+fn err_code(src: &str) -> u16 {
+    match run(src).0 {
+        RunEvent::Error { code, .. } => code,
+        other => panic!("Fehler erwartet, war {other:?}"),
+    }
+}
+
+// ---- 5.1 Ausdrücke und Konvertierungsmatrix --------------------------------
+
+#[test]
+fn print_hallo_welt() {
+    assert_eq!(out("PRINT \"Hallo, Welt!\"\nEND"), "Hallo, Welt!\n");
+}
+
+#[test]
+fn banker_rounding_cint() {
+    // Spec-Szenario: PRINT CINT(0.5); CINT(1.5); CINT(2.5) → " 0  2  2 "
+    assert_eq!(out("PRINT CINT(0.5); CINT(1.5); CINT(2.5)"), " 0  2  2 \n");
+}
+
+#[test]
+fn overflow_bei_zuweisung() {
+    // Spec-Szenario: INTEGER-Variable = 40000 → Fehler 6
+    assert_eq!(err_code("i% = 40000"), 6);
+}
+
+#[test]
+fn intdiv_rundet_operanden_vor() {
+    // Spec-Szenario: PRINT 7.5 \ 2 → 8 \ 2 = 4
+    assert_eq!(out("PRINT 7.5 \\ 2"), " 4 \n");
+}
+
+#[test]
+fn gemischte_arithmetik() {
+    assert_eq!(out("i% = 2\nd# = i% + 1.5#\nPRINT d#"), " 3.5 \n");
+    assert_eq!(out("PRINT 1 / 3"), " .3333333 \n"); // SINGLE-Division
+    assert_eq!(out("PRINT 7 MOD 3; -7 MOD 3"), " 1 -1 \n"); // Vorzeichen wie Dividend
+    assert_eq!(out("PRINT 2 ^ 10"), " 1024 \n");
+}
+
+#[test]
+fn logik_bitweise() {
+    assert_eq!(out("PRINT 6 AND 3; 6 OR 3; 6 XOR 3; NOT 0"), " 2  7  5 -1 \n");
+    // Operanden werden gerundet: 1.5 AND 1 → 2 AND 1 = 0
+    assert_eq!(out("PRINT 1.5 AND 1"), " 0 \n");
+}
+
+#[test]
+fn division_durch_null() {
+    assert_eq!(err_code("PRINT 1 / 0"), 11);
+    assert_eq!(err_code("PRINT 1 \\ 0"), 11);
+    assert_eq!(err_code("PRINT 0 ^ -1"), 11);
+}
+
+#[test]
+fn stringvergleich_und_verkettung() {
+    assert_eq!(out("PRINT \"a\" + \"b\""), "ab\n");
+    assert_eq!(out("PRINT (\"abc\" < \"abd\")"), "-1 \n");
+}
+
+// ---- 5.2 Kontrollfluss -------------------------------------------------------
+
+#[test]
+fn for_ohne_durchlauf() {
+    // Spec-Szenario: FOR i% = 3 TO 1 → Körper wird nicht betreten
+    assert_eq!(out("FOR i% = 3 TO 1\nPRINT i%\nNEXT\nPRINT \"ende\""), "ende\n");
+}
+
+#[test]
+fn for_mit_negativem_step() {
+    assert_eq!(out("FOR i% = 3 TO 1 STEP -1\nPRINT i%;\nNEXT\nPRINT"), " 3  2  1 \n");
+}
+
+#[test]
+fn for_mit_dynamischem_step() {
+    assert_eq!(
+        out("s% = -2\nFOR i% = 5 TO 1 STEP s%\nPRINT i%;\nNEXT\nPRINT"),
+        " 5  3  1 \n"
+    );
+}
+
+#[test]
+fn select_case_bereiche() {
+    let src = "FOR i% = 1 TO 4\nSELECT CASE i%\nCASE 1: PRINT \"eins\"\nCASE 2 TO 3: PRINT \"mittel\"\nCASE ELSE: PRINT \"rest\"\nEND SELECT\nNEXT";
+    assert_eq!(out(src), "eins\nmittel\nmittel\nrest\n");
+}
+
+#[test]
+fn do_loop_varianten() {
+    assert_eq!(
+        out("n% = 3\nDO WHILE n% > 0\nPRINT n%;\nn% = n% - 1\nLOOP\nPRINT"),
+        " 3  2  1 \n"
+    );
+    assert_eq!(
+        out("n% = 0\nDO\nn% = n% + 1\nLOOP UNTIL n% >= 3\nPRINT n%"),
+        " 3 \n"
+    );
+    assert_eq!(
+        out("n% = 5\nWHILE n% > 3\nn% = n% - 1\nWEND\nPRINT n%"),
+        " 3 \n"
+    );
+}
+
+#[test]
+fn exit_for_und_do() {
+    assert_eq!(
+        out("FOR i% = 1 TO 10\nIF i% = 3 THEN EXIT FOR\nNEXT\nPRINT i%"),
+        " 3 \n"
+    );
+}
+
+#[test]
+fn kontrollfluss_korpusdatei() {
+    // 5.2-Verifikation: kontrollfluss.bas byte-genau korrekt.
+    let src = std::fs::read_to_string(
+        std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../tests/compat/kontrollfluss.bas"),
+    )
+    .unwrap();
+    let want = std::fs::read_to_string(
+        std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../tests/compat/kontrollfluss.out"),
+    )
+    .unwrap();
+    assert_eq!(out(&src), want);
+}
+
+#[test]
+fn gosub_return_und_fehler_3() {
+    assert_eq!(
+        out("GOSUB U\nPRINT \"zurueck\"\nEND\nU:\nPRINT \"unten\"\nRETURN"),
+        "unten\nzurueck\n"
+    );
+    // Spec-Szenario: RETURN ohne GOSUB → Fehler 3
+    assert_eq!(err_code("RETURN"), 3);
+}
+
+#[test]
+fn on_goto_berechnet() {
+    let src = "FOR i% = 0 TO 3\nON i% GOTO A, B\nPRINT \"kein\";\nGOTO W\nA:\nPRINT \"a\";\nGOTO W\nB:\nPRINT \"b\";\nW:\nNEXT\nPRINT";
+    assert_eq!(out(src), "keinabkein\n");
+}
+
+// ---- 5.3 Prozeduren ------------------------------------------------------------
+
+#[test]
+fn byref_wirkt_zurueck() {
+    // Spec-Szenario BYREF
+    assert_eq!(
+        out("SUB Inc (x%)\nx% = x% + 1\nEND SUB\nn% = 1\nInc n%\nPRINT n%"),
+        " 2 \n"
+    );
+}
+
+#[test]
+fn klammern_erzwingen_byval() {
+    // Spec-Szenario BYVAL
+    assert_eq!(
+        out("SUB Inc (x%)\nx% = x% + 1\nEND SUB\nn% = 1\nInc (n%)\nPRINT n%"),
+        " 1 \n"
+    );
+}
+
+#[test]
+fn byref_auf_arrayelement() {
+    assert_eq!(
+        out("SUB Inc (x%)\nx% = x% + 1\nEND SUB\nDIM a%(5)\na%(2) = 7\nInc a%(2)\nPRINT a%(2)"),
+        " 8 \n"
+    );
+}
+
+#[test]
+fn function_und_rekursion() {
+    assert_eq!(
+        out("FUNCTION Quad (x)\nQuad = x * x\nEND FUNCTION\nPRINT Quad(3)"),
+        " 9 \n"
+    );
+    let fak = "FUNCTION Fak& (n%)\nIF n% <= 1 THEN\nFak& = 1\nELSE\nFak& = n% * Fak&(n% - 1)\nEND IF\nEND FUNCTION\nPRINT Fak&(10)";
+    assert_eq!(out(fak), " 3628800 \n");
+}
+
+#[test]
+fn static_behaelt_werte() {
+    let src = "SUB Zaehl\nSTATIC n%\nn% = n% + 1\nPRINT n%;\nEND SUB\nZaehl\nZaehl\nZaehl\nPRINT";
+    assert_eq!(out(src), " 1  2  3 \n");
+}
+
+#[test]
+fn def_fn_im_modulkontext() {
+    // DEF FN: Parameter lokal (BYVAL), freie Namen binden an Modulvariablen.
+    let src = "faktor = 10\nDEF FNmal (x) = x * faktor\nPRINT FNmal(3)";
+    assert_eq!(out(src), " 30 \n");
+}
+
+#[test]
+fn ganzes_array_uebergeben() {
+    let src = "SUB Summe (a%(), s%)\ns% = 0\nFOR i% = LBOUND(a%) TO UBOUND(a%)\ns% = s% + a%(i%)\nNEXT\nEND SUB\nDIM w%(3)\nFOR i% = 0 TO 3\nw%(i%) = i%\nNEXT\nSumme w%(), erg%\nPRINT erg%";
+    assert_eq!(out(src), " 6 \n");
+}
+
+#[test]
+fn udt_wertsemantik_und_felder() {
+    let src = "TYPE Punkt\nx AS INTEGER\ny AS INTEGER\nEND TYPE\nDIM a AS Punkt, b AS Punkt\na.x = 1\nb = a\nb.x = 9\nPRINT a.x; b.x";
+    assert_eq!(out(src), " 1  9 \n");
+}
+
+// ---- 5.4 DATA/READ/RESTORE -----------------------------------------------------
+
+#[test]
+fn data_read_restore() {
+    // Anmerkung: unquotierte DATA-Texte verlieren derzeit die
+    // Groß-/Kleinschreibung (Lexer normalisiert Bezeichner);
+    // Rohtext-Erhalt ist als Aufgabe in PLAN.md Phase 3 eingeplant.
+    let src = "DATA 1, 2.5, \"hallo\"\nREAD a%, b!, c$\nPRINT a%; b!; c$\nRESTORE\nREAD x%\nPRINT x%";
+    assert_eq!(out(src), " 1  2.5 hallo\n 1 \n");
+}
+
+#[test]
+fn out_of_data_fehler_4() {
+    assert_eq!(err_code("DATA 1\nREAD a%, b%"), 4);
+}
+
+#[test]
+fn data_typkonflikt_fehler_13() {
+    assert_eq!(err_code("DATA hallo\nREAD a%"), 13);
+}
+
+#[test]
+fn restore_mit_label() {
+    let src = "DATA 1\nMarke:\nDATA 2\nREAD a%\nRESTORE Marke\nREAD b%\nPRINT a%; b%";
+    assert_eq!(out(src), " 1  2 \n");
+}
+
+// ---- 5.5 Fehlerbehandlung -------------------------------------------------------
+
+#[test]
+fn modulweiter_handler_faengt_prozedurfehler() {
+    // Spec-Szenario: Hauptprogramm setzt Handler, SUB löst Fehler 6 aus.
+    let src = "SUB Knall\ni% = 40000\nEND SUB\nON ERROR GOTO Fehler\nKnall\nPRINT \"nie\"\nEND\nFehler:\nPRINT \"ERR=\"; ERR\nEND";
+    assert_eq!(out(src), "ERR= 6 \n");
+}
+
+#[test]
+fn lokaler_handler_verdeckt_modulweiten() {
+    let src = "SUB Tu\nON LOCAL ERROR GOTO L\nERROR 5\nEXIT SUB\nL:\nPRINT \"lokal\"; ERR\nRESUME Weiter\nWeiter:\nEND SUB\nON ERROR GOTO M\nTu\nEND\nM:\nPRINT \"modul\"\nEND";
+    assert_eq!(out(src), "lokal 5 \n");
+}
+
+#[test]
+fn ohne_handler_bricht_ab() {
+    // Spec-Szenario: Fehler 9 ohne Handler → Abbruch mit Meldung.
+    let (ev, _) = run("DIM a%(3)\nPRINT a%(7)");
+    match ev {
+        RunEvent::Error { code, message, .. } => {
+            assert_eq!(code, 9);
+            assert_eq!(message, "Subscript out of range");
+        }
+        other => panic!("{other:?}"),
+    }
+}
+
+#[test]
+fn erl_liefert_zeilennummer() {
+    let src = "ON ERROR GOTO H\n10 ERROR 5\nEND\nH:\nPRINT ERL\nEND";
+    assert_eq!(out(src), " 10 \n");
+}
+
+#[test]
+fn erl_null_ohne_zeilennummern() {
+    // Spec-Szenario: keine numerischen Zeilennummern → ERL = 0
+    let src = "ON ERROR GOTO H\nERROR 5\nEND\nH:\nPRINT ERL\nEND";
+    assert_eq!(out(src), " 0 \n");
+}
+
+#[test]
+fn error_anweisung() {
+    // Spec-Szenario: ERROR 53 → Handler mit ERR = 53
+    let src = "ON ERROR GOTO H\nERROR 53\nEND\nH:\nPRINT ERR\nEND";
+    assert_eq!(out(src), " 53 \n");
+}
+
+#[test]
+fn resume_wiederholt_anweisung() {
+    let src = "ON ERROR GOTO H\nn% = 0\nversuch% = 0\n10 versuch% = versuch% + 1\nIF versuch% < 3 THEN ERROR 5\nPRINT versuch%\nEND\nH:\nRESUME";
+    // RESUME wiederholt die IF-Anweisung; versuch% bleibt 1? Nein:
+    // Fehler in IF-Zeile, RESUME wiederholt IF — Endlosschleife ohne
+    // Zählerénderung wäre falsch. Zähler steht in Zeile 10, daher: der
+    // Fehler passiert im IF, RESUME wiederholt das IF, versuch% ist noch
+    // < 3 … Um Determinismus zu sichern, zählt der Handler mit.
+    let _ = src;
+    let src2 = "ON ERROR GOTO H\nversuch% = 0\nERROR 5\nPRINT \"nach\"; versuch%\nEND\nH:\nversuch% = versuch% + 1\nIF versuch% < 3 THEN RESUME\nRESUME NEXT";
+    assert_eq!(out(src2), "nach 3 \n");
+}
+
+#[test]
+fn resume_next_faehrt_fort() {
+    // Spec-Szenario: RESUME NEXT nach Division durch 0.
+    let src = "ON ERROR GOTO H\nx = 1 / 0\nPRINT \"weiter\"\nEND\nH:\nRESUME NEXT";
+    assert_eq!(out(src), "weiter\n");
+}
+
+#[test]
+fn resume_ohne_fehler_20() {
+    assert_eq!(err_code("RESUME"), 20);
+}
+
+#[test]
+fn fehler_im_handler_ist_fatal() {
+    // Spec-Szenario: kein Kaskadieren.
+    let src = "ON ERROR GOTO H\nERROR 5\nEND\nH:\ni% = 40000\nEND";
+    let (ev, _) = run(src);
+    match ev {
+        RunEvent::Error { code, .. } => assert_eq!(code, 6),
+        other => panic!("{other:?}"),
+    }
+}
+
+#[test]
+fn on_error_goto_0_deaktiviert() {
+    let src = "ON ERROR GOTO H\nON ERROR GOTO 0\nERROR 5\nEND\nH:\nPRINT \"nie\"\nEND";
+    assert_eq!(err_code(src), 5);
+}
+
+// ---- 5.6 Unterbrechbarkeit -------------------------------------------------------
+
+#[test]
+fn breakpoint_haelt_an_und_setzt_fort() {
+    let module =
+        tb_vm::compile_source("TEST", "a% = 1\nb% = 2\nc% = 3\nPRINT a% + b% + c%").unwrap();
+    let mut vm = Vm::new(module);
+    let mut host = CaptureHost::default();
+    vm.add_breakpoint(3);
+    // Spec-Szenario: hält VOR der Anweisung in Zeile 3.
+    match vm.run(&mut host) {
+        RunEvent::Breakpoint { line } => assert_eq!(line, 3),
+        other => panic!("{other:?}"),
+    }
+    // Spec-Szenario Inspektion: b% ist gesetzt, c% noch 0.
+    assert!(matches!(vm.inspect("b%"), Some(Value::Int(2))));
+    assert!(matches!(vm.inspect("c%"), Some(Value::Int(0))));
+    // Fortsetzen (Breakpoint entfernen, sonst hält Zeile 3 erneut).
+    vm.remove_breakpoint(3);
+    assert_eq!(vm.run(&mut host), RunEvent::Ended);
+    assert_eq!(host.output, " 6 \n");
+}
+
+#[test]
+fn einzelschritt() {
+    let module = tb_vm::compile_source("TEST", "a% = 1\nb% = 2\nEND").unwrap();
+    let mut vm = Vm::new(module);
+    let mut host = CaptureHost::default();
+    vm.set_step(true);
+    let mut lines = Vec::new();
+    loop {
+        match vm.run(&mut host) {
+            RunEvent::Stepped { line } => lines.push(line),
+            RunEvent::Ended => break,
+            other => panic!("{other:?}"),
+        }
+    }
+    assert_eq!(lines, vec![1, 2, 3]);
+}
+
+// ---- 5.7 Programmende --------------------------------------------------------------
+
+#[test]
+fn stop_liefert_zeile_und_ist_fortsetzbar() {
+    let module = tb_vm::compile_source("TEST", "PRINT \"a\"\nSTOP\nPRINT \"b\"").unwrap();
+    let mut vm = Vm::new(module);
+    let mut host = CaptureHost::default();
+    match vm.run(&mut host) {
+        RunEvent::Stopped { line } => assert_eq!(line, 2),
+        other => panic!("{other:?}"),
+    }
+    // IDE-Semantik: CONT = weiterlaufen.
+    assert_eq!(vm.run(&mut host), RunEvent::Ended);
+    assert_eq!(host.output, "a\nb\n");
+}
+
+#[test]
+fn end_und_system() {
+    assert_eq!(run("PRINT \"x\"\nEND").0, RunEvent::Ended);
+    assert_eq!(run("SYSTEM").0, RunEvent::Ended);
+}
+
+// ---- Eingabe -----------------------------------------------------------------------
+
+#[test]
+fn input_mit_redo() {
+    let (ev, output) = run_with_input(
+        "INPUT \"Zahl\"; n%\nPRINT n% * 2",
+        &["abc", "21"],
+    );
+    assert_eq!(ev, RunEvent::Ended);
+    assert!(output.contains("Redo from start"));
+    assert!(output.ends_with(" 42 \n"), "{output}");
+}
+
+#[test]
+fn line_input_liest_ganze_zeile() {
+    let (ev, output) = run_with_input("LINE INPUT s$\nPRINT s$", &["a, b, c"]);
+    assert_eq!(ev, RunEvent::Ended);
+    assert!(output.ends_with("a, b, c\n"));
+}
+
+// ---- Strings/PRINT über die VM -------------------------------------------------------
+
+#[test]
+fn mid_anweisung_mutiert() {
+    assert_eq!(out("s$ = \"hallo\"\nMID$(s$, 2, 2) = \"EY\"\nPRINT s$"), "hEYlo\n");
+}
+
+#[test]
+fn print_zonen_und_tab() {
+    assert_eq!(out("PRINT \"a\", \"b\""), "a             b\n");
+    assert_eq!(out("PRINT TAB(5); \"x\""), "    x\n");
+    assert_eq!(out("PRINT \"a\"; SPC(3); \"b\""), "a   b\n");
+}
+
+#[test]
+fn unsupported_feature_fehler_73() {
+    // Dokumentiert, aber Phase 3: Datei-E/A → Laufzeitfehler 73.
+    let (ev, _) = run("OPEN \"x.txt\" FOR INPUT AS #1");
+    match ev {
+        RunEvent::Error { code, message, .. } => {
+            assert_eq!(code, 73);
+            // Katalogtext des Vorbilds (VBDOS) für Code 73:
+            assert_eq!(message, "Feature unavailable");
+        }
+        other => panic!("{other:?}"),
+    }
+}