use std::sync::Arc;
use dive_core::memo::Memo;
use dive_core::plan::{Action, Code};
use dive_core::{Error, Handle, Machine, Opts, Plan, Sink, Store};
use dive_store::trace::TraceStep;
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct TraceState {
pub action: Option<usize>,
pub values: Vec<Handle>,
}
type Captured = (usize, Vec<Handle>, Vec<Handle>);
struct Capture {
want: u32,
seen: u32,
action: usize,
got: Option<Captured>,
}
impl Sink for Capture {
fn emit(&mut self, m: &mut Machine, _code: &Code) -> Result<(), Error> {
if self.seen == self.want {
let views = Vec::new();
let mut values = Vec::with_capacity(m.s1.len());
for &h in &m.s1 {
values.push(if h.is_empty() { h } else { m.heap.intern(h)? });
}
self.got = Some((self.action, values, views));
return Err(Error::stop());
}
self.seen += 1;
Ok(())
}
}
fn run(
m: &mut Machine,
code: &Code,
actions: &[Action],
want: u32,
) -> Result<Option<Captured>, Error> {
let mut sink = Capture {
want,
seen: 0,
action: 0,
got: None,
};
for (i, a) in actions.iter().enumerate() {
sink.action = i;
let old = m.enter(a.frame);
for &(slot, v) in &a.preset {
if let Some(x) = m.frame.get_mut(m.base + slot as usize) {
*x = v;
}
}
let r = m.run_action(code, a.g, &mut sink);
m.leave(old);
match r {
Ok(()) => {}
Err(e) if e.kind() == dive_core::ErrorKind::Stop => break,
Err(e) => return Err(e),
}
}
m.heap.reset();
Ok(sink.got)
}
pub fn replay(
plan: &Plan,
store: &Arc<Store>,
opts: Opts,
warn: bool,
path: &[TraceStep],
) -> Result<Vec<TraceState>, Error> {
let keys: Vec<usize> = plan
.code
.sites
.iter()
.map(dive_core::plan::MemoSite::key_len)
.collect();
let opts = Opts {
memo: false,
..opts
};
let mut m = Machine::new(Arc::clone(store), plan.vars.len(), opts, Memo::new(&keys));
m.warn = warn;
let mut out: Vec<TraceState> = Vec::with_capacity(path.len());
let mut source_views = Vec::new();
for step in path {
let got = if let Some(prev) = out.last() {
m.s0.copy_from_slice(if source_views.is_empty() {
&prev.values
} else {
&source_views
});
crate::start_stream(&mut m, plan, Some(&prev.values))?;
m.level = i64::try_from(out.len()).unwrap_or(i64::MAX);
run(&mut m, &plan.code, &plan.next, step.ordinal)?
.map(|(a, v, views)| (Some(a), v, views))
} else {
crate::start_stream(&mut m, plan, None)?;
m.level = 0;
run(&mut m, &plan.code, &plan.init, step.ordinal)?.map(|(_, v, views)| (None, v, views))
};
let Some((action, values, views)) = got else {
return Err(Error::internal(format!(
"trace replay did not reach ordinal {} of state {}",
step.ordinal, step.id
)));
};
source_views = views;
out.push(TraceState { action, values });
}
Ok(out)
}