noteuclid/minilua
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: noteuclid:just-value
Branches Tags
noteuclid:master
noteuclid:just-value
noteuclid:scalar
noteuclid:empty-table
..
compare: noteuclid:master
Branches Tags
noteuclid:just-value
noteuclid:scalar
noteuclid:master
noteuclid:empty-table

No commits in common. "just-value" and "master" have entirely different histories.
just-value ... master

2 changed files with 63 additions and 72 deletions
Show Stats Expand all files Collapse all files

105
src/twopass.rs
View File

@ -1,9 +1,6 @@
use std::{cell::RefCell, rc::Rc};
use crate::{
ast,
types::{self, Nil, Value},
};
use crate::{ast, types};
#[derive(Debug, Clone)]
pub struct OpenFunction(Function);
@ -276,14 +273,14 @@ pub fn build(code: &ast::Function) -> OpenFunction {
}
#[derive(Debug, Clone)]
struct Variable(RefCell<Value>);
struct Variable(RefCell<types::Value>);
impl Variable {
fn get(&self) -> Value {
fn get(&self) -> types::Value {
self.0.borrow().clone()
}
fn set(&self, value: Value) {
fn set(&self, value: types::Value) {
*self.0.borrow_mut() = value
}
}
@ -310,28 +307,28 @@ impl RunContext {
}
trait Eval {
fn eval(&self, ctx: &RunContext) -> Value;
fn eval(&self, ctx: &RunContext) -> types::Value;
}
impl Eval for ast::Constant {
fn eval(&self, _ctx: &RunContext) -> Value {
fn eval(&self, _ctx: &RunContext) -> types::Value {
match self {
ast::Constant::Nil => Nil,
ast::Constant::Boolean(value) => Value::Boolean(*value),
ast::Constant::Number(value) => Value::Number(*value),
ast::Constant::String(value) => Value::String(value.clone()),
ast::Constant::Nil => None,
ast::Constant::Boolean(value) => Some(types::ValueInner::Boolean(*value)),
ast::Constant::Number(value) => Some(types::ValueInner::Number(*value)),
ast::Constant::String(value) => Some(types::ValueInner::String(value.clone())),
}
}
}
impl Eval for Location {
fn eval(&self, ctx: &RunContext) -> Value {
fn eval(&self, ctx: &RunContext) -> types::Value {
match self {
Location::Variable { id } => ctx.var(*id).get(),
Location::Field { table, index } => {
let table = table.eval(ctx);
let index = index.eval(ctx);
let Value::Table(table) = table else {
let table = table.eval(ctx).expect("attempt to index a nil value");
let index = index.eval(ctx).expect("attempt to index with a nil value");
let types::ValueInner::Table(table) = table else {
panic!("attempt to index a non-table");
};
table.get(index)
@ -341,10 +338,10 @@ impl Eval for Location {
}
impl Eval for Call {
fn eval(&self, ctx: &RunContext) -> Value {
fn eval(&self, ctx: &RunContext) -> types::Value {
let callee = self.callee.eval(ctx);
let args: Vec<_> = self.args.iter().map(|arg| arg.eval(ctx)).collect();
let Value::Function(f) = callee else {
let Some(types::ValueInner::Function(f)) = callee else {
panic!("attempt to call a non-function");
};
f.call(&args)
@ -352,31 +349,33 @@ impl Eval for Call {
}
impl Eval for Function {
fn eval(&self, ctx: &RunContext) -> Value {
fn eval(&self, ctx: &RunContext) -> types::Value {
let upvalues: Vec<_> = self
.upvalues
.iter()
.map(|(_name, id)| ctx.var(*id))
.collect();
let self_ = self.clone(); // TODO reference, somehow
types::Function::new(self.name.clone(), move |args| self_.call(&upvalues, args)).into()
Some(
types::Function::new(self.name.clone(), move |args| self_.call(&upvalues, args)).into(),
)
}
}
impl Eval for Table {
fn eval(&self, ctx: &RunContext) -> Value {
fn eval(&self, ctx: &RunContext) -> types::Value {
let table = types::Table::default();
for field in &self.fields {
let key = field.key.eval(ctx);
let key = field.key.eval(ctx).expect("attempt to set a nil index");
let value = field.value.eval(ctx);
table.set(key, value);
}
table.into()
Some(table.into())
}
}
impl Eval for Expression {
fn eval(&self, ctx: &RunContext) -> Value {
fn eval(&self, ctx: &RunContext) -> types::Value {
match self {
Expression::Constant(inner) => inner.eval(ctx),
Expression::Variable(inner) => inner.eval(ctx),
@ -388,16 +387,16 @@ impl Eval for Expression {
}
impl Eval for Statement {
fn eval(&self, ctx: &RunContext) -> Value {
fn eval(&self, ctx: &RunContext) -> types::Value {
match self {
Statement::Assign { target, source } => {
let source = source.eval(ctx);
match target {
Location::Variable { id } => ctx.var(*id).set(source),
Location::Field { table, index } => {
let table = table.eval(ctx);
let index = index.eval(ctx);
let Value::Table(table) = table else {
let table = table.eval(ctx).expect("attempt to index a nil value");
let index = index.eval(ctx).expect("attempt to index with a nil value");
let types::ValueInner::Table(table) = table else {
panic!("attempt to index a non-table");
};
table.set(index, source)
@ -408,21 +407,21 @@ impl Eval for Statement {
call.eval(ctx);
}
};
Nil
None
}
}
fn new_var(value: &Value) -> VariableRef {
fn new_var(value: &types::Value) -> VariableRef {
Rc::new(Variable(RefCell::new(value.clone())))
}
impl Function {
fn call(&self, upvalues: &[VariableRef], args: &[Value]) -> Value {
fn call(&self, upvalues: &[VariableRef], args: &[types::Value]) -> types::Value {
assert_eq!(upvalues.len(), self.upvalues.len());
assert_eq!(args.len(), self.args.len());
let ctx = RunContext {
args: args.iter().map(new_var).collect(),
locals: (0..self.locals.len()).map(|_| new_var(&Nil)).collect(),
locals: (0..self.locals.len()).map(|_| new_var(&None)).collect(),
upvalues: upvalues.to_vec(),
};
for statement in &self.body {
@ -433,7 +432,7 @@ impl Function {
}
impl OpenFunction {
pub fn call(&self, env: Value, args: &[Value]) -> Value {
pub fn call(&self, env: types::Value, args: &[types::Value]) -> types::Value {
match self.0.upvalues.as_slice() {
[] => self.0.call(&[], args),
[up] if up.0 == "_ENV" => self.0.call(&[new_var(&env)], args),
@ -446,27 +445,27 @@ impl OpenFunction {
mod tests {
use crate::{
ast::*,
types::{Nil, Value},
types::{Value, ValueInner},
};
use super::build;
fn get(table: &Value, index: &str) -> Value {
let Value::Table(table) = table else {
let Some(ValueInner::Table(table)) = table else {
panic!("a table expected");
};
table.get(index.into())
}
fn set(table: &Value, index: &str, value: Value) {
let Value::Table(table) = table else {
let Some(ValueInner::Table(table)) = table else {
panic!("a table expected");
};
table.set(index.into(), value);
}
fn call(func: &Value, args: &[Value]) -> Value {
let Value::Function(func) = func else {
let Some(ValueInner::Function(func)) = func else {
panic!("a function expected");
};
func.call(args)
@ -495,9 +494,9 @@ mod tests {
};
let env = crate::types::Table::default();
let testee = build(&testee);
let ret = testee.call(env.clone().into(), &[]);
assert_eq!(ret, 3.into());
assert_eq!(env.get("x".into()), 1.into());
let ret = testee.call(Some(env.clone().into()), &[]);
assert_eq!(ret, Some(3.into()));
assert_eq!(env.get("x".into()), Some(1.into()));
}
#[test]
@ -527,9 +526,9 @@ mod tests {
};
let env = crate::types::Table::default();
let testee = build(&testee);
let ret = testee.call(env.clone().into(), &[]);
assert_eq!(ret, 42.into());
assert_eq!(env.get("x".into()), 666.into());
let ret = testee.call(Some(env.clone().into()), &[]);
assert_eq!(ret, Some(42.into()));
assert_eq!(env.get("x".into()), Some(666.into()));
}
#[test]
@ -546,8 +545,8 @@ mod tests {
}))),
};
let remember = build(&remember);
let the_answerer = remember.call(Nil, &[42.into()]);
assert_eq!(call(&the_answerer, &[]), 42.into());
let the_answerer = remember.call(None, &[Some(42.into())]);
assert_eq!(call(&the_answerer, &[]), Some(42.into()));
}
#[test]
@ -587,13 +586,13 @@ mod tests {
))),
};
let make_cell = build(&make_cell);
let cell1 = make_cell.call(Nil, &[]);
let cell2 = make_cell.call(Nil, &[]);
assert_eq!(call(&get(&cell1, "get"), &[]), Nil);
call(&get(&cell1, "set"), &[42.into()]);
call(&get(&cell2, "set"), &["foobar".into()]);
assert_eq!(call(&get(&cell1, "get"), &[]), 42.into());
let cell1 = make_cell.call(None, &[]);
let cell2 = make_cell.call(None, &[]);
assert_eq!(call(&get(&cell1, "get"), &[]), None);
call(&get(&cell1, "set"), &[Some(42.into())]);
call(&get(&cell2, "set"), &[Some("foobar".into())]);
assert_eq!(call(&get(&cell1, "get"), &[]), Some(42.into()));
call(&get(&cell1, "set"), &[call(&get(&cell2, "get"), &[])]);
assert_eq!(call(&get(&cell1, "get"), &[]), "foobar".into());
assert_eq!(call(&get(&cell1, "get"), &[]), Some("foobar".into()));
}
}

30
src/types.rs
View File

@ -1,9 +1,7 @@
use std::{cell::RefCell, collections::HashMap, fmt::Debug, hash::Hash, rc::Rc};
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
pub enum Value {
#[default]
Nil,
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum ValueInner {
Boolean(bool),
Number(i64),
String(String),
@ -11,18 +9,16 @@ pub enum Value {
Function(Function),
}
pub use Value::Nil;
macro_rules! impl_from {
($as: ident, $from: ty) => {
impl From<$from> for Value {
impl From<$from> for ValueInner {
fn from(value: $from) -> Self {
Self::$as(value.into())
}
}
};
(try $as: ident, $from: ty) => {
impl TryFrom<$from> for Value {
impl TryFrom<$from> for ValueInner {
type Error = ::std::num::TryFromIntError;
fn try_from(value: $from) -> Result<Self, Self::Error> {
Ok(Self::$as(value.try_into()?))
@ -43,9 +39,11 @@ impl_from!(String, &str);
impl_from!(Table, Table);
impl_from!(Function, Function);
pub type Value = Option<ValueInner>;
#[derive(Debug, Clone, Default)]
struct TableInner {
content: HashMap<Value, Value>,
content: HashMap<ValueInner, ValueInner>,
}
#[derive(Debug, Clone, Default)]
@ -66,19 +64,13 @@ impl Hash for Table {
}
impl Table {
pub fn get(&self, key: Value) -> Value {
self.0
.borrow()
.content
.get(&key)
.cloned()
.unwrap_or_default()
pub fn get(&self, key: ValueInner) -> Value {
self.0.borrow().content.get(&key).cloned()
}
pub fn set(&self, key: Value, value: Value) {
assert!(key != Nil);
pub fn set(&self, key: ValueInner, value: Value) {
let mut this = self.0.borrow_mut();
if value != Nil {
if let Some(value) = value {
this.content.insert(key, value);
} else {
this.content.remove(&key);