300 lines
11 KiB
Rust
300 lines
11 KiB
Rust
use tb_frontend::{
|
|
forms::FormCatalog,
|
|
source::{SourceSegment, SourceUnit},
|
|
};
|
|
use tb_runtime::{host::CaptureHost, value::Value};
|
|
use tb_ui::frm::{self, FormFile};
|
|
use tb_vm::{
|
|
bytecode::CompiledModule,
|
|
compile_project,
|
|
interp::{RunEvent, Vm},
|
|
};
|
|
|
|
fn compile(units: &[SourceUnit], forms: &[FormFile]) -> CompiledModule {
|
|
let mut catalog = FormCatalog::default();
|
|
for form in forms {
|
|
catalog.append(&form.catalog());
|
|
}
|
|
compile_project("APP", units, &catalog, forms).unwrap_or_else(|d| panic!("{d:#?}"))
|
|
}
|
|
|
|
#[test]
|
|
fn module_includes_erl_breakpoints_und_inspektion_behalten_ihren_ursprung() {
|
|
let a = SourceUnit::new("MAIN", "main.bas", "x%=1\nCALL Fehler\nEND\n");
|
|
let b = SourceUnit {
|
|
name: "LIB".into(),
|
|
segments: vec![
|
|
SourceSegment {
|
|
file: "lib.bas".into(),
|
|
first_line: 1,
|
|
text: "SUB Fehler\n".into(),
|
|
},
|
|
SourceSegment {
|
|
file: "nested.bi".into(),
|
|
first_line: 2,
|
|
text: "200 ERROR 6\n".into(),
|
|
},
|
|
SourceSegment {
|
|
file: "lib.bas".into(),
|
|
first_line: 3,
|
|
text: "END SUB\n".into(),
|
|
},
|
|
],
|
|
};
|
|
let module = compile(&[a, b], &[]);
|
|
let bytes = module.to_tbc();
|
|
let loaded = CompiledModule::from_tbc(&bytes).unwrap();
|
|
assert_eq!(loaded.to_tbc(), bytes);
|
|
let mut vm = Vm::new(loaded);
|
|
let mut host = CaptureHost::default();
|
|
vm.add_module_breakpoint(1, 2);
|
|
assert_eq!(vm.run(&mut host), RunEvent::Breakpoint { line: 2 });
|
|
assert_eq!(vm.current_module(), 1);
|
|
assert_eq!(vm.current_file(), "nested.bi");
|
|
assert_eq!(vm.current_source_pos().column, 1);
|
|
assert!(matches!(vm.inspect("MAIN!x"), Some(Value::Int(1))));
|
|
vm.remove_module_breakpoint(1, 2);
|
|
vm.set_step(true);
|
|
assert_eq!(vm.run(&mut host), RunEvent::Stepped { line: 2 });
|
|
assert_eq!(vm.current_file(), "nested.bi");
|
|
assert_eq!(vm.current_source_pos().column, 5);
|
|
vm.set_step(false);
|
|
assert!(matches!(
|
|
vm.run(&mut host),
|
|
RunEvent::Error {
|
|
code: 6,
|
|
line: 2,
|
|
..
|
|
}
|
|
));
|
|
let mut erl_vm = Vm::new(compile(
|
|
&[SourceUnit::new(
|
|
"NUM",
|
|
"num.bas",
|
|
"ON ERROR RESUME NEXT\n200 ERROR 6\nn%=ERL\nSTOP",
|
|
)],
|
|
&[],
|
|
));
|
|
assert!(matches!(erl_vm.run(&mut host), RunEvent::Stopped { .. }));
|
|
assert!(matches!(erl_vm.inspect("n"), Some(Value::Int(200))));
|
|
assert_eq!(vm.current_file(), "nested.bi");
|
|
}
|
|
|
|
#[test]
|
|
fn diagnose_im_include_und_echte_duplikate_bleiben_sichtbar() {
|
|
let source = SourceUnit {
|
|
name: "LIB".into(),
|
|
segments: vec![SourceSegment {
|
|
file: "nested.bi".into(),
|
|
first_line: 2,
|
|
text: "Text$ = 42\n".into(),
|
|
}],
|
|
};
|
|
let errors = compile_project("APP", &[source], &FormCatalog::default(), &[]).unwrap_err();
|
|
assert!(errors
|
|
.iter()
|
|
.any(|e| e.file.as_deref() == Some("nested.bi") && e.pos.line == 2 && e.pos.column == 1));
|
|
for text in [
|
|
"SUB X\nEND SUB\nSUB X\nEND SUB",
|
|
"CONST N=1\nCONST N=2",
|
|
"TYPE T\nx AS INTEGER\nEND TYPE\nTYPE T\nx AS INTEGER\nEND TYPE",
|
|
] {
|
|
let errors = compile_project(
|
|
"APP",
|
|
&[SourceUnit::new("M", "m.bas", text)],
|
|
&FormCatalog::default(),
|
|
&[],
|
|
)
|
|
.unwrap_err();
|
|
assert!(
|
|
errors
|
|
.iter()
|
|
.any(|e| e.message.contains("Duplicate definition")),
|
|
"{errors:?}"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn initialisierungen_def_fn_und_modulhandler_haben_eigene_quellorte() {
|
|
for (source, expected_line) in [
|
|
("' Bibliothek\nDIM a%(1 TO 0)", 2),
|
|
(
|
|
"' Bibliothek\nDEF FNkaputt(x)=1/x\nSUB Fehler\nPRINT FNkaputt(0)\nEND SUB",
|
|
2,
|
|
),
|
|
] {
|
|
let module = compile(
|
|
&[
|
|
SourceUnit::new("A", "a.bas", "CALL Fehler\nEND"),
|
|
SourceUnit::new(
|
|
"B",
|
|
"b.bas",
|
|
&format!(
|
|
"{source}\n{}",
|
|
if source.contains("SUB") {
|
|
""
|
|
} else {
|
|
"SUB Fehler\nEND SUB"
|
|
}
|
|
),
|
|
),
|
|
],
|
|
&[],
|
|
);
|
|
let mut vm = Vm::new(CompiledModule::from_tbc(&module.to_tbc()).unwrap());
|
|
let event = vm.run(&mut CaptureHost::default());
|
|
assert!(
|
|
matches!(event, RunEvent::Error { line, .. } if line == expected_line),
|
|
"{event:?}"
|
|
);
|
|
assert_eq!(vm.current_file(), "b.bas");
|
|
}
|
|
let units = [
|
|
SourceUnit::new(
|
|
"A",
|
|
"a.bas",
|
|
"ON ERROR GOTO H\nCALL Fehler\nEND\nH:\nPRINT ERR;ERL\nEND",
|
|
),
|
|
SourceUnit::new(
|
|
"B",
|
|
"b.bas",
|
|
"SUB Fehler\nON ERROR GOTO 0\n200 ERROR 6\nEND SUB",
|
|
),
|
|
];
|
|
let mut vm = Vm::new(compile(&units, &[]));
|
|
assert_eq!(vm.run(&mut CaptureHost::default()), RunEvent::Ended);
|
|
assert_eq!(tb_runtime::snapshot::text(&vm.rt.screen), " 6 200 \n");
|
|
}
|
|
|
|
#[test]
|
|
fn lokale_prozeduren_shared_common_und_wiederholte_includes_bleiben_getrennt() {
|
|
let a = SourceUnit::new("A", "a.bas", "CONST N=1\nDIM SHARED x%\nCOMMON SHARED c%\nx%=10\nCALL Privat\nCALL Zweites\nPRINT x%;c%\nEND\nSUB Privat\nx%=x%+N\nc%=c%+1\nEND SUB");
|
|
let b = SourceUnit::new("B", "b.bas", "CONST N=2\nDIM SHARED x%\nCOMMON SHARED c%\nSUB Zweites\nx%=20\nCALL Privat\nPRINT x%\nEND SUB\nSUB Privat\nx%=x%+N\nc%=c%+2\nEND SUB");
|
|
let mut vm = Vm::new(compile(&[a, b], &[]));
|
|
assert_eq!(vm.run(&mut CaptureHost::default()), RunEvent::Ended);
|
|
assert_eq!(tb_runtime::snapshot::text(&vm.rt.screen), " 22 \n 11 3 \n");
|
|
let include = SourceSegment {
|
|
file: "shared.bi".into(),
|
|
first_line: 1,
|
|
text: "CONST N=7\n".into(),
|
|
};
|
|
let units: Vec<_> = ["A", "B"]
|
|
.iter()
|
|
.map(|name| SourceUnit {
|
|
name: (*name).into(),
|
|
segments: vec![
|
|
include.clone(),
|
|
SourceSegment {
|
|
file: format!("{name}.bas"),
|
|
first_line: 2,
|
|
text: "PRINT N\n".into(),
|
|
},
|
|
],
|
|
})
|
|
.collect();
|
|
let mut vm = Vm::new(compile(&units, &[]));
|
|
assert_eq!(vm.run(&mut CaptureHost::default()), RunEvent::Ended);
|
|
assert_eq!(tb_runtime::snapshot::text(&vm.rt.screen), " 7 \n 7 \n");
|
|
}
|
|
|
|
#[test]
|
|
fn typreferenzen_signaturen_und_option_base_ueber_modulgrenzen() {
|
|
use tb_frontend::hir::{HProcKind, HTy, NumTy};
|
|
use tb_vm::bytecode::Instr;
|
|
let units = [
|
|
SourceUnit::new("A", "a.bas", "DECLARE SUB CmnDlgRegister(ok AS INTEGER)\nTYPE Klein\nx AS INTEGER\nEND TYPE\nDIM s AS Gross\nDIM a%(2)\ns.x=4\na%(1)=3\nCmnDlgRegister ok%\nPRINT ok%\nPRINT Summe%(a%(), s, 2)\nPRINT s.x\nCALL Basis\nEND"),
|
|
SourceUnit::new("B", "b.bas", "OPTION BASE 1\nTYPE Gross\nx AS LONG\ny AS STRING * 8\nEND TYPE\nFUNCTION Summe%(a%(), s AS Gross, n%)\nSumme%=a%(1)+s.x+n%\ns.x=s.x+1\nEND FUNCTION\nSUB Basis\nb%(1)=1\nPRINT LBOUND(b%)\nEND SUB\nSUB Datei\nOPEN \"unbenutzt.isam\" FOR ISAM Gross \"T\" AS #1\nCLOSE #1\nEND SUB"),
|
|
];
|
|
let module = compile(&units, &[]);
|
|
let bytes = module.to_tbc();
|
|
let loaded = CompiledModule::from_tbc(&bytes).unwrap();
|
|
assert_eq!(bytes, loaded.to_tbc());
|
|
let signature = loaded.procs.iter().find(|p| p.name == "B!SUMME").unwrap();
|
|
assert_eq!(signature.kind, HProcKind::Function);
|
|
assert_eq!(signature.ret_ty, Some(HTy::Num(NumTy::Int)));
|
|
assert!(signature.params[0].array && !signature.params[0].by_ref);
|
|
assert!(signature.params[2].by_ref);
|
|
assert!(signature.params[1].by_ref);
|
|
let HTy::Udt(udt) = signature.params[1].ty else {
|
|
panic!("UDT-Parameter fehlt")
|
|
};
|
|
assert_eq!(loaded.udts[udt as usize].name, "GROSS");
|
|
let file = loaded.procs.iter().find(|p| p.name == "B!DATEI").unwrap();
|
|
assert!(file.code.contains(&Instr::PushUdtId(udt)));
|
|
let mut vm = Vm::new(loaded);
|
|
assert_eq!(vm.run(&mut CaptureHost::default()), RunEvent::Ended);
|
|
assert_eq!(
|
|
tb_runtime::snapshot::text(&vm.rt.screen),
|
|
"-1 \n 9 \n 5 \n 1 \n"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn beschaedigte_container_werden_vor_der_ausfuehrung_abgewiesen() {
|
|
use tb_vm::bytecode::Instr;
|
|
let form = frm::read_text("f.frm", "VERSION 1.00\nBEGIN Form F\n BEGIN TextBox Text1\n Index = 2\n Text = \"hello\"\n END\nEND\n").unwrap();
|
|
let bytes = compile(&[SourceUnit::new("F", "f.frm", "END")], &[form]).to_tbc();
|
|
for length in 0..bytes.len() {
|
|
assert!(
|
|
CompiledModule::from_tbc(&bytes[..length]).is_err(),
|
|
"Länge {length}"
|
|
);
|
|
}
|
|
for (offset, value) in [(6, 1u32), (8, u32::MAX), (16, 0), (20, u32::MAX)] {
|
|
let mut bad = bytes.clone();
|
|
bad[offset..offset + 4].copy_from_slice(&value.to_le_bytes());
|
|
assert!(CompiledModule::from_tbc(&bad).is_err(), "Offset {offset}");
|
|
}
|
|
let mut duplicate = bytes.clone();
|
|
duplicate[24..28].copy_from_slice(b"MODN");
|
|
assert!(CompiledModule::from_tbc(&duplicate).is_err());
|
|
for mutation in 0..8 {
|
|
let mut bad = CompiledModule::from_tbc(&bytes).unwrap();
|
|
match mutation {
|
|
0 => bad.sources[0].module = u16::MAX,
|
|
1 => bad.procs[0].module = u16::MAX,
|
|
2 => bad.procs[0].code.push(Instr::Call(u16::MAX, 0)),
|
|
3 => bad.procs[0].n_params = 1,
|
|
4 => bad.objects[1].parent = Some(1),
|
|
5 => bad.form_initial[1].index = 3,
|
|
6 => {
|
|
bad.form_initial[1].properties.insert(
|
|
0,
|
|
tb_ui::forms::PropertyValue::Object(Some((u16::MAX, None))),
|
|
);
|
|
}
|
|
7 => bad.procs[0].code.push(Instr::Source(u32::MAX, 1)),
|
|
_ => unreachable!(),
|
|
}
|
|
assert!(
|
|
CompiledModule::from_tbc(&bad.to_tbc()).is_err(),
|
|
"Mutation {mutation}"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn zwei_formulare_mit_gleichen_controls_und_arrays_laufen_aus_dem_kompilat() {
|
|
let form = |name: &str, text: &str| {
|
|
frm::read_text(&format!("{name}.frm"), &format!(
|
|
"VERSION 1.00\nBEGIN Form {name}\n Width = 30\n Height = 10\n BEGIN Frame Frame1\n BEGIN TextBox Text1\n Text = \"{text}\"\n END\n END\n BEGIN TextBox Feld\n Index = 0\n Text = \"null\"\n END\n BEGIN TextBox Feld\n Index = 2\n Text = \"zwei\"\n END\nEND\n\nSUB Form_Load\nText1.Text = Text1.Text + \"!\"\nEND SUB\n"
|
|
)).unwrap()
|
|
};
|
|
let forms = [form("Form1", "a"), form("Form2", "b")];
|
|
let mut units = vec![SourceUnit::new("MAIN", "main.bas", "Form2.Show\na$=Form1!Text1.Text\nb$=Form2!Text1.Text\nc$=Form2!Feld(2).Text\nForm1.Hide\nForm2.Hide\nCLS\nPRINT a$\nPRINT b$\nPRINT c$\nEND")];
|
|
units.extend(
|
|
forms
|
|
.iter()
|
|
.map(|f| SourceUnit::new(&f.root.name, &format!("{}.frm", f.root.name), &f.code)),
|
|
);
|
|
let module = compile(&units, &forms);
|
|
assert_eq!(module.event_procs.len(), 2);
|
|
let bytes = module.to_tbc();
|
|
let loaded = CompiledModule::from_tbc(&bytes).unwrap();
|
|
assert_eq!(loaded.to_tbc(), bytes);
|
|
let mut vm = Vm::new(loaded);
|
|
assert_eq!(vm.run(&mut CaptureHost::default()), RunEvent::Ended);
|
|
assert_eq!(tb_runtime::snapshot::text(&vm.rt.screen), "a!\nb!\nzwei\n");
|
|
}
|