use std::os::raw::*;
use crate::ffi;
use crate::wrapper::{Status, Type};
pub struct State {
state: *mut ffi::lua::lua_State,
}
impl State {
pub fn new() -> State {
State {
state: unsafe { ffi::lauxlib::luaL_newstate() },
}
}
pub fn at_panic(&self, panicf: ffi::lua::lua_CFunction) -> ffi::lua::lua_CFunction {
unsafe { ffi::lua::lua_atpanic(self.state, panicf) }
}
pub fn call(&self, nargs: i32, nresults: i32) {
unsafe { ffi::lua::lua_call(self.state, nargs, nresults) }
}
pub fn check_stack(&self, extra: i32) -> i32 {
unsafe { ffi::lua::lua_checkstack(self.state, extra) }
}
pub fn concat(&self, n: i32) {
unsafe { ffi::lua::lua_concat(self.state, n); }
}
pub fn cpcall(&self, func: ffi::lua::lua_CFunction, ud: *mut c_void) -> i32 {
unsafe { ffi::lua::lua_cpcall(self.state, func, ud) }
}
pub fn create_table(&self, narr: i32, nrec: i32) {
unsafe { ffi::lua::lua_createtable(self.state, narr, nrec); }
}
pub fn dump(&self, writer: ffi::lua::lua_Writer, data: *mut c_void) -> i32 {
unsafe { ffi::lua::lua_dump(self.state, writer, data) }
}
pub fn equal(&self, index1: i32, index2: i32) -> i32 {
unsafe { ffi::lua::lua_equal(self.state, index1, index2) }
}
pub fn error(&self) -> i32 {
unsafe { ffi::lua::lua_error(self.state) }
}
pub fn gc(&self, what: i32, data: i32) -> i32 {
unsafe { ffi::lua::lua_gc(self.state, what, data) }
}
pub fn get_allocf(&self, ud: *mut *mut c_void) -> ffi::lua::lua_Alloc {
unsafe { ffi::lua::lua_getallocf(self.state, ud) }
}
pub fn get_fenv(&self, index: i32) {
unsafe { ffi::lua::lua_getfenv(self.state, index); }
}
pub fn get_field(&self, index: i32, k: &str) {
unsafe { ffi::lua::lua_getfield(self.state, index, std::ffi::CString::new(k).unwrap().as_ptr()); }
}
pub fn get_global(&self, name: &str) {
self.get_field(ffi::lua::LUA_GLOBALSINDEX, name);
}
pub fn get_metatable(&self, index: i32) -> i32 {
unsafe { ffi::lua::lua_getmetatable(self.state, index) }
}
pub fn get_table(&self, index: i32) {
unsafe { ffi::lua::lua_gettable(self.state, index); }
}
pub fn get_top(&self) -> i32 {
unsafe { ffi::lua::lua_gettop(self.state) }
}
pub fn insert(&self, index: i32) {
unsafe { ffi::lua::lua_insert(self.state, index); }
}
pub fn is_boolean(&self, index: i32) -> bool {
unsafe { ffi::lua::lua_isboolean(self.state, index) }
}
pub fn is_cfunction(&self, index: i32) -> bool {
unsafe { ffi::lua::lua_iscfunction(self.state, index) == 1 }
}
pub fn is_function(&self, index: i32) -> bool {
unsafe { ffi::lua::lua_isfunction(self.state, index) }
}
pub fn is_light_userdata(&self, index: i32) -> bool {
unsafe { ffi::lua::lua_islightuserdata(self.state, index) }
}
pub fn is_nil(&self, index: i32) -> bool {
unsafe { ffi::lua::lua_isnil(self.state, index) }
}
pub fn is_none(&self, index: i32) -> bool {
unsafe { ffi::lua::lua_isnone(self.state, index) }
}
pub fn is_none_or_nil(&self, index: i32) -> bool {
unsafe { ffi::lua::lua_isnoneornil(self.state, index) }
}
pub fn is_number(&self, index: i32) -> bool {
unsafe { ffi::lua::lua_isnumber(self.state, index) == 1 }
}
pub fn is_string(&self, index: i32) -> bool {
unsafe { ffi::lua::lua_isstring(self.state, index) == 1 }
}
pub fn is_table(&self, index: i32) -> bool {
unsafe { ffi::lua::lua_istable(self.state, index) }
}
pub fn is_thread(&self, index: i32) -> bool {
unsafe { ffi::lua::lua_isthread(self.state, index) }
}
pub fn is_userdata(&self, index: i32) -> bool {
unsafe { ffi::lua::lua_isuserdata(self.state, index) == 1 }
}
pub fn less_than(&self, index1: i32, index2: i32) -> bool {
unsafe { ffi::lua::lua_lessthan(self.state, index1, index2) == 1 }
}
pub fn load(&self, reader: ffi::lua::lua_Reader, data: *mut c_void, chunk_name: &str) -> i32 {
unsafe { ffi::lua::lua_load(self.state, reader, data, std::ffi::CString::new(chunk_name).unwrap().as_ptr()) }
}
pub fn new_table(&self) {
unsafe { ffi::lua::lua_newtable(self.state); }
}
pub fn new_userdata(&self, size: usize) -> *mut c_void {
unsafe { ffi::lua::lua_newuserdata(self.state, size) }
}
pub fn next(&self, index: i32) -> i32 {
unsafe { ffi::lua::lua_next(self.state, index) }
}
pub fn obj_len(&self, index: i32) -> usize {
unsafe { ffi::lua::lua_objlen(self.state, index) }
}
pub fn pcall(&self, nargs: i32, nresults: i32, errfunc: i32) -> i32 {
unsafe { ffi::lua::lua_pcall(self.state, nargs, nresults, errfunc) }
}
pub fn pop(&self, n: i32) {
unsafe { ffi::lua::lua_pop(self.state, n); }
}
pub fn push_boolean(&self, b: i32) {
unsafe { ffi::lua::lua_pushboolean(self.state, b); }
}
pub fn push_cclosure(&self, func: ffi::lua::lua_CFunction, n: i32) {
unsafe { ffi::lua::lua_pushcclosure(self.state, func, n); }
}
pub fn push_cfunction(&self, func: ffi::lua::lua_CFunction) {
unsafe { ffi::lua::lua_pushcfunction(self.state, func); }
}
pub fn push_integer(&self, n: ffi::lua::lua_Integer) {
unsafe { ffi::lua::lua_pushinteger(self.state, n); }
}
pub fn push_light_userdata(&self, p: *mut c_void) {
unsafe { ffi::lua::lua_pushlightuserdata(self.state, p); }
}
pub fn push_literal(&self, s: &str) {
self.push_lstring(s, s.len());
}
pub fn push_lstring(&self, s: &str, len: usize) {
unsafe { ffi::lua::lua_pushlstring(self.state, std::ffi::CString::new(s).unwrap().as_ptr(), len); }
}
pub fn push_nil(&self) {
unsafe { ffi::lua::lua_pushnil(self.state); }
}
pub fn push_number(&self, n: ffi::lua::lua_Number) {
unsafe { ffi::lua::lua_pushnumber(self.state, n); }
}
pub fn push_string(&self, s: &str) {
unsafe { ffi::lua::lua_pushstring(self.state, std::ffi::CString::new(s).unwrap().as_ptr()); }
}
pub fn push_thread(&self) -> i32 {
unsafe { ffi::lua::lua_pushthread(self.state) }
}
pub fn push_value(&self, index: i32) {
unsafe { ffi::lua::lua_pushvalue(self.state, index); }
}
pub fn raw_equal(&self, index1: i32, index2: i32) -> bool {
unsafe { ffi::lua::lua_rawequal(self.state, index1, index2) == 1 }
}
pub fn raw_get(&self, index: i32) {
unsafe { ffi::lua::lua_rawget(self.state, index); }
}
pub fn raw_geti(&self, index: i32, n: i32) {
unsafe { ffi::lua::lua_rawgeti(self.state, index, n); }
}
pub fn raw_set(&self, index: i32) {
unsafe { ffi::lua::lua_rawset(self.state, index); }
}
pub fn raw_seti(&self, index: i32, n: i32) {
unsafe { ffi::lua::lua_rawseti(self.state, index, n); }
}
pub fn register(&self, name: &str, func: ffi::lua::lua_CFunction) {
unsafe { ffi::lua::lua_register(self.state, std::ffi::CString::new(name).unwrap().as_ptr(), func); }
}
pub fn remove(&self, index: i32) {
unsafe { ffi::lua::lua_remove(self.state, index); }
}
pub fn replace(&self, index: i32) {
unsafe { ffi::lua::lua_replace(self.state, index) }
}
pub fn resume(&self, narg: i32) -> i32 {
unsafe { ffi::lua::lua_resume(self.state, narg) }
}
pub fn set_allocf(&self, f: ffi::lua::lua_Alloc, ud: *mut c_void) {
unsafe { ffi::lua::lua_setallocf(self.state, f, ud); }
}
pub fn set_fenv(&self, index: i32) -> i32 {
unsafe { ffi::lua::lua_setfenv(self.state, index) }
}
pub fn set_field(&self, index: i32, k: &str) {
unsafe { ffi::lua::lua_setfield(self.state, index, std::ffi::CString::new(k).unwrap().as_ptr()) }
}
pub fn set_global(&self, name: &str) {
self.set_field(ffi::lua::LUA_GLOBALSINDEX, name);
}
pub fn set_metatable(&self, index: i32) -> i32 {
unsafe { ffi::lua::lua_setmetatable(self.state, index) }
}
pub fn set_table(&self, index: i32) {
unsafe { ffi::lua::lua_settable(self.state, index); }
}
pub fn set_top(&self, index: i32) {
unsafe { ffi::lua::lua_settop(self.state, index); }
}
pub fn status(&self) -> Status {
unsafe { Status::from(ffi::lua::lua_status(self.state)) }
}
pub fn to_boolean(&self, index: i32) -> bool {
unsafe { ffi::lua::lua_toboolean(self.state, index) == 1 }
}
pub fn to_cfunction(&self, index: i32) -> ffi::lua::lua_CFunction {
unsafe { ffi::lua::lua_tocfunction(self.state, index).unwrap() }
}
pub fn to_integer(&self, index: i32) -> ffi::lua::lua_Integer {
unsafe { ffi::lua::lua_tointeger(self.state, index) }
}
pub fn to_lstring(&self, index: i32, len: *mut usize) -> &str {
unsafe { std::ffi::CStr::from_ptr(ffi::lua::lua_tolstring(self.state, index, len)).to_str().unwrap() }
}
pub fn to_number(&self, index: i32) -> ffi::lua::lua_Number {
unsafe { ffi::lua::lua_tonumber(self.state, index) }
}
pub fn to_pointer(&self, index: i32) -> *const c_void {
unsafe { ffi::lua::lua_topointer(self.state, index) }
}
pub fn to_string(&self, index: i32) -> &str {
unsafe { std::ffi::CStr::from_ptr(ffi::lua::lua_tostring(self.state, index)).to_str().unwrap() }
}
pub fn to_thread(&self, index: i32) -> *mut ffi::lua::lua_State {
unsafe { ffi::lua::lua_tothread(self.state, index) }
}
pub fn to_userdata(&self, index: i32) -> *mut c_void {
unsafe { ffi::lua::lua_touserdata(self.state, index) }
}
pub fn type_of(&self, index: i32) -> Type {
unsafe { Type::from(ffi::lua::lua_type(self.state, index)) }
}
pub fn typename(&self, tp: i32) -> &str {
unsafe { std::ffi::CStr::from_ptr(ffi::lua::lua_typename(self.state, tp)).to_str().unwrap() }
}
pub fn xmove(&self, to: *mut ffi::lua::lua_State, n: i32) {
unsafe { ffi::lua::lua_xmove(self.state, to, n); }
}
pub fn yield_coroutine(&self, nresults: i32) -> i32 {
unsafe { ffi::lua::lua_yield(self.state, nresults) }
}
pub fn load_string(&self, s: &str) -> i32 {
unsafe { ffi::lauxlib::luaL_loadstring(self.state, std::ffi::CString::new(s).unwrap().as_ptr()) }
}
pub fn load_buffer(&self, buff: &str, sz: usize, name: &str) -> i32 {
unsafe { ffi::lauxlib::luaL_loadbuffer(self.state, std::ffi::CString::new(buff).unwrap().as_ptr(), sz, std::ffi::CString::new(name).unwrap().as_ptr()) }
}
pub fn do_string(&self, s: &str) -> i32 {
unsafe { ffi::lauxlib::luaL_dostring(self.state, std::ffi::CString::new(s).unwrap().as_ptr()) }
}
pub fn open_libs(&self) {
unsafe { ffi::lauxlib::luaL_openlibs(self.state); }
}
}
impl Drop for State {
fn drop(&mut self) {
unsafe { ffi::lua::lua_close(self.state); }
}
}