luacir.hxx

#pragma once
#include<lua5.3/lua.hpp>
#include<vector>
#include<string>
#include<optional>
#include<cstdio>
#include"util.hxx"
#include"enums.hxx"

classlua_engine_t {
public:
lua_engine_t();
~lua_engine_t();

voidfile(constchar* filename);
voidscript(constchar* text);

template<typenameresult_t, typename... args_t>
result_tcall(constchar* fname, constargs_t&... args);

operator lua_State*() { return state; }

private:

template<typenamearg_t>
voidpush(constarg_t& arg);

template<typenamearg_t>
voidpush_array(constarg_t* data, size_t count);

template<typenamearg_t>
voidpush_object(constarg_t& obj);

template<typenamevalue_t>
 std::optional<value_t> get_value(constchar* name);

 lua_State* state;
};

inlinelua_engine_t::lua_engine_t() {
 state = luaL_newstate();
luaL_openlibs(state);
}

inlinelua_engine_t::~lua_engine_t() {
lua_close(state);
}

inlinevoidlua_engine_t::file(constchar* filename) {
luaL_dofile(state, filename);
}

inlinevoidlua_engine_t::script(constchar* text) {
luaL_dostring(state, text);
}

template<typenamearg_t>
voidlua_engine_t::push(constarg_t& arg) {
ifconstexpr(std::is_enum<arg_t>::value) {
lua_pushstring(state, name_from_enum(arg));

 } elseifconstexpr(@sfinae(arg.c_str())) {
lua_pushstring(state, arg.c_str());

 } elseifconstexpr(@sfinae(std::string(arg))) {
lua_pushstring(state, arg);

 } elseifconstexpr(std::is_integral<arg_t>::value) {
lua_pushinteger(state, arg);

 } elseifconstexpr(std::is_floating_point<arg_t>::value) {
lua_pushnumber(state, arg);

 } elseifconstexpr(std::is_array<arg_t>::value) {
push_array(arg, std::extent<arg_t>::value);

 } elseifconstexpr(@is_class_template(arg_t, std::vector)) {
push_array(arg.data(), arg.size());

 } else {
static_assert(std::is_class<arg_t>::value, "expected class type");
push_object(arg);
 }
}

template<typenamearg_t>
voidlua_engine_t::push_array(constarg_t* data, size_t count) {
lua_createtable(state, count, 0);
for(size_t i = 0; count; ++i) {
// Push the value.
push(data[i]);

// Insert the item at t[i + 1].
lua_seti(state, -2, i + 1);
 }
}

template<typenamearg_t>
voidlua_engine_t::push_object(constarg_t& object) {
lua_createtable(state, 0, @member_count(arg_t));
 @meta for(size_t i = 0; i < @member_count(arg_t); ++i) {
// Push the data member.
push(@member_value(object, i));

// Insert the item at t[member-name].
lua_setfield(state, -2, @member_name(arg_t, i));
 }
}

template<typenameresult_t, typename... args_t>
result_tlua_engine_t::call(constchar* fname, constargs_t&... args) {
// Push the function to the stack.
lua_getglobal(state, fname);

constsize_t num_args = sizeof...(args_t);
 @meta for(int i = 0; i < num_args; ++i)
// Push each argument to the stack.
push(args...[i]);

// Call the function.
lua_call(state, num_args, LUA_MULTRET);

ifconstexpr(!std::is_void<result_t>::value) {
result_t ret { };
if(auto value = get_value<result_t>(fname))
 ret = std::move(*value);
return ret;
 }
}

template<typenamevalue_t>
std::optional<value_t> lua_engine_t::get_value(constchar* name) {
if(lua_isnil(state, -1)) {
printf(" **No field in result object named '%s'\n", name);
lua_pop(state, 1);
return { };
 }

 std::optional<value_t> value { };
ifconstexpr(std::is_enum<value_t>::value) {
if(lua_isstring(state, -1)) {
constchar* s = lua_tostring(state, -1);
if(auto e = enum_from_name<value_t>(s))
 value = *e;
else
printf(" **Unrecognized enum '%s' in field '%s'\n", s, name);

 } else
printf(" **Expected enum in field '%s'\n", name);

lua_pop(state, 1);

 } elseifconstexpr(@is_class_template(value_t, std::vector)) {
typedeftypenamevalue_t::value_type inner_t;

if(lua_istable(state, 1)) {
int len = lua_rawlen(state, -1);
 std::vector<inner_t> vec;
 vec.reserve(len);

for(int i = 1; i <= len; ++i) {
lua_pushinteger(state, i);
if(LUA_TNIL != lua_gettable(state, -2)) {
if(auto x = get_value<inner_t>(name))
 vec.push_back(std::move(*x));
 }
 }
 value = std::move(vec);

 } else
printf(" **Expected array in field '%s'\n", name);

lua_pop(state, 1);

 } elseifconstexpr(std::is_integral<value_t>::value) {
if(lua_isinteger(state, -1))
 value = lua_tointeger(state, -1);
else
printf(" **Expected integer in field '%s'\n", name);

lua_pop(state, 1);

 } elseifconstexpr(std::is_floating_point<value_t>::value) {
if(lua_isnumber(state, -1))
 value = lua_tonumber(state, -1);
else
printf(" **Expected floating-point in field '%s'\n", name);

lua_pop(state, 1);

 } elseifconstexpr(std::is_same<std::string, value_t>::value) {
if(lua_isstring(state, -1))
 value = lua_tostring(state, -1);
else
printf(" **Expected string in field '%s'\n", name);

lua_pop(state, 1);

 } else {
static_assert(std::is_class<value_t>::value, "expected class type");

if(lua_istable(state, 1)) {
// Loop over each data member.
value_t obj { };
 @meta for(int i = 0; i < @member_count(value_t); ++i) {{
constchar* name = @member_name(value_t, i);
lua_pushstring(state, name);
lua_gettable(state, -2);
if(auto x = get_value<@member_type(value_t, i)>(name))
 @member_value(obj, i) = std::move(*x);
 }}

 value = std::move(obj);
lua_pop(state, 1);

 } else
printf(" **Expected table in field '%s'\n", name);
 }

return value;
}