From be4294a5c60d24643ba712db4b6b4c9b2586179c Mon Sep 17 00:00:00 2001 From: Cody Date: Wed, 12 Apr 2023 07:39:50 -0500 Subject: END THIS PAIN AND SUFFERING --- crates/sloth_vm/src/value.rs | 49 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 49 insertions(+) create mode 100644 crates/sloth_vm/src/value.rs (limited to 'crates/sloth_vm/src/value.rs') diff --git a/crates/sloth_vm/src/value.rs b/crates/sloth_vm/src/value.rs new file mode 100644 index 0000000..773da89 --- /dev/null +++ b/crates/sloth_vm/src/value.rs @@ -0,0 +1,49 @@ +use crate::Chunk; + +#[derive(Debug, Clone, Copy, PartialEq)] +pub enum Primitive { + Integer(i128), + Float(f64), + Bool(bool), + /// Pointer to an object living on heap + Object(u32), + Empty, +} + +pub struct Object { + /// If the object has been marked by the VM or not + pub(crate) marked: bool, + pub(crate) typ: ObjectType, +} + +impl Object { + pub fn new(typ: ObjectType) -> Self { + Self { marked: false, typ } + } +} + +pub enum ObjectType { + Box(Primitive), + String(String), + List(Vec), + + Function(Function), + + Free { next: usize }, +} + +pub struct Function { + pub(crate) name: Option, + pub(crate) chunk: Chunk, + pub(crate) arity: u8, +} + +impl Function { + pub(crate) fn root(chunk: Chunk) -> Self { + Self { + name: None, + chunk, + arity: 0, + } + } +} -- cgit v1.2.3 From a8b2a413a455fb06e0b10cf13d132c812f92bd4b Mon Sep 17 00:00:00 2001 From: Cody Date: Wed, 12 Apr 2023 21:02:16 -0500 Subject: Function calling, returning, jumping and fibonacci programs --- crates/sloth_bytecode/src/lib.rs | 2 +- crates/sloth_vm/src/value.rs | 2 + crates/sloth_vm/src/vm.rs | 273 +++++++++++++++++++++++++++++++++------ 3 files changed, 237 insertions(+), 40 deletions(-) (limited to 'crates/sloth_vm/src/value.rs') diff --git a/crates/sloth_bytecode/src/lib.rs b/crates/sloth_bytecode/src/lib.rs index 992c24f..2319330 100644 --- a/crates/sloth_bytecode/src/lib.rs +++ b/crates/sloth_bytecode/src/lib.rs @@ -16,7 +16,7 @@ pub enum Error { macro_rules! opcodes { ( $( $code:literal $name:ident $docs:literal ),* ) => { #[repr(u8)] - #[derive(Clone, Copy, Eq, PartialEq)] + #[derive(Debug, Clone, Copy, Eq, PartialEq)] pub enum Opcode { $( #[doc = $docs] diff --git a/crates/sloth_vm/src/value.rs b/crates/sloth_vm/src/value.rs index 773da89..9862326 100644 --- a/crates/sloth_vm/src/value.rs +++ b/crates/sloth_vm/src/value.rs @@ -36,6 +36,7 @@ pub struct Function { pub(crate) name: Option, pub(crate) chunk: Chunk, pub(crate) arity: u8, + pub(crate) returns_value: bool, } impl Function { @@ -44,6 +45,7 @@ impl Function { name: None, chunk, arity: 0, + returns_value: false, } } } diff --git a/crates/sloth_vm/src/vm.rs b/crates/sloth_vm/src/vm.rs index cab797e..300e22e 100644 --- a/crates/sloth_vm/src/vm.rs +++ b/crates/sloth_vm/src/vm.rs @@ -107,6 +107,7 @@ impl VM { self.stack.push(value); } + Opcode::Dup => { let value = self.stack.pop(); self.stack.push(value); @@ -175,32 +176,59 @@ impl VM { self.stack.push(value); } - Opcode::Call => { - let Primitive::Object(ptr) = self.stack.pop() else { - panic!("Last element on stack was not an object"); + Opcode::Eq => { + let value = match self.stack.pop2() { + (Integer(lhs), Integer(rhs)) => Bool(lhs == rhs), + (Float(lhs), Float(rhs)) => Bool(lhs == rhs), + (Bool(lhs), Bool(rhs)) => Bool(lhs == rhs), + (Object(lhs), Object(rhs)) => Bool(lhs == rhs), + (Empty, Empty) => Bool(true), + _ => Bool(false), }; - let Some(obj) = self.objects.get(ptr as usize) else { - panic!("Pointer referenced nothing"); + self.stack.push(value); + } + Opcode::Ne => { + let value = match self.stack.pop2() { + (Integer(lhs), Integer(rhs)) => Bool(lhs != rhs), + (Float(lhs), Float(rhs)) => Bool(lhs != rhs), + (Bool(lhs), Bool(rhs)) => Bool(lhs != rhs), + (Object(lhs), Object(rhs)) => Bool(lhs != rhs), + (Empty, Empty) => Bool(false), + _ => Bool(false), }; - let ObjectType::Function(function) = &obj.typ else { - panic!("Object was not a function"); + self.stack.push(value); + } + + Opcode::Jump => { + let to = self.read_u16(); + self.call_stack.peek_mut().pointer = to as usize; + } + Opcode::JumpIf => { + let to = self.read_u16(); + let value = self.stack.pop(); + + if let Bool(true) = value { + self.call_stack.peek_mut().pointer = to as usize; + } + } + + Opcode::Call => { + let Primitive::Object(ptr) = self.stack.pop() else { + panic!("Last element on stack was not an object"); }; - // Push the function onto the call stack - self.call_stack.push(CallFrame::new(0, function)); + self.call(ptr as usize); } Opcode::Return => { - // TODO: Return values - - self.call_stack.pop(); + self.call_return(); } Opcode::Halt => return false, - _ => unimplemented!(), + opcode => unimplemented!("Opcode {:?} unimplemented", opcode), } true @@ -210,12 +238,41 @@ impl VM { while self.step() {} } - fn call(&mut self, function: &Function) { - self.call_stack.push(CallFrame { - pointer: 0, - stack_offset: self.stack.top - 1 - (function.arity as usize), - function, - }); + fn call(&mut self, ptr: usize) { + let Some(obj) = self.objects.get(ptr) else { + panic!("Pointer referenced nothing"); + }; + + let ObjectType::Function(function) = &obj.typ else { + panic!("Object was not a function"); + }; + + // Add a callstack entry for the function + let offset = self.stack.top - (function.arity as usize); + self.call_stack.push(CallFrame::new(offset, function)); + } + + fn call_return(&mut self) { + let function = self.call_stack.peek().function(); + let stack_offset = self.call_stack.peek().stack_offset; + + let return_value = if function.returns_value { + Some(self.stack.pop()) + } else { + None + }; + + self.stack.top = stack_offset; + + if let Some(return_value) = return_value { + self.stack.push(return_value); + } + + self.call_stack.pop(); + } + + fn unwind(&mut self) { + unimplemented!("Implement unwinding for error handling"); } #[inline(always)] @@ -282,37 +339,175 @@ mod tests { } #[test] - fn allocation() { + fn basic_function() { let mut vm = VM::new( - ObjectMap::from(vec![ - Object::new(ObjectType::String("Hello World!".to_owned())), - Object::new(ObjectType::String("Hello Slothlang!".to_owned())), - Object::new(ObjectType::Function(Function { - name: Some("foo".to_string()), - chunk: Chunk { - constants: vec![Primitive::Integer(7)], - code: vec![0x00, 0, 0, 0x10, 0x20, 0x52], - }, - arity: 0, - })), - ]), + ObjectMap::from(vec![Object::new(ObjectType::Function(Function { + name: Some("add".to_string()), + chunk: Chunk { + constants: vec![], + code: vec![0x14, 0, 0, 0x14, 0, 1, 0x20, 0x52], + }, + arity: 2, + returns_value: true, + }))]), Function::root(Chunk { constants: vec![ + Primitive::Integer(6), + Primitive::Integer(3), Primitive::Object(0), - Primitive::Object(1), - Primitive::Object(2), ], code: vec![ - 0x00, 0, 0, // Load constant from 0 - 0x00, 0, 1, // Load constant from 1 - 0x00, 0, 2, // Load constant from 2 - 0x50, 0xE0, + 0x00, 0, 0, // Load first function parameter from 0 + 0x00, 0, 1, // Load second function parameter from 1 + 0x00, 0, 2, // Load function constant from 2 + 0x50, // Call function ], }), ); vm.run(); - assert_eq!(vm.stack.peek(), Primitive::Integer(14)); + assert_eq!(vm.stack.peek(), Primitive::Integer(9)); + } + + #[test] + fn fibonacci() { + #[rustfmt::skip] + let mut vm = VM::new( + ObjectMap::default(), + Function::root(Chunk { + constants: vec![ + Primitive::Integer(0), + Primitive::Integer(1), + Primitive::Integer(10), + ], + code: vec![ + // Load variables + 0x00, 0, 0, // 0 Index + 0x00, 0, 0, // 3 Me + 0x00, 0, 0, // 6 Parent + 0x00, 0, 1, // 9 Grandparent + + // Load parent and grandparent, sum them and put the value in me + 0x14, 0, 2, // 12 + 0x14, 0, 3, // 15 + 0x20, // 16 + 0x15, 0, 1, // 19 + + // Set grandparent to parent + 0x14, 0, 2, // 22 + 0x15, 0, 3, // 25 + + // Set parent to me + 0x14, 0, 1, // 28 + 0x15, 0, 2, // 31 + + // Increment Index by 1 + 0x00, 0, 1, // 34 + 0x14, 0, 0, // 37 Index + 0x20, // 40 + 0x15, 0, 0, // 41 Index + + // Load me + 0x14, 0, 1, // 44 + 0xE0, // 47 + 0x11, // 48 + + // Repeat until Index is 9 + 0x00, 0, 2, // 49 + 0x14, 0, 0, // 52 Index + 0x31, // 55 + 0x41, 0, 12, // 56 + ], + }), + ); + + let mut values = Vec::new(); + for _ in 0..10 { + vm.run(); + values.push(vm.stack.peek()); + } + + assert_eq!(&values, &[ + Primitive::Integer(1), + Primitive::Integer(1), + Primitive::Integer(2), + Primitive::Integer(3), + Primitive::Integer(5), + Primitive::Integer(8), + Primitive::Integer(13), + Primitive::Integer(21), + Primitive::Integer(34), + Primitive::Integer(55), + ]); + } + + #[test] + fn fibonacci_recursive() { + #[rustfmt::skip] + let mut vm = VM::new( + ObjectMap::from(vec![Object::new(ObjectType::Function(Function { + name: Some("fib".to_owned()), + chunk: Chunk { + constants: vec![ + Primitive::Object(0), + Primitive::Integer(0), + Primitive::Integer(1), + Primitive::Integer(2), + ], + code: vec![ + 0x14, 0, 0, // 0 + 0x00, 0, 1, // 3 + 0x31, // 6 + 0x41, 0, 14, // 7 + 0x00, 0, 1, // 10 + 0x52, // 13 + + 0x14, 0, 0, // 14 + 0x00, 0, 2, // 17 + 0x31, // 20 + 0x41, 0, 28, // 21 + 0x00, 0, 2, // 24 + 0x52, // 27 + + // fib(n - 1) + 0x00, 0, 2, // 28 + 0x14, 0, 0, // 31 + 0x21, // 34 + 0x00, 0, 0, // 35 + 0x50, // 38 + + // fib(n - 2) + 0x00, 0, 3, // 39 + 0x14, 0, 0, // 42 + 0x21, // 45 + 0x00, 0, 0, // 46 + 0x50, // 49 + + // add & return + 0x20, // 50 + 0x52, // 51 + ], + }, + arity: 1, + returns_value: true, + }))]), + Function::root(Chunk { + constants: vec![ + Primitive::Object(0), + Primitive::Integer(10), + ], + code: vec![ + // Load n and the function and call it + 0x00, 0, 1, // 0 + 0x00, 0, 0, // 3 + 0x50, // 6 + ], + }), + ); + + vm.run(); + + assert_eq!(Primitive::Integer(55), vm.stack.peek()); } } -- cgit v1.2.3 From fa0da150a5a481be3d1de448edb6f23c170da9a9 Mon Sep 17 00:00:00 2001 From: Cody Date: Fri, 14 Apr 2023 00:04:46 -0500 Subject: Improved VM. Started work on std --- Cargo.lock | 73 +++++++++++++++++++++++ crates/sloth_vm/Cargo.toml | 2 + crates/sloth_vm/src/lib.rs | 1 + crates/sloth_vm/src/native.rs | 17 ++++++ crates/sloth_vm/src/sloth_std/mod.rs | 24 ++++++++ crates/sloth_vm/src/sloth_std/rand.rs | 39 +++++++++++++ crates/sloth_vm/src/sloth_std/stdio.rs | 51 ++++++++++++++++ crates/sloth_vm/src/value.rs | 2 + crates/sloth_vm/src/vm.rs | 104 ++++++++++++++++++++++++++++++--- 9 files changed, 304 insertions(+), 9 deletions(-) create mode 100644 crates/sloth_vm/src/sloth_std/mod.rs create mode 100644 crates/sloth_vm/src/sloth_std/rand.rs create mode 100644 crates/sloth_vm/src/sloth_std/stdio.rs (limited to 'crates/sloth_vm/src/value.rs') diff --git a/Cargo.lock b/Cargo.lock index fa3bcfa..b7ccbe0 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -8,12 +8,29 @@ version = "1.4.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610" +[[package]] +name = "cfg-if" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" + [[package]] name = "either" version = "1.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "90e5c1c8368803113bf0c9584fc495a58b86dc8a29edbf8fe877d21d9507e797" +[[package]] +name = "getrandom" +version = "0.2.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c85e1d9ab2eadba7e5040d4e09cbd6d072b76a557ad64e797c2cb9d4da21d7e4" +dependencies = [ + "cfg-if", + "libc", + "wasi", +] + [[package]] name = "itertools" version = "0.10.5" @@ -23,6 +40,24 @@ dependencies = [ "either", ] +[[package]] +name = "libc" +version = "0.2.141" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3304a64d199bb964be99741b7a14d26972741915b3649639149b2479bb46f4b5" + +[[package]] +name = "once_cell" +version = "1.17.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b7e5500299e16ebb147ae15a00a942af264cf3688f47923b8fc2cd5858f23ad3" + +[[package]] +name = "ppv-lite86" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de" + [[package]] name = "proc-macro2" version = "1.0.54" @@ -41,6 +76,36 @@ dependencies = [ "proc-macro2", ] +[[package]] +name = "rand" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404" +dependencies = [ + "libc", + "rand_chacha", + "rand_core", +] + +[[package]] +name = "rand_chacha" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" +dependencies = [ + "ppv-lite86", + "rand_core", +] + +[[package]] +name = "rand_core" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" +dependencies = [ + "getrandom", +] + [[package]] name = "sloth" version = "0.1.0" @@ -60,6 +125,8 @@ dependencies = [ name = "sloth_vm" version = "0.1.0" dependencies = [ + "once_cell", + "rand", "sloth_bytecode", ] @@ -99,3 +166,9 @@ name = "unicode-ident" version = "1.0.8" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e5464a87b239f13a63a501f2701565754bae92d243d4bb7eb12f6d57d2269bf4" + +[[package]] +name = "wasi" +version = "0.11.0+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" diff --git a/crates/sloth_vm/Cargo.toml b/crates/sloth_vm/Cargo.toml index 1b1b6fe..f484402 100644 --- a/crates/sloth_vm/Cargo.toml +++ b/crates/sloth_vm/Cargo.toml @@ -8,3 +8,5 @@ edition.workspace = true [dependencies] sloth_bytecode = { path = "../sloth_bytecode" } +once_cell = "1.17.1" +rand = "0.8.5" diff --git a/crates/sloth_vm/src/lib.rs b/crates/sloth_vm/src/lib.rs index 121ea6a..295827d 100644 --- a/crates/sloth_vm/src/lib.rs +++ b/crates/sloth_vm/src/lib.rs @@ -8,6 +8,7 @@ )] pub mod native; +pub mod sloth_std; pub mod value; pub mod vm; diff --git a/crates/sloth_vm/src/native.rs b/crates/sloth_vm/src/native.rs index 8b13789..8790cbd 100644 --- a/crates/sloth_vm/src/native.rs +++ b/crates/sloth_vm/src/native.rs @@ -1 +1,18 @@ +use crate::value::Primitive; +use crate::VM; +pub type NativeFunctionResult = Result; +pub type NativeFunctionInput = fn(&mut VM, &[Primitive]) -> NativeFunctionResult; + +pub enum Error { + InvalidArgument, + Unknown(String), +} + +#[allow(clippy::type_complexity)] +pub struct NativeFunction { + pub name: &'static str, + pub function: NativeFunctionInput, + pub arity: u8, + pub returns_value: bool, +} diff --git a/crates/sloth_vm/src/sloth_std/mod.rs b/crates/sloth_vm/src/sloth_std/mod.rs new file mode 100644 index 0000000..86611d7 --- /dev/null +++ b/crates/sloth_vm/src/sloth_std/mod.rs @@ -0,0 +1,24 @@ +use std::collections::HashMap; + +use once_cell::sync::Lazy; + +use crate::native::NativeFunction; + +pub mod rand; +pub mod stdio; + +pub static NATIVE_LIBRARY: Lazy> = Lazy::new(|| { + let mut map = HashMap::new(); + + // rand + map.insert("rand$gen", rand::GEN_FUNCTION); + map.insert("rand$gen_range", rand::GEN_RANGE_FUNCTION); + + // stdio + map.insert("write", stdio::WRITE_FUNCTION); + map.insert("read", stdio::READ_FUNCTION); + + // filesystem + + map +}); diff --git a/crates/sloth_vm/src/sloth_std/rand.rs b/crates/sloth_vm/src/sloth_std/rand.rs new file mode 100644 index 0000000..bae0606 --- /dev/null +++ b/crates/sloth_vm/src/sloth_std/rand.rs @@ -0,0 +1,39 @@ +use rand::Rng; + +use crate::native::{self, NativeFunction, NativeFunctionResult}; +use crate::value::Primitive; +use crate::value::Primitive::{Float, Integer}; +use crate::VM; + +fn gen(_vm: &mut VM, _args: &[Primitive]) -> NativeFunctionResult { + let value = rand::thread_rng().gen_range(0.0..1.0); + + Ok(Float(value)) +} + +pub const GEN_FUNCTION: NativeFunction = NativeFunction { + name: "rand$gen", + function: gen, + arity: 0, + returns_value: true, +}; + +fn gen_range(_vm: &mut VM, args: &[Primitive]) -> NativeFunctionResult { + let min = args.get(0).cloned(); + let max = args.get(1).cloned(); + + let (Some(Integer(min)), Some(Integer(max))) = (min, max) else { + return Err(native::Error::InvalidArgument); + }; + + let value = rand::thread_rng().gen_range(min..max); + + Ok(Integer(value)) +} + +pub const GEN_RANGE_FUNCTION: NativeFunction = NativeFunction { + name: "rand$gen_range", + function: gen_range, + arity: 2, + returns_value: true, +}; diff --git a/crates/sloth_vm/src/sloth_std/stdio.rs b/crates/sloth_vm/src/sloth_std/stdio.rs new file mode 100644 index 0000000..a743ad1 --- /dev/null +++ b/crates/sloth_vm/src/sloth_std/stdio.rs @@ -0,0 +1,51 @@ +use std::io::{stdin, BufRead}; + +use crate::native::{self, NativeFunction, NativeFunctionResult}; +use crate::value::{Object, ObjectType, Primitive}; +use crate::VM; + +fn write(vm: &mut VM, args: &[Primitive]) -> NativeFunctionResult { + let Some(Primitive::Object(ptr)) = args.get(0).cloned() else { + return Err(native::Error::InvalidArgument); + }; + + let object = vm + .objects() + .get(ptr as usize) + .ok_or(native::Error::InvalidArgument)?; + + let ObjectType::String(str) = &object.typ else { + return Err(native::Error::InvalidArgument); + }; + + println!("{str}"); + + Ok(Primitive::Empty) +} + +pub const WRITE_FUNCTION: NativeFunction = NativeFunction { + name: "write", + function: write, + arity: 1, + returns_value: false, +}; + +fn read(vm: &mut VM, _args: &[Primitive]) -> NativeFunctionResult { + let mut line = String::new(); + stdin() + .lock() + .read_line(&mut line) + .map_err(|it| native::Error::Unknown(it.to_string()))?; + + let object = Object::new(ObjectType::String(line)); + let ptr = vm.objects_mut().allocate(object); + + Ok(Primitive::Object(ptr as u32)) +} + +pub const READ_FUNCTION: NativeFunction = NativeFunction { + name: "read", + function: read, + arity: 0, + returns_value: true, +}; diff --git a/crates/sloth_vm/src/value.rs b/crates/sloth_vm/src/value.rs index 9862326..f149c0e 100644 --- a/crates/sloth_vm/src/value.rs +++ b/crates/sloth_vm/src/value.rs @@ -1,3 +1,4 @@ +use crate::native::NativeFunction; use crate::Chunk; #[derive(Debug, Clone, Copy, PartialEq)] @@ -28,6 +29,7 @@ pub enum ObjectType { List(Vec), Function(Function), + NativeFunction(NativeFunction), Free { next: usize }, } diff --git a/crates/sloth_vm/src/vm.rs b/crates/sloth_vm/src/vm.rs index 300e22e..2d58c3d 100644 --- a/crates/sloth_vm/src/vm.rs +++ b/crates/sloth_vm/src/vm.rs @@ -3,7 +3,7 @@ use std::mem::MaybeUninit; use sloth_bytecode::Opcode; use crate::value::{Function, Object, ObjectType, Primitive}; -use crate::{ObjectMap, Stack}; +use crate::{native, ObjectMap, Stack}; #[derive(Clone, Copy)] pub struct CallFrame { @@ -238,18 +238,47 @@ impl VM { while self.step() {} } - fn call(&mut self, ptr: usize) { + pub fn call(&mut self, ptr: usize) { let Some(obj) = self.objects.get(ptr) else { panic!("Pointer referenced nothing"); }; - let ObjectType::Function(function) = &obj.typ else { - panic!("Object was not a function"); - }; + match &obj.typ { + ObjectType::Function(function) => { + // Add a callstack entry for the function + let offset = self.stack.top - (function.arity as usize); + self.call_stack.push(CallFrame::new(offset, function)); + } + ObjectType::NativeFunction(function) => { + let mut args = Vec::with_capacity(function.arity as usize); + for _ in 0..function.arity { + args.push(self.stack.pop()); + } - // Add a callstack entry for the function - let offset = self.stack.top - (function.arity as usize); - self.call_stack.push(CallFrame::new(offset, function)); + let name = function.name; + let returns_value = function.returns_value; + + let internal = function.function; + let result = internal(self, &args); + + match result { + Ok(value) => { + if returns_value { + self.stack.push(value); + } + } + Err(error) => match error { + native::Error::InvalidArgument => { + panic!("Invalid argument provided to '{name}'"); + } + native::Error::Unknown(msg) => { + panic!("Native function '{name}' failed due to '{msg}'"); + } + }, + } + } + _ => panic!("Object was not a function"), + } } fn call_return(&mut self) { @@ -295,12 +324,22 @@ impl VM { ((bytes.0 as u16) << 8) + (bytes.1 as u16) } + + #[inline(always)] + pub fn objects(&self) -> &ObjectMap { + &self.objects + } + + #[inline(always)] + pub fn objects_mut(&mut self) -> &mut ObjectMap { + &mut self.objects + } } #[cfg(test)] mod tests { use crate::value::{Function, Object, ObjectType, Primitive}; - use crate::{Chunk, ObjectMap, VM}; + use crate::{sloth_std, Chunk, ObjectMap, VM}; #[test] fn arithmetic_ops() { @@ -355,6 +394,8 @@ mod tests { Primitive::Integer(6), Primitive::Integer(3), Primitive::Object(0), + Primitive::Object(1), + Primitive::Object(2), ], code: vec![ 0x00, 0, 0, // Load first function parameter from 0 @@ -370,6 +411,51 @@ mod tests { assert_eq!(vm.stack.peek(), Primitive::Integer(9)); } + #[test] + fn native_function() { + let mut vm = VM::new( + ObjectMap::from(vec![ + Object::new(ObjectType::NativeFunction(sloth_std::rand::GEN_FUNCTION)), + Object::new(ObjectType::NativeFunction( + sloth_std::rand::GEN_RANGE_FUNCTION, + )), + ]), + Function::root(Chunk { + constants: vec![ + Primitive::Object(0), + Primitive::Object(1), + Primitive::Integer(5), + Primitive::Integer(10), + ], + code: vec![ + // First part + 0x00, 0, 0, // + 0x50, // + 0xE0, // + // Second part + 0x00, 0, 3, // + 0x00, 0, 2, // + 0x00, 0, 1, // + 0x50, // + ], + }), + ); + + vm.run(); + + assert!({ + let Primitive::Float(i) = vm.stack.peek() else { panic!(); }; + (0.0..=1.0).contains(&i) + }); + + vm.run(); + + assert!({ + let Primitive::Integer(i) = vm.stack.peek() else { panic!(); }; + (5..10).contains(&i) + }); + } + #[test] fn fibonacci() { #[rustfmt::skip] -- cgit v1.2.3