use super::opcode::*;
use crate::error::{Error, Result};
use crate::options::ReadOptions;
use crate::util::Cursor;
use crate::value::{Dict, PyObject, Value};
pub type PersistentLoad<'a> = &'a mut dyn FnMut(&Value) -> Result<Value>;
pub struct Machine<'a, 'b> {
pub cur: Cursor<'a>,
pub stack: Vec<Value>,
pub marks: Vec<usize>,
pub memo: Vec<Option<Value>>,
pub opts: &'b ReadOptions,
pub persistent: Option<PersistentLoad<'b>>,
pub proto: u8,
pub joblib: bool,
}
impl<'a, 'b> Machine<'a, 'b> {
pub fn new(buf: &'a [u8], opts: &'b ReadOptions) -> Self {
Machine {
cur: Cursor::new(buf),
stack: Vec::with_capacity(64),
marks: Vec::new(),
memo: Vec::new(),
opts,
persistent: None,
proto: 2,
joblib: false,
}
}
pub fn with_persistent(mut self, f: PersistentLoad<'b>) -> Self {
self.persistent = Some(f);
self
}
pub fn with_joblib(mut self) -> Self {
self.joblib = true;
self
}
pub fn run(&mut self) -> Result<Value> {
loop {
let op = self.cur.u8()?;
if op == STOP {
return self.pop();
}
self.step(op)?;
}
}
fn step(&mut self, op: u8) -> Result<()> {
match op {
PROTO => self.proto = self.cur.u8()?,
FRAME => {
self.cur.skip(8)?;
}
MARK => self.marks.push(self.stack.len()),
NONE => self.stack.push(Value::None),
NEWTRUE => self.stack.push(Value::Bool(true)),
NEWFALSE => self.stack.push(Value::Bool(false)),
POP => {
if self.marks.last() == Some(&self.stack.len()) {
self.marks.pop();
} else {
self.pop()?;
}
}
POP_MARK => {
self.pop_mark()?;
}
DUP => {
let v = self
.stack
.last()
.cloned()
.ok_or_else(|| Error::pickle("DUP on empty stack"))?;
self.stack.push(v);
}
MEMOIZE => {
let v = self
.stack
.last()
.cloned()
.ok_or_else(|| Error::pickle("MEMOIZE on empty stack"))?;
let i = self.memo.len();
self.memo_put(i, v);
}
PUT => {
let i: usize =
self.line()?.trim().parse().map_err(|_| Error::pickle("bad PUT index"))?;
let v = self
.stack
.last()
.cloned()
.ok_or_else(|| Error::pickle("PUT on empty stack"))?;
self.memo_put(i, v);
}
BINPUT => {
let i = self.cur.u8()? as usize;
let v = self.stack.last().cloned().unwrap_or(Value::None);
self.memo_put(i, v);
}
LONG_BINPUT => {
let i = self.cur.u32()? as usize;
let v = self.stack.last().cloned().unwrap_or(Value::None);
self.memo_put(i, v);
}
GET => {
let i: usize =
self.line()?.trim().parse().map_err(|_| Error::pickle("bad GET index"))?;
let v = self.memo_get(i)?;
self.stack.push(v);
}
BINGET => {
let i = self.cur.u8()? as usize;
let v = self.memo_get(i)?;
self.stack.push(v);
}
LONG_BINGET => {
let i = self.cur.u32()? as usize;
let v = self.memo_get(i)?;
self.stack.push(v);
}
_ => return self.step_data(op),
}
Ok(())
}
pub(crate) fn line(&mut self) -> Result<String> {
let start = self.cur.pos();
let buf = self.cur.buffer();
let mut i = start;
while i < buf.len() && buf[i] != b'\n' {
i += 1;
}
let s = String::from_utf8_lossy(&buf[start..i]).into_owned();
self.cur.set_pos((i + 1).min(buf.len()));
Ok(s)
}
pub(crate) fn build_object(&mut self, module: String, name: String) -> Value {
Value::Object(PyObject::new(module, name))
}
pub(crate) fn dict_from_flat(items: Vec<Value>) -> Result<Dict> {
if items.len() % 2 != 0 {
return Err(Error::pickle("odd number of items for a dict"));
}
let mut d = Dict::with_capacity(items.len() / 2);
let mut it = items.into_iter();
while let (Some(k), Some(v)) = (it.next(), it.next()) {
d.insert(k, v);
}
Ok(d)
}
}