feat: init
This commit is contained in:
188
src/vm/vm.rs
Normal file
188
src/vm/vm.rs
Normal file
@@ -0,0 +1,188 @@
|
||||
use anyhow::{anyhow, Result};
|
||||
use rpds::{HashTrieMap, HashTrieMapSync, Vector};
|
||||
|
||||
use crate::bytecode::{self, *};
|
||||
use crate::slice::*;
|
||||
use crate::value::{self, Value};
|
||||
use crate::builtins::env;
|
||||
|
||||
use super::env::Env;
|
||||
use super::stack::{Stack, STACK_SIZE};
|
||||
use super::value::{self as vmValue, *};
|
||||
use super::vmthunk::*;
|
||||
|
||||
pub fn run(prog: Program) -> Result<Value> {
|
||||
let vm = VM::new(prog.thunks);
|
||||
Ok(vm.eval(prog.top_level, &mut env())?.to_value(&vm))
|
||||
}
|
||||
|
||||
pub struct VM {
|
||||
thunks: Slice<VmThunk>,
|
||||
}
|
||||
|
||||
impl VM {
|
||||
fn new(thunks: Thunks) -> Self {
|
||||
let thunks = thunks
|
||||
.into_iter()
|
||||
.map(|bytecode::Thunk { opcodes }| VmThunk::new(opcodes))
|
||||
.collect();
|
||||
VM {
|
||||
thunks,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn get_thunk_value(&self, idx: usize, env: &mut Env) -> Result<VmValue> {
|
||||
self.thunks.get(idx).unwrap().force(self, env)
|
||||
}
|
||||
|
||||
pub fn eval(&self, opcodes: OpCodes, env: &mut Env) -> Result<VmValue> {
|
||||
let mut stack = Stack::<STACK_SIZE>::new();
|
||||
let mut iter = opcodes.into_iter();
|
||||
while let Some(opcode) = iter.next() {
|
||||
let jmp = self.single_op(opcode, &mut stack, env)?;
|
||||
for _ in 0..jmp {
|
||||
iter.next().unwrap();
|
||||
}
|
||||
}
|
||||
assert_eq!(stack.len(), 1);
|
||||
stack.pop()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn single_op<const CAP: usize>(
|
||||
&self,
|
||||
opcode: OpCode,
|
||||
stack: &mut Stack<CAP>,
|
||||
env: &mut Env,
|
||||
) -> Result<usize> {
|
||||
match opcode {
|
||||
OpCode::NoOp => (),
|
||||
OpCode::Const { value } => stack.push(VmValue::Const(value))?,
|
||||
OpCode::LoadThunk { idx } => stack.push(VmValue::Thunk(vmValue::Thunk::new(idx)))?,
|
||||
OpCode::LoadValue { idx } => {
|
||||
stack.push(self.get_thunk_value(idx, env)?)?;
|
||||
}
|
||||
OpCode::ForceValue => {
|
||||
stack.tos_mut()?.force(self, env)?;
|
||||
}
|
||||
OpCode::Jmp { step } => return Ok(step),
|
||||
OpCode::JmpIfTrue { step } => {
|
||||
if let VmValue::Const(Const::Bool(true)) = stack.pop()? {
|
||||
return Ok(step);
|
||||
}
|
||||
}
|
||||
OpCode::JmpIfFalse { step } => {
|
||||
if let VmValue::Const(Const::Bool(false)) = stack.pop()? {
|
||||
return Ok(step);
|
||||
}
|
||||
}
|
||||
OpCode::Call { arity } => {
|
||||
let mut args = Vec::with_capacity(arity);
|
||||
for _ in 0..arity {
|
||||
args.insert(0, stack.pop()?);
|
||||
}
|
||||
let func = stack.pop()?;
|
||||
stack.push(func.call(args))?;
|
||||
}
|
||||
OpCode::UnOp { op } => {
|
||||
use UnOp::*;
|
||||
let value = stack.pop()?;
|
||||
stack.push(match op {
|
||||
Not => value.not(),
|
||||
})?;
|
||||
}
|
||||
OpCode::BinOp { op } => {
|
||||
use BinOp::*;
|
||||
let rhs = stack.pop()?;
|
||||
let lhs = stack.pop()?;
|
||||
stack.push(match op {
|
||||
Add => lhs.add(rhs),
|
||||
And => lhs.and(rhs),
|
||||
Or => lhs.or(rhs),
|
||||
Eq => lhs.eq(rhs),
|
||||
Con => lhs.concat(rhs),
|
||||
Upd => lhs.update(rhs),
|
||||
})?;
|
||||
}
|
||||
OpCode::ConcatString => {
|
||||
let rhs = stack.pop()?;
|
||||
stack.tos_mut()?.concat_string(rhs);
|
||||
}
|
||||
OpCode::List => {
|
||||
stack.push(VmValue::List(List::new(Vector::new_sync())))?;
|
||||
}
|
||||
OpCode::PushElem => {
|
||||
let elem = stack.pop()?;
|
||||
stack.tos_mut()?.push(elem);
|
||||
}
|
||||
OpCode::AttrSet => {
|
||||
stack.push(VmValue::AttrSet(AttrSet::new(HashTrieMap::new_sync())))?;
|
||||
}
|
||||
OpCode::PushStaticAttr { name } => {
|
||||
let val = stack.pop()?;
|
||||
stack.tos_mut()?.push_attr(Symbol::new(name), val);
|
||||
}
|
||||
OpCode::PushDynamicAttr => {
|
||||
let val = stack.pop()?;
|
||||
let mut sym = stack.pop().unwrap();
|
||||
sym.coerce_to_string();
|
||||
let sym = sym.unwrap_const().unwrap_string().into();
|
||||
stack.tos_mut()?.push_attr(sym, val);
|
||||
}
|
||||
OpCode::Select { sym } => {
|
||||
stack.tos_mut()?.select(Symbol::new(sym)).force(self, env)?;
|
||||
}
|
||||
OpCode::SelectWithDefault { sym } => {
|
||||
let default = stack.pop()?;
|
||||
stack
|
||||
.tos_mut()?
|
||||
.select_with_default(Symbol::new(sym), default.clone());
|
||||
}
|
||||
OpCode::SelectOrEmpty { sym } => {
|
||||
stack
|
||||
.tos_mut()?
|
||||
.select_with_default(Symbol::new(sym), VmValue::AttrSet(AttrSet::new(HashTrieMapSync::new_sync())));
|
||||
}
|
||||
OpCode::SelectDynamic => {
|
||||
let mut val = stack.pop().unwrap();
|
||||
val.coerce_to_string();
|
||||
let sym = val.unwrap_const().unwrap_string().into();
|
||||
stack.tos_mut()?.select(sym);
|
||||
}
|
||||
OpCode::SelectDynamicWithDefault => {
|
||||
let mut val = stack.pop().unwrap();
|
||||
val.coerce_to_string();
|
||||
let sym = val.unwrap_const().unwrap_string().into();
|
||||
let default = stack.pop()?;
|
||||
stack.tos_mut()?.select_with_default(sym, default.clone());
|
||||
}
|
||||
OpCode::SelectDynamicOrEmpty => {
|
||||
let mut val = stack.pop().unwrap();
|
||||
val.coerce_to_string();
|
||||
let sym = val.unwrap_const().unwrap_string().into();
|
||||
stack.tos_mut()?.select_with_default(sym, VmValue::AttrSet(AttrSet::new(HashTrieMapSync::new_sync())));
|
||||
}
|
||||
OpCode::HasAttr { sym } => {
|
||||
stack.tos_mut()?.has_attr(Symbol::new(sym));
|
||||
}
|
||||
OpCode::HasDynamicAttr => {
|
||||
let mut val = stack.pop().unwrap();
|
||||
val.coerce_to_string();
|
||||
let sym = val.unwrap_const().unwrap_string().into();
|
||||
stack.tos_mut()?.has_attr(sym);
|
||||
}
|
||||
OpCode::LookUp { sym } => {
|
||||
stack.push(env.lookup(Symbol::new(sym)))?;
|
||||
}
|
||||
OpCode::EnterEnv => {
|
||||
env.enter(stack.pop()?.unwrap_attr_set().to_data());
|
||||
}
|
||||
OpCode::LeaveEnv => {
|
||||
env.leave();
|
||||
}
|
||||
_ => todo!(),
|
||||
}
|
||||
Ok(0)
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user