Merge pull request #28 from Maaarcocr/main

Implement arrays natively

Author: maximecb

src/array.rs

@@ -2,55 +2,144 @@ use crate::vm::{Value, Actor};
 use crate::alloc::Alloc;
 use crate::host::HostFn;
 
-#[derive(Clone, Default)]
 pub struct Array
 {
-    pub elems: Vec<Value>,
+    pub elems: *mut [Value],
+    pub len: usize,
 }
 
 impl Array
 {
-    pub fn with_capacity(cap: u32) -> Self
+    pub fn with_capacity(capacity: usize, alloc: &mut Alloc) -> Result<Self, ()>
     {
-        Self {
-            elems: Vec::with_capacity(cap as usize)
+        let table = alloc.alloc_table(capacity)?;
+        Ok(Array { elems: table, len: 0 })
+    }
+
+    pub fn clone(&self, alloc: &mut Alloc) -> Result<Self, ()>
+    {
+        let table = alloc.alloc_table(self.len)?;
+        let mut arr = Array { elems: table, len: self.len };
+        arr.items_mut().copy_from_slice(self.items());
+        Ok(arr)
+    }
+
+    pub fn items(&self) -> &[Value] {
+        unsafe { &(*self.elems)[..self.len] }
+    }
+
+    pub fn items_mut(&mut self) -> &mut [Value] {
+        unsafe { &mut (*self.elems)[..self.len] }
+    }
+
+    pub fn push(&mut self, val: Value, alloc: &mut Alloc) -> Result<(), ()>
+    {
+        if self.len == self.elems.len() {
+            let new_len = self.len * 2 + 1;
+            let new_elems = alloc.alloc_table(new_len)?;
+            unsafe {
+                (&mut *new_elems)[..self.len].copy_from_slice(&(*self.elems)[..self.len]);
+                self.elems = new_elems;
+            }
+        }
+        unsafe {
+            (&mut *self.elems)[self.len] = val;
+            self.len += 1;
+        }
+        Ok(())
+    }
+
+    pub fn insert(&mut self, idx: usize, val: Value, alloc: &mut Alloc) -> Result<(), ()>
+    {
+        if self.len == self.elems.len() {
+            let new_len = self.len * 2 + 1;
+            let new_elems = alloc.alloc_table(new_len)?;
+            unsafe {
+                (&mut *new_elems).copy_from_slice(&(*self.elems)[..self.len]);
+                self.elems = new_elems;
+            }
         }
+        unsafe {
+            (&mut *self.elems).copy_within(idx..self.len, idx + 1);
+            (&mut *self.elems)[idx] = val;
+            self.len += 1;
+        }
+
+        Ok(())
     }
 
-    pub fn push(&mut self, val: Value)
+    pub fn remove(&mut self, idx: usize) -> Value
     {
-        self.elems.push(val);
+        if idx >= self.len {
+            return Value::Nil;
+        }
+
+        let removed = unsafe { (&mut *self.elems)[idx] };
+        unsafe {
+            (&mut *self.elems).copy_within(idx + 1..self.len, idx);
+        }
+
+        self.len -= 1;
+        removed
+    }
+
+    pub fn extend(&mut self, other: &Array, alloc: &mut Alloc) -> Result<(), ()> {
+        let other_elems = other.elems;
+        if self.len + other_elems.len() > self.elems.len() {
+            let new_len = self.len + other_elems.len();
+            let new_elems = alloc.alloc_table(new_len)?;
+            unsafe {
+                (&mut *new_elems)[..self.len].copy_from_slice(&(*self.elems)[..self.len]);
+                (&mut *new_elems)[self.len..].copy_from_slice(&(*other_elems)[..other_elems.len()]);
+                self.elems = new_elems;
+            }
+        } else {
+            unsafe {
+                (&mut *self.elems)[self.len..].copy_from_slice(&(*other_elems)[..other_elems.len()]);
+            }
+        }
+        self.len += other_elems.len();
+
+        Ok(())
     }
 
     pub fn pop(&mut self) -> Value
     {
-        self.elems.pop().unwrap()
+        if self.len == 0 {
+            return Value::Nil;
+        }
+
+        self.len -= 1;
+        unsafe { (*self.elems) [self.len] }
     }
 
     pub fn get(&self, idx: usize) -> Value
     {
-        self.elems[idx]
+        unsafe { (*self.elems) [idx] }
     }
 
     pub fn set(&mut self, idx: usize, val: Value)
     {
-        self.elems[idx] = val;
+        unsafe { (*self.elems) [idx] = val };
+    }
+
+    pub fn len(&self) -> usize {
+        self.len
     }
 }
 
 pub fn array_with_size(actor: &mut Actor, _self: Value, num_elems: Value, fill_val: Value) -> Result<Value, String>
 {
     let num_elems = num_elems.unwrap_usize();
-    let mut elems = Vec::with_capacity(num_elems);
-    elems.resize(num_elems, fill_val);
-    let arr = Array { elems };
-    let p_arr = actor.alloc.alloc(arr).unwrap();
-    Ok(Value::Array(p_arr))
+    let mut elems = actor.alloc.alloc_table(num_elems).unwrap();
+    unsafe { (&mut *elems).fill(fill_val); }
+    let arr = Array { elems, len: num_elems };
+    Ok(Value::Array(actor.alloc.alloc(arr).unwrap()))
 }
 
 pub fn array_push(actor: &mut Actor, mut array: Value, val: Value) -> Result<Value, String>
 {
-    array.unwrap_arr().push(val);
+    array.unwrap_arr().push(val, &mut actor.alloc).unwrap();
     Ok(Value::Nil)
 }
 
@@ -62,19 +151,19 @@ pub fn array_pop(actor: &mut Actor, mut array: Value) -> Result<Value, String>
 pub fn array_remove(actor: &mut Actor, mut array: Value, idx: Value) -> Result<Value, String>
 {
     let idx = idx.unwrap_usize();
-    Ok(array.unwrap_arr().elems.remove(idx))
+    Ok(array.unwrap_arr().remove(idx))
 }
 
 pub fn array_insert(actor: &mut Actor, mut array: Value, idx: Value, val: Value) -> Result<Value, String>
 {
     let idx = idx.unwrap_usize();
-    array.unwrap_arr().elems.insert(idx, val);
+    array.unwrap_arr().insert(idx, val, &mut actor.alloc).unwrap();
     Ok(Value::Nil)
 }
 
-pub fn array_append(_actor: &mut Actor, mut self_array: Value, mut other_array: Value) -> Result<Value, String>
+pub fn array_append(actor: &mut Actor, mut self_array: Value, mut other_array: Value) -> Result<Value, String>
 {
-    let other_elems = other_array.unwrap_arr().elems.clone();
-    self_array.unwrap_arr().elems.extend(other_elems);
+    let other_elems = other_array.unwrap_arr();
+    self_array.unwrap_arr().extend(other_elems, &mut actor.alloc).unwrap();
     Ok(Value::Nil)
-}
+}

src/deepcopy.rs

@@ -127,9 +127,9 @@ pub fn deepcopy(
             }
 
             Value::Array(p) => {
-                let new_arr = unsafe { (*p).clone() };
+                let new_arr = unsafe { (*p).clone(dst_alloc).unwrap() };
 
-                for val in &new_arr.elems {
+                for val in new_arr.items() {
                     push_val!(val);
                 }
 
@@ -195,7 +195,7 @@ pub fn remap(dst_map: &mut HashMap<Value, Value>)
 
             Value::Array(p) => {
                 let arr = unsafe { &mut **p };
-                for val in &mut arr.elems {
+                for val in arr.items_mut() {
                     remap_val!(val);
                 }
             }

src/runtime.rs

@@ -1,3 +1,4 @@
+use crate::array::Array;
 use crate::ast::*;
 use crate::vm::{Value, Actor};
 use crate::{error, unwrap_usize, unwrap_str};
@@ -248,13 +249,16 @@ fn string_split(actor: &mut Actor, s: Value, sep: Value) -> Result<Value, String
 {
     let s = unwrap_str!(s);
     let sep = unwrap_str!(sep);
+    let str_parts = s.split(sep);
+    let size = str_parts.size_hint().0;
 
-    let parts: Vec<Value> = s.split(sep).map(|part| {
-        actor.alloc.str_val(&part.to_string()).unwrap()
-    }).collect();
+    let mut array = Array::with_capacity(size, &mut actor.alloc).unwrap();
 
-    let arr = crate::array::Array { elems: parts };
-    Ok(Value::Array(actor.alloc.alloc(arr).unwrap()))
+    for part in str_parts {
+        array.push(actor.alloc.str_val(part).unwrap(), &mut actor.alloc).unwrap();
+    }
+
+    Ok(Value::Array(actor.alloc.alloc(array).unwrap()))
 }
 
 pub fn init_runtime(prog: &mut Program)

src/vm.rs

@@ -1866,7 +1866,7 @@ impl Actor
                     let val = match obj {
                         Value::Array(p) => {
                             match field_name.as_str() {
-                                "len" => obj.unwrap_arr().elems.len().into(),
+                                "len" => obj.unwrap_arr().len().into(),
                                 _ => error!("get_field", "field not found on array")
                             }
                         }
@@ -1998,7 +1998,7 @@ impl Actor
                 Insn::arr_push => {
                     let val = pop!();
                     let mut arr = pop!();
-                    arr.unwrap_arr().push(val);
+                    arr.unwrap_arr().push(val, &mut self.alloc).unwrap();
                 }
 
                 // Clone a bytearray