Added support for table.concat, table.insert, table.remove, tonumber, string.sub

src/stdlib/base.rs

@@ -33,6 +33,31 @@ pub fn load_base<'gc>(ctx: Context<'gc>) {
         )
         .unwrap();
 
+    ctx.state
+        .globals
+        .set(
+            ctx,
+            "tonumber",
+            AnyCallback::from_fn(&ctx, |ctx, _, stack| {
+                if stack.is_empty() {
+                    Err("Bad argument to tonumber".into_value(ctx).into())
+                } else {
+                    let (v, base): (Value, Option<i64>) = stack.consume(ctx)?;
+
+                    if base.is_some() {
+                        // TODO
+                        return Err("tonumber does not currently support base parameter"
+                            .into_value(ctx)
+                            .into());
+                    }
+
+                    stack.replace(ctx, v.to_number());
+                    Ok(CallbackReturn::Return)
+                }
+            }),
+        )
+        .unwrap();
+
     ctx.state
         .globals
         .set(

src/stdlib/string.rs

@@ -1,4 +1,4 @@
-use crate::{AnyCallback, CallbackReturn, Context, IntoValue, Table, Value};
+use crate::{AnyCallback, CallbackReturn, Context, IntoValue, String, Table, Value};
 
 pub fn load_string<'gc>(ctx: Context<'gc>) {
     let string = Table::new(&ctx);
@@ -24,5 +24,40 @@ pub fn load_string<'gc>(ctx: Context<'gc>) {
         )
         .unwrap();
 
+    string
+        .set(
+            ctx,
+            "sub",
+            AnyCallback::from_fn(&ctx, |ctx, _, stack| {
+                let (str_value, v2, v3): (String, Value, Value) = stack.consume(ctx)?;
+
+                let start_index = match v2 {
+                    Value::Integer(i) => i as usize - 1,
+                    Value::Number(i) => i as usize - 1,
+                    _ => return Err("Bad argument to string.sub".into_value(ctx).into()),
+                };
+
+                let std_str_val = str_value.to_str()?;
+
+                let end_index = match v3 {
+                    Value::Nil => std_str_val.len(),
+                    Value::Integer(i) => i as usize,
+                    Value::Number(i) => i as usize,
+                    _ => return Err("Bad argument to string.sub".into_value(ctx).into()),
+                };
+
+                let sub_str = if start_index == 0 && end_index == std_str_val.len() {
+                    std_str_val
+                } else {
+                    std_str_val
+                        .get(start_index..end_index)
+                        .ok_or_else(|| "String index out of bounds".into_value(ctx))?
+                };
+                stack.replace(ctx, String::from_slice(&ctx, sub_str));
+                return Ok(CallbackReturn::Return);
+            }),
+        )
+        .unwrap();
+
     ctx.state.globals.set(ctx, "string", string).unwrap();
 }

src/stdlib/table.rs

@@ -1,4 +1,5 @@
-use crate::{AnyCallback, CallbackReturn, Context, Table};
+use crate::{AnyCallback, CallbackReturn, Context, IntoValue, String, Table, Value};
+use std::string::String as StdString;
 
 pub fn load_table<'gc>(ctx: Context<'gc>) {
     let table = Table::new(&ctx);
@@ -41,5 +42,116 @@ pub fn load_table<'gc>(ctx: Context<'gc>) {
         )
         .unwrap();
 
+    table
+        .set(
+            ctx,
+            "insert",
+            AnyCallback::from_fn(&ctx, |ctx, _, stack| {
+                let (table, v1, v2): (Table, Value, Value) = stack.consume(ctx)?;
+
+                let (insert_pos, new_value) = match v2 {
+                    Value::Nil => ((table.length() + 1) as usize, v1),
+                    _ => (
+                        match v1 {
+                            Value::Integer(i) => i as usize,
+                            _ => {
+                                return Err("Invalid index given to table.insert"
+                                    .into_value(ctx)
+                                    .into());
+                            }
+                        },
+                        v2,
+                    ),
+                };
+
+                table
+                    .0
+                    .borrow_mut(&ctx)
+                    .entries
+                    .insert(insert_pos, new_value.into_value(ctx))?;
+
+                Ok(CallbackReturn::Return)
+            }),
+        )
+        .unwrap();
+
+    table
+        .set(
+            ctx,
+            "remove",
+            AnyCallback::from_fn(&ctx, |ctx, _, stack| {
+                let (table, index): (Table, Option<i64>) = stack.consume(ctx)?;
+                let len = table.length();
+
+                if len == 0 {
+                    return Ok(CallbackReturn::Return);
+                }
+
+                let index = index.unwrap_or(len);
+
+                if index < 1 || index > len {
+                    return Ok(CallbackReturn::Return);
+                }
+
+                stack.replace(ctx, table.0.borrow_mut(&ctx).entries.remove(index as usize));
+                Ok(CallbackReturn::Return)
+            }),
+        )
+        .unwrap();
+
+    table
+        .set(
+            ctx,
+            "concat",
+            AnyCallback::from_fn(&ctx, |ctx, _, stack| {
+                let (table, sep, start, end): (Table, Option<String>, Option<i64>, Option<i64>) =
+                    stack.consume(ctx)?;
+
+                let start = start.unwrap_or(1);
+                let end = end.unwrap_or(table.length());
+                let mut result = StdString::new();
+
+                let sep = match sep {
+                    Some(sep) => Some(sep.to_str()?),
+                    None => None,
+                };
+
+                for i in start..=end {
+                    let entry = table.get(ctx, Value::Integer(i));
+
+                    match entry {
+                        Value::Nil => {
+                            return Err("Encountered nil within given range to table.concat"
+                                .into_value(ctx)
+                                .into());
+                        }
+                        Value::Integer(i) => result.push_str(&i.to_string()),
+                        Value::Number(i) => result.push_str(&i.to_string()),
+                        Value::String(s) => match s.to_str() {
+                            Ok(s) => result.push_str(s),
+                            Err(_) => {
+                                return Err("Failed to convert given string".into_value(ctx).into())
+                            }
+                        },
+                        _ => {
+                            return Err("Invalid value within given range to table.concat"
+                                .into_value(ctx)
+                                .into());
+                        }
+                    };
+
+                    if i != end {
+                        if let Some(ref sep) = sep {
+                            result.push_str(sep);
+                        }
+                    }
+                }
+
+                stack.replace(ctx, Value::String(String::from_slice(&ctx, result)));
+                Ok(CallbackReturn::Return)
+            }),
+        )
+        .unwrap();
+
     ctx.state.globals.set(ctx, "table", table).unwrap();
 }

src/table.rs

@@ -159,6 +159,22 @@ impl<'gc> TableEntries<'gc> {
         }
     }
 
+    pub fn remove(&mut self, index: usize) -> Value<'gc> {
+        self.array.remove(index - 1)
+    }
+
+    pub fn insert(&mut self, index: usize, value: Value<'gc>) -> Result<(), InvalidTableKey> {
+        if index >= 1 && index <= self.array.len() {
+            self.array.reserve(1);
+            self.array.insert(index - 1, value);
+        } else {
+            let key = Value::Integer(index.try_into().unwrap());
+            self.set(key, value)?;
+        }
+
+        Ok(())
+    }
+
     pub fn get(&self, key: Value<'gc>) -> Value<'gc> {
         if let Some(index) = to_array_index(key) {
             if index < self.array.len() {

tests/scripts/basic.lua

@@ -54,12 +54,23 @@ local function test_short_circuit_large()
     return (a + 2 + (a == 1 and (d or (c + (b + 2))))) == 10
 end
 
+local function test_tonumber()
+    return tonumber("1") == 1 and 
+      tonumber("1.1") == 1.1 and 
+      tonumber("0x1A") == 26 and 
+      -- TODO
+      -- tonumber("1010", 2) == 10 and  -- binary to decimal
+      -- tonumber("12", 8) and  -- octal to decimal
+      tonumber("foo") == nil
+end
+
 assert(
     test1() and
     test2() and
     test3() and
     test4() and
     test5() and
     test6() and
-    test_short_circuit_large()
+    test_short_circuit_large() and
+    test_tonumber()
 )

tests/scripts/string.lua

@@ -35,7 +35,14 @@ function test_len()
         string.len(-2147483648) == 11
 end
 
+function test_sub()
+    return string.sub("foo", 1) == "foo" and
+        string.sub("foo", 2) == "oo" and
+        string.sub("hello world", 3, 5) == "llo"
+end
+
 assert(
     test_concat() and
-    test_len()
+    test_len() and
+    test_sub()
 )

tests/scripts/table.lua

@@ -122,3 +122,48 @@ do
     assert(table.unpack(t, 4, 4) == nil)
     assert(table.unpack(t, 4, 2) == nil)
 end
+do
+    local t = {}
+    table.insert(t, 1)
+    assert(t[1] == 1)
+    assert(#t == 1)
+    table.insert(t, 2)
+    assert(t[1] == 1)
+    assert(t[2] == 2)
+    assert(#t == 2)
+    table.insert(t, 1, 4)
+    assert(#t == 3)
+    assert(t[1] == 4)
+    assert(t[2] == 1)
+    assert(t[3] == 2)
+    table.insert(t, 4, 5)
+    assert(#t == 4)
+    assert(t[1] == 4)
+    assert(t[2] == 1)
+    assert(t[3] == 2)
+    assert(t[4] == 5)
+    table.insert(t, 9, 8)
+    assert(#t == 4)
+    assert(t[1] == 4)
+    assert(t[2] == 1)
+    assert(t[3] == 2)
+    assert(t[4] == 5)
+    assert(t[9] == 8)
+end
+do
+    local t = {}
+    table.remove(t, 1)
+    assert(#t == 0)
+    t = {1, 2, 3}
+    table.remove(t, 1)
+    print(t[1])
+    print(t[2])
+    print(t[3])
+    assert(#t == 2)
+    assert(t[1] == 2)
+    assert(t[2] == 3)
+end
+do
+    local t = {"a", "b", "c"}
+    assert(table.concat(t) == "abc")
+end