Allow calling functions on arbitrary script types

Demindiro · Demindiro · commit cc2143d09535 · 2021-04-12T21:23:13.000+02:00
diff --git a/script/examples/vec2.bs b/script/examples/vec2.bs
@@ -3,5 +3,4 @@ fn main()
 
 
 fn length(x, y)
-	#return (x * x + y * y).sqrt()
-	return x * x + y * y
+	return (x * x + y * y).sqrt()
diff --git a/script/src/ast.rs b/script/src/ast.rs
@@ -60,6 +60,7 @@ pub(crate) enum Expression<'src> {
         right: Box<Expression<'src>>,
     },
     Function {
+		expr: Option<Box<Expression<'src>>>,
         name: &'src str,
         arguments: Vec<Expression<'src>>,
     },
@@ -292,7 +293,8 @@ impl<'src> Expression<'src> {
                             None => err!(UnexpectedEOF, 0, 0),
                         }
                     }
-                    (Expression::Function { name, arguments }, None)
+					let expr = None;
+                    (Expression::Function { expr, name, arguments }, None)
                 }
                 Some((tk, ..)) => (Expression::Atom(Atom::Name(name)), Some(tk)),
                 e => todo!("{:?}", e),
@@ -303,6 +305,7 @@ impl<'src> Expression<'src> {
             match last_tk {
                 Token::Op(opl) => match tokens.next() {
                     Some((Token::Name(mid), ..)) => {
+						let og_mid = mid;
                         let mid = Expression::Atom(Atom::Name(mid));
                         match tokens.next() {
                             Some((Token::Op(opr), ..)) => match tokens.next() {
@@ -332,6 +335,20 @@ impl<'src> Expression<'src> {
                                 }
                                 e => todo!("{:?}", e),
                             },
+							Some((Token::BracketRoundOpen, ..)) => {
+								// FIXME handle function args & check for ending brace
+								tokens.next();
+								match opl {
+									Op::Access => {
+										Ok((Expression::Function {
+											expr: Some(Box::new(lhs)),
+											name: og_mid,
+											arguments: Vec::new(),
+										}, Some(Token::BracketRoundClose)))
+									}
+									e => todo!("{:?}", e),
+								}
+							}
                             Some((tk, ..)) if tk == Token::BracketRoundClose => Ok((
                                 Expression::Operation {
                                     left: Box::new(lhs),
diff --git a/script/src/bytecode.rs b/script/src/bytecode.rs
@@ -15,8 +15,7 @@ pub(crate) struct CallArgs {
 
 #[derive(Debug)]
 pub(crate) enum Instruction {
-    // TODO avoid box
-    //Call(Box<(u16, Box<str>)>),
+    Call(Box<(u16, CallArgs)>),
     CallSelf(Box<CallArgs>),
     CallGlobal(Box<CallArgs>),
     //Iter(Box<dyn Iterator<Item = Box<dyn ScriptType>>>),
@@ -168,7 +167,7 @@ impl ByteCode {
                                 }
                                 Atom::Name(a) => todo!("call {:?}", a),
                             },
-                            Expression::Function { name, arguments } => {
+                            Expression::Function { name, arguments, expr } => {
                                 let mut args = Vec::with_capacity(arguments.len());
                                 let store_in = *curr_var_count;
                                 *curr_var_count += 1;
@@ -357,6 +356,42 @@ impl ByteCode {
                 }
                 a => todo!("{:?}", a),
             },
+			Expression::Function { expr, name, arguments } => {
+				let expr = if let Some(e) = expr { e } else { todo!("none expr in fn") };
+				let og_cvc = *curr_var_count;
+				let r = *curr_var_count;
+				*curr_var_count += 1;
+				let e = Self::parse_expression(r, expr, locals, instr, vars, min_var_count, curr_var_count)?;
+				let expr = if let Some(e) = e { e } else { r };
+				let mut args = Vec::with_capacity(arguments.len());
+				for a in arguments {
+					let r = *curr_var_count;
+					*curr_var_count += 1;
+					let e = Self::parse_expression(
+						r,
+						a,
+						locals,
+						instr,
+						vars,
+						min_var_count,
+						curr_var_count,
+					)?;
+					if let Some(e) = e {
+						args.push(e);
+						*curr_var_count -= 1;
+					} else {
+						args.push(r);
+					}
+				}
+				let ca = CallArgs {
+					store_in: Some(store),
+					func: (*name).into(),
+					args: args.into_boxed_slice(),
+				};
+				instr.push(Instruction::Call(Box::new((expr, ca))));
+				*curr_var_count = og_cvc;
+				Ok(None)
+			}
             e => todo!("{:#?}", e),
         }
     }
@@ -387,10 +422,24 @@ impl ByteCode {
             let err_roob = || RunError::RegisterOutOfBounds;
             let err_uf = || RunError::UndefinedFunction;
             let err_env = |e| RunError::EnvironmentError(e);
+            let err_call = |e| RunError::CallError(Box::new(e));
             if let Some(instr) = self.code.get(ip as usize) {
                 ip += 1;
                 use Instruction::*;
                 match instr {
+					Call(box (reg, CallArgs { store_in, func, args })) => {
+                        let r = {
+                            let mut ca = Vec::with_capacity(args.len());
+                            for &a in args.iter() {
+                                ca.push(vars.get(a as usize).ok_or(err_roob())?.as_ref());
+                            }
+							let obj = vars.get(*reg as usize).ok_or(err_roob())?.as_ref();
+							obj.call(func, &ca[..]).map_err(err_call)?
+                        };
+                        if let Some(reg) = store_in {
+                            *vars.get_mut(*reg as usize).ok_or(err_roob())? = r;
+                        }
+					}
                     CallGlobal(box CallArgs {
                         store_in,
                         func,
diff --git a/script/src/script.rs b/script/src/script.rs
@@ -4,6 +4,7 @@ use core::fmt::Debug;
 use core::ops::{Add, Mul};
 use rustc_hash::FxHashMap;
 use std::sync::Arc;
+use std::cell::RefCell;
 
 pub struct Class(Arc<Script>);
 
@@ -16,7 +17,20 @@ pub(crate) struct Script {
 #[derive(Debug)]
 pub struct Instance {
     script: Arc<Script>,
-    variables: Box<[Box<dyn ScriptType>]>,
+	// TODO we have 3 options to solve the `A.foo() -> B.bar() -> A.foo()` problem:
+	// * We use `Cell<Box<[_]>>`. This *should* have relatively little overhead but is
+	//   very unintuitive, and the second `A.foo()` call will only see old variable names.
+	//   It is also likely still less efficient than `RefCell` due to an extra alloc.
+	// * We use `RefCell<Box<[_]>>`. This is arguably the most "Rusty" way in terms of
+	//   "don't alias stuff", but is not very intuitive compared to other languages
+	//   and may also end up being impractical.
+	// * We use `Box<[Cell<_>]>`. This will allow mimicking other scripting languages in
+	//   terms of (expected) behaviour but may be less efficient than `RefCell`.
+	// The second and third option should be measured for performance. If the latter is
+	// fast enough (or perhaps even faster) we should use that.
+	// For now, the second option is chosen as the third can't be undone without being a
+	// massive breaking change.
+    variables: RefCell<Box<[Box<dyn ScriptType>]>>,
 }
 
 #[derive(Debug)]
@@ -29,10 +43,11 @@ pub enum CallError {
     IsEmpty,
     InvalidOperator,
     IncompatibleType,
+	AlreadyBorrowed,
 }
 
 pub trait ScriptType: Debug + Any {
-    fn call(&mut self, function: &str, args: &[&dyn ScriptType]) -> CallResult<CallError>;
+    fn call(&self, function: &str, args: &[&dyn ScriptType]) -> CallResult<CallError>;
 
     fn dup(&self) -> Box<dyn ScriptType>;
 
@@ -129,7 +144,7 @@ impl Class {
     pub fn instance(&self) -> Instance {
         Instance {
             script: self.0.clone(),
-            variables: Box::new([]),
+            variables: RefCell::new(Box::new([])),
         }
     }
 }
@@ -141,8 +156,12 @@ impl From<Script> for Class {
 }
 
 impl ScriptType for Instance {
-    fn call(&mut self, function: &str, args: &[&dyn ScriptType]) -> CallResult<CallError> {
-        self.script.call(function, &mut self.variables, args)
+    fn call(&self, function: &str, args: &[&dyn ScriptType]) -> CallResult<CallError> {
+		if let Ok(mut vars) = self.variables.try_borrow_mut() {
+			self.script.call(function, &mut vars, args)
+		} else {
+			Err(CallError::AlreadyBorrowed)
+		}
     }
 
     fn dup(&self) -> Box<dyn ScriptType> {
@@ -155,24 +174,27 @@ impl ScriptType for Instance {
 }
 
 impl ScriptType for () {
-    fn call(&mut self, _: &str, _: &[&dyn ScriptType]) -> CallResult<CallError> {
+    fn call(&self, _: &str, _: &[&dyn ScriptType]) -> CallResult<CallError> {
         Err(CallError::IsEmpty)
     }
 
     impl_dup!();
 }
 
 impl ScriptType for isize {
-    fn call(&mut self, _: &str, _: &[&dyn ScriptType]) -> CallResult<CallError> {
+    fn call(&self, _: &str, _: &[&dyn ScriptType]) -> CallResult<CallError> {
         todo!()
     }
 
     impl_dup!();
 }
 
 impl ScriptType for f64 {
-    fn call(&mut self, _: &str, _: &[&dyn ScriptType]) -> CallResult<CallError> {
-        todo!()
+    fn call(&self, func: &str, _: &[&dyn ScriptType]) -> CallResult<CallError> {
+		Ok(Box::new(match func {
+			"sqrt" => self.sqrt(),
+			_ => return Err(CallError::UndefinedFunction),
+		}))
     }
 
     impl_dup!();
@@ -193,23 +215,23 @@ impl ScriptType for f64 {
 }
 
 impl ScriptType for Box<str> {
-    fn call(&mut self, _: &str, _: &[&dyn ScriptType]) -> CallResult<CallError> {
+    fn call(&self, _: &str, _: &[&dyn ScriptType]) -> CallResult<CallError> {
         todo!()
     }
 
     impl_dup!();
 }
 
 impl ScriptType for char {
-    fn call(&mut self, _: &str, _: &[&dyn ScriptType]) -> CallResult<CallError> {
+    fn call(&self, _: &str, _: &[&dyn ScriptType]) -> CallResult<CallError> {
         todo!()
     }
 
     impl_dup!();
 }
 
 impl ScriptType for String {
-    fn call(&mut self, _: &str, _: &[&dyn ScriptType]) -> CallResult<CallError> {
+    fn call(&self, _: &str, _: &[&dyn ScriptType]) -> CallResult<CallError> {
         todo!()
     }
 
diff --git a/script/src/tokenizer.rs b/script/src/tokenizer.rs
@@ -17,6 +17,7 @@ pub enum Op {
     Greater,
     ShiftLeft,
     ShiftRight,
+	Access,
 }
 
 #[derive(Copy, Clone, Debug, PartialEq)]
@@ -57,7 +58,6 @@ pub enum Token<'src> {
     Return,
     Comma,
     Pass,
-    Dot,
 }
 
 #[derive(Debug, PartialEq)]
@@ -84,6 +84,7 @@ impl Op {
     fn precedence(&self) -> i8 {
         use Op::*;
         match *self {
+			Access => 12,
             Not => 11,
             Mul | Div | Rem => 10,
             Add | Sub => 9,
@@ -104,7 +105,7 @@ impl PartialOrd for Op {
 }
 
 impl Token<'_> {
-    const OPERATORS: &'static str = "=+-*/%&|^!<>";
+    const OPERATORS: &'static str = "=+-*/%&|^!<>.";
     const BRACKETS: &'static str = "()[]{}";
 
     fn parse(source: &str, start_of_file: bool) -> Result<(Token, usize), TokenError> {
@@ -141,7 +142,6 @@ impl Token<'_> {
                 '{' => Ok((Token::BracketCurlyOpen, start + 1)),
                 '}' => Ok((Token::BracketCurlyClose, start + 1)),
                 ',' => Ok((Token::Comma, start + 1)),
-                '.' => Ok((Token::Dot, start + 1)),
                 '"' => loop {
                     if let Some((i, c)) = chars.next() {
                         if c == '"' {
@@ -187,7 +187,8 @@ impl Token<'_> {
                         '<' => Ok((Token::Op(Op::Less), i)),
                         '>' => Ok((Token::Op(Op::Greater), i)),
                         '!' => Ok((Token::Op(Op::Not), i)),
-                        _ => unreachable!(),
+						'.' => Ok((Token::Op(Op::Access), i)),
+                        c => unreachable!("operator '{}' not covered", c),
                     }
                 }
                 _ if c.is_digit(10) => {
