From 05e82d4021ac9e4e4222838d0e3e5ffbbb0f4c70 Mon Sep 17 00:00:00 2001 From: imxyy_soope_ Date: Sun, 11 May 2025 12:57:29 +0800 Subject: [PATCH] feat: lots of optimization * allocate vm stack on the stack * use Rc instead of Arc * optimize recursive attribute set --- src/builtins/mod.rs | 20 ++++++------- src/bytecode.rs | 4 +-- src/compile.rs | 8 ++--- src/ir.rs | 4 ++- src/ty/internal/attrset.rs | 61 ++++++++++++++++++++++---------------- src/ty/internal/func.rs | 9 +++--- src/ty/internal/mod.rs | 32 ++++++++++++-------- src/ty/public/mod.rs | 4 +-- src/vm/env.rs | 44 +++++++++++++++------------ src/vm/mod.rs | 41 ++++++++++++------------- src/vm/stack.rs | 17 +++++++---- src/vm/test.rs | 4 +-- 12 files changed, 137 insertions(+), 111 deletions(-) diff --git a/src/builtins/mod.rs b/src/builtins/mod.rs index 8dd1c1b..bf80df7 100644 --- a/src/builtins/mod.rs +++ b/src/builtins/mod.rs @@ -1,12 +1,12 @@ -use std::cell::RefCell; -use std::sync::Arc; +use std::cell::{OnceCell, RefCell}; +use std::rc::Rc; use crate::ty::common::Symbol; use crate::ty::internal::{_Thunk, Const, PrimOp, RecAttrSet, Thunk, Value}; use crate::vm::Env; -pub fn env<'vm>() -> Arc> { - let env = Arc::new(Env::empty()); +pub fn env<'vm>() -> Rc> { + let env = Rc::new(Env::empty()); env.insert(Symbol::from("true"), Value::Const(Const::Bool(true))); env.insert(Symbol::from("false"), Value::Const(Const::Bool(false))); @@ -43,24 +43,22 @@ pub fn env<'vm>() -> Arc> { }), ]; - let builtins_env = Env::empty(); - let map = builtins_env.enter_rec(); + let builtins_env = Rc::new(Env::empty()); + let map = builtins_env.clone().new_rec(); for primop in primops { env.insert( Symbol::from(format!("__{}", primop.name)), Value::PrimOp(primop.clone()), ); - map.borrow_mut() - .insert_mut(Symbol::from(primop.name), Value::PrimOp(primop)); + map.insert(Symbol::from(primop.name), Value::PrimOp(primop)); } let builtins = Value::RecAttrSet(RecAttrSet::from_inner(map.clone())); let thunk = Thunk { thunk: RefCell::new(_Thunk::Value(Box::new(builtins.clone()))), env: RefCell::default(), }; - thunk.capture(Arc::new(builtins_env)); - map.borrow_mut() - .insert_mut(Symbol::from("builtins"), Value::Thunk(thunk)); + thunk.capture(builtins_env); + map.insert(Symbol::from("builtins"), Value::Thunk(thunk)); env.insert(Symbol::from("builtins"), builtins); env diff --git a/src/bytecode.rs b/src/bytecode.rs index 0c8c89d..96aa97d 100644 --- a/src/bytecode.rs +++ b/src/bytecode.rs @@ -37,8 +37,8 @@ pub enum OpCode { /// push an empty attribute set onto stack AttrSet, - /// push an empty recursive attribute set onto stack - RecAttrSet, + /// finalize the recursive attribute set at TOS + FinalizeRec, /// [ .. set value ] consume 1 element, push a static kv pair (`name`, `value`) into `set` PushStaticAttr { name: EcoString }, /// [ .. set name value ] consume 2 elements, push a dynamic kv pair (`name`, `value`) in to `set` diff --git a/src/compile.rs b/src/compile.rs index 7eec459..e1b88ce 100644 --- a/src/compile.rs +++ b/src/compile.rs @@ -95,11 +95,7 @@ impl Compile for ir::Thunk { impl Compile for ir::Attrs { fn compile(self, comp: &mut Compiler) { - comp.push(if self.rec { - OpCode::RecAttrSet - } else { - OpCode::AttrSet - }); + comp.push(OpCode::AttrSet); for stc in self.stcs { stc.1.compile(comp); comp.push(OpCode::PushStaticAttr { name: stc.0 }); @@ -110,7 +106,7 @@ impl Compile for ir::Attrs { comp.push(OpCode::PushDynamicAttr) } if self.rec { - comp.push(OpCode::LeaveEnv); + comp.push(OpCode::FinalizeRec); } } } diff --git a/src/ir.rs b/src/ir.rs index 339367e..7247f16 100644 --- a/src/ir.rs +++ b/src/ir.rs @@ -695,7 +695,9 @@ fn downgrade_attr(attr: ast::Attr, ctx: &mut DowngradeContext) -> Result { Ident(ident) => Ok(Attr::Str(ident.to_string().into())), Str(string) => { let parts = string.normalized_parts(); - if parts.len() == 1 { + if parts.len() == 0 { + Ok(Attr::Str("".into())) + } else if parts.len() == 1 { match parts.into_iter().next().unwrap() { Literal(ident) => Ok(Attr::Str(ident.into())), Interpolation(interpol) => { diff --git a/src/ty/internal/attrset.rs b/src/ty/internal/attrset.rs index 14b1d97..beacfb6 100644 --- a/src/ty/internal/attrset.rs +++ b/src/ty/internal/attrset.rs @@ -1,11 +1,10 @@ -use std::cell::RefCell; -use std::sync::Arc; +use std::rc::Rc; use derive_more::Constructor; -use rpds::HashTrieMapSync; +use rpds::HashTrieMap; use crate::error::Result; -use crate::vm::VM; +use crate::vm::{Env, VM}; use super::super::common::Symbol; use super::super::public as p; @@ -13,13 +12,13 @@ use super::{ToPublic, Value}; #[derive(Debug, Constructor, Clone, PartialEq)] pub struct AttrSet<'vm> { - data: HashTrieMapSync>, + data: HashTrieMap>, } impl<'vm> AttrSet<'vm> { pub fn empty() -> Self { AttrSet { - data: HashTrieMapSync::new_sync(), + data: HashTrieMap::new(), } } @@ -34,14 +33,22 @@ impl<'vm> AttrSet<'vm> { self.data.insert_mut(sym, val); } - pub fn select(&self, sym: Symbol) -> Option> { + pub fn select(&self, sym: &Symbol) -> Option> { self.data.get(&sym).cloned() } - pub fn has_attr(&self, sym: Symbol) -> bool { + pub fn has_attr(&self, sym: &Symbol) -> bool { self.data.get(&sym).is_some() } + pub fn capture(&mut self, env: Rc>) { + self.data = self + .data + .into_iter() + .map(|(k, v)| (k.clone(), match v.clone() { x @ Value::ThunkRef(thunk) => { thunk.capture(env.clone()); x }, x => x })) + .collect(); + } + pub fn update(mut self, other: AttrSet<'vm>) -> AttrSet<'vm> { for (k, v) in other.data.iter() { self.push_attr_force(k.clone(), v.clone()) @@ -50,17 +57,17 @@ impl<'vm> AttrSet<'vm> { } pub fn update_rec(mut self, other: RecAttrSet<'vm>) -> AttrSet<'vm> { - for (k, v) in other.data.borrow().iter() { + for (k, v) in other.data.map.borrow().iter() { self.push_attr_force(k.clone(), v.clone()) } self } - pub fn into_inner(self) -> HashTrieMapSync> { + pub fn into_inner(self) -> HashTrieMap> { self.data } - pub fn as_inner(&self) -> &HashTrieMapSync> { + pub fn as_inner(&self) -> &HashTrieMap> { &self.data } @@ -92,37 +99,37 @@ impl ToPublic for AttrSet<'_> { #[derive(Debug, Constructor, Clone, PartialEq)] pub struct RecAttrSet<'vm> { - data: Arc>>>, + data: Rc> } impl<'vm> RecAttrSet<'vm> { pub fn empty() -> Self { RecAttrSet { - data: Arc::default(), + data: Rc::default(), } } pub fn push_attr_force(&mut self, sym: Symbol, val: Value<'vm>) { - self.data.borrow_mut().insert_mut(sym, val); + self.data.insert(sym, val); } pub fn push_attr(&mut self, sym: Symbol, val: Value<'vm>) { - if self.data.borrow().get(&sym).is_some() { + if self.data.lookup(&sym).is_some() { todo!() } - self.data.borrow_mut().insert_mut(sym, val); + self.data.insert(sym, val); } - pub fn select(&self, sym: Symbol) -> Option> { - self.data.borrow().get(&sym).cloned() + pub fn select(&self, sym: &Symbol) -> Option> { + self.data.lookup(sym) } - pub fn has_attr(&self, sym: Symbol) -> bool { - self.data.borrow().get(&sym).is_some() + pub fn has_attr(&self, sym: &Symbol) -> bool { + self.data.lookup(sym).is_some() } pub fn update(mut self, other: RecAttrSet<'vm>) -> RecAttrSet<'vm> { - for (k, v) in other.data.borrow().iter() { + for (k, v) in other.data.map.borrow().iter() { self.push_attr_force(k.clone(), v.clone()) } self @@ -131,6 +138,7 @@ impl<'vm> RecAttrSet<'vm> { pub fn update_normal(self, other: AttrSet<'vm>) -> AttrSet<'vm> { let map = self .data + .map .borrow() .into_iter() .map(|(k, v)| (k.clone(), v.clone())) @@ -142,17 +150,18 @@ impl<'vm> RecAttrSet<'vm> { new } - pub fn into_inner(self) -> HashTrieMapSync> { - self.data.borrow().clone() + pub fn into_inner(self) -> Rc> { + self.data } - pub fn from_inner(data: Arc>>>) -> Self { + pub fn from_inner(data: Rc>) -> Self { RecAttrSet { data } } pub fn force_deep(&mut self, vm: &VM<'vm>) -> Result<()> { let mut map: Vec<_> = self .data + .map .borrow() .into_iter() .map(|(k, v)| (k.clone(), v.clone())) @@ -161,7 +170,7 @@ impl<'vm> RecAttrSet<'vm> { .map(|(_, v)| v.force_deep(vm).map(|_| ())) .find(|v| v.is_err()) .map_or(Ok(()), |err| err)?; - *self.data.borrow_mut() = map.into_iter().collect(); + *self.data.map.borrow_mut() = map.into_iter().collect(); Ok(()) } } @@ -169,7 +178,7 @@ impl<'vm> RecAttrSet<'vm> { impl ToPublic for RecAttrSet<'_> { fn to_public(self, vm: &VM) -> p::Value { p::Value::AttrSet(p::AttrSet::new( - self.data + self.data.map .borrow() .iter() .map(|(sym, value)| (sym.clone(), value.clone().to_public(vm))) diff --git a/src/ty/internal/func.rs b/src/ty/internal/func.rs index 332626b..a3fda30 100644 --- a/src/ty/internal/func.rs +++ b/src/ty/internal/func.rs @@ -54,14 +54,14 @@ impl<'vm> Func<'vm> { let env = self.env.get().unwrap().clone().released(); match &self.param { - Ident(ident) => env.enter(HashTrieMap::new_sync().insert(ident.clone().into(), arg)), + Ident(ident) => env.enter(HashTrieMap::new().insert(ident.clone().into(), arg)), Formals { formals, ellipsis, alias, } => { let arg = arg.unwrap_attr_set(); - let mut new = HashTrieMap::new_sync(); + let mut new = HashTrieMap::new(); if !ellipsis && arg .as_inner() @@ -73,11 +73,12 @@ impl<'vm> Func<'vm> { todo!() } for (formal, default) in formals { + let formal = formal.clone().into(); let arg = arg - .select(formal.clone().into()) + .select(&formal) .or_else(|| default.map(|idx| Value::ThunkRef(vm.get_thunk(idx)))) .unwrap(); - new.insert_mut(formal.clone().into(), arg); + new.insert_mut(formal, arg); } if let Some(alias) = alias { new.insert_mut(alias.clone().into(), Value::AttrSet(arg)); diff --git a/src/ty/internal/mod.rs b/src/ty/internal/mod.rs index 4215402..8bb79bf 100644 --- a/src/ty/internal/mod.rs +++ b/src/ty/internal/mod.rs @@ -1,5 +1,5 @@ use std::cell::RefCell; -use std::sync::Arc; +use std::rc::Rc; use derive_more::{IsVariant, Unwrap}; @@ -32,7 +32,7 @@ pub trait ToPublic { #[derive(Debug, Clone)] pub struct Thunk<'vm> { pub thunk: RefCell<_Thunk<'vm>>, - pub env: RefCell>>>, + pub env: RefCell>>>, } #[derive(Debug, IsVariant, Unwrap, Clone)] @@ -54,7 +54,7 @@ impl<'vm> Thunk<'vm> { self.thunk.borrow().clone().unwrap_code() } - pub fn capture(&self, env: Arc>) { + pub fn capture(&self, env: Rc>) { *self.env.borrow_mut() = Some(env); } @@ -137,7 +137,7 @@ pub enum ValueAsMut<'v, 'vm: 'v> { } impl<'v, 'vm: 'v> Value<'vm> { - pub fn as_ref(&'vm self) -> ValueAsRef<'v, 'vm> { + pub fn as_ref(&'v self) -> ValueAsRef<'v, 'vm> { use Value::*; use ValueAsRef as R; match self { @@ -154,7 +154,7 @@ impl<'v, 'vm: 'v> Value<'vm> { } } - pub fn as_mut(&'vm mut self) -> ValueAsMut<'v, 'vm> { + pub fn as_mut(&'v mut self) -> ValueAsMut<'v, 'vm> { use Value::*; use ValueAsMut as M; match self { @@ -379,13 +379,13 @@ impl<'vm> Value<'vm> { } } - pub fn select(&mut self, sym: Symbol) -> Result<&mut Self> { + pub fn select(&mut self, sym: &Symbol) -> Result<&mut Self> { let val = match self { Value::AttrSet(attrs) => attrs - .select(sym.clone()) + .select(sym) .ok_or_else(|| Error::EvalError(format!("{sym:?} not found"))), Value::RecAttrSet(attrs) => attrs - .select(sym.clone()) + .select(sym) .ok_or_else(|| Error::EvalError(format!("{sym:?} not found"))), Value::Catchable(_) => return Ok(self), _ => Err(Error::EvalError(format!( @@ -397,10 +397,10 @@ impl<'vm> Value<'vm> { Ok(self) } - pub fn select_with_default(&mut self, sym: Symbol, default: Value<'vm>) -> Result<&mut Self> { + pub fn select_with_default(&mut self, sym: &Symbol, default: Value<'vm>) -> Result<&mut Self> { let val = match self { - Value::AttrSet(attrs) => attrs.select(sym.clone()).unwrap_or(default), - Value::RecAttrSet(attrs) => attrs.select(sym.clone()).unwrap_or(default), + Value::AttrSet(attrs) => attrs.select(sym).unwrap_or(default), + Value::RecAttrSet(attrs) => attrs.select(sym).unwrap_or(default), Value::Catchable(_) => return Ok(self), _ => { return Err(Error::EvalError(format!( @@ -413,7 +413,7 @@ impl<'vm> Value<'vm> { Ok(self) } - pub fn has_attr(&mut self, sym: Symbol) -> &mut Self { + pub fn has_attr(&mut self, sym: &Symbol) -> &mut Self { if let Value::AttrSet(attrs) = self { let val = VmConst(Const::Bool(attrs.has_attr(sym))); *self = val; @@ -440,6 +440,9 @@ impl<'vm> Value<'vm> { if let Value::Thunk(thunk) = self { let value = thunk.force(vm)?; *self = value + } else if let Value::ThunkRef(thunk) = self { + let value = thunk.force(vm)?; + *self = value } Ok(self) } @@ -451,6 +454,11 @@ impl<'vm> Value<'vm> { let _ = value.force_deep(vm)?; *self = value; } + Value::ThunkRef(thunk) => { + let mut value = thunk.force(vm)?; + let _ = value.force_deep(vm)?; + *self = value; + } Value::List(list) => list.force_deep(vm)?, Value::AttrSet(attrs) => attrs.force_deep(vm)?, Value::RecAttrSet(attrs) => attrs.force_deep(vm)?, diff --git a/src/ty/public/mod.rs b/src/ty/public/mod.rs index 052d71b..9c6cff9 100644 --- a/src/ty/public/mod.rs +++ b/src/ty/public/mod.rs @@ -1,7 +1,7 @@ use std::fmt::{Debug, Display, Formatter, Result as FmtResult}; use derive_more::{Constructor, IsVariant, Unwrap}; -use rpds::{HashTrieMapSync, VectorSync}; +use rpds::{HashTrieMap, VectorSync}; use super::common::*; @@ -11,7 +11,7 @@ pub use cnst::Const; #[derive(Constructor, Clone, PartialEq)] pub struct AttrSet { - data: HashTrieMapSync, + data: HashTrieMap, } impl Debug for AttrSet { diff --git a/src/vm/env.rs b/src/vm/env.rs index 219b980..936f8db 100644 --- a/src/vm/env.rs +++ b/src/vm/env.rs @@ -1,15 +1,15 @@ use std::cell::RefCell; -use std::sync::Arc; +use std::rc::Rc; -use rpds::HashTrieMapSync; +use rpds::HashTrieMap; use crate::ty::common::Symbol; use crate::ty::internal::Value; -#[derive(Debug, Default)] +#[derive(Debug, Default, PartialEq)] pub struct Env<'vm> { - last: RefCell>>>, - map: Arc>>>, + last: RefCell>>>, + pub map: RefCell>>, } impl Clone for Env<'_> { @@ -19,16 +19,16 @@ impl Clone for Env<'_> { self.last .borrow() .clone() - .map(|e| Arc::new(e.as_ref().clone())), + .map(|e| Rc::new(e.as_ref().clone())), ), - map: Arc::new(RefCell::new(self.map.borrow().clone())), + map: RefCell::new(self.map.borrow().clone()), } } } #[derive(Debug, Clone)] pub struct CapturedEnv<'vm> { - env: Arc>, + env: Rc>, } impl<'vm> Env<'vm> { @@ -36,15 +36,15 @@ impl<'vm> Env<'vm> { Env::default() } - pub fn lookup(&self, symbol: Symbol) -> Option> { - self.map.borrow().get(&symbol).cloned() + pub fn lookup(&self, symbol: &Symbol) -> Option> { + self.map.borrow().get(symbol).cloned() } pub fn insert(&self, symbol: Symbol, value: Value<'vm>) { self.map.borrow_mut().insert_mut(symbol, value); } - pub fn enter(&self, new: HashTrieMapSync>) { + pub fn enter(&self, new: HashTrieMap>) { let mut map = self.map.borrow().clone(); for (k, v) in new.iter() { map.insert_mut(k.clone(), v.clone()); @@ -53,17 +53,23 @@ impl<'vm> Env<'vm> { last: self.last.clone(), map: self.map.clone(), }; - *self.last.borrow_mut() = Some(Arc::new(last)); + *self.last.borrow_mut() = Some(Rc::new(last)); *self.map.borrow_mut() = map; } - pub fn enter_rec(&self) -> Arc>>> { + pub fn enter_rec(self: &mut Rc, new: Rc>) { + let last = (*self.last.borrow_mut()).take(); + *self = new; + *self.last.borrow_mut() = last; + } + + pub fn new_rec(self: Rc) -> Rc { let last = Env { last: self.last.clone(), map: self.map.clone(), }; - *self.last.borrow_mut() = Some(Arc::new(last)); - self.map.clone() + *self.last.borrow_mut() = Some(Rc::new(last)); + self.clone() } pub fn leave(&self) { @@ -73,17 +79,17 @@ impl<'vm> Env<'vm> { *self.map.borrow_mut() = map; } - pub fn captured(self: Arc) -> CapturedEnv<'vm> { + pub fn captured(self: Rc) -> CapturedEnv<'vm> { CapturedEnv { env: self } } } impl<'vm> CapturedEnv<'vm> { - pub fn lookup(&self, symbol: Symbol) -> Option> { + pub fn lookup(&self, symbol: &Symbol) -> Option> { self.env.lookup(symbol) } - pub fn released(self) -> Arc> { - Arc::new(self.env.as_ref().clone()) + pub fn released(self) -> Rc> { + Rc::new(self.env.as_ref().clone()) } } diff --git a/src/vm/mod.rs b/src/vm/mod.rs index 011b490..bb0be16 100644 --- a/src/vm/mod.rs +++ b/src/vm/mod.rs @@ -1,5 +1,5 @@ use std::cell::OnceCell; -use std::sync::Arc; +use std::rc::Rc; use crate::builtins::env; use crate::bytecode::{BinOp, OpCode, OpCodes, Program, UnOp}; @@ -65,11 +65,11 @@ impl<'vm> VM<'vm> { unsafe { &*(&self.funcs[idx] as *const _) } } - pub fn eval(&self, opcodes: OpCodes, env: Arc>) -> Result> { + pub fn eval(&self, opcodes: OpCodes, env: Rc>) -> Result> { let mut stack = Stack::::new(); let mut iter = opcodes.into_iter(); while let Some(opcode) = iter.next() { - let jmp = self.single_op(opcode, &mut stack, env.clone())?; + let jmp = self.single_op(opcode, &mut stack, &env)?; for _ in 0..jmp { iter.next().unwrap(); } @@ -85,15 +85,16 @@ impl<'vm> VM<'vm> { &self, opcode: OpCode, stack: &'s mut Stack<'vm, CAP>, - env: Arc>, + env: &Rc>, ) -> Result { match opcode { OpCode::Illegal => panic!("illegal opcode"), OpCode::Const { value } => stack.push(Value::Const(value))?, OpCode::LoadThunk { idx } => { - self.thunks[idx].capture(env); - stack.push(Value::Thunk(self.thunks[idx].clone()))? + let thunk = self.get_thunk(idx); + thunk.capture(env.clone()); + stack.push(Value::ThunkRef(self.get_thunk(idx)))? } OpCode::LoadValue { idx } => { stack.push(self.get_thunk(idx).force(self)?)?; @@ -123,7 +124,7 @@ impl<'vm> VM<'vm> { } OpCode::Func { idx } => { let func = self.get_func(idx); - func.env.get_or_init(|| env.captured()); + func.env.get_or_init(|| env.clone().captured()); stack.push(Value::Func(func))?; } OpCode::UnOp { op } => { @@ -167,13 +168,13 @@ impl<'vm> VM<'vm> { OpCode::AttrSet => { stack.push(Value::AttrSet(AttrSet::empty()))?; } - OpCode::RecAttrSet => { - let new = env.enter_rec(); - stack.push(Value::RecAttrSet(RecAttrSet::new(new)))?; - } + OpCode::FinalizeRec => { + env.enter(stack.tos()?.clone().unwrap_attr_set().into_inner()); + stack.tos_mut()?.as_mut().unwrap_attr_set().capture(env.clone()); + }, OpCode::PushStaticAttr { name } => { let val = stack.pop(); - stack.tos_mut()?.push_attr(Symbol::new(name), val); + stack.tos_mut()?.push_attr(Symbol::new(name.clone()), val); } OpCode::PushDynamicAttr => { let val = stack.pop(); @@ -183,21 +184,21 @@ impl<'vm> VM<'vm> { stack.tos_mut()?.push_attr(sym, val); } OpCode::Select { sym } => { - stack.tos_mut()?.force(self)?.select(Symbol::new(sym))?; + stack.tos_mut()?.force(self)?.select(&Symbol::new(sym))?; } OpCode::SelectOrDefault { sym } => { let default = stack.pop(); stack .tos_mut()? .force(self)? - .select_with_default(Symbol::new(sym), default)?; + .select_with_default(&Symbol::new(sym), default)?; } OpCode::SelectDynamic => { let mut val = stack.pop(); val.force(self)?; val.coerce_to_string(); let sym = val.unwrap_const().unwrap_string().into(); - stack.tos_mut()?.force(self)?.select(sym)?; + stack.tos_mut()?.force(self)?.select(&sym)?; } OpCode::SelectDynamicOrDefault => { let default = stack.pop(); @@ -208,26 +209,26 @@ impl<'vm> VM<'vm> { stack .tos_mut()? .force(self)? - .select_with_default(sym, default)?; + .select_with_default(&sym, default)?; } OpCode::HasAttr { sym } => { - stack.tos_mut()?.force(self)?.has_attr(Symbol::new(sym)); + stack.tos_mut()?.force(self)?.has_attr(&Symbol::new(sym)); } OpCode::HasDynamicAttr => { let mut val = stack.pop(); val.coerce_to_string(); let sym = val.unwrap_const().unwrap_string().into(); - stack.tos_mut()?.force(self)?.has_attr(sym); + stack.tos_mut()?.force(self)?.has_attr(&sym); } OpCode::LookUp { sym } => { + let sym = Symbol::new(sym); stack.push( - env.lookup(Symbol::new(sym.clone())) + env.lookup(&sym) .ok_or_else(|| Error::EvalError(format!(r#""{sym}" not found"#)))?, )?; } OpCode::EnterEnv => match stack.pop() { Value::AttrSet(attrs) => env.enter(attrs.into_inner()), - Value::RecAttrSet(attrs) => env.enter(attrs.into_inner()), _ => unreachable!(), }, OpCode::LeaveEnv => { diff --git a/src/vm/stack.rs b/src/vm/stack.rs index 2186fb0..915ef82 100644 --- a/src/vm/stack.rs +++ b/src/vm/stack.rs @@ -7,7 +7,8 @@ use crate::ty::internal::Value; pub const STACK_SIZE: usize = 8 * 1024 / size_of::(); pub struct Stack<'vm, const CAP: usize> { - items: Box<[MaybeUninit>; CAP]>, + // items: Box<[MaybeUninit>; CAP]>, + items: [MaybeUninit>; CAP], top: usize, } @@ -24,11 +25,7 @@ macro_rules! into { impl<'vm, const CAP: usize> Stack<'vm, CAP> { pub fn new() -> Self { Stack { - items: (0..CAP) - .map(|_| MaybeUninit::uninit()) - .collect::>() - .try_into() - .unwrap(), + items: [const { MaybeUninit::uninit() }; CAP], top: 0, } } @@ -55,6 +52,14 @@ impl<'vm, const CAP: usize> Stack<'vm, CAP> { unsafe { replace(item, MaybeUninit::uninit()).assume_init() } } + pub fn tos(&self) -> Result<&Value<'vm>> { + if self.top == 0 { + panic!("stack empty") + } else { + Ok(into!(&self.items[self.top - 1])) + } + } + pub fn tos_mut(&mut self) -> Result<&mut Value<'vm>> { if self.top == 0 { panic!("stack empty") diff --git a/src/vm/test.rs b/src/vm/test.rs index 5913ee2..bb17c1b 100644 --- a/src/vm/test.rs +++ b/src/vm/test.rs @@ -3,7 +3,7 @@ extern crate test; use test::{Bencher, black_box}; use ecow::EcoString; -use rpds::{ht_map_sync, vector_sync}; +use rpds::{ht_map, vector_sync}; use crate::compile::compile; use crate::ir::downgrade; @@ -64,7 +64,7 @@ macro_rules! list { macro_rules! attrs { ($($x:tt)*) => ( - Value::AttrSet(AttrSet::new(ht_map_sync!{$($x)*})) + Value::AttrSet(AttrSet::new(ht_map!{$($x)*})) ) }