Merge pull request #57 from thevurv/lua-api-2-pt2-chapter2

Lua api 2 pt2 chapter2

Author: vurvdev

packages/autorun-env/src/env.rs

@@ -3,7 +3,7 @@ pub mod global;
 use anyhow::Context;
 use autorun_core::plugins::Plugin;
 use autorun_log::*;
-use autorun_lua::{Globals, LuaApi, LuaTable};
+use autorun_lua::{Globals, IntoLua, IntoLuaArgs, LuaApi, LuaFunction, LuaTable, LuaValue, RawLuaApi};
 use autorun_luajit::{GCRef, LJState, index2adr};
 use autorun_types::{LuaState, Realm};
 use std::ffi::{CStr, CString, c_int};
@@ -19,6 +19,12 @@ pub struct EnvHandle {
 	autorun: LuaTable,
 }
 
+impl IntoLua for &EnvHandle {
+	fn into_lua(self, lua: &RawLuaApi, state: *mut LuaState) {
+		lua.push(state, &self.env);
+	}
+}
+
 macro_rules! wrap {
 	($func:expr) => {
 		autorun_lua::as_lua_function!(|lua: &LuaApi, state: *mut LuaState| {
@@ -33,8 +39,7 @@ macro_rules! wrap {
 
 				// todo: potentially add a silenterror type so we can return that and it'll return a nil.
 				// right now this would kind of leak the fact that it's an autorun function.
-				lua.push(state, c"");
-				lua.raw.error(state);
+				lua.error(state, c"");
 			} else {
 				$func(lua, state, env)
 			}
@@ -43,10 +48,6 @@ macro_rules! wrap {
 }
 
 impl EnvHandle {
-	pub fn push(&self, lua: &LuaApi, state: *mut LuaState) {
-		lua.push(state, &self.env);
-	}
-
 	pub fn realm(&self) -> Realm {
 		self.realm
 	}
@@ -66,26 +67,23 @@ impl EnvHandle {
 	}
 
 	pub fn is_active(&self, lua: &LuaApi, state: *mut LuaState) -> bool {
-		if lua.raw.getinfo(state, 1, c"f").is_none() {
-			// No function info available
+		let Ok(info) = lua.getinfo(state, 1, c"f") else {
 			return false;
-		}
+		};
 
-		lua.raw.getfenv(state, -1);
-		self.push(lua, state);
-
-		let equal = lua.raw.rawequal(state, -1, -2);
-		lua.raw.pop(state, 3);
+		let Ok(Some(env)) = lua.getfenv(state, &info.func.unwrap()) else {
+			return false;
+		};
 
-		equal
+		lua.equal(state, &env, &self.env)
 	}
 
 	pub fn get_active_plugin(&self, lua: &LuaApi, state: *mut LuaState) -> Option<&Plugin> {
 		if !self.is_active(lua, state) {
 			return None;
 		}
 
-		let dir: *mut Plugin = lua.get(state, &self.autorun, "PLUGIN");
+		let dir: *mut Plugin = lua.get(state, &self.autorun, "PLUGIN").ok()?;
 		let dir = unsafe { dir.as_ref() }?;
 
 		Some(dir)
@@ -119,11 +117,7 @@ impl EnvHandle {
 		let name = self.format_chunk_name(name)?;
 		let chunk = lua.load(state, src, &name)?;
 		lua.setfenv(state, &chunk, &self.env)?;
-
-		lua.push(state, &chunk);
-		if let Err(why) = lua.raw.pcall(state, 0, 0, 0) {
-			anyhow::bail!("Failed to execute: {}", why);
-		}
+		lua.pcall(state, &chunk, ())?;
 
 		Ok(())
 	}
@@ -136,7 +130,7 @@ impl EnvHandle {
 		lua.set(state, &env, "_G", Globals);
 
 		// todo: refactor luajit code to not depend on the stack
-		lua.push(state, &env);
+		lua.raw.push(state, &env);
 
 		// Can unwrap since we are sure there is something on the stack
 		let lj_state = state as *mut LJState;
@@ -174,46 +168,15 @@ impl EnvHandle {
 		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.raw.insert(state, -(n_args + 1));
-
-		lua.push(state, &self.autorun);
-		lua.raw.getfield(state, -1, c"trigger".as_ptr());
-		lua.raw.remove(state, -2); // remove Autorun table
-
-		if lua.raw.typeid(state, -1) != autorun_lua::LuaTypeId::Function {
-			lua.raw.pop(state, 1);
-			anyhow::bail!("don't remove Autorun.trigger lil bro.");
-		}
-
-		lua.raw.insert(state, -(n_args + 2));
-		lua.raw.pcall(state, n_args + 1, 0, 0).map_err(|e| anyhow::anyhow!(e))?;
-
+	pub fn trigger(&self, lua: &LuaApi, state: *mut LuaState, args: impl IntoLuaArgs) -> anyhow::Result<()> {
+		let trigger: LuaFunction = lua.get(state, &self.autorun, "trigger")?;
+		lua.pcall(state, &trigger, args)?;
 		Ok(())
 	}
 
-	pub fn run_remote_callbacks(
-		&self,
-		lua: &LuaApi,
-		state: *mut LuaState,
-		event_name: &CStr,
-		n_args: c_int,
-	) -> anyhow::Result<()> {
-		lua.push(state, event_name);
-		lua.raw.insert(state, -(n_args + 1));
-
-		lua.push(state, &self.autorun);
-		lua.raw.getfield(state, -1, c"runRemoteCallbacks".as_ptr());
-		lua.raw.remove(state, -2); // remove Autorun table
-
-		if lua.raw.typeid(state, -1) != autorun_lua::LuaTypeId::Function {
-			lua.raw.pop(state, 1);
-			anyhow::bail!("don't remove Autorun.runRemoteCallbacks lil bro.");
-		}
-
-		lua.raw.insert(state, -(n_args + 2));
-		lua.raw.pcall(state, n_args + 1, 0, 0).map_err(|e| anyhow::anyhow!(e))?;
+	pub fn run_remote_callbacks(&self, lua: &LuaApi, state: *mut LuaState, args: impl IntoLuaArgs) -> anyhow::Result<()> {
+		let run_remote_callbacks = lua.get(state, &self.autorun, "runRemoteCallbacks")?;
+		lua.pcall(state, &run_remote_callbacks, args)?;
 
 		Ok(())
 	}

packages/autorun-env/src/functions/auth.rs

@@ -1,5 +1,5 @@
 use anyhow::Context;
-use autorun_lua::{DebugInfo, LuaApi};
+use autorun_lua::{LuaApi, RawDebugInfo};
 use autorun_luajit::{Frame, GCProto, LJ_TPROTO, LJState, get_gcobj, index2adr, push_tvalue};
 use autorun_types::LuaState;
 
@@ -13,8 +13,8 @@ pub fn is_function_authorized(lua: &LuaApi, state: *mut LuaState, env: crate::En
 
 	if lua.raw.typeid(state, 1) == autorun_lua::LuaTypeId::Number {
 		// attempt to resolve the function at the given stack level
-		let mut debug_info = unsafe { std::mem::zeroed::<DebugInfo>() };
-		let stack_level = lua.to::<i32>(state, 1);
+		let mut debug_info = unsafe { std::mem::zeroed::<RawDebugInfo>() };
+		let stack_level = lua.raw.try_to::<i32>(state, 1)?;
 		lua.raw.pop(state, 1); // remove the stack level argument
 
 		if lua.raw.getstack(state, stack_level, &raw mut debug_info as _) == 0 {
@@ -49,8 +49,7 @@ pub fn is_proto_authorized(_lua: &LuaApi, state: *mut LuaState, env: crate::EnvH
 
 	let proto_gc = get_gcobj::<GCProto>(lj_state, 1).context("Failed to get GCProto for given index.")?;
 	let proto_chunk_name = proto_gc.chunk_name_str().context("Failed to get chunk name from proto.")?;
-	let proto_chunk_name_cstr =
-		std::ffi::CString::new(proto_chunk_name.clone()).context("Failed to convert chunk name to CString.")?;
+	let proto_chunk_name_cstr = std::ffi::CString::new(proto_chunk_name).context("Failed to convert chunk name to CString.")?;
 
 	Ok(env.is_chunk_name_authorized(&proto_chunk_name_cstr))
 }

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

@@ -36,7 +36,7 @@ pub fn detour(lua: &LuaApi, state: *mut LuaState, _env: crate::EnvHandle) -> any
 		anyhow::bail!("Second argument must be a function to use as detour.");
 	}
 
-	let detour_callback = RawHandle::from_stack(lua, state).context("Failed to create raw handle for detour callback.")?;
+	let detour_callback = RawHandle::from_stack(&lua.raw, state).context("Failed to create raw handle for detour callback.")?;
 	let mut original_function_ptr = Box::new(0usize);
 
 	// create the trampoline
@@ -95,7 +95,7 @@ pub fn copy_fast_function(lua: &LuaApi, state: *mut LuaState, _env: crate::EnvHa
 	let original_ffid = gcfunc.header().ffid;
 	let original_upvalues = gcfunc.header().nupvalues;
 
-	let function_handle = RawHandle::from_stack(lua, state).context("Failed to create raw handle for function.")?;
+	let function_handle = RawHandle::from_stack(&lua.raw, state).context("Failed to create raw handle for function.")?;
 
 	let trampoline = make_detour_trampoline(lua, function_handle.id(), std::ptr::null(), detour_handler)?;
 	// Not a detour, but we can reuse the trampoline maker to create a fast-function trampoline

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

@@ -18,7 +18,7 @@ pub extern "C-unwind" fn detour_handler(
 	let lua = unsafe { &*lua_api };
 
 	let callback_handle = RawHandle::from_id(callback_id);
-	callback_handle.push(lua, state);
+	lua.raw.push(state, &callback_handle);
 	lua.raw.insert(state, 1);
 
 	let num_arguments = lua.raw.gettop(state) - 1;

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

@@ -14,8 +14,8 @@ pub struct Detour {
 impl LuaUserdata for Detour {}
 
 pub fn detour_enable(lua: &LuaApi, state: *mut LuaState, _env: crate::EnvHandle) -> anyhow::Result<()> {
-	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 = lua.raw.try_to::<*mut Detour>(state, 1)?;
+	let detour = unsafe { detour.as_mut() }.ok_or(anyhow!("Null detour"))?;
 
 	unsafe {
 		detour.detour.enable()?;
@@ -25,8 +25,8 @@ 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 = lua.to::<*mut Detour>(state, 1);
-	let detour = unsafe { detour.as_mut() }.ok_or(anyhow!("First argument must be a detour userdata"))?;
+	let detour = lua.raw.try_to::<*mut Detour>(state, 1)?;
+	let detour = unsafe { detour.as_mut() }.ok_or(anyhow!("Null detour"))?;
 
 	unsafe {
 		detour.detour.disable()?;
@@ -36,15 +36,15 @@ 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<LuaCFunction> {
-	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 = lua.raw.try_to::<*mut Detour>(state, 1)?;
+	let detour = unsafe { detour.as_mut() }.ok_or(anyhow!("Null detour"))?;
 
 	Ok(unsafe { std::mem::transmute::<usize, LuaCFunction>(*detour.original_function_ptr) })
 }
 
 pub fn detour_remove(lua: &LuaApi, state: *mut LuaState, _env: crate::EnvHandle) -> anyhow::Result<()> {
-	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 = lua.raw.try_to::<*mut Detour>(state, 1)?;
+	let detour = unsafe { detour.as_mut() }.ok_or(anyhow!("Null detour"))?;
 
 	unsafe {
 		detour.detour.disable()?;

packages/autorun-env/src/functions/load.rs

@@ -3,15 +3,19 @@ use autorun_types::LuaState;
 
 pub fn load(lua: &LuaApi, state: *mut LuaState, env: crate::EnvHandle) -> anyhow::Result<RawLuaReturn> {
 	let source = lua.raw.checkstring(state, 1);
-	let chunk_name = lua.to::<Option<&[u8]>>(state, 2).unwrap_or(b"loadstring");
+	let chunk_name = lua.raw.try_to::<Option<&[u8]>>(state, 2)?.unwrap_or(b"loadstring");
 	let chunk_name = std::ffi::CString::new(chunk_name)?;
 	let chunk_name = env.format_chunk_name(&chunk_name)?;
 
-	if let Err(why) = lua.raw.loadbufferx(state, source.as_bytes(), &chunk_name, c"t") {
-		lua.raw.pushnil(state);
-		lua.push(state, why.to_string());
-		return Ok(RawLuaReturn(2));
+	match lua.load(state, source.as_bytes(), &chunk_name) {
+		Err(why) => {
+			lua.raw.pushnil(state);
+			lua.raw.push(state, why.to_string());
+			Ok(RawLuaReturn(2))
+		}
+		Ok(chunk) => {
+			lua.raw.push(state, &chunk);
+			Ok(RawLuaReturn(1))
+		}
 	}
-
-	Ok(RawLuaReturn(1))
 }

packages/autorun-env/src/functions/print.rs

@@ -1,4 +1,4 @@
-use autorun_lua::LuaApi;
+use autorun_lua::{LuaApi, LuaValue};
 use autorun_types::LuaState;
 
 pub fn print(lua: &LuaApi, state: *mut LuaState, env: crate::EnvHandle) -> anyhow::Result<()> {
@@ -7,42 +7,29 @@ pub fn print(lua: &LuaApi, state: *mut LuaState, env: crate::EnvHandle) -> anyho
 	let nargs = lua.raw.gettop(state);
 	let mut args = Vec::with_capacity(nargs as usize);
 	for i in 1..=nargs {
-		match lua.raw.typeid(state, i) {
-			autorun_lua::LuaTypeId::Nil => {
+		match lua.raw.to::<LuaValue>(state, i) {
+			LuaValue::Nil => {
 				args.push(String::from("nil"));
 			}
 
-			autorun_lua::LuaTypeId::LightUserdata => {
-				let ptr = lua.raw.touserdata(state, i);
+			LuaValue::LightUserdata(ptr) => {
 				args.push(format!("lightuserdata: {:p}", ptr));
 			}
 
-			autorun_lua::LuaTypeId::Userdata => {
-				let ptr = lua.raw.touserdata(state, i);
+			LuaValue::Userdata(ptr) => {
 				args.push(format!("userdata: {:p}", ptr));
 			}
 
-			autorun_lua::LuaTypeId::Function => {
-				let ptr = lua.raw.tocfunction(state, i);
-				if let Some(func) = ptr {
-					args.push(format!("function: {:p}", func));
-				} else {
-					args.push(String::from("function: <null>"));
-				}
+			LuaValue::CFunction(func) => {
+				args.push(format!("function: {:p}", func));
 			}
 
-			autorun_lua::LuaTypeId::Thread => {
-				let ptr = lua.raw.tothread(state, i);
-				args.push(format!("thread: {:p}", ptr));
-			}
-
-			autorun_lua::LuaTypeId::Boolean => {
-				let val = lua.to::<bool>(state, i);
+			LuaValue::Boolean(val) => {
 				args.push(String::from(if val { "true" } else { "false" }));
 			}
 
 			_ => {
-				let arg = lua.to::<String>(state, i);
+				let arg = lua.raw.try_to::<String>(state, i)?;
 				args.push(arg);
 			}
 		}