More abstractions

- Add LuaApi.equal, LuaApi.rawequal
- Update example code
- Add DebugInfo struct which is higher level and rename previous struct
  to RawDebugInfo
- Add LuaApi.getfenv and LuaApi.getinfo

Author: vurvdev

packages/autorun-env/src/env.rs

@@ -67,18 +67,15 @@ 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);
-		lua.raw.push(state, self);
+		};
 
-		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> {

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,7 +13,7 @@ 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 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
 
@@ -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-lua/README.md

@@ -11,8 +11,8 @@ This implements Autorun's lua abstractions and being able to access the lua api
 use autorun_lua::*;
 
 fn lua_adder(lua: &LuaApi, state: *mut LuaState) -> Result<f64, Box<dyn std::error::Error>> {
-	let x = lua.check_number(state, 1);
-	let y = lua.check_number(state, 2);
+	let x = lua.raw.try_to::<f64>(state, 1)?;
+	let y = lua.raw.try_to::<f64>(state, 2)?;
 
 	// This pushes it onto lua's stack for you.
 	// You can return multiple values via a tuple of values

packages/autorun-lua/examples/basic.rs

@@ -4,8 +4,8 @@
 use autorun_lua::*;
 
 fn lua_adder(lua: &LuaApi, state: *mut LuaState) -> Result<f64, Box<dyn std::error::Error>> {
-	let x = lua.check_number(state, 1);
-	let y = lua.check_number(state, 2);
+	let x = lua.raw.try_to::<f64>(state, 1)?;
+	let y = lua.raw.try_to::<f64>(state, 2)?;
 
 	// This pushes it onto lua's stack for you.
 	// You can return multiple values via a tuple of values

packages/autorun-lua/src/lua/mod.rs

@@ -7,14 +7,29 @@ pub use result::*;
 mod returns;
 pub use returns::*;
 
-use crate::{FromLua, IntoLua, LuaFunction, LuaTable, LuaValue, types::LuaState};
-use std::ffi::{CStr, c_char, c_int};
+use crate::{IntoLua, LuaFunction, LuaTable, LuaValue, types::LuaState};
+use std::ffi::{CStr, c_int};
 
 #[derive(Debug)]
 pub struct LuaApi {
 	pub raw: RawLuaApi,
 }
 
+#[derive(Debug)]
+pub struct DebugInfo {
+	pub event: c_int,
+	pub name: Option<String>,           // n
+	pub namewhat: Option<String>,       // n
+	pub what: Option<String>,           // S
+	pub source: Option<String>,         // S
+	pub currentline: Option<c_int>,     // l
+	pub nups: Option<c_int>,            // u
+	pub linedefined: Option<c_int>,     // S
+	pub lastlinedefined: Option<c_int>, // S
+	pub short_src: Option<String>,      // S
+	pub func: Option<LuaFunction>,      // f
+}
+
 impl LuaApi {
 	pub fn new(lib: &libloading::Library) -> Result<Self, libloading::Error> {
 		let raw = RawLuaApi::new(lib)?;
@@ -39,6 +54,15 @@ impl LuaApi {
 		Ok(())
 	}
 
+	pub fn getfenv(&self, state: *mut LuaState, f: &LuaFunction) -> LuaResult<Option<LuaTable>> {
+		self.raw.push(state, f);
+		self.raw.getfenv(state, -1);
+		let env: Option<LuaTable> = self.raw.try_to(state, -1)?;
+		self.raw.pop(state, 2);
+
+		Ok(env)
+	}
+
 	pub fn getregistry(&self, state: *mut LuaState, key: impl IntoLua) -> LuaValue<'_> {
 		key.into_lua(&self.raw, state);
 		self.raw.rawget(state, REGISTRY_INDEX);
@@ -57,6 +81,83 @@ impl LuaApi {
 		self.raw.push(state, msg);
 		self.raw.error(state);
 	}
+
+	pub fn equal(&self, state: *mut LuaState, a: impl IntoLua, b: impl IntoLua) -> bool {
+		a.into_lua(&self.raw, state);
+		b.into_lua(&self.raw, state);
+		let result = self.raw.equal(state, -2, -1);
+		self.raw.pop(state, 2);
+		result
+	}
+
+	pub fn rawequal(&self, state: *mut LuaState, a: impl IntoLua, b: impl IntoLua) -> bool {
+		a.into_lua(&self.raw, state);
+		b.into_lua(&self.raw, state);
+		let result = self.raw.rawequal(state, -2, -1);
+		self.raw.pop(state, 2);
+		result
+	}
+
+	pub fn getinfo(&self, state: *mut LuaState, level: c_int, select: &CStr) -> LuaResult<DebugInfo> {
+		let info = self.raw.getinfo(state, level, select).ok_or(LuaError::GenericFailure)?;
+		let select = select.to_bytes();
+
+		let mut name = None;
+		let mut namewhat = None;
+		let mut what = None;
+		let mut source = None;
+		let mut currentline = None;
+		let mut nups = None;
+		let mut linedefined = None;
+		let mut lastlinedefined = None;
+		let mut short_src = None;
+		let mut func = None;
+
+		if select.contains(&b'f') {
+			let f: LuaFunction = self.raw.try_to(state, -1)?;
+			self.raw.pop(state, 1);
+			func = Some(f);
+		}
+
+		if select.contains(&b'n') {
+			name = Some(unsafe { CStr::from_ptr(info.name) }.to_string_lossy().to_string());
+			namewhat = Some(unsafe { CStr::from_ptr(info.namewhat) }.to_string_lossy().to_string());
+		}
+
+		if select.contains(&b'S') {
+			what = Some(unsafe { CStr::from_ptr(info.what) }.to_string_lossy().to_string());
+			source = Some(unsafe { CStr::from_ptr(info.source) }.to_string_lossy().to_string());
+			linedefined = Some(info.linedefined);
+			lastlinedefined = Some(info.lastlinedefined);
+			short_src = Some(
+				unsafe { CStr::from_ptr(info.short_src.as_ptr()) }
+					.to_string_lossy()
+					.to_string(),
+			);
+		}
+
+		if select.contains(&b'l') {
+			currentline = Some(info.currentline);
+		}
+
+		if select.contains(&b'u') {
+			nups = Some(info.nups);
+		}
+
+		Ok(DebugInfo {
+			event: info.event,
+			name,
+			namewhat,
+			what,
+			source,
+			currentline,
+			nups,
+			linedefined,
+			lastlinedefined,
+			short_src,
+			func,
+		})
+	}
 }
 
 #[macro_export]

packages/autorun-lua/src/lua/raw.rs

@@ -11,7 +11,7 @@ const LUA_IDSIZE: usize = 60;
 
 #[repr(C)]
 #[derive(Debug)]
-pub struct DebugInfo {
+pub struct RawDebugInfo {
 	pub event: c_int,
 	pub name: *const c_char,             // n
 	pub namewhat: *const c_char,         // n
@@ -239,8 +239,8 @@ impl RawLuaApi {
 		self._toboolean(state, index) != 0
 	}
 
-	pub fn getinfo(&self, state: *mut LuaState, level: c_int, what: &CStr) -> Option<DebugInfo> {
-		let mut debug_info = unsafe { std::mem::zeroed::<DebugInfo>() };
+	pub fn getinfo(&self, state: *mut LuaState, level: c_int, what: &CStr) -> Option<RawDebugInfo> {
+		let mut debug_info = unsafe { std::mem::zeroed::<RawDebugInfo>() };
 
 		if self.getstack(state, level, &raw mut debug_info as _) == 0 {
 			return None;

packages/autorun-lua/src/value/table.rs

@@ -1,4 +1,6 @@
-use crate::{FromLua, Globals, IntoLua, LuaApi, LuaResult, LuaState, RawHandle, RawLuaApi, TryFromLua};
+use crate::{
+	FromLua, Globals, IntoLua, LuaApi, LuaError, LuaResult, LuaState, LuaTypeId, LuaValue, RawHandle, RawLuaApi, TryFromLua,
+};
 
 #[derive(Debug, Clone, Copy)]
 pub struct LuaTable {
@@ -47,3 +49,12 @@ impl IntoLua for &LuaTable {
 		lua.push(state, &self.handle);
 	}
 }
+
+impl TryFromLua for LuaTable {
+	fn try_from_lua(lua: &RawLuaApi, state: *mut LuaState, index: i32) -> LuaResult<Self> {
+		match lua.to(state, index) {
+			LuaValue::Table(table) => Ok(table),
+			other => Err(LuaError::mismatch(LuaTypeId::Table, other.typeid())),
+		}
+	}
+}