Files
dl_old/third/LuaBridge3/Source/LuaBridge/detail/CFunctions.h
T
2024-12-25 20:57:42 +08:00

1608 lines
46 KiB
C++
Vendored
Raw Blame History

This file contains invisible Unicode characters
This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// https://github.com/kunitoki/LuaBridge3
// Copyright 2020, Lucio Asnaghi
// Copyright 2019, Dmitry Tarakanov
// Copyright 2012, Vinnie Falco <vinnie.falco@gmail.com>
// SPDX-License-Identifier: MIT
#pragma once
#include "Config.h"
#include "Errors.h"
#include "FuncTraits.h"
#include "LuaHelpers.h"
#include "Options.h"
#include "Stack.h"
#include "TypeTraits.h"
#include "Userdata.h"
#include <algorithm>
#include <array>
#include <cstdint>
#include <optional>
#include <string>
namespace luabridge {
namespace detail {
//=================================================================================================
/**
* @brief Make argument lists extracting them from the lua state, starting at a stack index.
*
* @tparam ArgsPack Arguments pack to extract from the lua stack.
* @tparam Start Start index where stack variables are located in the lua stack.
*/
template <class T>
auto unwrap_argument_or_error(lua_State* L, std::size_t index, std::size_t start)
{
auto result = Stack<T>::get(L, static_cast<int>(index + start));
if (! result)
raise_lua_error(L, "Error decoding argument #%d: %s", static_cast<int>(index + 1), result.message().c_str());
return std::move(*result);
}
template <class ArgsPack, std::size_t Start, std::size_t... Indices>
auto make_arguments_list_impl(lua_State* L, std::index_sequence<Indices...>)
{
return tupleize(unwrap_argument_or_error<std::tuple_element_t<Indices, ArgsPack>>(L, Indices, Start)...);
}
template <class ArgsPack, std::size_t Start>
auto make_arguments_list(lua_State* L)
{
return make_arguments_list_impl<ArgsPack, Start>(L, std::make_index_sequence<std::tuple_size_v<ArgsPack>>());
}
//=================================================================================================
/**
* @brief Helpers for iterating through tuple arguments, pushing each argument to the lua stack.
*/
template <std::size_t Index = 0, class... Types>
auto push_arguments(lua_State*, std::tuple<Types...>)
-> std::enable_if_t<Index == sizeof...(Types), std::tuple<Result, std::size_t>>
{
return std::make_tuple(Result(), Index + 1);
}
template <std::size_t Index = 0, class... Types>
auto push_arguments(lua_State* L, std::tuple<Types...> t)
-> std::enable_if_t<Index < sizeof...(Types), std::tuple<Result, std::size_t>>
{
using T = std::tuple_element_t<Index, std::tuple<Types...>>;
auto result = Stack<T>::push(L, std::get<Index>(t));
if (! result)
return std::make_tuple(result, Index + 1);
return push_arguments<Index + 1, Types...>(L, std::move(t));
}
//=================================================================================================
/**
* @brief Helpers for iterating through tuple arguments, popping each argument from the lua stack.
*/
template <std::ptrdiff_t Start, std::ptrdiff_t Index = 0, class... Types>
auto pop_arguments(lua_State*, std::tuple<Types...>&)
-> std::enable_if_t<Index == sizeof...(Types), std::size_t>
{
return sizeof...(Types);
}
template <std::ptrdiff_t Start, std::ptrdiff_t Index = 0, class... Types>
auto pop_arguments(lua_State* L, std::tuple<Types...>& t)
-> std::enable_if_t<Index < sizeof...(Types), std::size_t>
{
using T = std::tuple_element_t<Index, std::tuple<Types...>>;
std::get<Index>(t) = Stack<T>::get(L, Start - Index);
return pop_arguments<Start, Index + 1, Types...>(L, t);
}
//=================================================================================================
/**
* @brief Check if a method name is a metamethod.
*/
template <class T = void, class... Args>
constexpr auto make_array(Args&&... args)
{
if constexpr (std::is_same_v<void, T>)
return std::array<std::common_type_t<std::decay_t<Args>...>, sizeof...(Args)>{{ std::forward<Args>(args)... }};
else
return std::array<T, sizeof...(Args)>{{ std::forward<Args>(args)... }};
}
inline bool is_metamethod(std::string_view method_name)
{
static constexpr auto metamethods = make_array<std::string_view>(
"__add",
"__band",
"__bnot",
"__bor",
"__bxor",
"__call",
"__close",
"__concat",
"__div",
"__eq",
"__gc",
"__idiv",
"__index",
"__ipairs",
"__le",
"__len",
"__lt",
"__metatable",
"__mod",
"__mode",
"__mul",
"__name",
"__newindex",
"__pairs",
"__pow",
"__shl",
"__shr",
"__sub",
"__tostring",
"__unm"
);
if (method_name.size() <= 2 || method_name[0] != '_' || method_name[1] != '_')
return false;
auto result = std::lower_bound(metamethods.begin(), metamethods.end(), method_name);
return result != metamethods.end() && *result == method_name;
}
/**
* @brief Make super method name.
*/
inline std::string make_super_method_name(const char* name)
{
LUABRIDGE_ASSERT(name != nullptr);
return (std::string_view(name).find("_") == 0u)
? (std::string("super") + name)
: (std::string("super_") + name);
}
//=================================================================================================
/**
* @brief Make super method name.
*/
inline Options get_class_options(lua_State* L, int index)
{
LUABRIDGE_ASSERT(lua_istable(L, index)); // Stack: mt
Options options = defaultOptions;
lua_rawgetp(L, index, getClassOptionsKey()); // Stack: mt, ifb (may be nil)
if (lua_isnumber(L, -1))
options = Options::fromUnderlying(lua_tointeger(L, -1));
lua_pop(L, 1);
return options;
}
//=================================================================================================
/**
* @brief Push class or const table onto stack.
*/
inline void push_class_or_const_table(lua_State* L, int index)
{
LUABRIDGE_ASSERT(lua_istable(L, index)); // Stack: mt
lua_rawgetp(L, index, getClassKey()); // Stack: mt, class table (ct) | nil
if (! lua_istable(L, -1)) // Stack: mt, nil
{
lua_pop(L, 1); // Stack: mt
lua_rawgetp(L, index, getConstKey()); // Stack: mt, const table (co) | nil
if (! lua_istable(L, -1)) // Stack: mt, nil
return;
}
}
//=================================================================================================
/**
* @brief __index metamethod for a namespace or class static and non-static members.
*
* Retrieves functions from metatables and properties from propget tables. Looks through the class hierarchy if inheritance is present.
*/
inline std::optional<int> try_call_index_fallback(lua_State* L)
{
LUABRIDGE_ASSERT(lua_istable(L, -1)); // Stack: mt
lua_rawgetp(L, -1, getIndexFallbackKey()); // Stack: mt, ifb (may be nil)
if (! lua_iscfunction(L, -1))
{
lua_pop(L, 1); // Stack: mt
return std::nullopt;
}
lua_pushvalue(L, 1); // Stack: mt, ifb, arg1
lua_pushvalue(L, 2); // Stack: mt, ifb, arg1, arg2
lua_call(L, 2, 1); // Stack: mt, ifbresult
if (! lua_isnoneornil(L, -1))
{
lua_remove(L, -2); // Stack: ifbresult
return 1;
}
lua_pop(L, 1); // Stack: mt
return std::nullopt;
}
template <bool IsObject>
inline std::optional<int> try_call_index_extensible(lua_State* L, const char* key)
{
LUABRIDGE_ASSERT(lua_istable(L, -1)); // Stack: mt
if constexpr (IsObject)
push_class_or_const_table(L, -1); // Stack: mt, cl | co
else
lua_rawgetp(L, -1, getStaticKey()); // Stack: mt, st
LUABRIDGE_ASSERT(lua_istable(L, -1)); // Stack: mt, cl | co | st
rawgetfield(L, -1, key); // Stack: mt, st, ifbresult | nil
if (! lua_isnoneornil(L, -1)) // Stack: mt, cl | co | st, ifbresult
{
lua_remove(L, -2); // Stack: mt, ifbresult
lua_remove(L, -2); // Stack: ifbresult
return 1;
}
lua_pop(L, 2); // Stack: mt
return std::nullopt;
}
template <bool IsObject>
inline int index_metamethod(lua_State* L)
{
#if LUABRIDGE_SAFE_STACK_CHECKS
luaL_checkstack(L, 3, detail::error_lua_stack_overflow);
#endif
LUABRIDGE_ASSERT(lua_istable(L, 1) || lua_isuserdata(L, 1)); // Stack (further not shown): table | userdata, name
lua_getmetatable(L, 1); // Stack: class/const table (mt)
LUABRIDGE_ASSERT(lua_istable(L, -1));
// Protect internal meta methods
const char* key = lua_tostring(L, 2);
if (key != nullptr && is_metamethod(key))
{
lua_pushnil(L);
return 1;
}
for (;;)
{
if constexpr (IsObject)
{
// Repeat the lookup in the index fallback
if (auto result = try_call_index_fallback(L))
return *result;
}
// Search into self or metatable
if (lua_istable(L, 1))
{
if constexpr (IsObject)
lua_pushvalue(L, 1); // Stack: mt, self
else
push_class_or_const_table(L, -1); // Stack: mt, cl | co
if (lua_istable(L, -1))
{
lua_pushvalue(L, 2); // Stack: mt, self | cl | co, field name
lua_rawget(L, -2); // Stack: mt, self | cl | co, field | nil
lua_remove(L, -2); // Stack: mt, field | nil
if (! lua_isnil(L, -1)) // Stack: mt, field
{
lua_remove(L, -2); // Stack: field
return 1;
}
}
lua_pop(L, 1); // Stack: mt
}
lua_pushvalue(L, 2); // Stack: mt, field name
lua_rawget(L, -2); // Stack: mt, field | nil
if (! lua_isnil(L, -1)) // Stack: mt, field
{
lua_remove(L, -2); // Stack: field
return 1;
}
LUABRIDGE_ASSERT(lua_isnil(L, -1)); // Stack: mt, nil
lua_pop(L, 1); // Stack: mt
// Repeat the lookup in the index extensible, for method overrides
const Options options = get_class_options(L, -1); // Stack: mt
if (options.test(extensibleClass | allowOverridingMethods))
{
if (auto result = try_call_index_extensible<IsObject>(L, key))
return *result;
}
// Try in the propget key
lua_rawgetp(L, -1, getPropgetKey()); // Stack: mt, propget table (pg)
LUABRIDGE_ASSERT(lua_istable(L, -1));
lua_pushvalue(L, 2); // Stack: mt, pg, field name
lua_rawget(L, -2); // Stack: mt, pg, getter | nil
lua_remove(L, -2); // Stack: mt, getter | nil
if (lua_iscfunction(L, -1)) // Stack: mt, getter
{
lua_remove(L, -2); // Stack: getter
lua_pushvalue(L, 1); // Stack: getter, table | userdata
lua_call(L, 1, 1); // Stack: value
return 1;
}
LUABRIDGE_ASSERT(lua_isnil(L, -1)); // Stack: mt, nil
lua_pop(L, 1); // Stack: mt
// It may mean that the field may be in const table and it's constness violation.
// Repeat the lookup in the parent metafield, or fallback to extensible class check.
lua_rawgetp(L, -1, getParentKey()); // Stack: mt, parent mt | nil
if (lua_isnil(L, -1)) // Stack: mt, nil
{
lua_pop(L, 2); // Stack: -
break;
}
// Remove the metatable and repeat the search in the parent one.
LUABRIDGE_ASSERT(lua_istable(L, -1)); // Stack: mt, parent mt
lua_remove(L, -2); // Stack: parent mt
}
lua_getmetatable(L, 1); // Stack: class/const table (mt)
LUABRIDGE_ASSERT(lua_istable(L, -1));
for (;;)
{
const Options options = get_class_options(L, -1); // Stack: mt
if (options.test(extensibleClass | ~allowOverridingMethods))
{
if (auto result = try_call_index_extensible<IsObject>(L, key))
return *result;
}
// Repeat the lookup in the parent metafield, or return nil if the field doesn't exist.
lua_rawgetp(L, -1, getParentKey()); // Stack: mt, parent mt | nil
if (lua_isnil(L, -1)) // Stack: mt, nil
{
lua_remove(L, -2); // Stack: nil
return 1;
}
// Remove the metatable and repeat the search in the parent one.
LUABRIDGE_ASSERT(lua_istable(L, -1)); // Stack: mt, parent mt
lua_remove(L, -2); // Stack: parent mt
}
// no return
}
//=================================================================================================
/**
* @brief __newindex metamethod for non-static members.
*
* Retrieves properties from propset tables.
*/
inline std::optional<int> try_call_newindex_fallback(lua_State* L)
{
LUABRIDGE_ASSERT(lua_istable(L, -1)); // Stack: mt
lua_rawgetp(L, -1, getNewIndexFallbackKey()); // Stack: mt, nifb (may be nil)
if (! lua_iscfunction(L, -1))
{
lua_pop(L, 1); // Stack: mt
return std::nullopt;
}
lua_pushvalue(L, 1); // stack: mt, nifb, arg1
lua_pushvalue(L, 2); // stack: mt, nifb, arg1, arg2
lua_pushvalue(L, 3); // stack: mt, nifb, arg1, arg2, arg3
lua_call(L, 3, 0); // stack: mt
return 0;
}
inline std::optional<int> try_call_newindex_extensible(lua_State* L, const char* key)
{
LUABRIDGE_ASSERT(key != nullptr);
LUABRIDGE_ASSERT(lua_istable(L, -1)); // Stack: mt
lua_pushvalue(L, -1); // Stack: mt, mt
for (;;)
{
push_class_or_const_table(L, -1); // Stack: mt, mt, class table (ct) | nil
if (! lua_istable(L, -1)) // Stack: mt, mt, nil
{
lua_pop(L, 2); // Stack: mt
return std::nullopt;
}
lua_pushvalue(L, 2); // Stack: mt, mt, ct | co, field name
lua_rawget(L, -2); // Stack: mt, mt, ct | co, field | nil
if (! lua_isnil(L, -1)) // Stack: mt, mt, ct | co, field
{
if (! lua_iscfunction(L, -1))
{
lua_pop(L, 1);
break;
}
// Obtain class options
const Options options = get_class_options(L, -2); // Stack: mt, mt, ct | co, field
if (! options.test(allowOverridingMethods))
luaL_error(L, "immutable member '%s'", key);
rawsetfield(L, -2, make_super_method_name(key).c_str()); // Stack: mt, mt, ct | co
break;
}
lua_pop(L, 1); // Stack: mt, mt, ct | co
lua_rawgetp(L, -2, getParentKey()); // Stack: mt, mt, ct | co, parent mt (pmt) | nil
if (lua_isnil(L, -1)) // Stack: mt, mt, ct | co, nil
{
lua_pop(L, 1); // Stack: mt, mt, ct | co
break;
}
LUABRIDGE_ASSERT(lua_istable(L, -1)); // Stack: mt, mt, ct | co, pmt
lua_remove(L, -2); // Stack: mt, mt, pmt
lua_remove(L, -2); // Stack: mt, pmt
}
lua_remove(L, -2); // Stack: mt, ct | co
lua_getmetatable(L, -1); // Stack: mt, ct | co, mt2
lua_pushvalue(L, 3); // Stack: mt, ct | co, mt2, arg3
rawsetfield(L, -2, key); // Stack: mt, ct | co, mt2
lua_pop(L, 2); // Stack: mt
return 0;
}
template <bool IsObject>
inline int newindex_metamethod(lua_State* L)
{
#if LUABRIDGE_SAFE_STACK_CHECKS
luaL_checkstack(L, 3, detail::error_lua_stack_overflow);
#endif
LUABRIDGE_ASSERT(lua_istable(L, 1) || lua_isuserdata(L, 1)); // Stack (further not shown): table | userdata, name, new value
lua_getmetatable(L, 1); // Stack: metatable (mt)
LUABRIDGE_ASSERT(lua_istable(L, -1));
const char* key = lua_tostring(L, 2);
for (;;)
{
const Options options = get_class_options(L, -1);
// Try in the property set table
lua_rawgetp(L, -1, getPropsetKey()); // Stack: mt, propset table (ps) | nil
if (lua_isnil(L, -1)) // Stack: mt, nil
luaL_error(L, "no member named '%s'", key);
LUABRIDGE_ASSERT(lua_istable(L, -1));
lua_pushvalue(L, 2); // Stack: mt, ps, field name
lua_rawget(L, -2); // Stack: mt, ps, setter | nil
lua_remove(L, -2); // Stack: mt, setter | nil
if (lua_iscfunction(L, -1)) // Stack: mt, setter
{
lua_remove(L, -2); // Stack: setter
if constexpr (IsObject)
lua_pushvalue(L, 1); // Stack: setter, table | userdata
lua_pushvalue(L, 3); // Stack: setter, table | userdata, new value
lua_call(L, IsObject ? 2 : 1, 0); // Stack: -
return 0;
}
LUABRIDGE_ASSERT(lua_isnil(L, -1)); // Stack: mt, nil
lua_pop(L, 1); // Stack: mt
if constexpr (IsObject)
{
// Try in the new index fallback
if (auto result = try_call_newindex_fallback(L))
return *result;
}
else
{
// Try in the new index extensible
if (options.test(extensibleClass))
{
if (auto result = try_call_newindex_extensible(L, key))
return *result;
}
}
// Try in the parent
lua_rawgetp(L, -1, getParentKey()); // Stack: mt, parent mt | nil
if (lua_isnil(L, -1)) // Stack: mt, nil
luaL_error(L, "no writable member '%s'", key);
LUABRIDGE_ASSERT(lua_istable(L, -1)); // Stack: mt, parent mt
lua_remove(L, -2); // Stack: parent mt
// Repeat the search in the parent
}
return 0;
}
//=================================================================================================
/**
* @brief lua_CFunction to report an error writing to a read-only value.
*
* The name of the variable is in the first upvalue.
*/
inline int read_only_error(lua_State* L)
{
std::stringstream ss;
ss << "'" << lua_tostring(L, lua_upvalueindex(1)) << "' is read-only";
raise_lua_error(L, "%s", ss.str().c_str());
return 0;
}
//=================================================================================================
/**
* @brief __tostring metamethod for a class.
*/
template <class C>
static int tostring_metamethod(lua_State* L)
{
const void* ptr = lua_topointer(L, 1);
lua_getmetatable(L, -1); // Stack: metatable (mt)
lua_rawgetp(L, -1, getTypeKey()); // Stack: mt, classname (cn)
lua_remove(L, -2); // Stack: cn
std::stringstream ss;
ss << ": 0x" << std::hex << reinterpret_cast<std::uintptr_t>(const_cast<void*>(ptr));
lua_pushstring(L, ss.str().c_str()); // Stack: cn, address string (astr)
lua_concat(L, 2); // Stack: astr
return 1;
}
//=================================================================================================
/**
* @brief __gc metamethod for a class.
*/
template <class C>
static int gc_metamethod(lua_State* L)
{
Userdata* ud = Userdata::getExact<C>(L, 1);
LUABRIDGE_ASSERT(ud);
ud->~Userdata();
return 0;
}
//=================================================================================================
template <class T, class C = void>
struct property_getter;
/**
* @brief lua_CFunction to get a variable.
*
* This is used for global variables or class static data members. The pointer to the data is in the first upvalue.
*/
template <class T>
struct property_getter<T, void>
{
static int call(lua_State* L)
{
LUABRIDGE_ASSERT(lua_islightuserdata(L, lua_upvalueindex(1)));
T* ptr = static_cast<T*>(lua_touserdata(L, lua_upvalueindex(1)));
LUABRIDGE_ASSERT(ptr != nullptr);
auto result = Stack<T&>::push(L, *ptr);
if (! result)
raise_lua_error(L, "%s", result.message().c_str());
return 1;
}
};
/**
* @brief lua_CFunction to get a class data member.
*
* The pointer-to-member is in the first upvalue. The class userdata object is at the top of the Lua stack.
*/
template <class T, class C>
struct property_getter
{
static int call(lua_State* L)
{
C* c = Userdata::get<C>(L, 1, true);
T C::** mp = static_cast<T C::**>(lua_touserdata(L, lua_upvalueindex(1)));
Result result;
#if LUABRIDGE_HAS_EXCEPTIONS
try
{
#endif
result = Stack<T&>::push(L, c->**mp);
#if LUABRIDGE_HAS_EXCEPTIONS
}
catch (const std::exception& e)
{
raise_lua_error(L, "%s", e.what());
}
#endif
if (! result)
raise_lua_error(L, "%s", result.message().c_str());
return 1;
}
};
/**
* @brief Helper function to push a property getter on a table at a specific index.
*/
inline void add_property_getter(lua_State* L, const char* name, int tableIndex)
{
#if LUABRIDGE_SAFE_STACK_CHECKS
luaL_checkstack(L, 2, detail::error_lua_stack_overflow);
#endif
LUABRIDGE_ASSERT(name != nullptr);
LUABRIDGE_ASSERT(lua_istable(L, tableIndex));
LUABRIDGE_ASSERT(lua_iscfunction(L, -1)); // Stack: getter
lua_rawgetp(L, tableIndex, getPropgetKey()); // Stack: getter, propget table (pg)
lua_pushvalue(L, -2); // Stack: getter, pg, getter
rawsetfield(L, -2, name); // Stack: getter, pg
lua_pop(L, 2); // Stack: -
}
//=================================================================================================
template <class T, class C = void>
struct property_setter;
/**
* @brief lua_CFunction to set a variable.
*
* This is used for global variables or class static data members. The pointer to the data is in the first upvalue.
*/
template <class T>
struct property_setter<T, void>
{
static int call(lua_State* L)
{
LUABRIDGE_ASSERT(lua_islightuserdata(L, lua_upvalueindex(1)));
T* ptr = static_cast<T*>(lua_touserdata(L, lua_upvalueindex(1)));
LUABRIDGE_ASSERT(ptr != nullptr);
auto result = Stack<T>::get(L, 1);
if (! result)
raise_lua_error(L, "%s", result.error().message().c_str());
*ptr = std::move(*result);
return 0;
}
};
/**
* @brief lua_CFunction to set a class data member.
*
* The pointer-to-member is in the first upvalue. The class userdata object is at the top of the Lua stack.
*/
template <class T, class C>
struct property_setter
{
static int call(lua_State* L)
{
C* c = Userdata::get<C>(L, 1, false);
T C::** mp = static_cast<T C::**>(lua_touserdata(L, lua_upvalueindex(1)));
#if LUABRIDGE_HAS_EXCEPTIONS
try
{
#endif
auto result = Stack<T>::get(L, 2);
if (! result)
raise_lua_error(L, "%s", result.error().message().c_str());
c->** mp = std::move(*result);
#if LUABRIDGE_HAS_EXCEPTIONS
}
catch (const std::exception& e)
{
raise_lua_error(L, "%s", e.what());
}
#endif
return 0;
}
};
/**
* @brief Helper function to push a property setter on a table at a specific index.
*/
inline void add_property_setter(lua_State* L, const char* name, int tableIndex)
{
#if LUABRIDGE_SAFE_STACK_CHECKS
luaL_checkstack(L, 2, detail::error_lua_stack_overflow);
#endif
LUABRIDGE_ASSERT(name != nullptr);
LUABRIDGE_ASSERT(lua_istable(L, tableIndex));
LUABRIDGE_ASSERT(lua_iscfunction(L, -1)); // Stack: setter
lua_rawgetp(L, tableIndex, getPropsetKey()); // Stack: setter, propset table (ps)
lua_pushvalue(L, -2); // Stack: setter, ps, setter
rawsetfield(L, -2, name); // Stack: setter, ps
lua_pop(L, 2); // Stack: -
}
//=================================================================================================
/**
* @brief Function generator.
*/
template <class ReturnType, class ArgsPack, std::size_t Start = 1u>
struct function
{
template <class F>
static int call(lua_State* L, F func)
{
Result result;
#if LUABRIDGE_HAS_EXCEPTIONS
try
{
#endif
result = Stack<ReturnType>::push(L, std::apply(func, make_arguments_list<ArgsPack, Start>(L)));
#if LUABRIDGE_HAS_EXCEPTIONS
}
catch (const std::exception& e)
{
raise_lua_error(L, "%s", e.what());
}
#endif
if (! result)
raise_lua_error(L, "%s", result.message().c_str());
return 1;
}
template <class T, class F>
static int call(lua_State* L, T* ptr, F func)
{
Result result;
#if LUABRIDGE_HAS_EXCEPTIONS
try
{
#endif
auto f = [ptr, func](auto&&... args) -> ReturnType { return (ptr->*func)(std::forward<decltype(args)>(args)...); };
result = Stack<ReturnType>::push(L, std::apply(f, make_arguments_list<ArgsPack, Start>(L)));
#if LUABRIDGE_HAS_EXCEPTIONS
}
catch (const std::exception& e)
{
raise_lua_error(L, "%s", e.what());
}
#endif
if (! result)
raise_lua_error(L, "%s", result.message().c_str());
return 1;
}
};
template <class ArgsPack, std::size_t Start>
struct function<void, ArgsPack, Start>
{
template <class F>
static int call(lua_State* L, F func)
{
#if LUABRIDGE_HAS_EXCEPTIONS
try
{
#endif
std::apply(func, make_arguments_list<ArgsPack, Start>(L));
#if LUABRIDGE_HAS_EXCEPTIONS
}
catch (const std::exception& e)
{
raise_lua_error(L, "%s", e.what());
}
#endif
return 0;
}
template <class T, class F>
static int call(lua_State* L, T* ptr, F func)
{
#if LUABRIDGE_HAS_EXCEPTIONS
try
{
#endif
auto f = [ptr, func](auto&&... args) { (ptr->*func)(std::forward<decltype(args)>(args)...); };
std::apply(f, make_arguments_list<ArgsPack, Start>(L));
#if LUABRIDGE_HAS_EXCEPTIONS
}
catch (const std::exception& e)
{
raise_lua_error(L, "%s", e.what());
}
#endif
return 0;
}
};
//=================================================================================================
/**
* @brief lua_CFunction to call a class member function with a return value.
*
* The member function pointer is in the first upvalue. The class userdata object is at the top of the Lua stack.
*/
template <class F, class T>
int invoke_member_function(lua_State* L)
{
using FnTraits = function_traits<F>;
LUABRIDGE_ASSERT(isfulluserdata(L, lua_upvalueindex(1)));
T* ptr = Userdata::get<T>(L, 1, false);
const F& func = *static_cast<const F*>(lua_touserdata(L, lua_upvalueindex(1)));
LUABRIDGE_ASSERT(func != nullptr);
return function<typename FnTraits::result_type, typename FnTraits::argument_types, 2>::call(L, ptr, func);
}
template <class F, class T>
int invoke_const_member_function(lua_State* L)
{
using FnTraits = function_traits<F>;
LUABRIDGE_ASSERT(isfulluserdata(L, lua_upvalueindex(1)));
const T* ptr = Userdata::get<T>(L, 1, true);
const F& func = *static_cast<const F*>(lua_touserdata(L, lua_upvalueindex(1)));
LUABRIDGE_ASSERT(func != nullptr);
return function<typename FnTraits::result_type, typename FnTraits::argument_types, 2>::call(L, ptr, func);
}
//=================================================================================================
/**
* @brief lua_CFunction to call a class member lua_CFunction.
*
* The member function pointer is in the first upvalue. The object userdata ('this') value is at top ot the Lua stack.
*/
template <class T>
int invoke_member_cfunction(lua_State* L)
{
using F = int (T::*)(lua_State * L);
LUABRIDGE_ASSERT(isfulluserdata(L, lua_upvalueindex(1)));
T* t = Userdata::get<T>(L, 1, false);
const F& func = *static_cast<const F*>(lua_touserdata(L, lua_upvalueindex(1)));
LUABRIDGE_ASSERT(func != nullptr);
#if LUABRIDGE_HAS_EXCEPTIONS
try
{
#endif
return (t->*func)(L);
#if LUABRIDGE_HAS_EXCEPTIONS
}
catch (const std::exception& e)
{
raise_lua_error(L, "%s", e.what());
}
return 0;
#endif
}
template <class T>
int invoke_const_member_cfunction(lua_State* L)
{
using F = int (T::*)(lua_State * L) const;
LUABRIDGE_ASSERT(isfulluserdata(L, lua_upvalueindex(1)));
const T* t = Userdata::get<T>(L, 1, true);
const F& func = *static_cast<const F*>(lua_touserdata(L, lua_upvalueindex(1)));
LUABRIDGE_ASSERT(func != nullptr);
#if LUABRIDGE_HAS_EXCEPTIONS
try
{
#endif
return (t->*func)(L);
#if LUABRIDGE_HAS_EXCEPTIONS
}
catch (const std::exception& e)
{
raise_lua_error(L, "%s", e.what());
}
return 0;
#endif
}
//=================================================================================================
/**
* @brief lua_CFunction to call on a object via function pointer.
*
* The proxy function pointer (lightuserdata) is in the first upvalue. The class userdata object is at the top of the Lua stack.
*/
template <class F>
int invoke_proxy_function(lua_State* L)
{
using FnTraits = function_traits<F>;
LUABRIDGE_ASSERT(lua_islightuserdata(L, lua_upvalueindex(1)));
auto func = reinterpret_cast<F>(lua_touserdata(L, lua_upvalueindex(1)));
LUABRIDGE_ASSERT(func != nullptr);
return function<typename FnTraits::result_type, typename FnTraits::argument_types, 1>::call(L, func);
}
//=================================================================================================
/**
* @brief lua_CFunction to call on a object via functor (lambda wrapped in a std::function).
*
* The proxy std::function (lightuserdata) is in the first upvalue. The class userdata object is at the top of the Lua stack.
*/
template <class F>
int invoke_proxy_functor(lua_State* L)
{
using FnTraits = function_traits<F>;
LUABRIDGE_ASSERT(isfulluserdata(L, lua_upvalueindex(1)));
auto& func = *align<F>(lua_touserdata(L, lua_upvalueindex(1)));
return function<typename FnTraits::result_type, typename FnTraits::argument_types, 1>::call(L, func);
}
//=================================================================================================
/**
* @brief lua_CFunction to call safely by trapping exceptions
*/
#if LUABRIDGE_SAFE_LUA_C_EXCEPTION_HANDLING && LUABRIDGE_HAS_EXCEPTIONS
inline int invoke_safe_cfunction(lua_State* L)
{
LUABRIDGE_ASSERT(lua_iscfunction(L, lua_upvalueindex(1)));
auto func = lua_tocfunction(L, lua_upvalueindex(1));
try
{
return func(L);
}
catch (const std::exception& e)
{
raise_lua_error(L, "%s", e.what());
}
return 0;
}
#endif
//=================================================================================================
/**
* @brief lua_CFunction to call on a object constructor via functor (lambda wrapped in a std::function).
*
* The proxy std::function (lightuserdata) is in the first upvalue. The class userdata object will be pushed at the top of the Lua stack.
*/
template <class F>
int invoke_proxy_constructor(lua_State* L)
{
using FnTraits = function_traits<F>;
LUABRIDGE_ASSERT(isfulluserdata(L, lua_upvalueindex(1)));
auto& func = *align<F>(lua_touserdata(L, lua_upvalueindex(1)));
function<void, typename FnTraits::argument_types, 1>::call(L, func);
return 1;
}
//=================================================================================================
/**
* @brief lua_CFunction to resolve an invocation between several overloads.
*
* The list of overloads is in the first upvalue. The arguments of the function call are at the top of the Lua stack.
*/
template <bool Member>
inline int try_overload_functions(lua_State* L)
{
const int nargs = lua_gettop(L);
const int effective_args = nargs - (Member ? 1 : 0);
// get the list of overloads
lua_pushvalue(L, lua_upvalueindex(1));
LUABRIDGE_ASSERT(lua_istable(L, -1));
const int idx_overloads = nargs + 1;
const int num_overloads = get_length(L, idx_overloads);
// create table to hold error messages
lua_createtable(L, num_overloads, 0);
const int idx_errors = nargs + 2;
int nerrors = 0;
// iterate through table, snippet taken from Lua docs
lua_pushnil(L); // first key
while (lua_next(L, idx_overloads) != 0)
{
LUABRIDGE_ASSERT(lua_istable(L, -1));
// check matching arity
lua_rawgeti(L, -1, 1);
LUABRIDGE_ASSERT(lua_isnumber(L, -1));
const int overload_arity = static_cast<int>(lua_tointeger(L, -1));
if (overload_arity >= 0 && overload_arity != effective_args)
{
// store error message and try next overload
lua_pushfstring(L, "Skipped overload #%d with unmatched arity of %d instead of %d", nerrors, overload_arity, effective_args);
lua_rawseti(L, idx_errors, ++nerrors);
lua_pop(L, 2); // pop arity, value (table)
continue;
}
lua_pop(L, 1); // pop arity
// push function
lua_pushnumber(L, 2);
lua_gettable(L, -2);
LUABRIDGE_ASSERT(lua_isfunction(L, -1));
// push arguments
for (int i = 1; i <= nargs; ++i)
lua_pushvalue(L, i);
// call f, this pops the function and its args, pushes result(s)
const int err = lua_pcall(L, nargs, LUA_MULTRET, 0);
if (err == LUABRIDGE_LUA_OK)
{
// calculate number of return values and return
return lua_gettop(L) - nargs - 4; // 4: overloads, errors, key, table
}
else if (err == LUA_ERRRUN)
{
// store error message and try next overload
lua_rawseti(L, idx_errors, ++nerrors);
}
else
{
return lua_error_x(L); // critical error: rethrow
}
lua_pop(L, 1); // pop value (table)
}
lua_Debug debug;
lua_getstack_info_x(L, 0, "n", &debug);
lua_pushfstring(L, "All %d overloads of %s returned an error:", nerrors, debug.name);
// Concatenate error messages of each overload
for (int i = 1; i <= nerrors; ++i)
{
lua_pushfstring(L, "\n%d: ", i);
lua_rawgeti(L, idx_errors, i);
}
lua_concat(L, nerrors * 2 + 1);
return lua_error_x(L); // throw error message just built
}
//=================================================================================================
// Lua CFunction
inline void push_function(lua_State* L, lua_CFunction fp)
{
#if LUABRIDGE_SAFE_LUA_C_EXCEPTION_HANDLING && LUABRIDGE_HAS_EXCEPTIONS
lua_pushcfunction_x(L, fp);
lua_pushcclosure_x(L, invoke_safe_cfunction, 1);
#else
lua_pushcfunction_x(L, fp);
#endif
}
// Generic function pointer
template <class ReturnType, class... Params>
inline void push_function(lua_State* L, ReturnType (*fp)(Params...))
{
using FnType = decltype(fp);
lua_pushlightuserdata(L, reinterpret_cast<void*>(fp));
lua_pushcclosure_x(L, &invoke_proxy_function<FnType>, 1);
}
template <class ReturnType, class... Params>
inline void push_function(lua_State* L, ReturnType (*fp)(Params...) noexcept)
{
using FnType = decltype(fp);
lua_pushlightuserdata(L, reinterpret_cast<void*>(fp));
lua_pushcclosure_x(L, &invoke_proxy_function<FnType>, 1);
}
// Callable object (lambdas)
template <class F, class = std::enable_if<is_callable_v<F> && !std::is_pointer_v<F> && !std::is_member_function_pointer_v<F>>>
inline void push_function(lua_State* L, F&& f)
{
lua_newuserdata_aligned<F>(L, std::forward<F>(f));
lua_pushcclosure_x(L, &invoke_proxy_functor<F>, 1);
}
//=================================================================================================
// Lua CFunction
template <class T>
void push_member_function(lua_State* L, lua_CFunction fp)
{
#if LUABRIDGE_SAFE_LUA_C_EXCEPTION_HANDLING && LUABRIDGE_HAS_EXCEPTIONS
lua_pushcfunction_x(L, fp);
lua_pushcclosure_x(L, invoke_safe_cfunction, 1);
#else
lua_pushcfunction_x(L, fp);
#endif
}
// Generic function pointer
template <class T, class ReturnType, class... Params>
void push_member_function(lua_State* L, ReturnType (*fp)(T*, Params...))
{
using FnType = decltype(fp);
lua_pushlightuserdata(L, reinterpret_cast<void*>(fp));
lua_pushcclosure_x(L, &invoke_proxy_function<FnType>, 1);
}
template <class T, class ReturnType, class... Params>
void push_member_function(lua_State* L, ReturnType (*fp)(T*, Params...) noexcept)
{
using FnType = decltype(fp);
lua_pushlightuserdata(L, reinterpret_cast<void*>(fp));
lua_pushcclosure_x(L, &invoke_proxy_function<FnType>, 1);
}
template <class T, class ReturnType, class... Params>
void push_member_function(lua_State* L, ReturnType (*fp)(const T*, Params...))
{
using FnType = decltype(fp);
lua_pushlightuserdata(L, reinterpret_cast<void*>(fp));
lua_pushcclosure_x(L, &invoke_proxy_function<FnType>, 1);
}
template <class T, class ReturnType, class... Params>
void push_member_function(lua_State* L, ReturnType (*fp)(const T*, Params...) noexcept)
{
using FnType = decltype(fp);
lua_pushlightuserdata(L, reinterpret_cast<void*>(fp));
lua_pushcclosure_x(L, &invoke_proxy_function<FnType>, 1);
}
// Callable object (lambdas)
template <class T, class F, class = std::enable_if<
is_callable_v<F> &&
std::is_object_v<F> &&
!std::is_pointer_v<F> &&
!std::is_member_function_pointer_v<F>>>
void push_member_function(lua_State* L, F&& f)
{
static_assert(std::is_same_v<T, remove_cvref_t<std::remove_pointer_t<function_argument_or_void_t<0, F>>>>);
lua_newuserdata_aligned<F>(L, std::forward<F>(f));
lua_pushcclosure_x(L, &invoke_proxy_functor<F>, 1);
}
// Non const member function pointer
template <class T, class U, class ReturnType, class... Params>
void push_member_function(lua_State* L, ReturnType (U::*mfp)(Params...))
{
static_assert(std::is_same_v<T, U> || std::is_base_of_v<U, T>);
using F = decltype(mfp);
new (lua_newuserdata_x<F>(L, sizeof(F))) F(mfp);
lua_pushcclosure_x(L, &invoke_member_function<F, T>, 1);
}
template <class T, class U, class ReturnType, class... Params>
void push_member_function(lua_State* L, ReturnType (U::*mfp)(Params...) noexcept)
{
static_assert(std::is_same_v<T, U> || std::is_base_of_v<U, T>);
using F = decltype(mfp);
new (lua_newuserdata_x<F>(L, sizeof(F))) F(mfp);
lua_pushcclosure_x(L, &invoke_member_function<F, T>, 1);
}
// Const member function pointer
template <class T, class U, class ReturnType, class... Params>
void push_member_function(lua_State* L, ReturnType (U::*mfp)(Params...) const)
{
static_assert(std::is_same_v<T, U> || std::is_base_of_v<U, T>);
using F = decltype(mfp);
new (lua_newuserdata_x<F>(L, sizeof(F))) F(mfp);
lua_pushcclosure_x(L, &detail::invoke_const_member_function<F, T>, 1);
}
template <class T, class U, class ReturnType, class... Params>
void push_member_function(lua_State* L, ReturnType (U::*mfp)(Params...) const noexcept)
{
static_assert(std::is_same_v<T, U> || std::is_base_of_v<U, T>);
using F = decltype(mfp);
new (lua_newuserdata_x<F>(L, sizeof(F))) F(mfp);
lua_pushcclosure_x(L, &detail::invoke_const_member_function<F, T>, 1);
}
// Non const member Lua CFunction pointer
template <class T, class U = T>
void push_member_function(lua_State* L, int (U::*mfp)(lua_State*))
{
static_assert(std::is_same_v<T, U> || std::is_base_of_v<U, T>);
using F = decltype(mfp);
new (lua_newuserdata_x<F>(L, sizeof(F))) F(mfp);
lua_pushcclosure_x(L, &invoke_member_cfunction<T>, 1);
}
// Const member Lua CFunction pointer
template <class T, class U = T>
void push_member_function(lua_State* L, int (U::*mfp)(lua_State*) const)
{
static_assert(std::is_same_v<T, U> || std::is_base_of_v<U, T>);
using F = decltype(mfp);
new (lua_newuserdata_x<F>(L, sizeof(F))) F(mfp);
lua_pushcclosure_x(L, &invoke_const_member_cfunction<T>, 1);
}
//=================================================================================================
/**
* @brief Constructor generators.
*
* These templates call operator new with the contents of a type/value list passed to the constructor. Two versions of call() are provided.
* One performs a regular new, the other performs a placement new.
*/
template <class T, class Args>
struct constructor
{
static T* construct(const Args& args)
{
auto alloc = [](auto&&... args) { return new T(std::forward<decltype(args)>(args)...); };
return std::apply(alloc, args);
}
static T* construct(void* ptr, const Args& args)
{
auto alloc = [ptr](auto&&... args) { return new (ptr) T(std::forward<decltype(args)>(args)...); };
return std::apply(alloc, args);
}
};
//=================================================================================================
/**
* @brief Placement constructor generators.
*/
template <class T>
struct placement_constructor
{
template <class F, class Args>
static T* construct(void* ptr, const F& func, const Args& args)
{
auto alloc = [ptr, &func](auto&&... args) { return func(ptr, std::forward<decltype(args)>(args)...); };
return std::apply(alloc, args);
}
};
//=================================================================================================
/**
* @brief Container allocator generators.
*/
template <class C>
struct container_constructor
{
template <class F, class Args>
static C construct(const F& func, const Args& args)
{
auto alloc = [&func](auto&&... args) { return func(std::forward<decltype(args)>(args)...); };
return std::apply(alloc, args);
}
};
//=================================================================================================
/**
* @brief External allocator generators.
*/
template <class T>
struct external_constructor
{
template <class F, class Args>
static T* construct(const F& func, const Args& args)
{
auto alloc = [&func](auto&&... args) { return func(std::forward<decltype(args)>(args)...); };
return std::apply(alloc, args);
}
};
//=================================================================================================
/**
* @brief lua_CFunction to construct a class object wrapped in a container.
*/
template <class C, class Args>
int constructor_container_proxy(lua_State* L)
{
using T = typename ContainerTraits<C>::Type;
T* object = nullptr;
#if LUABRIDGE_HAS_EXCEPTIONS
try
{
#endif
object = constructor<T, Args>::construct(detail::make_arguments_list<Args, 2>(L));
#if LUABRIDGE_HAS_EXCEPTIONS
}
catch (const std::exception& e)
{
raise_lua_error(L, "%s", e.what());
}
#endif
auto result = UserdataSharedHelper<C, false>::push(L, object);
if (! result)
raise_lua_error(L, "%s", result.message().c_str());
return 1;
}
/**
* @brief lua_CFunction to construct a class object in-place in the userdata.
*/
template <class T, class Args>
int constructor_placement_proxy(lua_State* L)
{
auto args = make_arguments_list<Args, 2>(L);
std::error_code ec;
auto* value = UserdataValue<T>::place(L, ec);
if (! value)
raise_lua_error(L, "%s", ec.message().c_str());
#if LUABRIDGE_HAS_EXCEPTIONS
try
{
#endif
constructor<T, Args>::construct(value->getObject(), std::move(args));
#if LUABRIDGE_HAS_EXCEPTIONS
}
catch (const std::exception& e)
{
raise_lua_error(L, "%s", e.what());
}
#endif
value->commit();
return 1;
}
//=================================================================================================
/**
* @brief Constructor forwarder.
*/
template <class T, class F>
struct constructor_forwarder
{
explicit constructor_forwarder(F f)
: m_func(std::move(f))
{
}
T* operator()(lua_State* L)
{
using FnTraits = function_traits<F>;
using FnArgs = remove_first_type_t<typename FnTraits::argument_types>;
auto args = make_arguments_list<FnArgs, 2>(L);
std::error_code ec;
auto* value = UserdataValue<T>::place(L, ec);
if (! value)
raise_lua_error(L, "%s", ec.message().c_str());
T* object = nullptr;
#if LUABRIDGE_HAS_EXCEPTIONS
try
{
#endif
object = placement_constructor<T>::construct(value->getObject(), m_func, std::move(args));
#if LUABRIDGE_HAS_EXCEPTIONS
}
catch (const std::exception& e)
{
raise_lua_error(L, "%s", e.what());
}
#endif
value->commit();
return object;
}
private:
F m_func;
};
//=================================================================================================
/**
* @brief Constructor forwarder.
*/
template <class T, class Alloc, class Dealloc>
struct factory_forwarder
{
explicit factory_forwarder(Alloc alloc, Dealloc dealloc)
: m_alloc(std::move(alloc))
, m_dealloc(std::move(dealloc))
{
}
T* operator()(lua_State* L)
{
using FnTraits = function_traits<Alloc>;
using FnArgs = typename FnTraits::argument_types;
T* object = nullptr;
#if LUABRIDGE_HAS_EXCEPTIONS
try
{
#endif
object = external_constructor<T>::construct(m_alloc, make_arguments_list<FnArgs, 0>(L));
#if LUABRIDGE_HAS_EXCEPTIONS
}
catch (const std::exception& e)
{
raise_lua_error(L, "%s", e.what());
}
#endif
std::error_code ec;
auto* value = UserdataValueExternal<T>::place(L, object, m_dealloc, ec);
if (! value)
raise_lua_error(L, "%s", ec.message().c_str());
return object;
}
private:
Alloc m_alloc;
Dealloc m_dealloc;
};
//=================================================================================================
/**
* @brief Container forwarder.
*/
template <class C, class F>
struct container_forwarder
{
explicit container_forwarder(F f)
: m_func(std::move(f))
{
}
C operator()(lua_State* L)
{
using FnTraits = function_traits<F>;
using FnArgs = typename FnTraits::argument_types;
C object;
#if LUABRIDGE_HAS_EXCEPTIONS
try
{
#endif
object = container_constructor<C>::construct(m_func, make_arguments_list<FnArgs, 2>(L));
#if LUABRIDGE_HAS_EXCEPTIONS
}
catch (const std::exception& e)
{
raise_lua_error(L, "%s", e.what());
}
#endif
auto result = UserdataSharedHelper<C, false>::push(L, object);
if (! result)
raise_lua_error(L, "%s", result.message().c_str());
return object;
}
private:
F m_func;
};
} // namespace detail
} // namespace luabridge