Everything compiling and testing successfully.

dm_lib/std/core/array.dm

@@ -12,7 +12,7 @@ pub int Array<T> : Monad + Default + Empty {
 
 impl ArrayImpl<T> : Array<T> {
 
-    fld pointer: Pointer<T>
+    fld pointer: Pointer
     fld length: Int
 
     pub unsafe ctor(length: Int) {
@@ -20,12 +20,12 @@ impl ArrayImpl<T> : Array<T> {
         self.length = length
     }
     
-    pub ctor(pointer: Pointer<T>, length: Int) {
+    pub ctor(pointer: Pointer, length: Int) {
         self.pointer = pointer
         self.length = length
     }
     
-    pub unsafe fn set(index: Int, item: Pointer<T>) {
+    pub unsafe fn set(index: Int, item: Pointer) {
         pointer.offset(index * T::size()).write(item.read())
     }
 

dm_lib/std/core/string.dm

@@ -13,8 +13,7 @@ pub int String : Display {
 
 }
 
-impl Utf8String(bytes: Array<Byte>) : String {
+impl StringImpl(bytes: Array<Byte>, /* encoding: Encoding */) {
-    encoding = Encoding::Utf8
     length = bytes.length
     characters = lazy {
         todo('parse the utf8 bytes and return an Array<Character>')
@@ -27,6 +26,6 @@ pub mod string {
     // let bytes = array::of(0x64, 0x65, 0x69, 0x6d, 0x6f, 0x73)
     // let s = string::from_utf8_bytes(bytes)
     // println s // "deimos"
-    fn from_utf8_bytes(bytes: Array<Byte>): String = Utf8String(bytes)
+    fn from_utf8_bytes(bytes: Array<Byte>): String = StringImpl(bytes, /* Encoding::Utf8 */)
 
 }

dm_lib/std/unsafe/mem.dm

@@ -1,18 +1,14 @@
 ns std::unsafe
 
-pub int Pointer<T> {}
+pub int Pointer
 
-impl PointerImpl<T> {
+// Contains two fields:
-
+//   fld raw_address: Long
-    fld raw_address: Long
+//   fld size: Long
-    fld size: Long
+decl impl PointerImpl(size: Long) : Pointer
-
-    decl ctor(size: Long)
-
-}
 
 pub mod mem {
 
-    pub fn <T> alloc(size: Long): Pointer<T> = PointerImpl(size)
+    pub fn alloc(size: Long): Pointer = PointerImpl(size)
 
 }

src/bin/dvm/main.rs

@@ -2,11 +2,10 @@ use deimos::vm::dm_type::DmType;
 use deimos::vm::lib::{DmConstant, DmLib};
 use deimos::vm::object_type::{DmField, DmFn, DmImplementation, DmInterface, DmMethod};
 use deimos::vm::op_codes::{
-    add_alloc, add_alloc_raw_from, add_invoke_fn, add_invoke_method, add_mov_const,
+    add_alloc, add_alloc_raw_from, add_invoke_fn, add_mov_const, add_mov_register_to,
-    add_mov_register_to, add_mov_size_of, add_multiply, add_platform_call, add_ret,
+    add_mov_size_of, add_multiply, add_platform_call,
-    add_ret_register,
 };
-use deimos::vm::DmVirtualMachine;
+use deimos::vm::{call_fn, DvmContext, DvmState};
 use std::rc::Rc;
 
 fn main() {
@@ -16,61 +15,62 @@ fn main() {
     // fn main() { println "Hello, World!" }
 
     // std/unsafe/mem lib
-    let mut unsafe_mem_lib = DmLib::new("std/unsafe/mem");
+    let mut mem_lib = DmLib::new("std/unsafe/mem");
 
     // std::unsafe::Pointer
-    let unsafe_pointer_int = DmInterface::new("std::unsafe::Pointer", "Pointer");
+    let pointer_int = DmInterface::new("std::unsafe::Pointer", "Pointer");
-    let unsafe_pointer_rc = Rc::new(unsafe_pointer_int);
+    let pointer_int_rc = Rc::new(pointer_int);
 
     // std::unsafe::PointerImpl : Pointer
-    let mut unsafe_pointer_impl = DmImplementation::new(
+    let mut pointer_impl = DmImplementation::new(
         "std::unsafe:PointerImpl",
         "PointerImpl",
-        Some(unsafe_pointer_rc.clone()),
+        Some(pointer_int_rc.clone()),
     );
 
-    let raw_address_field = DmField::new("raw_address", DmType::Long, 0);
+    let pointer_impl_raw_address = DmField::new("raw_address", DmType::Long, 0);
-    let size_field = DmField::new("size", DmType::Long, 8);
+    let pointer_impl_size = DmField::new("size", DmType::Long, 8);
 
-    // std::unsafe::Pointer::_ctor_0(
+    // std::unsafe::PointerImpl::_ctor_0(
     //   r0: self
     //   r1: size Long
     // )
     // r2: raw_address Long
-    let mut unsafe_pointer_ctor_0_bytecode: Vec<u8> = Vec::new();
+    let mut pointer_impl_ctor_0_code: Vec<u8> = Vec::new();
-    add_alloc_raw_from(&mut unsafe_pointer_ctor_0_bytecode, 2, 1);
+    add_alloc_raw_from(&mut pointer_impl_ctor_0_code, 2, 1);
     add_mov_register_to(
-        &mut unsafe_pointer_ctor_0_bytecode,
+        &mut pointer_impl_ctor_0_code,
         0,
-        raw_address_field.data_offset() as u32,
+        pointer_impl_raw_address.data_offset() as u32,
         2,
     );
     add_mov_register_to(
-        &mut unsafe_pointer_ctor_0_bytecode,
+        &mut pointer_impl_ctor_0_code,
         0,
-        size_field.data_offset() as u32,
+        pointer_impl_size.data_offset() as u32,
         1,
     );
 
-    let unsafe_pointer_init_fn = DmFn::new(
+    let pointer_impl_ctor_0_fn = DmFn::new(
         "std::unsafe::PointerImpl::_ctor_0",
         "_ctor_0",
-        unsafe_pointer_ctor_0_bytecode,
+        pointer_impl_ctor_0_code,
         3,
+        None,
     );
 
-    let unsafe_pointer_init_method = DmMethod::new(unsafe_pointer_init_fn, None);
+    let pointer_impl_ctor_0_method = DmMethod::new(pointer_impl_ctor_0_fn, None);
 
-    unsafe_pointer_impl.fields.push(raw_address_field);
+    pointer_impl.fields.push(pointer_impl_raw_address);
-    unsafe_pointer_impl.fields.push(size_field);
+    pointer_impl.fields.push(pointer_impl_size);
-    unsafe_pointer_impl
+    pointer_impl
         .methods
-        .push(Rc::new(unsafe_pointer_init_method));
+        .push(Rc::new(pointer_impl_ctor_0_method));
 
-    let unsafe_pointer_impl_rc = Rc::new(unsafe_pointer_impl);
+    let unsafe_pointer_impl_rc = Rc::new(pointer_impl);
 
-    unsafe_mem_lib.interfaces.push(unsafe_pointer_rc.clone());
+    mem_lib.interfaces.push(pointer_int_rc.clone());
-    unsafe_mem_lib
+    mem_lib
         .implementations
         .push(unsafe_pointer_impl_rc.clone());
 
@@ -79,39 +79,44 @@ fn main() {
     // )
     // r0: size Long
     // r1: Pointer object
+    // r2: Void from PointerImpl::_ctor_0
     // @return r1
-    let mut alloc_fn_byte_code: Vec<u8> = Vec::new();
+    let mut alloc_fn_code: Vec<u8> = Vec::new();
     add_alloc(
-        &mut alloc_fn_byte_code,
+        &mut alloc_fn_code,
         1,
         unsafe_pointer_impl_rc.size_in_bytes() as u32,
         "std::unsafe::PointerImpl",
     );
-    add_invoke_method(
+    add_invoke_fn(
-        &mut alloc_fn_byte_code,
+        &mut alloc_fn_code,
-        "std::unsafe::Pointer::_ctor_0",
+        "std::unsafe::PointerImpl::_ctor_0",
+        2,
         &[1u8, 0u8],
     );
-    add_ret_register(&mut alloc_fn_byte_code, 1);
 
-    let alloc_fn = DmFn {
+    let alloc_fn = DmFn::new(
-        fqn: "std::unsafe::mem::alloc".to_string(),
+        "std::unsafe::mem::alloc",
-        short_name: "alloc".to_string(),
+        "alloc",
-        byte_code: alloc_fn_byte_code,
+        alloc_fn_code,
-        number_used_registers: 2,
+        3,
-    };
+        Some(1),
+    );
 
-    unsafe_mem_lib.functions.push(Rc::new(alloc_fn));
+    mem_lib.functions.push(Rc::new(alloc_fn));
+
+    // std/core/array lib
+    let mut array_lib = DmLib::new("std/core/array");
 
     // std::core::Array
-    let core_array_int = DmInterface::new("std::core::Array", "Array");
+    let array_int = DmInterface::new("std::core::Array", "Array");
-    let core_array_int_rc = Rc::new(core_array_int);
+    let array_int_rc = Rc::new(array_int);
 
     // std::core::ArrayImpl
-    let mut core_array_impl = DmImplementation::new(
+    let mut array_impl = DmImplementation::new(
         "std::core::ArrayImpl",
         "ArrayImpl",
-        Some(core_array_int_rc.clone()),
+        Some(array_int_rc.clone()),
     );
 
     let array_impl_pointer_fld = DmField::new("pointer", DmType::Pointer, 0);
@@ -153,16 +158,18 @@ fn main() {
         "_ctor_0",
         array_impl_ctor_0_bytecode,
         6,
+        None,
     );
     let array_impl_ctor_0_method = DmMethod::new(array_impl_ctor_0_fn, None);
-    core_array_impl
+    array_impl.methods.push(Rc::new(array_impl_ctor_0_method));
-        .methods
+
-        .push(Rc::new(array_impl_ctor_0_method));
+    // Add Array and ArrayImpl to array lib
+    array_lib.interfaces.push(array_int_rc.clone());
+    array_lib.implementations.push(Rc::new(array_impl));
 
     // std::core::String
-
+    let mut string_lib = DmLib::new("std/core/string");
-    let mut core_string_lib = DmLib::new("std/core/string");
+    let mut string_impl = DmImplementation::new("std::core::String", "String", None);
-    let mut core_string_impl = DmImplementation::new("std::core::String", "String", None);
 
     let bytes_field = DmField::new("bytes", DmType::Pointer, 0);
 
@@ -170,31 +177,31 @@ fn main() {
     //   r0: self
     //   r1: DvmPointer to Array<Byte>
     // )
-    let mut core_string_ctor_0_bytecode: Vec<u8> = Vec::new();
+    let mut string_ctor_0_bytecode: Vec<u8> = Vec::new();
     add_mov_register_to(
-        &mut core_string_ctor_0_bytecode,
+        &mut string_ctor_0_bytecode,
         0,
         bytes_field.data_offset() as u32,
         1,
     );
 
-    let core_string_ctor_0_fn = DmFn {
+    let string_ctor_0_fn = DmFn::new(
-        fqn: "std::core::String::_ctor_0".to_string(),
+        "std::core::String::_ctor_0",
-        short_name: "_ctor_0".to_string(),
+        "_ctor_0",
-        byte_code: core_string_ctor_0_bytecode,
+        string_ctor_0_bytecode,
-        number_used_registers: 2,
+        2,
-    };
+        None,
+    );
 
-    let core_string_ctor_0_method = DmMethod::new(core_string_ctor_0_fn, None);
+    let string_ctor_0_method = DmMethod::new(string_ctor_0_fn, None);
 
-    core_string_impl.fields.push(bytes_field);
+    string_impl.fields.push(bytes_field);
-    core_string_impl.methods.push(Rc::new(core_string_ctor_0_method));
+    string_impl.methods.push(Rc::new(string_ctor_0_method));
-    let core_string_impl_size = core_string_impl.size_in_bytes();
+    let core_string_impl_size = string_impl.size_in_bytes();
 
-    core_string_lib
+    string_lib.implementations.push(Rc::new(string_impl));
-        .implementations
-        .push(Rc::new(core_string_impl));
 
+    // greeting lib
     let mut greeting_lib = DmLib::new("greeting");
     greeting_lib
         .constants
@@ -202,9 +209,9 @@ fn main() {
 
     let mut main_byte_code = Vec::new();
 
-    // 1. Move constant: r0 receives DvmValue::Pointer to Array<Byte>
+    // 1. Move constant: r0 receives DvmValue::Pointer to ArrayImpl<Byte>
-    // 2. Allocate for std::core::String into r1
+    // 2. Allocate for std::core::StringImpl into r1
-    // 3. Call String::_ctor_0(r0) -> r2
+    // 3. Call StringImpl::_ctor_0(r0) -> r2
     // 4. Platform call std::core::println(r1) -> r3
     add_alloc(
         &mut main_byte_code,
@@ -213,21 +220,22 @@ fn main() {
         "std::core::String",
     );
     add_mov_const(&mut main_byte_code, 1, "greeting", 0);
-    add_invoke_method(&mut main_byte_code, "std::core::String::_init_0", &[0, 1]);
+    add_invoke_fn(
-    add_platform_call(&mut main_byte_code, "std::core::println", 0, 1, &vec![0u8]);
+        &mut main_byte_code,
+        "std::core::StringImpl::_ctor_0",
+        2,
+        &[0, 1],
+    );
+    add_platform_call(&mut main_byte_code, "std::core::println", 3, 1, &vec![0u8]);
 
-    let main_dm_fn = DmFn {
+    let main_dm_fn = DmFn::new("main", "main", main_byte_code, 2, None);
-        fqn: "default::main".to_string(),
-        short_name: "main".to_string(),
-        byte_code: main_byte_code,
-        number_used_registers: 2,
-    };
 
     greeting_lib.functions.push(Rc::new(main_dm_fn));
 
-    let mut vm = DmVirtualMachine::new(vec![greeting_lib, core_string_lib]);
+    let mut state = DvmState::new();
-    let main_fn = vm
+    let mut context = DvmContext::new();
-        .get_fn_by_fqn("default::main")
+    context.load_functions(&vec![greeting_lib, string_lib, mem_lib]);
-        .expect("Could not find function: default::main");
+
-    vm.call_fn(&main_fn, Vec::new());
+    let main_fn = context.fn_by_fqn("main").unwrap();
+    call_fn(&mut state, &context, &main_fn, vec![]);
 }

src/vm/dvm_value.rs

@@ -9,5 +9,24 @@ pub enum DvmValue {
     Double(f64),
     Boolean(bool),
     Pointer(Rc<DmAllocObject>),
-    Unit,
+    Uninit,
+    Void,
+}
+
+impl DvmValue {
+    pub fn expect_long(&self) -> i64 {
+        if let DvmValue::Long(l) = self {
+            *l
+        } else {
+            panic!("Expected DvmValue::long, but found {:?}", self)
+        }
+    }
+
+    pub fn expect_pointer(&self) -> Rc<DmAllocObject> {
+        if let DvmValue::Pointer(p) = self {
+            p.clone()
+        } else {
+            panic!("Expected DvmValue::Pointer, but found {:?}", self);
+        }
+    }
 }

src/vm/lib/mod.rs

@@ -26,6 +26,7 @@ impl DmLib {
     }
 }
 
+#[derive(Debug)]
 pub enum DmConstant {
     String(String),
 }

src/vm/mem.rs

@@ -1,17 +1,40 @@
 use crate::vm::dm_type::DmType;
 use crate::vm::dvm_value::DvmValue;
 use crate::vm::object_type::{DmField, DmImplementation};
-use std::alloc::Layout;
+use std::alloc::{alloc, dealloc, Layout};
+use std::collections::HashSet;
 use std::rc::Rc;
 
 #[derive(Debug, PartialEq, Eq)]
 pub struct DmAllocObject {
     pub data: *mut u8,
+    pub units: HashSet<usize>,
     pub size: usize,
     pub layout: Layout,
     pub implementation: Rc<DmImplementation>,
 }
 
+impl DmAllocObject {
+    pub fn new(size: usize, implementation: Rc<DmImplementation>) -> Self {
+        let layout = Layout::from_size_align(size, 1).unwrap();
+        DmAllocObject {
+            data: unsafe { alloc(layout) },
+            units: HashSet::new(),
+            size,
+            layout,
+            implementation,
+        }
+    }
+}
+
+impl Drop for DmAllocObject {
+    fn drop(&mut self) {
+        unsafe {
+            dealloc(self.data, self.layout);
+        }
+    }
+}
+
 pub unsafe fn get_field_value(dm_field: &DmField, self_object: &DmAllocObject) -> DvmValue {
     let data_size = dm_field.dm_type().size_in_bytes();
     let mut raw_data: Vec<u8> = Vec::with_capacity(data_size);
@@ -29,13 +52,13 @@ pub unsafe fn get_field_value(dm_field: &DmField, self_object: &DmAllocObject) -
         DmType::Double => DvmValue::Double(f64::from_ne_bytes(
             raw_data[0..data_size].try_into().unwrap(),
         )),
-        DmType::Boolean => DvmValue::Boolean(raw_data[0] == 1),
+        DmType::Boolean => DvmValue::Boolean(raw_data[0] != 0),
         DmType::Pointer => {
             // read the pointer's (address) value
             let address = usize::from_ne_bytes(raw_data[0..data_size].try_into().unwrap());
             DvmValue::Pointer(Rc::from_raw(address as *const DmAllocObject))
         }
-        DmType::Unit => DvmValue::Unit,
+        DmType::Unit => DvmValue::Uninit,
     }
 }
 

src/vm/mod.rs

@@ -11,381 +11,583 @@ use crate::vm::dvm_value::DvmValue;
 use crate::vm::lib::{DmConstant, DmLib};
 use crate::vm::mem::{get_field_value, DmAllocObject};
 use crate::vm::object_type::DmFn;
-use crate::vm::platform::init_platform_functions;
 use op_codes::*;
-use std::alloc::{alloc, Layout};
+use std::alloc::{alloc, dealloc, Layout};
 use std::collections::HashMap;
 use std::rc::Rc;
-use util::{get_32_le, get_64_le};
 
-pub type PlatformFunction = fn(args: Vec<DvmValue>, &mut DmVirtualMachine) -> DvmValue;
+pub type PlatformFunction =
+    fn(args: Vec<DvmValue>, state: &mut DvmState, context: &DvmContext) -> DvmValue;
 
 enum CallFrame {
-    PlatformCall(PlatformCallFrame),
+    PlatformCall(CallFrameInfo),
-    DeimosCall(DeimosCallFrame),
+    DeimosCall(CallFrameInfo),
 }
 
-pub struct PlatformCallFrame {
+struct CallFrameInfo {
-    pub name: String,
+    fn_fqn: String,
-    pub args: Vec<DvmValue>,
 }
 
-struct DeimosCallFrame {
+pub struct DvmContext {
-    return_address: usize,
-}
-
-pub struct DmVirtualMachine {
     libs: Vec<DmLib>,
     functions: HashMap<String, Rc<DmFn>>,
-    platform_functions: HashMap<String, PlatformFunction>,
+    platform_functions: HashMap<String, Rc<PlatformFunction>>,
-    ip: usize,
-    call_stack: Vec<CallFrame>,
-    registers: Vec<DvmValue>,
-    register_state_stack: Vec<Vec<DvmValue>>,
 }
 
-fn load_functions(destination: &mut HashMap<String, Rc<DmFn>>, libs: &Vec<DmLib>) {
+impl DvmContext {
-    for module in libs {
+    pub fn new() -> Self {
-        for lib_fn in &module.functions {
+        DvmContext {
-            destination.insert(lib_fn.fqn.clone(), lib_fn.clone());
+            libs: Vec::new(),
+            functions: HashMap::new(),
+            platform_functions: HashMap::new(),
         }
-        for interface_function in module
+    }
+
+    pub fn load_functions(&mut self, libs: &Vec<DmLib>) {
+        for lib in libs {
+            for lib_fn in &lib.functions {
+                self.functions
+                    .insert(lib_fn.fqn().to_string(), lib_fn.clone());
+            }
+            for interface_function in lib
                 .interfaces
                 .iter()
                 .flat_map(|interface| interface.get_functions())
             {
-            destination.insert(interface_function.fqn.clone(), interface_function.clone());
+                self.functions.insert(
+                    interface_function.fqn().to_string(),
+                    interface_function.clone(),
+                );
             }
-        for implementation_function in module
+            for implementation_function in lib
                 .implementations
                 .iter()
                 .flat_map(|implementation| &implementation.functions)
             {
-            destination.insert(
+                self.functions.insert(
-                implementation_function.fqn.clone(),
+                    implementation_function.fqn().to_string(),
                     implementation_function.clone(),
                 );
             }
         }
     }
 
-impl DmVirtualMachine {
+    pub fn fn_by_fqn(&self, fqn: &str) -> Option<Rc<DmFn>> {
-    pub fn new(libs: Vec<DmLib>) -> DmVirtualMachine {
-        let mut vm = DmVirtualMachine {
-            libs: libs,
-            functions: HashMap::new(),
-            platform_functions: init_platform_functions(),
-            ip: 0,
-            registers: Vec::new(),
-            call_stack: Vec::new(),
-            register_state_stack: Vec::new(),
-        };
-        load_functions(&mut vm.functions, &vm.libs);
-        vm
-    }
-
-    pub fn get_fn_by_fqn(&self, fqn: &str) -> Option<Rc<DmFn>> {
         self.functions.get(fqn).cloned()
     }
 
-    pub fn call_fn(&mut self, dm_function: &DmFn, args: Vec<DvmValue>) -> Option<DvmValue> {
+    pub fn platform_fn_by_fqn(&self, fqn: &str) -> Option<Rc<PlatformFunction>> {
+        self.platform_functions.get(fqn).cloned()
+    }
+}
+
+pub struct DvmState {
+    call_stack: Vec<CallFrame>,
+    registers: Vec<DvmValue>,
+    register_state_stack: Vec<Vec<DvmValue>>,
+}
+
+impl DvmState {
+    pub fn new() -> Self {
+        DvmState {
+            call_stack: Vec::new(),
+            registers: Vec::new(),
+            register_state_stack: Vec::new(),
+        }
+    }
+}
+
+pub fn call_fn(
+    state: &mut DvmState,
+    context: &DvmContext,
+    dm_fn: &DmFn,
+    args: Vec<DvmValue>,
+) -> DvmValue {
     // save current state
-        self.call_stack.push(CallFrame::DeimosCall(DeimosCallFrame {
+    state.call_stack.push(CallFrame::DeimosCall(CallFrameInfo {
-            return_address: self.ip,
+        fn_fqn: dm_fn.fqn().to_string(),
     }));
-        self.register_state_stack.push(self.registers.clone());
+    state.register_state_stack.push(state.registers.clone());
 
     // zero registers and make sure there are enough for dm_function
-        self.registers.clear();
+    state.registers.clear();
-        if self.registers.len() < args.len() {
+    if state.registers.len() < dm_fn.number_used_registers() {
-            self.registers.resize(args.len(), DvmValue::Unit);
+        state
+            .registers
+            .resize(dm_fn.number_used_registers(), DvmValue::Uninit);
     }
 
     // push args
-        for i in 0..args.len() {
+    for arg in args {
-            self.registers.insert(i, args[i].clone());
+        state.registers.push(arg);
     }
 
     // run the byte code
-        self.run_raw(&dm_function.byte_code);
+    run_byte_code(state, context, &dm_fn.byte_code());
 
     // restore state
-        self.registers = self.register_state_stack.pop().unwrap();
+    state.registers = state.register_state_stack.pop().unwrap();
-        if let CallFrame::DeimosCall(deimos_call_frame) = self.call_stack.pop().unwrap() {
+    state.call_stack.pop();
-            self.ip = deimos_call_frame.return_address;
+
+    // get return value
+    if let Some(return_register) = dm_fn.return_register() {
+        state
+            .registers
+            .get(return_register as usize)
+            .map(|m| m.clone())
+            .unwrap()
+    } else {
+        DvmValue::Void
+    }
 }
 
-        // return result
+macro_rules! next_8 {
-        self.registers.get(0).map(|x| x.clone())
+    ( $byte_code: expr, $T: ident ) => {
+        $byte_code.next().unwrap() as $T
+    };
 }
 
-    pub fn run_raw(&mut self, code: &Vec<u8>) {
+macro_rules! next_32_le {
+    ( $byte_code: expr, $T: ident ) => {
+        next_8!($byte_code, $T)
+            + (next_8!($byte_code, $T) << 8)
+            + (next_8!($byte_code, $T) << 16)
+            + (next_8!($byte_code, $T) << 24)
+    };
+}
+
+macro_rules! next_64_le {
+    ( $byte_code: expr, $T: ident ) => {
+        next_8!($byte_code, $T)
+            + (next_8!($byte_code, $T) << 8)
+            + (next_8!($byte_code, $T) << 16)
+            + (next_8!($byte_code, $T) << 24)
+            + (next_8!($byte_code, $T) << 32)
+            + (next_8!($byte_code, $T) << 40)
+            + (next_8!($byte_code, $T) << 48)
+            + (next_8!($byte_code, $T) << 56)
+    };
+}
+
+macro_rules! read_array_u8 {
+    ( $iter: expr ) => {{
+        let arr_length = next_8!($iter, u8);
+        let mut arr = Vec::with_capacity(arr_length as usize);
         let mut i = 0;
-        while i < code.len() {
+        while i < arr_length {
-            let op_code = code[i];
+            arr.push(next_8!($iter, u8));
-            println!("op_code: {:#04x}", op_code);
+            i += 1;
-            match code[i] {
+        }
+        arr
+    }};
+}
+
+macro_rules! read_string {
+    ( $iter: expr ) => {{
+        let str_length = next_32_le!($iter, usize);
+        let mut str_raw: Vec<u8> = Vec::new();
+        let mut i = 0;
+        while i < str_length {
+            str_raw.push($iter.next().unwrap());
+            i += 1;
+        }
+        String::from_utf8(str_raw).unwrap()
+    }};
+}
+
+macro_rules! write_string {
+    ( $raw_ptr: expr, $s: expr ) => {
+        for (i, b) in $s.bytes().enumerate() {
+            unsafe {
+                $raw_ptr.add(i).write(b);
+            }
+        }
+    };
+}
+
+macro_rules! write_bytes {
+    ( $ptr: expr, $offset: expr, $src: expr ) => {
+        for (i, &b) in $src.iter().enumerate() {
+            unsafe {
+                $ptr.add($offset + i).write(b);
+            }
+        }
+    };
+}
+
+pub fn run_byte_code(state: &mut DvmState, context: &DvmContext, byte_code: &[u8]) {
+    let mut iter = byte_code.iter().cloned();
+    while let Some(op_code) = iter.next() {
+        match op_code {
             MOV_INT => {
-                    let target_register = code[i + 1] as usize;
+                let target_register = next_8!(iter, usize);
-                    let operand = get_32_le!(code, i, 2, u32);
+                let operand = next_32_le!(iter, u32) as i32;
-                    self.registers
+                state
-                        .insert(target_register, DvmValue::Int(operand as i32));
+                    .registers
-                    i += 6;
+                    .insert(target_register, DvmValue::Int(operand));
             }
             MOV_LONG => {
-                    let target_register = code[i + 1] as usize;
+                let target_register = next_8!(iter, usize);
-                    let operand = get_64_le!(code, i, 2, u64);
+                let operand = next_64_le!(iter, u64) as i64;
-                    self.registers
+                state
-                        .insert(target_register, DvmValue::Long(operand as i64));
+                    .registers
-                    i += 10;
+                    .insert(target_register, DvmValue::Long(operand));
             }
             MOV_DOUBLE => {
-                    unimplemented!();
+                let target_register = next_8!(iter, usize);
+                let operand = next_64_le!(iter, u64) as f64;
+                state
+                    .registers
+                    .insert(target_register, DvmValue::Double(operand));
             }
             MOV_REGISTER => {
-                    let target_register = code[i + 1] as usize;
+                let target_register = next_8!(iter, usize);
-                    let source_register = code[i + 2] as usize;
+                let source_register = next_8!(iter, usize);
-                    let source_value = self.registers.get(source_register).unwrap();
+                let source_value = state.registers.get(source_register).unwrap();
-                    self.registers.insert(target_register, source_value.clone());
+                state
-                    i += 3;
+                    .registers
+                    .insert(target_register, source_value.clone())
             }
             ALLOC => {
-                    i += 1;
+                let target_register = next_8!(iter, usize);
-                    let target_register = code[i] as usize;
+                let alloc_size = next_32_le!(iter, usize);
-                    i += 1;
+                let impl_name = read_string!(iter);
-                    let alloc_size = get_32_le!(code, i, 0, usize);
-                    i += 4;
-                    let raw_implementation_name_length = get_32_le!(code, i, 0, usize);
-                    i += 4;
-                    let raw_implementation_name_bytes =
-                        code[i..(i + raw_implementation_name_length)].to_vec();
-                    i += raw_implementation_name_length;
-                    let implementation_name =
-                        String::from_utf8(raw_implementation_name_bytes).unwrap();
 
-                    let implementation = self
+                let implementation = context
                     .libs
                     .iter()
                     .find_map(|lib| {
                         lib.implementations
                             .iter()
-                                .find(|implementation| implementation.fqn == implementation_name)
+                            .find(|implementation| implementation.fqn == impl_name)
                     })
-                        .expect(&format!(
+                    .expect(&format!("Implementation not found: {}", impl_name));
-                            "Implementation not found: {}",
-                            implementation_name
-                        ));
 
-                    let layout = Layout::from_size_align(alloc_size, 1).unwrap();
+                let dm_alloc_object = DmAllocObject::new(alloc_size, implementation.clone());
-                    let raw_data_ptr;
+                let dvm_pointer = DvmValue::Pointer(Rc::new(dm_alloc_object));
-                    unsafe {
+                state.registers.insert(target_register, dvm_pointer);
-                        raw_data_ptr = alloc(layout);
-                    }
-                    let dm_alloc_object = DmAllocObject {
-                        data: raw_data_ptr,
-                        layout,
-                        size: alloc_size,
-                        implementation: implementation.clone(),
-                    };
-
-                    let dvm_value = DvmValue::Pointer(Rc::new(dm_alloc_object));
-                    self.registers.insert(target_register, dvm_value);
             }
             DEALLOC => {
-                    todo!()
+                let target_register = next_8!(iter, usize);
+                let dm_alloc_object = state.registers.remove(target_register).expect_pointer();
+                drop(dm_alloc_object); // explicit
             }
             MOV_INT_TO => {
+                let target_register = next_8!(iter, usize);
+                let offset = next_32_le!(iter, usize);
+                let operand = next_32_le!(iter, u32) as i32;
+
+                let dm_alloc_object = state
+                    .registers
+                    .get(target_register)
+                    .unwrap()
+                    .expect_pointer();
+                write_bytes!(dm_alloc_object.data, offset, operand.to_ne_bytes());
+            }
+            MOV_LONG_TO => {
+                todo!()
+            }
+            MOV_DOUBLE_TO => {
                 todo!()
             }
             MOV_REGISTER_TO => {
-                    i += 1;
+                // Moves the value from the source register to the object pointed to by the target
-                    let target_register = code[i] as usize;
+                // register, at the given offset.
-                    i += 1;
+                let target_register = next_8!(iter, usize);
-                    let offset = get_32_le!(code, i, 0, isize);
+                let offset = next_32_le!(iter, usize);
-                    i += 4;
+                let source_register = next_8!(iter, usize);
-                    let source_register = code[i] as usize;
-                    i += 1;
 
-                    let target_value = self.registers.get(target_register).unwrap();
+                let target_alloc_object = state
-                    let target_pointer = match target_value {
+                    .registers
-                        DvmValue::Pointer(alloc_object) => alloc_object.data,
+                    .get(target_register)
-                        _ => panic!("Expected a DvmValue::Pointer, but got: {:?}", target_value),
+                    .unwrap()
-                    };
+                    .expect_pointer();
 
-                    let source_value = self.registers.get(source_register).unwrap();
+                let source_value = state.registers.get(source_register).unwrap();
                 match source_value {
-                        DvmValue::Pointer(source_alloc_object) => unsafe {
+                    DvmValue::Int(i) => {
-                            let source_pointer = Rc::into_raw(source_alloc_object.clone());
+                        write_bytes!(target_alloc_object.data, offset, i.to_ne_bytes());
-                            for (j, b) in (source_pointer as usize).to_le_bytes().iter().enumerate()
-                            {
-                                target_pointer.offset(offset + j as isize).write(*b);
                     }
+                    DvmValue::Byte(b) => unsafe {
+                        target_alloc_object.data.add(offset).write(*b);
                     },
-                        _ => panic!("Currently unsupported source value: {:?}", source_value),
+                    DvmValue::Long(l) => {
+                        write_bytes!(target_alloc_object.data, offset, l.to_ne_bytes());
+                    }
+                    DvmValue::Double(d) => {
+                        write_bytes!(target_alloc_object.data, offset, d.to_ne_bytes());
+                    }
+                    DvmValue::Boolean(b) => unsafe {
+                        target_alloc_object.data.add(offset).write(*b as u8);
+                    },
+                    DvmValue::Pointer(source_alloc_object) => {
+                        let source_ptr = Rc::into_raw(source_alloc_object.clone());
+                        write_bytes!(
+                            target_alloc_object.data,
+                            offset,
+                            (source_ptr as usize).to_ne_bytes()
+                        );
+                    }
+                    DvmValue::Uninit => {
+                        panic!("Cannot move DvmValue::Uninit to object.")
+                    }
+                    DvmValue::Void => {
+                        panic!("Cannot move DvmValue::Void to object.")
+                    }
                 }
             }
             MOV_CONST => {
-                    i += 1;
+                // TODO: reduce the complexity of this.
-                    let target_register = code[i] as usize;
+                // Perhaps the target register should just contain a ptr where the data is written.
-                    i += 1;
-                    let lib_name_length = get_32_le!(code, i, 0, usize);
-                    i += 4;
-                    let lib_name_raw = code[i..(i + lib_name_length)].to_vec();
-                    i += lib_name_length;
-                    let const_id = get_32_le!(code, i, 0, usize);
-                    i += 4;
 
-                    let lib_name = String::from_utf8(lib_name_raw).unwrap();
+                // Decode
+                let target_register = next_8!(iter, usize); // must contain an allocated StringImpl
+                let lib_name = read_string!(iter);
+                let const_id = next_8!(iter, usize);
+                let pointer_impl_register = next_8!(iter, usize);
+                let byte_array_impl_register = next_8!(iter, usize);
 
-                    if let Some(lib) = self.libs.iter().find(|&lib| lib.name == lib_name) {
+                // Get constant
-                        let constant = &lib.constants[const_id];
+                let Some(lib) = context.libs.iter().find(|lib| lib.name == lib_name) else {
-                        match constant {
+                    panic!("Could not find lib with name: {}", lib_name);
-                            DmConstant::String(s) => {
-                                let alloc_fn = self.get_fn_by_fqn("std::unsafe::mem::alloc")
-                                    .expect("Could not find std::unsafe::mem::alloc");
-                                let alloc_size_arg = DvmValue::Long(s.len() as i64);
-                                let alloc_return_value = self.call_fn(&alloc_fn, vec![alloc_size_arg]).unwrap();
-                                let DvmValue::Pointer(pointer_object) = alloc_return_value else {
-                                    panic!("Expected std::unsafe::mem::alloc to return DvmValue::Pointer, but got: {:?}", alloc_return_value);
                 };
-                                let raw_address_field = pointer_object.implementation.get_field("raw_address", &pointer_object)
+                let constant = lib.constants.get(const_id).unwrap();
-                                    .expect("Could not get PointerImpl.raw_address field.");
+                let DmConstant::String(s) = constant;
+
+                // Get allocated PointerImpl
+                let pointer_impl = state
+                    .registers
+                    .get(pointer_impl_register)
+                    .unwrap()
+                    .expect_pointer();
+
+                // Init PointerImpl object
+                let pointer_impl_ctor_0_fn = context
+                    .functions
+                    .get("std::unsafe::PointerImpl::_ctor_0")
+                    .expect("Could not find std::unsafe::PointerImpl::_ctor_0");
+                call_fn(
+                    state,
+                    context,
+                    pointer_impl_ctor_0_fn,
+                    vec![
+                        DvmValue::Pointer(pointer_impl.clone()),
+                        DvmValue::Long(s.len() as i64),
+                    ],
+                );
+
+                // Get std::unsafe::PointerImpl.raw_address field as *mut u8
+                let raw_ptr = unsafe {
+                    get_field_value(
+                        pointer_impl
+                            .implementation
+                            .get_field("raw_address", &pointer_impl)
+                            .expect("Could not get PointerImpl.raw_address field."),
+                        &pointer_impl,
+                    )
+                }
+                .expect_long() as usize as *mut u8;
+
+                // Write the constant bytes to the raw_ptr
+                write_string!(raw_ptr, s);
+
+                // Get allocated ArrayImpl<Byte> from byte_array_impl_register
+                let byte_array_impl = state
+                    .registers
+                    .get(byte_array_impl_register)
+                    .unwrap()
+                    .expect_pointer();
+
+                // Init ArrayImpl<Byte>
+                let array_ctor_0_fn = context
+                    .functions
+                    .get("std::core::ArrayImpl::_ctor_1")
+                    .expect("Could not find std::core::ArrayImpl::_ctor_1");
+                call_fn(
+                    state,
+                    context,
+                    array_ctor_0_fn,
+                    vec![
+                        DvmValue::Pointer(byte_array_impl.clone()), // self
+                        DvmValue::Pointer(pointer_impl.clone()),    // PointerImpl
+                        DvmValue::Int(s.len() as i32),              // length
+                    ],
+                );
+
+                // Get allocated StringImpl from string_impl_register
+                let string_impl = state
+                    .registers
+                    .get(target_register)
+                    .unwrap()
+                    .expect_pointer();
+
+                // Init StringImpl
+                let string_impl_ctor_0_fn = context
+                    .functions
+                    .get("std::core::StringImpl::_ctor_0")
+                    .expect("Could not find std::core::StringImpl::_ctor_0");
+                call_fn(
+                    state,
+                    context,
+                    string_impl_ctor_0_fn,
+                    vec![
+                        DvmValue::Pointer(string_impl.clone()),
+                        DvmValue::Pointer(byte_array_impl.clone()),
+                    ],
+                );
+            }
+            ALLOC_RAW => {
+                // Allocates a raw number of bytes, with the number of bytes determined by the value
+                // of the source register. The address is stored in the target register as a
+                // DvmValue::Long.
+                let target_register = next_8!(iter, usize);
+                let source_register = next_8!(iter, usize);
+                let number_of_bytes =
+                    state.registers.get(source_register).unwrap().expect_long() as usize;
+                let layout = Layout::from_size_align(number_of_bytes, 0).unwrap();
+                let ptr = unsafe { alloc(layout) };
+                state
+                    .registers
+                    .insert(target_register, DvmValue::Long(ptr as i64))
+            }
+            DEALLOC_RAW => {
+                // Deallocates a raw number of bytes at an address, with the number of bytes
+                // determined by the value in the source register, and the address stored in the
+                // target register.
+                let target_register = next_8!(iter, usize);
+                let source_register = next_8!(iter, usize);
+                let number_of_bytes =
+                    state.registers.get(source_register).unwrap().expect_long() as usize;
+
+                let layout = Layout::from_size_align(number_of_bytes, 0).unwrap();
+                let ptr =
+                    state.registers.get(target_register).unwrap().expect_long() as usize as *mut u8;
                 unsafe {
-                                    let raw_address_value = get_field_value(&raw_address_field, &pointer_object);
+                    dealloc(ptr, layout);
-                                    let DvmValue::Long(raw_address) = raw_address_value else {
-                                        panic!("Expected PointerImpl.raw_address to be a DvmValue::Long, but got: {:?}", raw_address_value);
-                                    };
-                                    let ptr = raw_address as usize as *mut u8;
-                                    for (j, b) in s.bytes().enumerate() {
-                                        ptr.offset(j as isize).write(b);
-                                    }
-                                    self.registers.insert(target_register, DvmValue::Pointer(pointer_object));
-                                }
-                            }
-                            _ => {
-                                panic!("Invalid constant type");
-                            }
-                        }
-                    } else {
-                        panic!("Could not find lib: {}", lib_name);
                 }
+                state.registers.insert(target_register, DvmValue::Uninit);
             }
             PLATFORM_CALL => {
-                    i += 1;
+                // Calls a platform function. The result of the platform call is stored in the
+                // specified return register.
+                let symbol_name = read_string!(iter);
+                let return_register = next_8!(iter, usize);
+                let arg_registers = read_array_u8!(iter);
 
-                    let symbol_name_length = get_32_le!(code, i, 0, usize);
+                let mut args = Vec::with_capacity(arg_registers.len());
-                    i += 4;
-
-                    let symbol_name_raw = code[i..(i + symbol_name_length)].to_vec();
-                    i += symbol_name_length;
-
-                    let symbol_name = String::from_utf8(symbol_name_raw).unwrap();
-
-                    let return_register = code[i + 1] as usize;
-                    i += 1;
-
-                    let arg_registers_length = code[i] as usize;
-                    i += 1;
-
-                    let arg_registers = code[i..(i + arg_registers_length)].to_vec();
-                    i += arg_registers_length;
-
-                    let mut args = Vec::new();
                 for arg_register in arg_registers {
-                        let register_value = self.registers.get(arg_register as usize).unwrap();
+                    let value = state.registers.get(arg_register as usize).unwrap();
-                        args.push(register_value.clone());
+                    args.push(value.clone());
                 }
 
-                    let platform_function_result = self.platform_functions.get(&symbol_name);
+                let platform_function = context
-                    if platform_function_result.is_none() {
+                    .platform_functions
-                        panic!("Unknown platform function {}", symbol_name);
+                    .get(&symbol_name)
-                    }
+                    .unwrap()
-                    let platform_function = platform_function_result.unwrap();
+                    .clone();
-
+                state
-                    let call_result = platform_function(args, self);
+                    .call_stack
-                    self.registers.insert(return_register, call_result);
+                    .push(CallFrame::PlatformCall(CallFrameInfo {
+                        fn_fqn: symbol_name,
+                    }));
+                let call_result = platform_function(args, state, context);
+                state.registers.insert(return_register, call_result);
+                state.call_stack.pop();
             }
             INVOKE_FN => {
-                    unimplemented!()
+                let symbol_name = read_string!(iter);
+                let return_register = next_8!(iter, usize);
+                let arg_registers = read_array_u8!(iter);
+
+                let mut args = Vec::with_capacity(arg_registers.len());
+                for arg_register in arg_registers {
+                    let value = state.registers.get(arg_register as usize).unwrap();
+                    args.push(value.clone());
+                }
+
+                let dm_fn = context.functions.get(&symbol_name).unwrap();
+                let call_result = call_fn(state, context, dm_fn, args);
+                state.registers.insert(return_register, call_result);
             }
             INVOKE_VIRTUAL => {
-                    unimplemented!();
+                let symbol_name = read_string!(iter);
-                }
+                let return_register = next_8!(iter, usize);
-                INVOKE_METHOD => {
+                let arg_registers = read_array_u8!(iter);
-                    i += 1;
-                    let name_length = get_32_le!(code, i, 0, usize);
-                    i += 4;
-                    let name_raw = code[i..(i + name_length)].to_vec();
-                    i += name_length;
-                    let arg_registers_length = code[i] as usize;
-                    i += 1;
-                    let arg_registers = code[i..(i + arg_registers_length)].to_vec();
-                    i += arg_registers_length;
 
-                    let method_name = String::from_utf8(name_raw).unwrap();
+                let mut args = Vec::with_capacity(arg_registers.len());
-
-                    let method = self
-                        .get_fn_by_fqn(&method_name)
-                        .expect(&format!("Could not find method: {}", method_name));
-
-                    let mut args: Vec<DvmValue> = Vec::new();
                 for arg_register in arg_registers {
-                        let register_value = self.registers.get(arg_register as usize).unwrap();
+                    let value = state.registers.get(arg_register as usize).unwrap();
-                        args.push(register_value.clone());
+                    args.push(value.clone());
                 }
 
-                    self.call_fn(method.as_ref(), args);
+                let self_obj = args.get(0).unwrap().expect_pointer();
+                let method = self_obj
+                    .implementation
+                    .get_method(&symbol_name, &self_obj)
+                    .expect(&format!("Could not find method: {}", symbol_name));
+                let dm_fn = method.dm_fn();
+
+                let call_result = call_fn(state, context, dm_fn, args);
+                state.registers.insert(return_register, call_result);
             }
             INVOKE_DYNAMIC => {
-                    unimplemented!()
+                unimplemented!("INVOKE_DYNAMIC is not yet supported and may never be.")
             }
-                RETURN => {
+            MOV_SIZE_OF => {
-                    i += 1;
+                todo!()
             }
-                RETURN_REGISTER => {
+            MULTIPLY => {
-                    unimplemented!()
+                todo!()
             }
-                op_code => panic!("Invalid or unimplemented op code: {:#04x}", op_code),
+            op_code => {
+                panic!("Invalid op_code: {}", op_code);
             }
         }
     }
 }
 
 #[cfg(test)]
-mod dvm_run_tests {
+mod run_code_tests {
     use super::*;
 
     macro_rules! assert_register {
-        ( $expected: expr, $register: expr ) => {
+        ( $expected: expr, $state: expr, $register_number: expr ) => {
-            assert_eq!($expected, $register.unwrap().clone());
+            assert_eq!(
+                $expected,
+                $state.registers.get($register_number).unwrap().clone()
+            );
         };
     }
 
+    fn setup() -> (DvmState, DvmContext) {
+        (DvmState::new(), DvmContext::new())
+    }
+
     #[test]
     fn mov_1_as_int() {
         let mut code = Vec::new();
         add_mov_int(&mut code, 0, 1);
-        let mut vm = DmVirtualMachine::new(Vec::new());
+        let (mut state, context) = setup();
-        vm.run_raw(&code);
+        run_byte_code(&mut state, &context, &code);
-        assert_register!(DvmValue::Int(1), vm.registers.get(0));
+        assert_register!(DvmValue::Int(1), state, 0);
     }
 
     #[test]
     fn move_65535_as_int() {
         let mut code = Vec::new();
         add_mov_int(&mut code, 0, 0xffff);
-        let mut vm = DmVirtualMachine::new(Vec::new());
+        let (mut state, context) = setup();
-        vm.run_raw(&code);
+        run_byte_code(&mut state, &context, &code);
-        assert_register!(DvmValue::Int(0xffff), vm.registers.get(0));
+        assert_register!(DvmValue::Int(0xffff), state, 0);
     }
 
     #[test]
     fn move_int_max_as_int() {
         let mut code = Vec::new();
         add_mov_int(&mut code, 0, 0x0fff_ffff);
-        let mut vm = DmVirtualMachine::new(Vec::new());
+        let (mut state, context) = setup();
-        vm.run_raw(&code);
+        run_byte_code(&mut state, &context, &code);
-        assert_register!(DvmValue::Int(0x0fff_ffff), vm.registers.get(0));
+        assert_register!(DvmValue::Int(0x0fff_ffff), state, 0);
     }
 
     #[test]
@@ -393,37 +595,9 @@ mod dvm_run_tests {
         let mut code = Vec::new();
         add_mov_int(&mut code, 1, 1);
         add_mov_register(&mut code, 0, 1);
-        let mut vm = DmVirtualMachine::new(Vec::new());
+        let (mut state, context) = setup();
-        vm.registers.resize(2, DvmValue::Unit);
+        state.registers.resize(2, DvmValue::Uninit);
-        vm.run_raw(&code);
+        run_byte_code(&mut state, &context, &code);
-        assert_register!(DvmValue::Int(1), vm.registers.get(0));
+        assert_register!(DvmValue::Int(1), state, 0);
-    }
-
-    #[test]
-    #[ignore]
-    fn mov_int_to_register_as_address() {
-        let mut code = Vec::new();
-        add_alloc(&mut code, 0, 4);
-        add_mov_int_to(&mut code, 0, 0, 0xff);
-        let mut vm = DmVirtualMachine::new(Vec::new());
-        vm.run_raw(&code);
-        let actual = vm.registers.get(0).unwrap().clone();
-        match actual {
-            DvmValue::Pointer(value_box) => {
-                assert_eq!(DvmValue::Int(0xff), *value_box);
-            }
-            _ => panic!("Target register is not a pointer"),
-        }
-    }
-
-    #[test]
-    #[ignore]
-    fn alloc_and_dealloc_expect_register_cleared() {
-        let mut code = Vec::new();
-        add_alloc(&mut code, 0, 4);
-        add_dealloc(&mut code, 0);
-        let mut vm = DmVirtualMachine::new(Vec::new());
-        vm.run_raw(&code);
-        assert_register!(DvmValue::Unit, vm.registers.get(0));
     }
 }

src/vm/object_type.rs

@@ -11,19 +11,27 @@ pub enum DmObjectType {
 
 #[derive(Debug, Eq)]
 pub struct DmFn {
-    pub fqn: String,
+    fqn: String,
-    pub short_name: String,
+    short_name: String,
-    pub byte_code: Vec<u8>,
+    byte_code: Vec<u8>,
-    pub number_used_registers: usize,
+    number_used_registers: usize,
+    return_register: Option<u8>,
 }
 
 impl DmFn {
-    pub fn new(fqn: &str, short_name: &str, byte_code: Vec<u8>, number_used_registers: usize) -> Self {
+    pub fn new(
+        fqn: &str,
+        short_name: &str,
+        byte_code: Vec<u8>,
+        number_used_registers: usize,
+        return_register: Option<u8>,
+    ) -> Self {
         DmFn {
             fqn: fqn.to_string(),
             short_name: short_name.to_string(),
             byte_code,
-            number_used_registers
+            number_used_registers,
+            return_register,
         }
     }
 
@@ -42,6 +50,10 @@ impl DmFn {
     pub fn number_used_registers(&self) -> usize {
         self.number_used_registers
     }
+
+    pub fn return_register(&self) -> Option<u8> {
+        self.return_register
+    }
 }
 
 impl PartialEq for DmFn {
@@ -69,6 +81,10 @@ impl DmMethod {
             implements,
         }
     }
+
+    pub fn dm_fn(&self) -> &DmFn {
+        &self.dm_fn
+    }
 }
 
 #[derive(Debug, Eq)]
@@ -237,7 +253,7 @@ impl DmField {
         DmField {
             name: name.to_string(),
             dm_type,
-            data_offset
+            data_offset,
         }
     }
 

src/vm/op_codes.rs

@@ -39,18 +39,14 @@ pub const MOV_REGISTER_TO: u8 = 0x0a;
 
 pub const MOV_CONST: u8 = 0x0b;
 
-pub const ALLOC_RAW: u8 = 0x0c;
+pub const ALLOC_RAW: u8 = 0x0d;
-pub const ALLOC_RAW_FROM: u8 = 0x0d;
+pub const DEALLOC_RAW: u8 = 0x0e;
 
 pub const PLATFORM_CALL: u8 = 0x10;
 pub const INVOKE_FN: u8 = 0x11;
 pub const INVOKE_VIRTUAL: u8 = 0x12;
-pub const INVOKE_METHOD: u8 = 0x13;
 pub const INVOKE_DYNAMIC: u8 = 0x14;
 
-pub const RETURN: u8 = 0x20;
-pub const RETURN_REGISTER: u8 = 0x21;
-
 pub const MOV_SIZE_OF: u8 = 0x30;
 
 pub const MULTIPLY: u8 = 0x40;
@@ -87,14 +83,8 @@ pub fn add_alloc(code: &mut Vec<u8>, register: u8, size: u32, implementation_nam
     push_string!(code, implementation_name);
 }
 
-pub fn add_alloc_raw(code: &mut Vec<u8>, target_register: u8, size: u32) {
-    code.push(ALLOC_RAW);
-    code.push(target_register);
-    push_number!(code, size);
-}
-
 pub fn add_alloc_raw_from(code: &mut Vec<u8>, target_register: u8, source_register: u8) {
-    code.push(ALLOC_RAW_FROM);
+    code.push(ALLOC_RAW);
     code.push(target_register);
     push_number!(code, source_register);
 }
@@ -159,25 +149,6 @@ pub fn add_invoke_fn(code: &mut Vec<u8>, fn_name: &str, return_register: u8, arg
     }
 }
 
-pub fn add_invoke_method(code: &mut Vec<u8>, name: &str, arg_registers: &[u8]) {
-    code.push(INVOKE_METHOD);
-    push_number!(code, name.len() as u32);
-    push_string!(code, name);
-    push_number!(code, arg_registers.len() as u8);
-    for &b in arg_registers {
-        code.push(b);
-    }
-}
-
-pub fn add_ret(code: &mut Vec<u8>) {
-    code.push(RETURN);
-}
-
-pub fn add_ret_register(code: &mut Vec<u8>, register: u8) {
-    code.push(RETURN_REGISTER);
-    code.push(register);
-}
-
 pub fn add_mov_size_of(code: &mut Vec<u8>, target_register: u8, source_register: u8) {
     code.push(MOV_SIZE_OF);
     code.push(target_register);

src/vm/platform/std_lib/core.rs

@@ -1,96 +1,84 @@
 use crate::vm::dvm_value::DvmValue;
 use crate::vm::mem::{get_field_value, DmAllocObject};
-use crate::vm::DmVirtualMachine;
+use crate::vm::{DvmContext, DvmState};
 use std::rc::Rc;
 
-pub fn dm_print(args: Vec<DvmValue>, vm: &mut DmVirtualMachine) -> DvmValue {
+pub fn dm_print(args: Vec<DvmValue>, _state: &mut DvmState, _context: &DvmContext) -> DvmValue {
     if args.len() != 1 {
-        return DvmValue::Unit; // TODO: make exception
+        return DvmValue::Void; // TODO: make exception
     }
     unsafe {
-        print!("{}", get_string(&args[0], vm));
+        print!("{}", get_string(&args[0]));
     }
-    DvmValue::Unit
+    DvmValue::Void
 }
 
-pub fn dm_println(args: Vec<DvmValue>, vm: &mut DmVirtualMachine) -> DvmValue {
+pub fn dm_println(args: Vec<DvmValue>, _state: &mut DvmState, _context: &DvmContext) -> DvmValue {
     if args.len() != 1 {
-        return DvmValue::Unit;
+        return DvmValue::Uninit;
     }
     unsafe {
-        println!("{}", get_string(&args[0], vm));
+        println!("{}", get_string(&args[0]));
     }
-    DvmValue::Unit
+    DvmValue::Void
 }
 
-unsafe fn get_string(dvm_value: &DvmValue, vm: &mut DmVirtualMachine) -> String {
+unsafe fn get_string(dvm_value: &DvmValue) -> String {
     match dvm_value {
         DvmValue::Byte(b) => b.to_string(),
         DvmValue::Int(i) => i.to_string(),
         DvmValue::Long(l) => l.to_string(),
         DvmValue::Double(d) => d.to_string(),
         DvmValue::Boolean(b) => b.to_string(),
-        DvmValue::Pointer(alloc_object_rc) => convert_to_string(alloc_object_rc.clone(), vm),
+        DvmValue::Pointer(object) => convert_to_string(object.clone()),
-        DvmValue::Unit => String::from("Unit"),
+        DvmValue::Uninit => String::from("Uninit"),
+        DvmValue::Void => String::from("Void"),
     }
 }
 
-unsafe fn convert_to_string(
+fn convert_to_string(alloc_object_rc: Rc<DmAllocObject>) -> String {
-    alloc_object_rc: Rc<DmAllocObject>,
-    vm: &mut DmVirtualMachine,
-) -> String {
     if alloc_object_rc.implementation.fqn == "std::core::String" {
-        let bytes_field = alloc_object_rc
+        extract_string_from_string(alloc_object_rc.clone())
-            .implementation
-            .get_field("bytes", &alloc_object_rc)
-            .expect("Could not get String.bytes field.");
-        let bytes_value = get_field_value(&bytes_field, &alloc_object_rc);
-        match bytes_value {
-            DvmValue::Pointer(bytes_object) => {
-                if bytes_object.implementation.fqn == "std::core::ArrayImpl" {
-                    let pointer_field = bytes_object
-                        .implementation
-                        .get_field("pointer", &bytes_object)
-                        .expect("Could not get ArrayImpl.pointer field.");
-                    let pointer_value = get_field_value(&pointer_field, &alloc_object_rc);
-                    match pointer_value {
-                        DvmValue::Pointer(pointer_object) => {
-                            if pointer_object.implementation.fqn == "std::unsafe::PointerImpl" {
-                                let raw_address_field = pointer_object.implementation.get_field("raw_address", &pointer_object)
-                                    .expect("Could not get PointerImpl.raw_address field.");
-                                let raw_address_value = get_field_value(raw_address_field, &alloc_object_rc);
-                                
-                                let size_field = pointer_object.implementation.get_field("size", &alloc_object_rc)
-                                    .expect("Could not get PointerImpl.size field.");
-                                let size_value = get_field_value(&size_field, &alloc_object_rc);
-                                let DvmValue::Long(size) = size_value else {
-                                    panic!("Expected PointerImpl.size to be a Long");
-                                };
-                                
-                                match raw_address_value {
-                                    DvmValue::Long(raw_address) => {
-                                        let raw_bytes_pointer = raw_address as usize as *mut u8;
-                                        let mut v: Vec<u8> = Vec::new();
-                                        for i in 0..(size as isize) {
-                                            v.push(raw_bytes_pointer.offset(i).read());
-                                        }
-                                        String::from_utf8(v).unwrap()
-                                    }
-                                    _ => panic!("Expected raw_address to be a Long.")
-                                }
-                            } else {
-                                panic!("Expected ArrayImpl.pointer to be a Pointer to PointerImpl, instead found: {:?}", pointer_object);
-                            }
-                        }
-                        _ => panic!("Expected ArrayImpl.pointer to be a Pointer, instead found: {:?}", pointer_value)
-                    }
-                } else {
-                    panic!("Expected String.bytes to be a Pointer to an ArrayImpl, instead found: {:?}", bytes_object.implementation.fqn);
-                }
-            }
-            _ => panic!("Expected String.bytes to be a Pointer, instead found: {:?}", bytes_value),
-        }
     } else {
         todo!("what happens if we don't have a String?")
     }
 }
+
+fn extract_string_from_string(string_object: Rc<DmAllocObject>) -> String {
+    let bytes_field = string_object
+        .implementation
+        .get_field("bytes", &string_object)
+        .expect("Could not get String.bytes field.");
+    let bytes_object = unsafe { get_field_value(&bytes_field, &string_object) }.expect_pointer();
+    if bytes_object.implementation.fqn != "std::core::ArrayImpl" {
+        panic!("String.bytes field is not a std::core::ArrayImpl");
+    }
+
+    let pointer_field = bytes_object
+        .implementation
+        .get_field("pointer", &bytes_object)
+        .expect("Could not get ArrayImpl.pointer field.");
+    let pointer_object = unsafe { get_field_value(&pointer_field, &bytes_object) }.expect_pointer();
+    if pointer_object.implementation.fqn != "std::unsafe::PointerImpl" {
+        panic!("ArrayImpl.pointer is not a std::unsafe::PointerImpl");
+    }
+
+    let raw_address_field = pointer_object
+        .implementation
+        .get_field("raw_address", &pointer_object)
+        .expect("Could not get PointerImpl.raw_address field.");
+    let raw_address = unsafe { get_field_value(&raw_address_field, &pointer_object) }.expect_long();
+
+    let size_field = pointer_object
+        .implementation
+        .get_field("size", &pointer_object)
+        .expect("Could not get PointerImpl.size field.");
+    let size = unsafe { get_field_value(&size_field, &pointer_object) }.expect_long();
+
+    let raw_bytes_pointer = raw_address as usize as *mut u8;
+    let mut v: Vec<u8> = Vec::new();
+    for i in 0..(size as isize) {
+        v.push(unsafe { raw_bytes_pointer.offset(i).read() });
+    }
+    String::from_utf8(v).unwrap()
+}