Merge pull request #54 from thevurv/none-lua-tables

Add an mlua like tables api

Author: vurvdev

Cargo.toml

@@ -21,3 +21,17 @@ serde = { version = "1.0.219", features = ["derive"] }
 interprocess = "2.2.3"
 nanoserde = { version = "0.2.1", default-features = false, features = ["binary"] }
 retour = { git = "https://github.com/thevurv/retour-rs" }
+
+autorun-lua = { path = "packages/autorun-lua" }
+autorun-ipc = { path = "packages/autorun-ipc" }
+autorun-types = { path = "packages/autorun-types" }
+autorun-log = { path = "packages/autorun-log" }
+autorun-interfaces = { path = "packages/autorun-interfaces" }
+autorun-scan = { path = "packages/autorun-scan" }
+autorun-core = { path = "packages/autorun-core" }
+autorun-env = { path = "packages/autorun-env" }
+autorun-fs = { path = "packages/autorun-fs" }
+autorun-steam = { path = "packages/autorun-steam" }
+autorun-jit = { path = "packages/autorun-jit" }
+autorun-luajit = { path = "packages/autorun-luajit" }
+autorun-plugin-api = { path = "packages/autorun-plugin-api" }

apps/autorun-egui/Cargo.toml

@@ -12,11 +12,11 @@ egui_extras = { version = "0.28.0", default-features = false, features = ["synte
 shh = { version = "1.0.1" }
 image = { version = "0.24", default-features = false, features = ["png"] }
 
-autorun-ipc = { path = "../../packages/autorun-ipc" }
-autorun-steam = { path = "../../packages/autorun-steam" }
-autorun-types = { path = "../../packages/autorun-types" }
-autorun-log = { path = "../../packages/autorun-log" }
-autorun-core = { path = "../../packages/autorun-core" }
+autorun-ipc = { workspace = true }
+autorun-steam = { workspace = true }
+autorun-types = { workspace = true }
+autorun-log = { workspace = true }
+autorun-core = { workspace = true }
 
 [target.'cfg(windows)'.dependencies]
 eframe = { version = "0.28.0" }

packages/autorun-core/Cargo.toml

@@ -9,5 +9,7 @@ description.workspace = true
 serde = { workspace = true }
 cap-std = { workspace = true }
 anyhow = { workspace = true }
+autorun-lua = { workspace = true }
+
 nestify = "0.3.3"
 toml = "0.9.5"

packages/autorun-core/src/plugins.rs

@@ -1,3 +1,4 @@
+use autorun_lua::LuaUserdata;
 use cap_std::fs::Dir;
 use serde::{Deserialize, Serialize};
 
@@ -11,6 +12,8 @@ pub struct Plugin {
 	config: Config,
 }
 
+impl LuaUserdata for Plugin {}
+
 impl core::fmt::Display for Plugin {
 	fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
 		let cfg = &self.config;

packages/autorun-env/Cargo.toml

@@ -13,10 +13,10 @@ retour = { workspace = true }
 cap-std = { workspace = true }
 rand = "0.8.5"
 
-autorun-core = { path = "../autorun-core" }
-autorun-types = { path = "../autorun-types" }
-autorun-lua = { path = "../autorun-lua" }
-autorun-log = { path = "../autorun-log" }
-autorun-jit = { path = "../autorun-jit" }
-autorun-luajit = { path = "../autorun-luajit" }
-autorun-interfaces = { path = "../autorun-interfaces" }
+autorun-core = { workspace = true }
+autorun-types = { workspace = true }
+autorun-lua = { workspace = true }
+autorun-log = { workspace = true }
+autorun-jit = { workspace = true }
+autorun-luajit = { workspace = true }
+autorun-interfaces = { workspace = true }

packages/autorun-env/src/env.rs

@@ -3,28 +3,23 @@ pub mod global;
 use anyhow::Context;
 use autorun_core::plugins::Plugin;
 use autorun_log::*;
-use autorun_lua::{LuaApi, RawHandle};
+use autorun_lua::{Globals, LuaApi, LuaTable};
 use autorun_luajit::{GCRef, LJState, index2adr};
 use autorun_types::{LuaState, Realm};
 use std::ffi::{CStr, CString, c_int};
 
+use crate::functions;
+
 #[derive(Debug, Clone, Copy)]
 pub struct EnvHandle {
 	realm: Realm,
 	env_gcr: GCRef,
 	chunk_nonce: u64,
-	handle: RawHandle,
-}
-
-impl core::ops::Deref for EnvHandle {
-	type Target = RawHandle;
-
-	fn deref(&self) -> &Self::Target {
-		&self.handle
-	}
+	env: LuaTable,
+	autorun: LuaTable,
 }
 
-macro_rules! as_env_lua_function {
+macro_rules! wrap {
 	($func:expr) => {
 		autorun_lua::as_lua_function!(|lua: &LuaApi, state: *mut LuaState| {
 			let realm = crate::global::get_realm(state);
@@ -48,6 +43,10 @@ macro_rules! as_env_lua_function {
 }
 
 impl EnvHandle {
+	pub fn push(&self, lua: &LuaApi, state: *mut LuaState) {
+		self.env.push(lua, state);
+	}
+
 	pub fn realm(&self) -> Realm {
 		self.realm
 	}
@@ -86,93 +85,34 @@ impl EnvHandle {
 			return None;
 		}
 
-		self.push_autorun_table(lua, state);
-		lua.get_field(state, -1, c"PLUGIN".as_ptr());
-
-		let dir = lua.to_userdata(state, -1) as *mut Plugin;
-		if dir.is_null() {
-			lua.pop(state, 2);
-			return None;
-		}
-		lua.pop(state, 2);
+		let dir: *mut Plugin = lua.get(state, &self.autorun, "PLUGIN");
+		let dir = unsafe { dir.as_ref() }?;
 
-		unsafe { dir.as_ref() }
+		Some(dir)
 	}
 
-	fn create_autorun_table(lua: &LuaApi, state: *mut LuaState) {
-		lua.create_table(state, 0, 6);
-
-		lua.push(state, c"print");
-		lua.push(state, as_env_lua_function!(crate::functions::print));
-		lua.set_table(state, -3);
-
-		lua.push(state, c"read");
-		lua.push(state, as_env_lua_function!(crate::functions::read));
-		lua.set_table(state, -3);
-
-		lua.push(state, c"write");
-		lua.push(state, as_env_lua_function!(crate::functions::write));
-		lua.set_table(state, -3);
-
-		lua.push(state, c"writeAsync");
-		lua.push(state, as_env_lua_function!(crate::functions::write_async));
-		lua.set_table(state, -3);
-
-		lua.push(state, c"mkdir");
-		lua.push(state, as_env_lua_function!(crate::functions::mkdir));
-		lua.set_table(state, -3);
-
-		lua.push(state, c"append");
-		lua.push(state, as_env_lua_function!(crate::functions::append));
-		lua.set_table(state, -3);
-
-		lua.push(state, c"exists");
-		lua.push(state, as_env_lua_function!(crate::functions::exists));
-		lua.set_table(state, -3);
-
-		lua.push(state, c"detour");
-		lua.push(state, as_env_lua_function!(crate::functions::detour));
-		lua.set_table(state, -3);
-
-		lua.push(state, c"enableDetour");
-		lua.push(state, as_env_lua_function!(crate::functions::detour_enable));
-		lua.set_table(state, -3);
-
-		lua.push(state, c"disableDetour");
-		lua.push(state, as_env_lua_function!(crate::functions::detour_disable));
-		lua.set_table(state, -3);
-
-		lua.push(state, c"removeDetour");
-		lua.push(state, as_env_lua_function!(crate::functions::detour_remove));
-		lua.set_table(state, -3);
-
-		lua.push(state, c"getOriginalFunction");
-		lua.push(state, as_env_lua_function!(crate::functions::detour_get_original));
-		lua.set_table(state, -3);
-
-		lua.push(state, c"copyFastFunction");
-		lua.push(state, as_env_lua_function!(crate::functions::copy_fast_function));
-		lua.set_table(state, -3);
-
-		lua.push(state, c"load");
-		lua.push(state, as_env_lua_function!(crate::functions::load));
-		lua.set_table(state, -3);
-
-		lua.push(state, c"triggerRemote");
-		lua.push(state, as_env_lua_function!(crate::functions::trigger_remote));
-		lua.set_table(state, -3);
-
-		lua.push(state, c"isFunctionAuthorized");
-		lua.push(state, as_env_lua_function!(crate::functions::is_function_authorized));
-		lua.set_table(state, -3);
-
-		lua.push(state, c"isProtoAuthorized");
-		lua.push(state, as_env_lua_function!(crate::functions::is_proto_authorized));
-		lua.set_table(state, -3);
-
-		lua.push(state, c"VERSION");
-		lua.push(state, env!("CARGO_PKG_VERSION").to_string());
-		lua.set_table(state, -3);
+	fn create_autorun_table(lua: &LuaApi, state: *mut LuaState) -> LuaTable {
+		let t = lua.table(state);
+		lua.set(state, &t, "print", wrap!(functions::print));
+		lua.set(state, &t, "read", wrap!(functions::read));
+		lua.set(state, &t, "write", wrap!(functions::write));
+		lua.set(state, &t, "writeAsync", wrap!(functions::write_async));
+		lua.set(state, &t, "mkdir", wrap!(functions::mkdir));
+		lua.set(state, &t, "append", wrap!(functions::append));
+		lua.set(state, &t, "exists", wrap!(functions::exists));
+		lua.set(state, &t, "detour", wrap!(functions::detour));
+		lua.set(state, &t, "enableDetour", wrap!(functions::detour_enable));
+		lua.set(state, &t, "disableDetour", wrap!(functions::detour_disable));
+		lua.set(state, &t, "removeDetour", wrap!(functions::detour_remove));
+		lua.set(state, &t, "getOriginalFunction", wrap!(functions::detour_get_original));
+		lua.set(state, &t, "copyFastFunction", wrap!(functions::copy_fast_function));
+		lua.set(state, &t, "load", wrap!(functions::load));
+		lua.set(state, &t, "triggerRemote", wrap!(functions::trigger_remote));
+		lua.set(state, &t, "isFunctionAuthorized", wrap!(functions::is_function_authorized));
+		lua.set(state, &t, "isProtoAuthorized", wrap!(functions::is_proto_authorized));
+		lua.set(state, &t, "VERSION", env!("CARGO_PKG_VERSION"));
+
+		return t;
 	}
 
 	pub fn execute(&self, lua: &LuaApi, state: *mut LuaState, name: &CStr, src: &[u8]) -> anyhow::Result<()> {
@@ -194,30 +134,31 @@ impl EnvHandle {
 	}
 
 	pub fn create(lua: &LuaApi, state: *mut LuaState, realm: Realm) -> anyhow::Result<Self> {
-		// Create autorun environment
-		lua.create_table(state, 0, 2);
+		let autorun = Self::create_autorun_table(lua, state);
 
-		lua.push(state, "Autorun");
-		Self::create_autorun_table(lua, state);
-		lua.set_table(state, -3);
+		let env = lua.table(state);
+		lua.set(state, &env, "Autorun", &autorun);
+		lua.set(state, &env, "_G", Globals);
 
-		lua.push(state, "_G");
-		lua.push_globals(state);
-		lua.set_table(state, -3);
+		// todo: refactor luajit code to not depend on the stack
+		env.push(lua, state);
 
 		// Can unwrap since we are sure there is something on the stack
 		let lj_state = state as *mut LJState;
 		let lj_state = unsafe { lj_state.as_ref().context("Failed to dereference LJState")? };
 		let env_tvalue = index2adr(lj_state, -1).context("Failed to get TValue for environment")?;
 		let env_gcr = unsafe { (*env_tvalue).gcr };
 
-		let handle = RawHandle::from_stack(lua, state).unwrap();
+		// todo: refactor luajit code to not depend on the stack
+		lua.pop(state, 1);
+
 		let chunk_nonce = rand::random::<u64>();
 		Ok(Self {
 			realm,
 			env_gcr,
 			chunk_nonce,
-			handle,
+			env,
+			autorun,
 		})
 	}
 
@@ -233,28 +174,16 @@ impl EnvHandle {
 		}
 	}
 
-	fn push_autorun_table(&self, lua: &LuaApi, state: *mut LuaState) {
-		self.push(lua, state);
-		lua.get_field(state, -1, c"Autorun".as_ptr());
-		lua.remove(state, -2);
-	}
-
 	pub fn set_plugin(&self, lua: &LuaApi, state: *mut LuaState, plugin: &Plugin) -> anyhow::Result<()> {
-		self.push_autorun_table(lua, state);
-
-		lua.push(state, c"PLUGIN");
-		lua.new_userdata(state, plugin.try_clone()?);
-		lua.set_table(state, -3);
-
-		lua.pop(state, 1);
+		lua.set(state, &self.autorun, "PLUGIN", plugin.try_clone()?);
 		Ok(())
 	}
 
 	pub fn trigger(&self, lua: &LuaApi, state: *mut LuaState, event_name: &CStr, n_args: c_int) -> anyhow::Result<()> {
 		lua.push(state, event_name);
 		lua.insert(state, -(n_args + 1));
 
-		self.push_autorun_table(lua, state);
+		self.autorun.push(lua, state);
 		lua.get_field(state, -1, c"trigger".as_ptr());
 		lua.remove(state, -2); // remove Autorun table
 
@@ -279,7 +208,7 @@ impl EnvHandle {
 		lua.push(state, event_name);
 		lua.insert(state, -(n_args + 1));
 
-		self.push_autorun_table(lua, state);
+		self.autorun.push(lua, state);
 		lua.get_field(state, -1, c"runRemoteCallbacks".as_ptr());
 		lua.remove(state, -2); // remove Autorun table
 

packages/autorun-env/src/functions/detour/userdata.rs

@@ -1,5 +1,6 @@
+use anyhow::anyhow;
 use autorun_jit::Function;
-use autorun_lua::{IntoLua, LuaApi, LuaFunction, RawHandle};
+use autorun_lua::{LuaApi, LuaFunction, LuaUserdata, RawHandle};
 use autorun_types::LuaState;
 
 pub struct Detour {
@@ -10,19 +11,12 @@ pub struct Detour {
 	pub original_function_ptr: Box<usize>,
 }
 
-impl IntoLua for Detour {
-	fn into_lua(self, lua: &LuaApi, state: *mut LuaState) {
-		lua.new_userdata(state, self);
-	}
-}
+impl LuaUserdata for Detour {}
 
 pub fn detour_enable(lua: &LuaApi, state: *mut LuaState, _env: crate::EnvHandle) -> anyhow::Result<()> {
-	let detour_userdata = lua.to_userdata(state, 1) as *mut Detour;
-	if detour_userdata.is_null() {
-		anyhow::bail!("First argument must be a detour userdata.");
-	}
+	let detour = lua.to::<*mut Detour>(state, 1);
+	let detour = unsafe { detour.as_mut() }.ok_or(anyhow!("First argument must be a detour userdata"))?;
 
-	let detour = unsafe { &mut *detour_userdata };
 	unsafe {
 		detour.detour.enable()?;
 	}
@@ -31,12 +25,9 @@ pub fn detour_enable(lua: &LuaApi, state: *mut LuaState, _env: crate::EnvHandle)
 }
 
 pub fn detour_disable(lua: &LuaApi, state: *mut LuaState, _env: crate::EnvHandle) -> anyhow::Result<()> {
-	let detour_userdata = lua.to_userdata(state, 1) as *mut Detour;
-	if detour_userdata.is_null() {
-		anyhow::bail!("First argument must be a detour userdata.");
-	}
+	let detour = lua.to::<*mut Detour>(state, 1);
+	let detour = unsafe { detour.as_mut() }.ok_or(anyhow!("First argument must be a detour userdata"))?;
 
-	let detour = unsafe { &mut *detour_userdata };
 	unsafe {
 		detour.detour.disable()?;
 	}
@@ -45,26 +36,19 @@ pub fn detour_disable(lua: &LuaApi, state: *mut LuaState, _env: crate::EnvHandle
 }
 
 pub fn detour_get_original(lua: &LuaApi, state: *mut LuaState, _env: crate::EnvHandle) -> anyhow::Result<LuaFunction> {
-	let detour_userdata = lua.to_userdata(state, 1) as *mut Detour;
-	if detour_userdata.is_null() {
-		anyhow::bail!("First argument must be a detour userdata.");
-	}
-
-	let detour = unsafe { &mut *detour_userdata };
+	let detour = lua.to::<*mut Detour>(state, 1);
+	let detour = unsafe { detour.as_mut() }.ok_or(anyhow!("First argument must be a detour userdata"))?;
 
 	Ok(unsafe { std::mem::transmute::<usize, LuaFunction>(*detour.original_function_ptr) })
 }
 
 pub fn detour_remove(lua: &LuaApi, state: *mut LuaState, _env: crate::EnvHandle) -> anyhow::Result<()> {
-	let detour_userdata = lua.to_userdata(state, 1) as *mut Detour;
-	if detour_userdata.is_null() {
-		anyhow::bail!("First argument must be a detour userdata.");
-	}
+	let detour = lua.to::<*mut Detour>(state, 1);
+	let detour = unsafe { detour.as_mut() }.ok_or(anyhow!("First argument must be a detour userdata"))?;
 
-	let detour = unsafe { &mut *detour_userdata };
 	unsafe {
 		detour.detour.disable()?;
-		std::ptr::drop_in_place(detour_userdata);
+		std::ptr::drop_in_place(detour);
 	}
 
 	Ok(())