0.2.0

* Use inline functions instead of macros for lua_pop, lua_get/setglobal etc.

* Deprecate cstring! in favor of the user manually converting their strings to pointers.

* Types use std::ffi::raw now

* Fix printgm from last commit.

Author: vurvdev

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "rglua"
 description = "Rust bindings to the lua api for gmod binary module creation"
-version = "0.1.1"
+version = "0.2.0"
 authors = ["Vurv <vurvdevelops@gmail.com>"]
 keywords = ["glua","garrysmod","lua"]
 readme = "README.md"

README.md

@@ -1,6 +1,6 @@
 # rglua [![Release Shield](https://img.shields.io/github/v/release/Vurv78/rglua)](https://github.com/Vurv78/rglua/releases/latest) ![Linux Build Status](https://www.travis-ci.com/Vurv78/rglua.svg?branch=main) [![License](https://img.shields.io/github/license/Vurv78/rglua?color=red)](https://opensource.org/licenses/Apache-2.0) [![github/Vurv78](https://img.shields.io/discord/824727565948157963?color=7289DA&label=chat&logo=discord)](https://discord.gg/epJFC6cNsw)
 
-This is a crate that contains bindings for using the lua c api in garrysmod through bindings using rust-dlopen.
+This is a crate that contains bindings for using the lua c api in garrysmod through bindings using the rust libloading library.
 Can be used for either binary modules or just manual injections into gmod, like with [Autorun-rs](https://github.com/Vurv78/Autorun-rs)
 
 This works by finding a ``lua_shared.dll`` file relative to the currently running program, so you need to make sure your file is either in ``GarrysMod/bin/`` or ``GarrysMod/garrysmod/bin`` for srcds servers. The library will panic if the file is not found.
@@ -39,15 +39,14 @@ Also do this if you have never compiled to 32 bit, to get rustup to install 32 b
 ## Example Module
 ```rust
 use rglua::{
-	types::LuaState,
+	types::{ LuaState, CharBuf },
 	cstring,
-	lua_shared::*,
-	lua_getglobal,
+	lua_shared::*
 };
 
 #[no_mangle]
 pub extern fn gmod13_open(state: LuaState) -> i32 {
-	lua_getglobal!( state, cstring!("print") );
+	lua_getglobal( state, b"print\0".as_ptr() as CharBuf );
 	lua_pushstring( state, cstring!("Hello from rust!") );
 	lua_call( state, 1, 0 );
 	0

src/globals.rs

@@ -1,99 +1,99 @@
 use crate::types::*;
 
 pub mod Lua {
-    use super::CInt;
+	use super::CInt;
 
-    pub static VERSION: &'static str = "Lua 5.1";
-    pub static RELEASE: &'static str = "Lua 5.1.4";
-    pub static VERSION_NUM: CInt = 501;
-    pub static COPYRIGHT: &'static str = "Copyright (C) 1994-2008 Lua.org, PUC-Rio";
-    pub static AUTHORS: &'static str = "R. Ierusalimschy, L. H. de Figueiredo & W. Celes";
+	pub static VERSION: &'static str = "Lua 5.1";
+	pub static RELEASE: &'static str = "Lua 5.1.4";
+	pub static VERSION_NUM: CInt = 501;
+	pub static COPYRIGHT: &'static str = "Copyright (C) 1994-2008 Lua.org, PUC-Rio";
+	pub static AUTHORS: &'static str = "R. Ierusalimschy, L. H. de Figueiredo & W. Celes";
 
-    pub static REGISTRYINDEX: CInt = -10000;
-    pub static ENVIRONINDEX: CInt = -10001;
-    pub static GLOBALSINDEX: CInt = -10002;
+	pub static REGISTRYINDEX: CInt = -10000;
+	pub static ENVIRONINDEX: CInt = -10001;
+	pub static GLOBALSINDEX: CInt = -10002;
 
-    pub static MULTRET: CInt = -1;
-    pub static SIGNATURE: &'static str = "\x1bLua";
-    pub static MINSTACK: CInt = 20;
+	pub static MULTRET: CInt = -1;
+	pub static SIGNATURE: &'static str = "\x1bLua";
+	pub static MINSTACK: CInt = 20;
 
-    pub static NUMTYPES: CInt = 9;
-    pub static NUMTAGS: CInt = NUMTYPES;
+	pub static NUMTYPES: CInt = 9;
+	pub static NUMTAGS: CInt = NUMTYPES;
 
 
-    // Proper enums to use. Cast these to integers when using them
-    pub enum Type {
-        None = -1,
-        Nil,
-        Bool,
-        LUserData,
-        Number,
-        String,
-        Table,
-        Function,
-        UserData,
-        Thread
-    }
+	// Proper enums to use. Cast these to integers when using them
+	pub enum Type {
+		None = -1,
+		Nil,
+		Bool,
+		LUserData,
+		Number,
+		String,
+		Table,
+		Function,
+		UserData,
+		Thread
+	}
 
-    pub enum Status {
-        Ok = 0,
-        Yield,
-        ErrRun,
-        ErrSyntax,
-        ErrMem,
-        ErrErr
-    }
+	pub enum Status {
+		Ok = 0,
+		Yield,
+		ErrRun,
+		ErrSyntax,
+		ErrMem,
+		ErrErr
+	}
 
-    // Garbage collection
-    pub enum Gc {
-        Stop = 0,
-        Restart,
-        Collect,
-        Count,
-        CountB,
-        Step,
-        SetPause,
-        SetStepMul,
-        IsRunning,
-        Gen,
-        Inc // 11
-    }
+	// Garbage collection
+	pub enum Gc {
+		Stop = 0,
+		Restart,
+		Collect,
+		Count,
+		CountB,
+		Step,
+		SetPause,
+		SetStepMul,
+		IsRunning,
+		Gen,
+		Inc // 11
+	}
 
-    // To be used with debug.sethook
-    pub enum Hook {
-        Call = 0,
-        Ret,
-        Line,
-        Count,
-        TailCall
-    }
+	// To be used with debug.sethook
+	pub enum Hook {
+		Call = 0,
+		Ret,
+		Line,
+		Count,
+		TailCall
+	}
 
-    pub enum Mask {
-        Call = (1 << Hook::Call as i32),
-        Ret = (1 << Hook::Ret as i32),
-        Line = (1 << Hook::Line as i32),
-        Count = (1 << Hook::Count as i32)
-    }
+	pub enum Mask {
+		Call = (1 << Hook::Call as i32),
+		Ret = (1 << Hook::Ret as i32),
+		Line = (1 << Hook::Line as i32),
+		Count = (1 << Hook::Count as i32)
+	}
 }
 
 pub mod Jit {
-    pub enum Mode {
-        ENGINE,
-        DEBUG,
-        FUNC,
-        ALLFUNC,
-        ALLSUBFUNC,
-        TRACE,
-        WRAPCFUNC = 0x10,
-        MAX,
-        MASK = 0x0ff // LUAJIT_MODE_MASK
-    }
+	pub enum Mode {
+		ENGINE,
+		DEBUG,
+		FUNC,
+		ALLFUNC,
+		ALLSUBFUNC,
+		TRACE,
+		WRAPCFUNC = 0x10,
+		MAX,
+		MASK = 0x0ff // LUAJIT_MODE_MASK
+	}
 
-    use super::CInt;
-    // Associated Constants, woah
-    impl Mode {
-        pub const OFF: CInt = 0x0000;
-        pub const ON: CInt = 0x0100;
-        pub const FLUSH: CInt = 0x0200;
-    }
+	use super::CInt;
+	// Associated Constants, woah
+	impl Mode {
+		pub const OFF: CInt = 0x0000;
+		pub const ON: CInt = 0x0100;
+		pub const FLUSH: CInt = 0x0200;
+	}
 }

src/helpers.rs

@@ -1,42 +1,48 @@
 #![allow(unused)]
 
 // Get a const char* from a &str
+
+#[deprecated(
+	since = "0.2.0",
+	note = "Use b\"string\".as_ptr() as std::os::raw::c_char format or CStrings directly instead."
+)]
 #[macro_export]
 macro_rules! cstring {
-    ($rstring:expr) => {
-        {
-            let v = std::ffi::CString::new($rstring);
-            v.expect("Couldn't make CString from rust string").as_ptr()
-        }
-    }
+	($rstring:expr) => {
+		{
+			let v = std::ffi::CString::new($rstring);
+			v.expect("Couldn't make CString from rust string").as_ptr()
+		}
+	}
 }
 
 // Get a rust &str from a const char*
 #[macro_export]
 macro_rules! rstring {
-    ($cstring:expr) => {
-        {
-            #[allow(unused_unsafe)]
-            let cstr = unsafe{ std::ffi::CStr::from_ptr($cstring) };
-            cstr.to_str().expect("Couldn't unwrap CString")
-        }
-    }
+	($cstring:expr) => {
+		{
+			#[allow(unused_unsafe)]
+			let cstr = unsafe{ std::ffi::CStr::from_ptr($cstring) };
+			cstr.to_str().expect("Couldn't unwrap CString")
+		}
+	}
 }
 
 #[allow(unused_macros)]
 #[macro_export]
 /// Like println!, however it prints to the gmod server's console.
+// First arg is the lua state.
+// Rest are varargs.
+// Can be either a variable storing a str literal, or a referenced String / str variable
 macro_rules! printgm {
-    // First arg is the lua state.
-    // Rest are varargs.
-    // Can be either a variable storing a str literal, or a referenced String / str variable
-    ($state:expr, $($x:expr),*) => {
-        {
-            let stmt = format!( $($x,)* ); // Everything past the state will be as if it were inside a format! call.
-            rglua::lua_getglobal!($state, rglua::cstring!("print") );
-            rglua::lua_shared::lua_pushstring($state, rglua::cstring!(stmt) );
-            // 1 arg, 0 results
-            rglua::lua_shared::lua_call($state, 1, 0);
-        }
-    };
+	($state:expr, $($x:expr),*) => {
+		{
+			let printargs = format!( $($x,)* );
+			if let Ok(fmt) = std::ffi::CString::new(printargs) {
+				rglua::lua_shared::lua_getglobal( $state, b"print".as_ptr() as *const std::os::raw::c_char );
+				rglua::lua_shared::lua_pushstring( $state, fmt.as_ptr() );
+				rglua::lua_shared::lua_call( $state, 1, 0 );
+			}
+		}
+	};
 }

src/lua_shared.rs

@@ -52,7 +52,6 @@ macro_rules! expose_symbol {
 	};
 }
 
-// dlopen raw lua_shared.dll library. Don't use this unless you know what you're doing.
 pub const LUA_SHARED_RAW: Lazy<Library> = Lazy::new(|| {
 	let path = LUA_SHARED_PATH.as_ref().expect("Couldn't find lua_shared.dll!");
 	unsafe { Library::new(path).expect("Could not open library") }
@@ -151,44 +150,32 @@ expose_symbol!( lua_rawequal, CInt, (state: LuaState, ind1: CInt, ind2: CInt) );
 // Raising Errors
 expose_symbol!( luaL_typerror, CInt, (state: LuaState, narg: CInt, typename: CharBuf) );
 
-#[macro_export]
-macro_rules! lua_pop {
-	($state:expr, $ind:literal) => {
-		rglua::lua_shared::lua_settop( $state, -($ind)-1 );
-	}
+#[inline(always)]
+pub fn lua_pop(state: LuaState, ind: CInt) {
+	lua_settop( state, -(ind)-1 );
 }
 
-#[macro_export]
-macro_rules! lua_getglobal {
-	($state:expr, $name:expr) => {
-		rglua::lua_shared::lua_getfield($state, rglua::globals::Lua::GLOBALSINDEX, $name);
-	}
+#[inline(always)]
+pub fn lua_getglobal(state: LuaState, name: CharBuf) {
+	lua_getfield(state, GLOBALSINDEX, name);
 }
 
-#[macro_export]
-macro_rules! lua_setglobal {
-	($state:expr, $name:expr) => {
-		rglua::lua_shared::lua_setfield($state, rglua::globals::Lua::GLOBALSINDEX, $name);
-	}
+#[inline(always)]
+pub fn lua_setglobal(state: LuaState, name: CharBuf) {
+	lua_setfield(state, GLOBALSINDEX, name);
 }
 
-#[macro_export]
-macro_rules! lua_pushcfunction {
-	($state:expr, $fnc:expr) => {
-		rglua::lua_shared::lua_pushcclosure($state, $fnc, 0);
-	}
+#[inline(always)]
+pub fn lua_pushcfunction(state: LuaState, fnc: LuaCFunction) {
+	lua_pushcclosure(state, fnc, 0);
 }
 
-#[macro_export]
-macro_rules! lua_tostring {
-	($state:expr, $idx:expr) => {
-		rglua::lua_shared::lua_tolstring($state, $idx, 0)
-	}
+#[inline(always)]
+pub fn lua_tostring(state: LuaState, idx: CInt) -> CharBuf {
+	lua_tolstring(state, idx, 0)
 }
 
-#[macro_export]
-macro_rules! lua_resume {
-	($state:expr, $narg:expr) => {
-		rglua::lua_shared::lua_resume_real($state, $narg)
-	}
+#[inline(always)]
+pub fn lua_resume(state: LuaState, narg: CInt) -> CInt {
+	lua_resume_real(state, narg)
 }

src/types.rs

@@ -1,11 +1,15 @@
-pub type CVoid = std::ffi::c_void;
+use std::os::raw as ffi;
+
+// C FFI Types
+pub type CVoid = ffi::c_void;
+pub type CInt = ffi::c_int;
+pub type CLong = ffi::c_long;
+pub type CharBuf = *const ffi::c_char; //*const i8; // const char*
 pub type SizeT = usize;
 
+// Lua Types below
 pub type LuaNumber = f64; // All lua numbers are doubles in Lua 5.1 (Glua)
 pub type LuaInteger = isize;
 
 pub type LuaState = *mut CVoid; // Raw Lua state.
-pub type CharBuf = *const i8; // const char*
-pub type CInt = i32;
 pub type LuaCFunction = extern "C" fn(LuaState) -> CInt;
-pub type CLong = i64;