Merge pull request #55 from thevurv/lua-api-2

Lua API 2.0

Author: vurvdev

packages/autorun-env/src/env.rs

@@ -34,7 +34,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.error(state);
+				lua.raw.error(state);
 			} else {
 				$func(lua, state, env)
 			}
@@ -44,7 +44,7 @@ macro_rules! wrap {
 
 impl EnvHandle {
 	pub fn push(&self, lua: &LuaApi, state: *mut LuaState) {
-		self.env.push(lua, state);
+		lua.push(state, &self.env);
 	}
 
 	pub fn realm(&self) -> Realm {
@@ -57,25 +57,25 @@ impl EnvHandle {
 		let lj_state = state as *mut LJState;
 		let lj_state = unsafe { lj_state.as_ref().context("Failed to dereference LJState")? };
 
-		lua.get_fenv(state, func_index);
+		lua.raw.getfenv(state, func_index);
 		let function_env_tvalue = index2adr(lj_state, -1).context("Failed to get TValue for function environment")?;
 		let function_env_gcr = unsafe { (*function_env_tvalue).gcr };
 
-		lua.pop(state, 1);
+		lua.raw.pop(state, 1);
 		Ok(function_env_gcr == self.env_gcr)
 	}
 
 	pub fn is_active(&self, lua: &LuaApi, state: *mut LuaState) -> bool {
-		if lua.get_info(state, 1, c"f").is_none() {
+		if lua.raw.getinfo(state, 1, c"f").is_none() {
 			// No function info available
 			return false;
 		}
 
-		lua.get_fenv(state, -1);
+		lua.raw.getfenv(state, -1);
 		self.push(lua, state);
 
-		let equal = lua.is_raw_equal(state, -1, -2);
-		lua.pop(state, 3);
+		let equal = lua.raw.rawequal(state, -1, -2);
+		lua.raw.pop(state, 3);
 
 		equal
 	}
@@ -117,16 +117,11 @@ impl EnvHandle {
 
 	pub fn execute(&self, lua: &LuaApi, state: *mut LuaState, name: &CStr, src: &[u8]) -> anyhow::Result<()> {
 		let name = self.format_chunk_name(name)?;
-		if let Err(why) = lua.load_buffer_x(state, src, &name, c"t") {
-			anyhow::bail!("Failed to compile: {why}");
-		}
-
-		self.push(lua, state);
-		if lua.set_fenv(state, -2).is_err() {
-			anyhow::bail!("Failed to set environment");
-		}
+		let chunk = lua.load(state, src, &name)?;
+		lua.setfenv(state, &chunk, &self.env)?;
 
-		if let Err(why) = lua.pcall(state, 0, 0, 0) {
+		lua.push(state, &chunk);
+		if let Err(why) = lua.raw.pcall(state, 0, 0, 0) {
 			anyhow::bail!("Failed to execute: {}", why);
 		}
 
@@ -141,7 +136,7 @@ impl EnvHandle {
 		lua.set(state, &env, "_G", Globals);
 
 		// todo: refactor luajit code to not depend on the stack
-		env.push(lua, state);
+		lua.push(state, &env);
 
 		// Can unwrap since we are sure there is something on the stack
 		let lj_state = state as *mut LJState;
@@ -150,7 +145,7 @@ impl EnvHandle {
 		let env_gcr = unsafe { (*env_tvalue).gcr };
 
 		// todo: refactor luajit code to not depend on the stack
-		lua.pop(state, 1);
+		lua.raw.pop(state, 1);
 
 		let chunk_nonce = rand::random::<u64>();
 		Ok(Self {
@@ -181,19 +176,19 @@ impl EnvHandle {
 
 	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));
+		lua.raw.insert(state, -(n_args + 1));
 
-		self.autorun.push(lua, state);
-		lua.get_field(state, -1, c"trigger".as_ptr());
-		lua.remove(state, -2); // remove Autorun table
+		lua.push(state, &self.autorun);
+		lua.raw.getfield(state, -1, c"trigger".as_ptr());
+		lua.raw.remove(state, -2); // remove Autorun table
 
-		if lua.type_id(state, -1) != autorun_lua::LuaTypeId::Function {
-			lua.pop(state, 1);
+		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.insert(state, -(n_args + 2));
-		lua.pcall(state, n_args + 1, 0, 0).map_err(|e| anyhow::anyhow!(e))?;
+		lua.raw.insert(state, -(n_args + 2));
+		lua.raw.pcall(state, n_args + 1, 0, 0).map_err(|e| anyhow::anyhow!(e))?;
 
 		Ok(())
 	}
@@ -206,19 +201,19 @@ impl EnvHandle {
 		n_args: c_int,
 	) -> anyhow::Result<()> {
 		lua.push(state, event_name);
-		lua.insert(state, -(n_args + 1));
+		lua.raw.insert(state, -(n_args + 1));
 
-		self.autorun.push(lua, state);
-		lua.get_field(state, -1, c"runRemoteCallbacks".as_ptr());
-		lua.remove(state, -2); // remove Autorun table
+		lua.push(state, &self.autorun);
+		lua.raw.getfield(state, -1, c"runRemoteCallbacks".as_ptr());
+		lua.raw.remove(state, -2); // remove Autorun table
 
-		if lua.type_id(state, -1) != autorun_lua::LuaTypeId::Function {
-			lua.pop(state, 1);
+		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.insert(state, -(n_args + 2));
-		lua.pcall(state, n_args + 1, 0, 0).map_err(|e| anyhow::anyhow!(e))?;
+		lua.raw.insert(state, -(n_args + 2));
+		lua.raw.pcall(state, n_args + 1, 0, 0).map_err(|e| anyhow::anyhow!(e))?;
 
 		Ok(())
 	}

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

@@ -4,8 +4,8 @@ use autorun_lua::LuaApi;
 use autorun_types::LuaState;
 
 pub fn append(lua: &LuaApi, state: *mut LuaState, env: crate::EnvHandle) -> anyhow::Result<()> {
-	let target_path = lua.check_string(state, 1);
-	let content = lua.check_string(state, 2);
+	let target_path = lua.raw.checkstring(state, 1);
+	let content = lua.raw.checkstring(state, 2);
 
 	let plugin = env
 		.get_active_plugin(lua, state)

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

@@ -5,19 +5,19 @@ use autorun_types::LuaState;
 
 pub fn is_function_authorized(lua: &LuaApi, state: *mut LuaState, env: crate::EnvHandle) -> anyhow::Result<bool> {
 	if !matches!(
-		lua.type_id(state, 1),
+		lua.raw.typeid(state, 1),
 		autorun_lua::LuaTypeId::Function | autorun_lua::LuaTypeId::Number
 	) {
 		anyhow::bail!("First argument must be a function or stack level.");
 	}
 
-	if lua.type_id(state, 1) == autorun_lua::LuaTypeId::Number {
+	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);
-		lua.pop(state, 1); // remove the stack level argument
+		lua.raw.pop(state, 1); // remove the stack level argument
 
-		if lua.get_stack(state, stack_level, &raw mut debug_info as _) == 0 {
+		if lua.raw.getstack(state, stack_level, &raw mut debug_info as _) == 0 {
 			anyhow::bail!("Invalid stack level provided.");
 		}
 

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

@@ -6,15 +6,15 @@ use crate::functions::detour::handlers::{detour_handler, retour_handler};
 use crate::functions::detour::raw::{make_detour_trampoline, make_retour_lua_trampoline};
 use crate::functions::detour::userdata::Detour;
 use anyhow::Context;
-use autorun_lua::{LuaApi, LuaFunction, LuaTypeId, RawHandle, RawLuaReturn};
+use autorun_lua::{LuaApi, LuaCFunction, LuaTypeId, RawHandle, RawLuaReturn};
 use autorun_luajit::{GCfunc, LJState, get_gcobj, get_gcobj_mut};
 use autorun_types::LuaState;
 use retour::GenericDetour;
 use std::ffi::c_int;
 pub use userdata::{detour_disable, detour_enable, detour_get_original, detour_remove};
 
 pub fn detour(lua: &LuaApi, state: *mut LuaState, _env: crate::EnvHandle) -> anyhow::Result<Detour> {
-	if lua.is_c_function(state, 1) == 0 {
+	if !lua.raw.iscfunction(state, 1) {
 		anyhow::bail!("First argument must be a C function to detour.");
 	}
 
@@ -27,12 +27,12 @@ pub fn detour(lua: &LuaApi, state: *mut LuaState, _env: crate::EnvHandle) -> any
 		anyhow::bail!("Cannot detour a fast-function. Use copyFastFunction instead.");
 	}
 
-	let target_function: LuaFunction = unsafe { std::mem::transmute(gcfunc.c.c) };
+	let target_function: LuaCFunction = unsafe { std::mem::transmute(gcfunc.c.c) };
 	if target_function as usize == 0 {
 		anyhow::bail!("Target function pointer is null.");
 	}
 
-	if lua.type_id(state, 2) != LuaTypeId::Function {
+	if lua.raw.typeid(state, 2) != LuaTypeId::Function {
 		anyhow::bail!("Second argument must be a function to use as detour.");
 	}
 
@@ -50,7 +50,7 @@ pub fn detour(lua: &LuaApi, state: *mut LuaState, _env: crate::EnvHandle) -> any
 	let detour = unsafe {
 		Box::new(GenericDetour::new(
 			target_function,
-			std::mem::transmute::<*const u8, LuaFunction>(detour_trampoline.as_ptr()),
+			std::mem::transmute::<*const u8, LuaCFunction>(detour_trampoline.as_ptr()),
 		)?)
 	};
 
@@ -61,7 +61,7 @@ pub fn detour(lua: &LuaApi, state: *mut LuaState, _env: crate::EnvHandle) -> any
 	}
 
 	// create retour trampoline
-	let retour_trampoline = make_retour_lua_trampoline(detour.as_ref() as *const GenericDetour<LuaFunction>, retour_handler)?;
+	let retour_trampoline = make_retour_lua_trampoline(detour.as_ref() as *const GenericDetour<LuaCFunction>, retour_handler)?;
 
 	// link the original function pointer
 	*original_function_ptr = retour_trampoline.as_ptr() as usize;
@@ -76,11 +76,11 @@ pub fn detour(lua: &LuaApi, state: *mut LuaState, _env: crate::EnvHandle) -> any
 }
 
 pub fn copy_fast_function(lua: &LuaApi, state: *mut LuaState, _env: crate::EnvHandle) -> anyhow::Result<RawLuaReturn> {
-	if lua.is_c_function(state, 1) == 0 {
+	if !lua.raw.iscfunction(state, 1) {
 		anyhow::bail!("First argument must be a C function to copy.");
 	}
 
-	if lua.type_id(state, 2) != LuaTypeId::Function {
+	if lua.raw.typeid(state, 2) != LuaTypeId::Function {
 		anyhow::bail!("Second argument must be a function to use.");
 	}
 
@@ -102,9 +102,9 @@ pub fn copy_fast_function(lua: &LuaApi, state: *mut LuaState, _env: crate::EnvHa
 
 	// Push it as a closure to call
 	unsafe {
-		lua.push_closure(
+		lua.raw.pushcclosure(
 			state,
-			std::mem::transmute::<*const u8, LuaFunction>(trampoline.as_ptr()),
+			std::mem::transmute::<*const u8, LuaCFunction>(trampoline.as_ptr()),
 			original_upvalues as c_int,
 		);
 	}

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

@@ -1,33 +1,33 @@
 use crate::functions::detour::raw;
 use autorun_log::*;
-use autorun_lua::{LUA_MULTRET, LuaApi, LuaFunction, RawHandle};
+use autorun_lua::{LUA_MULTRET, LuaApi, LuaCFunction, RawHandle};
 use autorun_types::LuaState;
 
-pub extern "C-unwind" fn retour_handler(state: *mut LuaState, detour: *const retour::GenericDetour<LuaFunction>) -> i32 {
+pub extern "C-unwind" fn retour_handler(state: *mut LuaState, detour: *const retour::GenericDetour<LuaCFunction>) -> i32 {
 	unsafe { (*detour).call(state) }
 }
 
 pub extern "C-unwind" fn detour_handler(
 	state: *mut LuaState,
 	metadata: i32,
 	lua_api: *const LuaApi,
-	original_function: *const LuaFunction,
+	original_function: *const LuaCFunction,
 ) -> i32 {
 	let detour_metadata = raw::DetourMetadata::from_packed(metadata);
 	let callback_id = detour_metadata.callback_ref();
 	let lua = unsafe { &*lua_api };
 
 	let callback_handle = RawHandle::from_id(callback_id);
 	callback_handle.push(lua, state);
-	lua.insert(state, 1);
+	lua.raw.insert(state, 1);
 
-	let num_arguments = lua.get_top(state) - 1;
+	let num_arguments = lua.raw.gettop(state) - 1;
 
 	let original_function_included = if original_function as usize != 0 {
 		// add the original function as the first argument
 		unsafe {
-			lua.push_function(state, *original_function);
-			lua.insert(state, 2);
+			lua.raw.pushcfunction(state, *original_function);
+			lua.raw.insert(state, 2);
 		}
 
 		true
@@ -41,12 +41,12 @@ pub extern "C-unwind" fn detour_handler(
 		num_arguments
 	};
 
-	let base = lua.get_top(state) - num_arguments;
+	let base = lua.raw.gettop(state) - num_arguments;
 
-	if let Err(why) = lua.pcall(state, num_arguments, LUA_MULTRET, 0) {
+	if let Err(why) = lua.raw.pcall(state, num_arguments, LUA_MULTRET, 0) {
 		error!("Error calling detour callback: {why}");
 		return 0;
 	}
 
-	lua.get_top(state) - base + 1
+	lua.raw.gettop(state) - base + 1
 }

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

@@ -1,6 +1,6 @@
 use autorun_jit::Function;
 use autorun_jit::{Arg, CallingConvention, Jump};
-use autorun_lua::{LuaApi, LuaFunction, LuaState};
+use autorun_lua::{LuaApi, LuaCFunction, LuaState};
 use std::ffi::c_int;
 
 const CALLBACK_REF_BITS: u32 = 24;
@@ -42,9 +42,10 @@ type HandlerType = extern "C-unwind" fn(
 	state: *mut LuaState,
 	metadata: i32,
 	lua: *const LuaApi,
-	original_function: *const LuaFunction,
+	original_function: *const LuaCFunction,
 ) -> c_int;
-type RetourHandlerType = extern "C-unwind" fn(state: *mut LuaState, detour: *const retour::GenericDetour<LuaFunction>) -> c_int;
+type RetourHandlerType =
+	extern "C-unwind" fn(state: *mut LuaState, detour: *const retour::GenericDetour<LuaCFunction>) -> c_int;
 
 const TRAMPOLINE_SIZE: usize = 64;
 
@@ -78,7 +79,7 @@ pub fn make_detour_trampoline(
 }
 
 pub fn make_retour_lua_trampoline(
-	detour_ptr: *const retour::GenericDetour<LuaFunction>,
+	detour_ptr: *const retour::GenericDetour<LuaCFunction>,
 	handler: RetourHandlerType,
 ) -> anyhow::Result<Function> {
 	let mut trampoline = Function::allocate(TRAMPOLINE_SIZE);

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

@@ -1,10 +1,10 @@
 use anyhow::anyhow;
 use autorun_jit::Function;
-use autorun_lua::{LuaApi, LuaFunction, LuaUserdata, RawHandle};
+use autorun_lua::{LuaApi, LuaCFunction, LuaUserdata, RawHandle};
 use autorun_types::LuaState;
 
 pub struct Detour {
-	pub detour: Box<retour::GenericDetour<LuaFunction>>,
+	pub detour: Box<retour::GenericDetour<LuaCFunction>>,
 	pub _detour_callback: RawHandle,
 	pub _detour_trampoline: Function,
 	pub _retour_trampoline: Function,
@@ -35,11 +35,11 @@ pub fn detour_disable(lua: &LuaApi, state: *mut LuaState, _env: crate::EnvHandle
 	Ok(())
 }
 
-pub fn detour_get_original(lua: &LuaApi, state: *mut LuaState, _env: crate::EnvHandle) -> anyhow::Result<LuaFunction> {
+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"))?;
 
-	Ok(unsafe { std::mem::transmute::<usize, LuaFunction>(*detour.original_function_ptr) })
+	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<()> {

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

@@ -2,7 +2,7 @@ use autorun_lua::LuaApi;
 use autorun_types::LuaState;
 
 pub fn exists(lua: &LuaApi, state: *mut LuaState, env: crate::EnvHandle) -> anyhow::Result<bool> {
-	let target_path = lua.check_string(state, 1);
+	let target_path = lua.raw.checkstring(state, 1);
 	let plugin = env
 		.get_active_plugin(lua, state)
 		.ok_or(anyhow::anyhow!("dont delete autorun.plugin lil bro."))?;

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

@@ -2,14 +2,14 @@ use autorun_lua::{LuaApi, RawLuaReturn};
 use autorun_types::LuaState;
 
 pub fn load(lua: &LuaApi, state: *mut LuaState, env: crate::EnvHandle) -> anyhow::Result<RawLuaReturn> {
-	let source = lua.check_string(state, 1);
+	let source = lua.raw.checkstring(state, 1);
 	let chunk_name = lua.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.load_buffer_x(state, source.as_bytes(), &chunk_name, c"t") {
-		lua.push_nil(state);
-		lua.push(state, &why);
+	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));
 	}