1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
// TODO: remove!; tmp implementation
#![cfg_attr(coverage_nightly, coverage(off))]
use super::*;
pub struct PQLRunner {}
impl PQLRunner {
// TODO: check max selectors
// TODO: refactor run logic
// TODO: remove
#[allow(clippy::missing_panics_doc)]
pub fn try_run_stmt(stmt: &ast::Stmt<'_>) -> PQLResult<RunnerOutput> {
let mut rng = rand::rng();
let mut vm = Vm::from_stmt(stmt)?;
let n_trails = vm.static_data.n_trails;
let game = vm.static_data.game;
let mut output = RunnerOutput::new(game, &stmt.selectors);
let where_program = match &stmt.where_clause {
Some(expr) => Some(vm::compile_where(&mut vm, expr)?),
None => None,
};
let programs = stmt
.selectors
.iter()
.map(|s| vm::compile_selector(&mut vm, s))
.collect::<PQLResult<Vec<_>>>()?;
while output.n_succ < n_trails {
if output.n_fail == n_trails {
// TODO: fix this
return Err(((0, 1), VmError::SamplingFailed).into());
}
match vm.sample(&mut rng) {
Some(()) => {
if let Some(wp) = &where_program {
let keep = matches!(
wp.execute(&mut vm.as_context())?,
VmStackValue::Bool(true)
);
if !keep {
//TODO: refine this
output.n_fail += 1;
continue;
}
}
for (idx, program) in programs.iter().enumerate() {
output.push_value(
idx,
program.execute(&mut vm.as_context())?,
);
}
output.n_succ += 1;
}
None => output.n_fail += 1,
}
}
Ok(output)
}
// tmp function
pub fn run<S: io::Write, T: io::Write>(
src: &str,
stream_out: &mut S,
stream_err: &mut T,
) -> io::Result<()> {
match parse_pql(src) {
Ok(stmts) => {
for (i, stmt) in stmts.iter().enumerate() {
if i > 0 {
writeln!(stream_out, "{:-<80}", "")?;
}
match Self::try_run_stmt(stmt) {
Ok(output) => {
output.report_to_stream(stmt, stream_out)?;
writeln!(stream_out, "{} trials", output.n_succ)?;
}
Err(err) => {
writeln!(
stream_err,
"{err:?} {}",
&src[err.loc.0..err.loc.1]
)?;
}
}
}
}
Err(err) => writeln!(stream_err, "{err:?}")?,
}
Ok(())
}
}