From 279c233cb1f32ed42419ed6a9c2e14c1c1bc80e7 Mon Sep 17 00:00:00 2001
From: Micha White <botahamec@outlook.com>
Date: Wed, 8 Nov 2023 14:09:17 -0500
Subject: Create a script system

---
 scripts/src/libs/allocate.rs |  76 +++++++++
 scripts/src/libs/buffer.rs   | 182 ++++++++++++++++++++
 scripts/src/libs/ctype.rs    |  85 +++++++++
 scripts/src/libs/math.rs     | 398 +++++++++++++++++++++++++++++++++++++++++++
 scripts/src/libs/mod.rs      |  19 +++
 scripts/src/libs/system.rs   | 154 +++++++++++++++++
 6 files changed, 914 insertions(+)
 create mode 100644 scripts/src/libs/allocate.rs
 create mode 100644 scripts/src/libs/buffer.rs
 create mode 100644 scripts/src/libs/ctype.rs
 create mode 100644 scripts/src/libs/math.rs
 create mode 100644 scripts/src/libs/mod.rs
 create mode 100644 scripts/src/libs/system.rs

(limited to 'scripts/src/libs')

diff --git a/scripts/src/libs/allocate.rs b/scripts/src/libs/allocate.rs
new file mode 100644
index 0000000..7f2825d
--- /dev/null
+++ b/scripts/src/libs/allocate.rs
@@ -0,0 +1,76 @@
+use wasmtime::Caller;
+
+use crate::{ScriptManager, WasmScriptState};
+
+use super::{
+	system::{_alloc, _get_memory},
+	LIBRARY_NAME,
+};
+
+fn allocate_zeroed(mut caller: Caller<'_, WasmScriptState>, size: u32, align: u32) -> u32 {
+	let Some((ptr, data)) = _alloc(&mut caller, size, align) else {
+		return 0;
+	};
+
+	data.fill(0);
+	ptr
+}
+
+fn reallocate(
+	mut caller: Caller<'_, WasmScriptState>,
+	ptr: u32,
+	size: u32,
+	new_size: u32,
+	align: u32,
+) -> u32 {
+	if new_size < size {
+		return ptr;
+	}
+
+	let bump_pointer = &mut caller.data_mut().bump_pointer;
+	if *bump_pointer == ptr + size {
+		*bump_pointer = ptr;
+		let Some((new_ptr, _)) = _alloc(&mut caller, new_size, align) else {
+			return 4;
+		};
+		return new_ptr;
+	}
+
+	let (_, original) = _get_memory(&mut caller);
+	let Some(original) = original.get(ptr as usize..(ptr + size) as usize) else {
+		return 4;
+	};
+	let original = original.to_vec();
+
+	let Some((new_ptr, data)) = _alloc(&mut caller, new_size, align) else {
+		return 0;
+	};
+
+	data.get_mut(..size as usize)
+		.unwrap()
+		.clone_from_slice(&original);
+	new_ptr
+}
+
+fn duplicate(mut caller: Caller<'_, WasmScriptState>, ptr: u32, size: u32, align: u32) -> u32 {
+	let (_, original) = _get_memory(&mut caller);
+	let Some(original) = original.get(ptr as usize..(ptr + size) as usize) else {
+		return 4;
+	};
+	let original = original.to_vec();
+
+	let Some((new_ptr, data)) = _alloc(&mut caller, size, align) else {
+		return 0;
+	};
+
+	data.clone_from_slice(&original);
+	new_ptr
+}
+
+pub fn library(manager: &mut ScriptManager) -> Option<()> {
+	manager.add_library_function(LIBRARY_NAME, "calloc", allocate_zeroed)?;
+	manager.add_library_function(LIBRARY_NAME, "realloc", reallocate)?;
+	manager.add_library_function(LIBRARY_NAME, "memdup", duplicate)?;
+
+	Some(())
+}
diff --git a/scripts/src/libs/buffer.rs b/scripts/src/libs/buffer.rs
new file mode 100644
index 0000000..b4cee77
--- /dev/null
+++ b/scripts/src/libs/buffer.rs
@@ -0,0 +1,182 @@
+use wasmtime::Caller;
+
+use crate::{ScriptManager, WasmScriptState};
+
+use super::{system::_get_memory, LIBRARY_NAME};
+
+fn memory_search(mut caller: Caller<'_, WasmScriptState>, ptr: u32, ch: u32, len: u32) -> u32 {
+	let (_, mem_ptr) = _get_memory(&mut caller);
+	let len = len as usize;
+	let ptr = ptr as usize;
+	let ch = ch as u8;
+	if (len + ptr) > mem_ptr.len() {
+		return 4;
+	}
+
+	for i in 0..len {
+		if mem_ptr[ptr + i] == ch {
+			return (ptr + i) as u32;
+		}
+	}
+
+	0
+}
+
+fn memory_search_last(mut caller: Caller<'_, WasmScriptState>, ptr: u32, ch: u32, len: u32) -> u32 {
+	let (_, mem_ptr) = _get_memory(&mut caller);
+	let len = len as usize;
+	let ptr = ptr as usize;
+	let ch = ch as u8;
+	if (len + ptr) > mem_ptr.len() {
+		return 4;
+	}
+
+	for i in 0..len {
+		let index = ptr + len - i - 1;
+		if mem_ptr[index] == ch {
+			return index as u32;
+		}
+	}
+
+	0
+}
+
+fn memory_compare(
+	mut caller: Caller<'_, WasmScriptState>,
+	lhs: u32,
+	rhs: u32,
+	len: u32,
+) -> (u32, u32) {
+	let (_, mem_ptr) = _get_memory(&mut caller);
+	let len = len as usize;
+	let lhs = lhs as usize;
+	let rhs = rhs as usize;
+	if (len + lhs) > mem_ptr.len() || (len + rhs) > mem_ptr.len() {
+		return (4, 0);
+	}
+
+	for i in 0..len {
+		let diff = mem_ptr[lhs + i] - mem_ptr[rhs + i];
+		if diff != 0 {
+			return (0, diff as u32);
+		}
+	}
+
+	(0, 0)
+}
+
+fn memory_fill(mut caller: Caller<'_, WasmScriptState>, dest: u32, ch: u32, len: u32) -> u32 {
+	let (_, mem_ptr) = _get_memory(&mut caller);
+	let len = len as usize;
+	let dest = dest as usize;
+	let ch = ch as u8;
+
+	if (len + dest) > mem_ptr.len() {
+		return 4;
+	}
+
+	for i in 0..len {
+		mem_ptr[dest + i] = ch;
+	}
+
+	0
+}
+
+fn memory_copy(mut caller: Caller<'_, WasmScriptState>, dest: u32, src: u32, len: u32) -> u32 {
+	let (_, mem_ptr) = _get_memory(&mut caller);
+	let len = len as usize;
+	let dest = dest as usize;
+	let src = src as usize;
+	if (len + dest) > mem_ptr.len() || (len + src) > mem_ptr.len() {
+		return 4;
+	}
+
+	// check for overlap
+	if (dest < src && dest + len > src) || (src < dest && src + len > dest) {
+		let src = mem_ptr[src..src + len].to_vec();
+		let dest = &mut mem_ptr[dest..dest + len];
+		dest.clone_from_slice(&src);
+	} else {
+		for i in 0..len {
+			mem_ptr[dest + i] = mem_ptr[src + i];
+		}
+	}
+
+	0
+}
+
+fn memory_copy_until(
+	mut caller: Caller<'_, WasmScriptState>,
+	dest: u32,
+	src: u32,
+	len: u32,
+	delimiter: u32,
+) -> u32 {
+	let (_, mem_ptr) = _get_memory(&mut caller);
+	let len = len as usize;
+	let dest = dest as usize;
+	let src = src as usize;
+	let delimiter = delimiter as u8;
+	if (len + dest) > mem_ptr.len() || (len + src) > mem_ptr.len() {
+		return 4;
+	}
+
+	// check for overlap
+	if (dest < src && dest + len > src) || (src < dest && src + len > dest) {
+		let cloned_src = mem_ptr[src..src + len].to_vec();
+		let dest = &mut mem_ptr[dest..dest + len];
+		for i in 0..len {
+			let ch = cloned_src[i];
+			dest[i] = ch;
+			if ch == delimiter {
+				return (src + i + 1) as u32;
+			}
+		}
+	} else {
+		for i in 0..len {
+			let ch = mem_ptr[src + i];
+			mem_ptr[dest + i] = ch;
+			if ch == delimiter {
+				return (src + i + 1) as u32;
+			}
+		}
+	}
+
+	0
+}
+
+fn memory_concatenate(
+	mut caller: Caller<'_, WasmScriptState>,
+	dest: u32,
+	src: u32,
+	dest_len: u32,
+	src_len: u32,
+) -> u32 {
+	let (_, mem_ptr) = _get_memory(&mut caller);
+	let dest = dest as usize;
+	let src = src as usize;
+	let dest_len = dest_len as usize;
+	let src_len = src_len as usize;
+	if (dest_len + src_len + dest) > mem_ptr.len() || (src_len + src) > mem_ptr.len() {
+		return 4;
+	}
+
+	let src = mem_ptr[src..src + src_len].to_vec();
+	let dest_offset = dest + dest_len;
+	let dest = &mut mem_ptr[dest_offset..dest_offset + src_len];
+	dest.clone_from_slice(&src);
+
+	0
+}
+
+pub fn library(manager: &mut ScriptManager) -> Option<()> {
+	manager.add_library_function(LIBRARY_NAME, "memchr", memory_search)?;
+	manager.add_library_function(LIBRARY_NAME, "memrchr", memory_search_last)?;
+	manager.add_library_function(LIBRARY_NAME, "memcmp", memory_compare)?;
+	manager.add_library_function(LIBRARY_NAME, "memset", memory_fill)?;
+	manager.add_library_function(LIBRARY_NAME, "memcpy", memory_copy)?;
+	manager.add_library_function(LIBRARY_NAME, "memccpy", memory_copy_until)?;
+	manager.add_library_function(LIBRARY_NAME, "memcat", memory_concatenate)?;
+
+	Some(())
+}
diff --git a/scripts/src/libs/ctype.rs b/scripts/src/libs/ctype.rs
new file mode 100644
index 0000000..ca4f326
--- /dev/null
+++ b/scripts/src/libs/ctype.rs
@@ -0,0 +1,85 @@
+use crate::{libs::LIBRARY_NAME, ScriptManager};
+
+fn char_is(func: impl Fn(char) -> bool, ch: u32) -> u32 {
+	let Some(ch) = char::from_u32(ch) else {
+		return 0;
+	};
+
+	func(ch) as u32
+}
+
+macro_rules! ctype {
+	(fn $fn_name: ident => $fn: expr;) => {
+		fn $fn_name(ch: u32) -> u32 {
+			char_is($fn, ch)
+		}
+	};
+	(fn $fn_name: ident => $fn: expr; $(fn $fn_name2: ident => $fn2: expr;)*) => {
+		fn $fn_name(ch: u32) -> u32 {
+			char_is($fn, ch)
+		}
+		ctype!($(fn $fn_name2 => $fn2;)*);
+	};
+}
+
+ctype!(
+	fn is_alphanumeric => |ch| ch.is_alphanumeric();
+	fn is_alphabetic => |ch| ch.is_alphabetic();
+	fn is_lowercase => |ch| ch.is_lowercase();
+	fn is_uppercase => |ch| ch.is_uppercase();
+	fn is_control => |ch| ch.is_control();
+	fn is_whitespace => |ch| ch.is_whitespace();
+	fn is_ascii_alphanumeric => |ch| ch.is_ascii_alphanumeric();
+	fn is_ascii_alphabetic => |ch| ch.is_ascii_alphabetic();
+	fn is_ascii_lowercase => |ch| ch.is_ascii_lowercase();
+	fn is_ascii_uppercase => |ch| ch.is_ascii_lowercase();
+	fn is_ascii_digit => |ch| ch.is_ascii_digit();
+	fn is_ascii_hexdigit => |ch| ch.is_ascii_hexdigit();
+	fn is_ascii_control => |ch| ch.is_ascii_control();
+	fn is_ascii_graphical => |ch| ch.is_ascii_graphic();
+	fn is_ascii_whitespace => |ch| ch.is_ascii_whitespace();
+	fn is_ascii_blank => |ch| ch == ' ' || ch == '\t';
+	fn is_ascii_printable => |ch| ch.is_alphanumeric() || ch.is_ascii_punctuation();
+	fn is_ascii_punctuation => |ch| ch.is_ascii_punctuation();
+);
+
+fn to_ascii_lower(ch: u32) -> u32 {
+	let Some(ch) = char::from_u32(ch) else {
+		return ch;
+	};
+
+	ch.to_ascii_lowercase() as u32
+}
+
+fn to_ascii_upper(ch: u32) -> u32 {
+	let Some(ch) = char::from_u32(ch) else {
+		return ch;
+	};
+
+	ch.to_ascii_uppercase() as u32
+}
+
+pub fn library(manager: &mut ScriptManager) -> Option<()> {
+	manager.add_library_function(LIBRARY_NAME, "iswalnum", is_alphanumeric)?;
+	manager.add_library_function(LIBRARY_NAME, "iswalpha", is_alphabetic)?;
+	manager.add_library_function(LIBRARY_NAME, "iswlower", is_lowercase)?;
+	manager.add_library_function(LIBRARY_NAME, "iswupper", is_uppercase)?;
+	manager.add_library_function(LIBRARY_NAME, "iswcntrl", is_control)?;
+	manager.add_library_function(LIBRARY_NAME, "iswspace", is_whitespace)?;
+	manager.add_library_function(LIBRARY_NAME, "isalnum", is_ascii_alphanumeric)?;
+	manager.add_library_function(LIBRARY_NAME, "isalpha", is_ascii_alphabetic)?;
+	manager.add_library_function(LIBRARY_NAME, "islower", is_ascii_lowercase)?;
+	manager.add_library_function(LIBRARY_NAME, "isupper", is_ascii_uppercase)?;
+	manager.add_library_function(LIBRARY_NAME, "isdigit", is_ascii_digit)?;
+	manager.add_library_function(LIBRARY_NAME, "isxdigit", is_ascii_hexdigit)?;
+	manager.add_library_function(LIBRARY_NAME, "iscntrl", is_ascii_control)?;
+	manager.add_library_function(LIBRARY_NAME, "isgraph", is_ascii_graphical)?;
+	manager.add_library_function(LIBRARY_NAME, "isspace", is_ascii_whitespace)?;
+	manager.add_library_function(LIBRARY_NAME, "isblank", is_ascii_blank)?;
+	manager.add_library_function(LIBRARY_NAME, "isprint", is_ascii_printable)?;
+	manager.add_library_function(LIBRARY_NAME, "ispunct", is_ascii_punctuation)?;
+	manager.add_library_function(LIBRARY_NAME, "tolower", to_ascii_lower)?;
+	manager.add_library_function(LIBRARY_NAME, "toupper", to_ascii_upper)?;
+
+	Some(())
+}
diff --git a/scripts/src/libs/math.rs b/scripts/src/libs/math.rs
new file mode 100644
index 0000000..4aae3c3
--- /dev/null
+++ b/scripts/src/libs/math.rs
@@ -0,0 +1,398 @@
+use crate::ScriptManager;
+
+use super::LIBRARY_NAME;
+
+fn abs_i32(n: i32) -> i32 {
+	n.abs()
+}
+
+fn abs_i64(n: i64) -> i64 {
+	n.abs()
+}
+
+fn mod_f32(x: f32, y: f32) -> f32 {
+	libm::fmodf(x, y)
+}
+
+fn mod_f64(x: f64, y: f64) -> f64 {
+	libm::fmod(x, y)
+}
+
+fn remainder_f32(x: f32, y: f32) -> f32 {
+	libm::remainderf(x, y)
+}
+
+fn remainder_f64(x: f64, y: f64) -> f64 {
+	libm::remainder(x, y)
+}
+
+fn mul_add_f32(x: f32, y: f32, z: f32) -> f32 {
+	x.mul_add(y, z)
+}
+
+fn mul_add_f64(x: f64, y: f64, z: f64) -> f64 {
+	x.mul_add(y, z)
+}
+
+fn fdim_f32(x: f32, y: f32) -> f32 {
+	libm::fdimf(x, y)
+}
+
+fn fdim_f64(x: f64, y: f64) -> f64 {
+	libm::fdim(x, y)
+}
+
+fn exp_f32(x: f32) -> f32 {
+	x.exp()
+}
+
+fn exp_f64(x: f64) -> f64 {
+	x.exp()
+}
+
+fn exp2_f32(x: f32) -> f32 {
+	x.exp2()
+}
+
+fn exp2_f64(x: f64) -> f64 {
+	x.exp2()
+}
+
+fn expm1_f32(x: f32) -> f32 {
+	x.exp_m1()
+}
+
+fn expm1_f64(x: f64) -> f64 {
+	x.exp_m1()
+}
+
+fn ln_f32(x: f32) -> f32 {
+	x.ln()
+}
+
+fn ln_f64(x: f64) -> f64 {
+	x.ln()
+}
+
+fn log10_f32(x: f32) -> f32 {
+	x.log10()
+}
+
+fn log10_f64(x: f64) -> f64 {
+	x.log10()
+}
+
+fn log2_f32(x: f32) -> f32 {
+	x.log2()
+}
+
+fn log2_f64(x: f64) -> f64 {
+	x.log2()
+}
+
+fn ln1p_f32(x: f32) -> f32 {
+	x.ln_1p()
+}
+
+fn ln1p_f64(x: f64) -> f64 {
+	x.ln_1p()
+}
+
+fn pow_f32(base: f32, exponent: f32) -> f32 {
+	base.powf(exponent)
+}
+
+fn pow_f64(base: f64, exponent: f64) -> f64 {
+	base.powf(exponent)
+}
+
+fn cbrt_f32(x: f32) -> f32 {
+	x.cbrt()
+}
+
+fn cbrt_f64(x: f64) -> f64 {
+	x.cbrt()
+}
+
+fn hypotenuse_f32(x: f32, y: f32) -> f32 {
+	x.hypot(y)
+}
+
+fn hypotenuse_f64(x: f64, y: f64) -> f64 {
+	x.hypot(y)
+}
+
+fn sin_f32(x: f32) -> f32 {
+	x.sin()
+}
+
+fn sin_f64(x: f64) -> f64 {
+	x.sin()
+}
+
+fn cos_f32(x: f32) -> f32 {
+	x.cos()
+}
+
+fn cos_f64(x: f64) -> f64 {
+	x.cos()
+}
+
+fn tan_f32(x: f32) -> f32 {
+	x.tan()
+}
+
+fn tan_f64(x: f64) -> f64 {
+	x.tan()
+}
+
+fn asin_f32(x: f32) -> f32 {
+	x.asin()
+}
+
+fn asin_f64(x: f64) -> f64 {
+	x.asin()
+}
+
+fn acos_f32(x: f32) -> f32 {
+	x.acos()
+}
+
+fn acos_f64(x: f64) -> f64 {
+	x.acos()
+}
+
+fn atan_f32(x: f32) -> f32 {
+	x.atan()
+}
+
+fn atan_f64(x: f64) -> f64 {
+	x.atan()
+}
+
+fn sinh_f32(x: f32) -> f32 {
+	x.sinh()
+}
+
+fn sinh_f64(x: f64) -> f64 {
+	x.sinh()
+}
+
+fn cosh_f32(x: f32) -> f32 {
+	x.cosh()
+}
+
+fn cosh_f64(x: f64) -> f64 {
+	x.cosh()
+}
+
+fn tanh_f32(x: f32) -> f32 {
+	x.tanh()
+}
+
+fn tanh_f64(x: f64) -> f64 {
+	x.tanh()
+}
+
+fn asinh_f32(x: f32) -> f32 {
+	x.asinh()
+}
+
+fn asinh_f64(x: f64) -> f64 {
+	x.asinh()
+}
+
+fn acosh_f32(x: f32) -> f32 {
+	x.acosh()
+}
+
+fn acosh_f64(x: f64) -> f64 {
+	x.acosh()
+}
+
+fn atanh_f32(x: f32) -> f32 {
+	x.atanh()
+}
+
+fn atanh_f64(x: f64) -> f64 {
+	x.atanh()
+}
+
+fn erf_f32(x: f32) -> f32 {
+	libm::erff(x)
+}
+
+fn erf_f64(x: f64) -> f64 {
+	libm::erf(x)
+}
+
+fn erfc_f32(x: f32) -> f32 {
+	libm::erfcf(x)
+}
+
+fn erfc_f64(x: f64) -> f64 {
+	libm::erfc(x)
+}
+
+fn gamma_f32(x: f32) -> f32 {
+	libm::tgammaf(x)
+}
+
+fn gamma_f64(x: f64) -> f64 {
+	libm::tgamma(x)
+}
+
+fn ln_gamma_f32(x: f32) -> f32 {
+	libm::lgammaf(x)
+}
+
+fn ln_gamma_f64(x: f64) -> f64 {
+	libm::lgamma(x)
+}
+
+fn round_f32_i32(x: f32) -> i32 {
+	x.round() as i32
+}
+
+fn round_f64_i32(x: f64) -> i32 {
+	x.round() as i32
+}
+
+fn round_f32_i64(x: f32) -> i64 {
+	x.round() as i64
+}
+
+fn round_f64_i64(x: f64) -> i64 {
+	x.round() as i64
+}
+
+fn frexp_f32(x: f32) -> (f32, i32) {
+	libm::frexpf(x)
+}
+
+fn frexp_f64(x: f64) -> (f64, i32) {
+	libm::frexp(x)
+}
+
+fn ldexp_f32(x: f32, exp: i32) -> f32 {
+	libm::ldexpf(x, exp)
+}
+
+fn ldexp_f64(x: f64, exp: i32) -> f64 {
+	libm::ldexp(x, exp)
+}
+
+fn modf_f32(x: f32) -> (f32, f32) {
+	libm::modff(x)
+}
+
+fn modf_f64(x: f64) -> (f64, f64) {
+	libm::modf(x)
+}
+
+fn logb_f32(x: f32) -> i32 {
+	libm::ilogbf(x)
+}
+
+fn logb_f64(x: f64) -> i32 {
+	libm::ilogb(x)
+}
+
+fn next_after_f32(from: f32, to: f32) -> f32 {
+	libm::nextafterf(from, to)
+}
+
+fn next_after_f64(from: f64, to: f64) -> f64 {
+	libm::nextafter(from, to)
+}
+
+fn copy_sign_f32(x: f32, y: f32) -> f32 {
+	libm::copysignf(x, y)
+}
+
+fn copy_sign_f64(x: f64, y: f64) -> f64 {
+	libm::copysign(x, y)
+}
+
+pub fn library(manager: &mut ScriptManager) -> Option<()> {
+	manager.add_library_function(LIBRARY_NAME, "abs", abs_i32)?;
+	manager.add_library_function(LIBRARY_NAME, "labs", abs_i64)?;
+	manager.add_library_function(LIBRARY_NAME, "modf", mod_f32)?;
+	manager.add_library_function(LIBRARY_NAME, "mod", mod_f64)?;
+	manager.add_library_function(LIBRARY_NAME, "remf", remainder_f32)?;
+	manager.add_library_function(LIBRARY_NAME, "rem", remainder_f64)?;
+	manager.add_library_function(LIBRARY_NAME, "fmaf", mul_add_f32)?;
+	manager.add_library_function(LIBRARY_NAME, "fma", mul_add_f64)?;
+	manager.add_library_function(LIBRARY_NAME, "fdimf", fdim_f32)?;
+	manager.add_library_function(LIBRARY_NAME, "fdim", fdim_f64)?;
+	manager.add_library_function(LIBRARY_NAME, "expf", exp_f32)?;
+	manager.add_library_function(LIBRARY_NAME, "exp", exp_f64)?;
+	manager.add_library_function(LIBRARY_NAME, "exp2f", exp2_f32)?;
+	manager.add_library_function(LIBRARY_NAME, "exp2", exp2_f64)?;
+	manager.add_library_function(LIBRARY_NAME, "expm1f", expm1_f32)?;
+	manager.add_library_function(LIBRARY_NAME, "expm1", expm1_f64)?;
+	manager.add_library_function(LIBRARY_NAME, "lnf", ln_f32)?;
+	manager.add_library_function(LIBRARY_NAME, "ln", ln_f64)?;
+	manager.add_library_function(LIBRARY_NAME, "log2f", log2_f32)?;
+	manager.add_library_function(LIBRARY_NAME, "log2", log2_f64)?;
+	manager.add_library_function(LIBRARY_NAME, "log10f", log10_f32)?;
+	manager.add_library_function(LIBRARY_NAME, "log10", log10_f64)?;
+	manager.add_library_function(LIBRARY_NAME, "ln1pf", ln1p_f32)?;
+	manager.add_library_function(LIBRARY_NAME, "ln1p", ln1p_f64)?;
+	manager.add_library_function(LIBRARY_NAME, "powf", pow_f32)?;
+	manager.add_library_function(LIBRARY_NAME, "pow", pow_f64)?;
+	manager.add_library_function(LIBRARY_NAME, "cbrtf", cbrt_f32)?;
+	manager.add_library_function(LIBRARY_NAME, "cbrt", cbrt_f64)?;
+	manager.add_library_function(LIBRARY_NAME, "hypotf", hypotenuse_f32)?;
+	manager.add_library_function(LIBRARY_NAME, "hypot", hypotenuse_f64)?;
+	manager.add_library_function(LIBRARY_NAME, "sinf", sin_f32)?;
+	manager.add_library_function(LIBRARY_NAME, "sin", sin_f64)?;
+	manager.add_library_function(LIBRARY_NAME, "cosf", cos_f32)?;
+	manager.add_library_function(LIBRARY_NAME, "cos", cos_f64)?;
+	manager.add_library_function(LIBRARY_NAME, "tanf", tan_f32)?;
+	manager.add_library_function(LIBRARY_NAME, "tan", tan_f64)?;
+	manager.add_library_function(LIBRARY_NAME, "asinf", asin_f32)?;
+	manager.add_library_function(LIBRARY_NAME, "asin", asin_f64)?;
+	manager.add_library_function(LIBRARY_NAME, "acosf", acos_f32)?;
+	manager.add_library_function(LIBRARY_NAME, "acos", acos_f64)?;
+	manager.add_library_function(LIBRARY_NAME, "atanf", atan_f32)?;
+	manager.add_library_function(LIBRARY_NAME, "atan", atan_f64)?;
+	manager.add_library_function(LIBRARY_NAME, "sinhf", sinh_f32)?;
+	manager.add_library_function(LIBRARY_NAME, "sinh", sinh_f64)?;
+	manager.add_library_function(LIBRARY_NAME, "coshf", cosh_f32)?;
+	manager.add_library_function(LIBRARY_NAME, "cosh", cosh_f64)?;
+	manager.add_library_function(LIBRARY_NAME, "tanhf", tanh_f32)?;
+	manager.add_library_function(LIBRARY_NAME, "tanh", tanh_f64)?;
+	manager.add_library_function(LIBRARY_NAME, "asinhf", asinh_f32)?;
+	manager.add_library_function(LIBRARY_NAME, "asinh", asinh_f64)?;
+	manager.add_library_function(LIBRARY_NAME, "acoshf", acosh_f32)?;
+	manager.add_library_function(LIBRARY_NAME, "acosh", acosh_f64)?;
+	manager.add_library_function(LIBRARY_NAME, "atanhf", atanh_f32)?;
+	manager.add_library_function(LIBRARY_NAME, "atanh", atanh_f64)?;
+	manager.add_library_function(LIBRARY_NAME, "erff", erf_f32)?;
+	manager.add_library_function(LIBRARY_NAME, "erf", erf_f64)?;
+	manager.add_library_function(LIBRARY_NAME, "erfcf", erfc_f32)?;
+	manager.add_library_function(LIBRARY_NAME, "erfc", erfc_f64)?;
+	manager.add_library_function(LIBRARY_NAME, "gammaf", gamma_f32)?;
+	manager.add_library_function(LIBRARY_NAME, "gamma", gamma_f64)?;
+	manager.add_library_function(LIBRARY_NAME, "lgammaf", ln_gamma_f32)?;
+	manager.add_library_function(LIBRARY_NAME, "lgamma", ln_gamma_f64)?;
+	manager.add_library_function(LIBRARY_NAME, "lroundf", round_f32_i32)?;
+	manager.add_library_function(LIBRARY_NAME, "lround", round_f64_i32)?;
+	manager.add_library_function(LIBRARY_NAME, "llroundf", round_f32_i64)?;
+	manager.add_library_function(LIBRARY_NAME, "llround", round_f64_i64)?;
+	manager.add_library_function(LIBRARY_NAME, "frexpf", frexp_f32)?;
+	manager.add_library_function(LIBRARY_NAME, "frexp", frexp_f64)?;
+	manager.add_library_function(LIBRARY_NAME, "ldexpf", ldexp_f32)?;
+	manager.add_library_function(LIBRARY_NAME, "ldexp", ldexp_f64)?;
+	manager.add_library_function(LIBRARY_NAME, "modff", modf_f32)?;
+	manager.add_library_function(LIBRARY_NAME, "modf", modf_f64)?;
+	manager.add_library_function(LIBRARY_NAME, "ilogbf", logb_f32)?;
+	manager.add_library_function(LIBRARY_NAME, "ilogb", logb_f64)?;
+	manager.add_library_function(LIBRARY_NAME, "nextafterf", next_after_f32)?;
+	manager.add_library_function(LIBRARY_NAME, "nextafter", next_after_f64)?;
+	manager.add_library_function(LIBRARY_NAME, "copysignf", copy_sign_f32)?;
+	manager.add_library_function(LIBRARY_NAME, "copysign", copy_sign_f64)?;
+
+	Some(())
+}
diff --git a/scripts/src/libs/mod.rs b/scripts/src/libs/mod.rs
new file mode 100644
index 0000000..c6b1ffc
--- /dev/null
+++ b/scripts/src/libs/mod.rs
@@ -0,0 +1,19 @@
+use crate::ScriptManager;
+
+mod allocate;
+mod buffer;
+mod ctype;
+mod math;
+mod system;
+
+const LIBRARY_NAME: &str = "alligator";
+
+pub fn add_alligator_library(manager: &mut ScriptManager) -> Option<()> {
+	allocate::library(manager)?;
+	buffer::library(manager)?;
+	ctype::library(manager)?;
+	math::library(manager)?;
+	system::library(manager)?;
+
+	Some(())
+}
diff --git a/scripts/src/libs/system.rs b/scripts/src/libs/system.rs
new file mode 100644
index 0000000..e2d0ddb
--- /dev/null
+++ b/scripts/src/libs/system.rs
@@ -0,0 +1,154 @@
+use std::mem::align_of;
+use std::{borrow::Cow, process::Command};
+
+use chrono::Offset;
+use wasmtime::{Caller, Memory};
+
+use crate::{ScriptManager, WasmScriptState};
+
+use super::LIBRARY_NAME;
+
+pub fn _get_memory<'a>(caller: &'a mut Caller<WasmScriptState>) -> (Memory, &'a mut [u8]) {
+	let memory = caller.get_export("memory").unwrap().into_memory().unwrap();
+	let mem_ptr = memory.data_mut(caller);
+	(memory, mem_ptr)
+}
+
+fn _get_string<'a>(
+	caller: &'a mut Caller<WasmScriptState>,
+	offset: u32,
+	length: u32,
+) -> Option<Cow<'a, str>> {
+	let (_, mem_ptr) = _get_memory(caller);
+	if (offset as usize + length as usize) > mem_ptr.len() {
+		return None;
+	}
+
+	Some(String::from_utf8_lossy(
+		&mem_ptr[offset as usize..length as usize],
+	))
+}
+
+fn _log(caller: &mut Caller<WasmScriptState>, level: log::Level, message: u32, length: u32) -> u32 {
+	let Some(message) = _get_string(caller, message, length) else {
+		return 4;
+	};
+	log::log!(level, "{}", message);
+	0
+}
+
+pub fn _alloc<'a>(
+	mut caller: &'a mut Caller<WasmScriptState>,
+	size: u32,
+	align: u32,
+) -> Option<(u32, &'a mut [u8])> {
+	// find bumper location in memory
+	let bump_offset = caller.data().bump_pointer;
+	let (memory, memory_ptr) = _get_memory(caller);
+	let bump_ptr = &memory_ptr[bump_offset as usize..];
+
+	// calculate pointer to the new allocation
+	let offset = bump_ptr.as_ptr().align_offset(align as usize);
+	let new_offset = bump_offset + offset as u32;
+
+	// update bump pointer
+	let bump_offset = &mut caller.data_mut().bump_pointer;
+	*bump_offset = new_offset + size;
+
+	// grow memory if necessary
+	let bump_offset = *bump_offset;
+	if memory.data_size(&caller) < bump_offset as usize {
+		let delta = (size + offset as u32) / (64 * 1024) + 1;
+		if memory.grow(&mut caller, delta as u64).is_err() {
+			return None;
+		}
+	}
+
+	let new_ptr = &mut _get_memory(caller).1[new_offset as usize..size as usize];
+	Some((new_offset, new_ptr))
+}
+
+fn allocate(mut caller: Caller<WasmScriptState>, size: u32, align: u32) -> u32 {
+	match _alloc(&mut caller, size, align) {
+		Some((ptr, _)) => ptr,
+		None => 0,
+	}
+}
+
+fn free_sized(mut caller: Caller<'_, WasmScriptState>, ptr: u32, size: u32) -> u32 {
+	let bump_offset = &mut caller.data_mut().bump_pointer;
+	if ptr + size == *bump_offset {
+		*bump_offset = ptr;
+	}
+
+	0
+}
+
+fn free_aligned_sized(
+	caller: Caller<'_, WasmScriptState>,
+	ptr: u32,
+	_alignment: u32,
+	size: u32,
+) -> u32 {
+	free_sized(caller, ptr, size)
+}
+
+fn env_var(mut caller: Caller<'_, WasmScriptState>, name: u32, length: u32) -> u32 {
+	let Some(name) = _get_string(&mut caller, name, length) else {
+		return 4;
+	};
+	let Ok(value) = std::env::var(name.to_string()) else {
+		return 1;
+	};
+
+	let Some((offset, ptr)) = _alloc(&mut caller, value.len() as u32, align_of::<u8>() as u32)
+	else {
+		return 0;
+	};
+	ptr.clone_from_slice(value.as_bytes());
+
+	offset
+}
+
+fn random_number() -> u64 {
+	rand::random()
+}
+
+fn current_time_utc() -> (i64, u32) {
+	let duration = chrono::Utc::now() - chrono::DateTime::<chrono::Utc>::MIN_UTC;
+	(
+		duration.num_seconds(),
+		duration.to_std().unwrap().subsec_nanos(),
+	)
+}
+
+fn local_offset() -> i32 {
+	chrono::Local::now().offset().fix().local_minus_utc()
+}
+
+fn log(mut caller: Caller<'_, WasmScriptState>, message: u32, length: u32) {
+	_log(&mut caller, log::Level::Info, message, length);
+}
+
+fn log_warn(mut caller: Caller<'_, WasmScriptState>, message: u32, length: u32) {
+	_log(&mut caller, log::Level::Warn, message, length);
+}
+
+fn log_error(mut caller: Caller<'_, WasmScriptState>, message: u32, length: u32) {
+	_log(&mut caller, log::Level::Error, message, length);
+}
+
+pub fn library(manager: &mut ScriptManager) -> Option<()> {
+	manager.add_library_function(LIBRARY_NAME, "aligned_alloc", allocate)?;
+	manager.add_library_function(LIBRARY_NAME, "free_sized", free_sized)?;
+	manager.add_library_function(LIBRARY_NAME, "free_aligned_sized", free_aligned_sized)?;
+	manager.add_library_function(LIBRARY_NAME, "env_var", env_var)?;
+	manager.add_library_function(LIBRARY_NAME, "random_number", random_number)?;
+	manager.add_library_function(LIBRARY_NAME, "current_time_utc", current_time_utc)?;
+	manager.add_library_function(LIBRARY_NAME, "local_offset", local_offset)?;
+	manager.add_library_function(LIBRARY_NAME, "log", log)?;
+	manager.add_library_function(LIBRARY_NAME, "log_warn", log_warn)?;
+	manager.add_library_function(LIBRARY_NAME, "log_error", log_error)?;
+
+	Some(())
+}
-- 
cgit v1.2.3