AbleScript
/
ablescript
3
4
Fork 1
Code Issues Pull Requests Projects Releases 7 Wiki Activity

Introduced newtype for `Rc<RefCell<Value>>`

pull/6/head
ondra05 2022-03-01 22:13:49 +01:00
parent acb9bed2aa
commit 0dee4ad9ab
2 changed files with 70 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
ablescript/src/interpret.rs
View File

@ -8,14 +8,12 @@
#![deny(missing_docs)]
use std::{
cell::RefCell,
cmp::Ordering,
collections::{HashMap, VecDeque},
io::{stdin, stdout, Read, Write},
mem::take,
ops::Range,
process::exit,
rc::Rc,
};
use rand::random;
@ -25,7 +23,7 @@ use crate::{
base_55,
consts::ablescript_consts,
error::{Error, ErrorKind},
variables::{Functio, Value, Variable},
variables::{Functio, Value, ValueRef, Variable},
};
/// An environment for executing AbleScript code.
@ -179,8 +177,7 @@ impl ExecEnv {
.iter()
.map(|(value, key)| {
self.eval_expr(value).and_then(|value| {
self.eval_expr(key)
.map(|key| (key, Rc::new(RefCell::new(value))))
self.eval_expr(key).map(|key| (key, ValueRef::new(value)))
})
})
.collect::<Result<HashMap<_, _>, _>>()?,
@ -323,14 +320,13 @@ impl ExecEnv {
if let Some(x) = c.get(&index) {
// cell[index] exists, get a shared
// reference to it.
Rc::clone(x)
ValueRef::clone(x)
} else {
// cell[index] does not exist, so we
// insert an empty cart by default
// instead.
let next_cell =
Rc::new(RefCell::new(Value::Cart(Default::default())));
c.insert(index, Rc::clone(&next_cell));
let next_cell = ValueRef::new(Value::Cart(Default::default()));
c.insert(index, ValueRef::clone(&next_cell));
next_cell
}
}
@ -339,8 +335,8 @@ impl ExecEnv {
// it into a cart, and write the result
// back into it.
let mut cart = take(x).into_cart();
let next_cell = Rc::new(RefCell::new(Value::Cart(Default::default())));
cart.insert(index, Rc::clone(&next_cell));
let next_cell = ValueRef::new(Value::Cart(Default::default()));
cart.insert(index, ValueRef::clone(&next_cell));
*x = Value::Cart(cart);
next_cell
}
@ -369,7 +365,7 @@ impl ExecEnv {
span: arg.span.clone(),
})
} else {
self.eval_expr(arg).map(|v| Rc::new(RefCell::new(v)))
self.eval_expr(arg).map(ValueRef::new)
}
})
.collect::<Result<Vec<_>, Error>>()?;
@ -380,7 +376,7 @@ impl ExecEnv {
fn fn_call_with_values(
&mut self,
func: Functio,
args: &[Rc<RefCell<Value>>],
args: &[ValueRef],
span: &Range<usize>,
) -> Result<(), Error> {
match func {
@ -464,9 +460,9 @@ impl ExecEnv {
}
fn deinterlace(
args: &[Rc<RefCell<Value>>],
args: &[ValueRef],
arities: (usize, usize),
) -> (Vec<Rc<RefCell<Value>>>, Vec<Rc<RefCell<Value>>>) {
) -> (Vec<ValueRef>, Vec<ValueRef>) {
let n_alternations = usize::min(arities.0, arities.1);
let (extra_l, extra_r) = match Ord::cmp(&arities.0, &arities.1) {
Ordering::Less => (0, arities.1 - arities.0),
@ -477,21 +473,21 @@ impl ExecEnv {
(
args.chunks(2)
.take(n_alternations)
.map(|chunk| Rc::clone(&chunk[0]))
.map(|chunk| ValueRef::clone(&chunk[0]))
.chain(
args[2 * n_alternations..]
.iter()
.map(Rc::clone)
.map(ValueRef::clone)
.take(extra_l),
)
.collect(),
args.chunks(2)
.take(n_alternations)
.map(|chunk| Rc::clone(&chunk[1]))
.map(|chunk| ValueRef::clone(&chunk[1]))
.chain(
args[2 * n_alternations..]
.iter()
.map(Rc::clone)
.map(ValueRef::clone)
.take(extra_r),
)
.collect(),
@ -582,17 +578,17 @@ impl ExecEnv {
/// Get an Rc'd pointer to the value of a variable. Throw an error
/// if the variable is inaccessible or banned.
fn get_var_rc(&mut self, name: &Ident) -> Result<Rc<RefCell<Value>>, Error> {
fn get_var_rc(&mut self, name: &Ident) -> Result<ValueRef, Error> {
Ok(self.get_var_mut(name)?.value.clone())
}
/// Declare a new variable, with the given initial value.
fn decl_var(&mut self, name: &str, value: Value) {
self.decl_var_shared(name, Rc::new(RefCell::new(value)));
self.decl_var_shared(name, ValueRef::new(value));
}
/// Declare a new variable, with the given shared initial value.
fn decl_var_shared(&mut self, name: &str, value: Rc<RefCell<Value>>) {
fn decl_var_shared(&mut self, name: &str, value: ValueRef) {
self.stack
.iter_mut()
.last()

86
ablescript/src/variables.rs
View File

@ -1,6 +1,13 @@
use std::{
cell::RefCell, collections::HashMap, fmt::Display, hash::Hash, io::Write, mem::discriminant,
ops, rc::Rc, vec,
cell::{Ref, RefCell, RefMut},
collections::HashMap,
fmt::Display,
hash::Hash,
io::Write,
mem::discriminant,
ops,
rc::Rc,
vec,
};
use rand::Rng;
@ -69,14 +76,14 @@ impl Functio {
#[derive(Clone)]
pub struct BuiltinFunctio {
function: Rc<dyn Fn(&[Rc<RefCell<Value>>]) -> Result<(), crate::error::ErrorKind>>,
function: Rc<dyn Fn(&[ValueRef]) -> Result<(), crate::error::ErrorKind>>,
arity: usize,
}
impl BuiltinFunctio {
pub fn new<F>(f: F, arity: usize) -> Self
where
F: Fn(&[Rc<RefCell<Value>>]) -> Result<(), crate::error::ErrorKind> + 'static,
F: Fn(&[ValueRef]) -> Result<(), crate::error::ErrorKind> + 'static,
{
Self {
function: Rc::new(f),
@ -84,7 +91,7 @@ impl BuiltinFunctio {
}
}
pub fn call(&self, args: &[Rc<RefCell<Value>>]) -> Result<(), crate::error::ErrorKind> {
pub fn call(&self, args: &[ValueRef]) -> Result<(), crate::error::ErrorKind> {
(self.function)(args)
}
@ -121,7 +128,7 @@ pub enum FunctioChainKind {
ByArity,
}
pub type Cart = HashMap<Value, Rc<RefCell<Value>>>;
pub type Cart = HashMap<Value, ValueRef>;
#[derive(Debug, Clone)]
pub enum Value {
@ -263,9 +270,8 @@ impl Value {
)
.into_abool(),
Functio::Able { params, body } => {
let str_to_isize = |x: String| -> isize {
x.as_bytes().iter().map(|x| *x as isize).sum()
};
let str_to_isize =
|x: String| -> isize { x.as_bytes().iter().map(|x| *x as isize).sum() };
let params: isize = params.into_iter().map(str_to_isize).sum();
let body: isize = body
@ -377,7 +383,7 @@ impl Value {
.map(|(i, x)| {
(
Value::Int(i as isize + 1),
Rc::new(RefCell::new(Value::Str(x.to_string()))),
ValueRef::new(Value::Str(x.to_string())),
)
})
.collect(),
@ -389,12 +395,7 @@ impl Value {
let params: Cart = params
.into_iter()
.enumerate()
.map(|(i, x)| {
(
Value::Int(i as isize + 1),
Rc::new(RefCell::new(Value::Str(x))),
)
})
.map(|(i, x)| (Value::Int(i as isize + 1), ValueRef::new(Value::Str(x))))
.collect();
let body: Cart = body
@ -403,7 +404,7 @@ impl Value {
.map(|(i, x)| {
(
Value::Int(i as isize + 1),
Rc::new(RefCell::new(Value::Str(format!("{:?}", x)))),
ValueRef::new(Value::Str(format!("{:?}", x))),
)
})
.collect();
@ -411,12 +412,12 @@ impl Value {
let mut cart = HashMap::new();
cart.insert(
Value::Str("params".to_owned()),
Rc::new(RefCell::new(Value::Cart(params))),
ValueRef::new(Value::Cart(params)),
);
cart.insert(
Value::Str("body".to_owned()),
Rc::new(RefCell::new(Value::Cart(body))),
ValueRef::new(Value::Cart(body)),
);
cart
@ -431,18 +432,18 @@ impl Value {
.map(|(i, x)| {
(
Value::Int(i as isize + 1),
Rc::new(RefCell::new(
ValueRef::new(
char::from_u32(x as u32)
.map(|x| Value::Str(x.to_string()))
.unwrap_or(Value::Nul),
)),
),
)
})
.collect();
cart.insert(
Value::Str("tapelen".to_owned()),
Rc::new(RefCell::new(Value::Int(tape_len as _))),
ValueRef::new(Value::Int(tape_len as _)),
);
cart
}
@ -450,14 +451,12 @@ impl Value {
let mut cart = HashMap::new();
cart.insert(
Value::Str("addr".to_owned()),
Rc::new(RefCell::new(Value::Cart(
Value::Int(b.fn_addr() as _).into_cart(),
))),
ValueRef::new(Value::Cart(Value::Int(b.fn_addr() as _).into_cart())),
);
cart.insert(
Value::Str("arity".to_owned()),
Rc::new(RefCell::new(Value::Int(b.arity as _))),
ValueRef::new(Value::Int(b.arity as _)),
);
cart
@ -647,9 +646,7 @@ impl ops::Sub for Value {
.iter()
.cloned()
.take(resulting_arity)
.chain(std::iter::repeat_with(|| {
Rc::new(RefCell::new(Value::Nul))
}))
.chain(std::iter::repeat_with(|| ValueRef::new(Value::Nul)))
.take(arity)
.collect::<Vec<_>>(),
)
@ -748,7 +745,7 @@ impl ops::Div for Value {
.map(|(i, x)| {
(
Value::Int(i as isize + 1),
Rc::new(RefCell::new(Value::Str(x.to_owned()))),
ValueRef::new(Value::Str(x.to_owned())),
)
})
.collect(),
@ -817,7 +814,7 @@ impl ops::Div for Value {
.map(|(k, v)| {
(
Value::Int(k as isize + 1),
Rc::new(RefCell::new(Value::Cart(v.iter().cloned().collect()))),
ValueRef::new(Value::Cart(v.iter().cloned().collect())),
)
})
.collect(),
@ -883,7 +880,7 @@ impl ops::Not for Value {
}),
Value::Cart(c) => Value::Cart(
c.into_iter()
.map(|(k, v)| (v.borrow().clone(), Rc::new(RefCell::new(k))))
.map(|(k, v)| (v.borrow().clone(), ValueRef::new(k)))
.collect(),
),
}
@ -999,20 +996,41 @@ impl Display for Value {
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct ValueRef(Rc<RefCell<Value>>);
impl ValueRef {
pub fn new(v: Value) -> Self {
Self(Rc::new(RefCell::new(v)))
}
pub fn borrow(&self) -> Ref<Value> {
self.0.borrow()
}
pub fn borrow_mut(&self) -> RefMut<Value> {
self.0.borrow_mut()
}
pub fn replace(&self, v: Value) -> Value {
self.0.replace(v)
}
}
#[derive(Debug)]
pub struct Variable {
pub melo: bool,
// Multiple Variables can reference the same underlying Value when
// pass-by-reference is used, therefore we use Rc here.
pub value: Rc<RefCell<Value>>,
pub value: ValueRef,
}
impl Variable {
pub fn from_value(value: Value) -> Self {
Self {
melo: false,
value: Rc::new(RefCell::new(value)),
value: ValueRef::new(value),
}
}
}