StarMirror/sol2
1
0
Fork 0
mirror of https://github.com/ThePhD/sol2.git synced 2024-03-22 13:10:44 +08:00
Code Issues Projects Releases Wiki Activity

Merge pull request #701 from isvogor-foi/develop

Browse Source 
fmt rename to fmt_ to avoid naming conflict with the spdlog library
This commit is contained in:
The Phantom Derpstorm 2018-09-03 09:40:02 -04:00 committed by GitHub
commit 4f974a7424
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 53 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

88
single/sol/sol.hpp
View File

@ -40,7 +40,7 @@
#ifdef check #ifdef check
#define SOL_INSIDE_UNREAL_REMOVED_CHECK 1 #define SOL_INSIDE_UNREAL_REMOVED_CHECK 1
#undef check #undef check
#endif #endif
#endif // Unreal Engine 4 Bullshit #endif // Unreal Engine 4 Bullshit
#if defined(__GNUC__) #if defined(__GNUC__)
@ -156,7 +156,7 @@
#define SOL_SAFE_REFERENCES 1 #define SOL_SAFE_REFERENCES 1
#endif #endif
// Changes all typedefs of sol::function to point to the // Changes all typedefs of sol::function to point to the
// protected_function version, instead of unsafe_function // protected_function version, instead of unsafe_function
#if !defined(SOL_SAFE_FUNCTION) #if !defined(SOL_SAFE_FUNCTION)
#define SOL_SAFE_FUNCTION 1 #define SOL_SAFE_FUNCTION 1
@ -186,7 +186,7 @@
#endif #endif
// Turn off Number Precision Checks // Turn off Number Precision Checks
// if this is defined, we do not do range // if this is defined, we do not do range
// checks on integers / unsigned integers that might // checks on integers / unsigned integers that might
// be bigger than what Lua can represent // be bigger than what Lua can represent
#if !defined(SOL_NO_CHECK_NUMBER_PRECISION) #if !defined(SOL_NO_CHECK_NUMBER_PRECISION)
@ -246,7 +246,7 @@
#ifndef SOL_UNORDERED_MAP_COMPATIBLE_HASH #ifndef SOL_UNORDERED_MAP_COMPATIBLE_HASH
#define SOL_UNORDERED_MAP_COMPATIBLE_HASH 1 #define SOL_UNORDERED_MAP_COMPATIBLE_HASH 1
#endif // SOL_UNORDERED_MAP_COMPATIBLE_HASH #endif // SOL_UNORDERED_MAP_COMPATIBLE_HASH
#endif #endif
#ifndef SOL_STACK_STRING_OPTIMIZATION_SIZE #ifndef SOL_STACK_STRING_OPTIMIZATION_SIZE
#define SOL_STACK_STRING_OPTIMIZATION_SIZE 1024 #define SOL_STACK_STRING_OPTIMIZATION_SIZE 1024
@ -1171,7 +1171,7 @@ namespace sol {
hash ^= static_cast<size_t>(*cptr++); hash ^= static_cast<size_t>(*cptr++);
hash *= static_cast<size_t>(1099511628211ULL); hash *= static_cast<size_t>(1099511628211ULL);
} }
return hash; return hash;
#endif #endif
} }
}; };
@ -1435,7 +1435,7 @@ namespace sol {
struct is_callable : std::is_function<std::remove_pointer_t<T>> {}; struct is_callable : std::is_function<std::remove_pointer_t<T>> {};
template <typename T> template <typename T>
struct is_callable<T, std::enable_if_t<std::is_final<unqualified_t<T>>::value struct is_callable<T, std::enable_if_t<std::is_final<unqualified_t<T>>::value
&& std::is_class<unqualified_t<T>>::value && std::is_class<unqualified_t<T>>::value
&& std::is_same<decltype(void(&T::operator())), void>::value>> { && std::is_same<decltype(void(&T::operator())), void>::value>> {
@ -1747,7 +1747,7 @@ namespace sol {
template <typename T> template <typename T>
using is_string_constructible = any< using is_string_constructible = any<
meta::all<std::is_array<unqualified_t<T>>, std::is_same<meta::unqualified_t<std::remove_all_extents_t<meta::unqualified_t<T>>>, char>>, meta::all<std::is_array<unqualified_t<T>>, std::is_same<meta::unqualified_t<std::remove_all_extents_t<meta::unqualified_t<T>>>, char>>,
std::is_same<unqualified_t<T>, const char*>, std::is_same<unqualified_t<T>, const char*>,
std::is_same<unqualified_t<T>, char>, std::is_same<unqualified_t<T>, std::string>, std::is_same<unqualified_t<T>, std::initializer_list<char>> std::is_same<unqualified_t<T>, char>, std::is_same<unqualified_t<T>, std::string>, std::is_same<unqualified_t<T>, std::initializer_list<char>>
#if defined(SOL_CXX17_FEATURES) && SOL_CXX17_FEATURES #if defined(SOL_CXX17_FEATURES) && SOL_CXX17_FEATURES
, std::is_same<unqualified_t<T>, std::string_view> , std::is_same<unqualified_t<T>, std::string_view>
@ -5350,7 +5350,7 @@ namespace sol {
"__ipairs", "__ipairs",
"next", "next",
"__type", "__type",
"__typeinfo" "__typeinfo"
} }; } };
return names; return names;
} }
@ -5417,7 +5417,7 @@ namespace sol {
template <typename T> template <typename T>
struct is_container<T, std::enable_if_t<meta::all< struct is_container<T, std::enable_if_t<meta::all<
meta::has_begin_end<meta::unqualified_t<T>> meta::has_begin_end<meta::unqualified_t<T>>
, meta::neg<is_initializer_list<meta::unqualified_t<T>>> , meta::neg<is_initializer_list<meta::unqualified_t<T>>>
, meta::neg<meta::is_string_like<meta::unqualified_t<T>>> , meta::neg<meta::is_string_like<meta::unqualified_t<T>>>
>::value >::value
>> : std::true_type {}; >> : std::true_type {};
@ -5914,7 +5914,7 @@ namespace sol {
} }
#if !defined(SOL_EXCEPTIONS_SAFE_PROPAGATION) #if !defined(SOL_EXCEPTIONS_SAFE_PROPAGATION)
// LuaJIT cannot have the catchall when the safe propagation is on // LuaJIT cannot have the catchall when the safe propagation is on
// but LuaJIT will swallow all C++ errors // but LuaJIT will swallow all C++ errors
// if we don't at least catch std::exception ones // if we don't at least catch std::exception ones
catch (...) { catch (...) {
call_exception_handler(L, optional<const std::exception&>(nullopt), "caught (...) exception"); call_exception_handler(L, optional<const std::exception&>(nullopt), "caught (...) exception");
@ -5925,7 +5925,7 @@ namespace sol {
} }
#ifdef SOL_NOEXCEPT_FUNCTION_TYPE #ifdef SOL_NOEXCEPT_FUNCTION_TYPE
#if 0 #if 0
// impossible: g++/clang++ choke as they think this function is ambiguous: // impossible: g++/clang++ choke as they think this function is ambiguous:
// to fix, wait for template <auto X> and then switch on no-exceptness of the function // to fix, wait for template <auto X> and then switch on no-exceptness of the function
template <lua_CFunction_noexcept f> template <lua_CFunction_noexcept f>
@ -5968,7 +5968,7 @@ namespace sol {
} }
#if !defined(SOL_EXCEPTIONS_SAFE_PROPAGATION) #if !defined(SOL_EXCEPTIONS_SAFE_PROPAGATION)
// LuaJIT cannot have the catchall when the safe propagation is on // LuaJIT cannot have the catchall when the safe propagation is on
// but LuaJIT will swallow all C++ errors // but LuaJIT will swallow all C++ errors
// if we don't at least catch std::exception ones // if we don't at least catch std::exception ones
catch (...) { catch (...) {
call_exception_handler(L, optional<const std::exception&>(nullopt), "caught (...) exception"); call_exception_handler(L, optional<const std::exception&>(nullopt), "caught (...) exception");
@ -7443,7 +7443,7 @@ namespace sol {
return false; return false;
} }
allocated_size -= sizeof(T*); allocated_size -= sizeof(T*);
adjusted = static_cast<void*>(static_cast<char*>(pointer_adjusted) + sizeof(T*)); adjusted = static_cast<void*>(static_cast<char*>(pointer_adjusted) + sizeof(T*));
dx_adjusted = align(std::alignment_of<unique_destructor>::value, sizeof(unique_destructor), adjusted, allocated_size); dx_adjusted = align(std::alignment_of<unique_destructor>::value, sizeof(unique_destructor), adjusted, allocated_size);
if (dx_adjusted == nullptr) { if (dx_adjusted == nullptr) {
@ -7451,7 +7451,7 @@ namespace sol {
return false; return false;
} }
allocated_size -= sizeof(unique_destructor); allocated_size -= sizeof(unique_destructor);
adjusted = static_cast<void*>(static_cast<char*>(dx_adjusted) + sizeof(unique_destructor)); adjusted = static_cast<void*>(static_cast<char*>(dx_adjusted) + sizeof(unique_destructor));
id_adjusted = align(std::alignment_of<unique_tag>::value, sizeof(unique_tag), adjusted, allocated_size); id_adjusted = align(std::alignment_of<unique_tag>::value, sizeof(unique_tag), adjusted, allocated_size);
@ -7460,7 +7460,7 @@ namespace sol {
return false; return false;
} }
allocated_size -= sizeof(unique_tag); allocated_size -= sizeof(unique_tag);
adjusted = static_cast<void*>(static_cast<char*>(id_adjusted) + sizeof(unique_tag)); adjusted = static_cast<void*>(static_cast<char*>(id_adjusted) + sizeof(unique_tag));
data_adjusted = align(std::alignment_of<Real>::value, sizeof(Real), adjusted, allocated_size); data_adjusted = align(std::alignment_of<Real>::value, sizeof(Real), adjusted, allocated_size);
if (data_adjusted == nullptr) { if (data_adjusted == nullptr) {
@ -8763,7 +8763,7 @@ namespace stack {
struct qualified_checker<X, type::userdata, std::enable_if_t<is_unique_usertype<X>::value && !std::is_reference<X>::value>> { struct qualified_checker<X, type::userdata, std::enable_if_t<is_unique_usertype<X>::value && !std::is_reference<X>::value>> {
typedef unique_usertype_traits<meta::unqualified_t<X>> u_traits; typedef unique_usertype_traits<meta::unqualified_t<X>> u_traits;
typedef typename u_traits::type T; typedef typename u_traits::type T;
template <typename Handler> template <typename Handler>
static bool check(std::false_type, lua_State* L, int index, Handler&& handler, record& tracking) { static bool check(std::false_type, lua_State* L, int index, Handler&& handler, record& tracking) {
return stack::unqualified_check<X>(L, index, std::forward<Handler>(handler), tracking); return stack::unqualified_check<X>(L, index, std::forward<Handler>(handler), tracking);
@ -8771,7 +8771,7 @@ namespace stack {
template <typename Handler> template <typename Handler>
static bool check(std::true_type, lua_State* L, int index, Handler&& handler, record& tracking) { static bool check(std::true_type, lua_State* L, int index, Handler&& handler, record& tracking) {
// we have a unique pointer type that can be // we have a unique pointer type that can be
// rebound to a base/derived type // rebound to a base/derived type
const type indextype = type_of(L, index); const type indextype = type_of(L, index);
tracking.use(1); tracking.use(1);
@ -8801,7 +8801,7 @@ namespace stack {
handler(L, index, type::userdata, indextype, "value is a userdata but is not the correct unique usertype"); handler(L, index, type::userdata, indextype, "value is a userdata but is not the correct unique usertype");
return false; return false;
} }
template <typename Handler> template <typename Handler>
static bool check(lua_State* L, int index, Handler&& handler, record& tracking) { static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
return check(meta::neg<std::is_void<typename u_traits::base_id>>(), L, index, std::forward<Handler>(handler), tracking); return check(meta::neg<std::is_void<typename u_traits::base_id>>(), L, index, std::forward<Handler>(handler), tracking);
@ -9098,7 +9098,7 @@ namespace sol {
dr.error = error_code::invalid_code_point; dr.error = error_code::invalid_code_point;
return dr; return dr;
} }
// then everything is fine // then everything is fine
dr.codepoint = decoded; dr.codepoint = decoded;
dr.error = error_code::ok; dr.error = error_code::ok;
@ -9116,7 +9116,7 @@ namespace sol {
} }
char16_t lead = static_cast<char16_t>(*it); char16_t lead = static_cast<char16_t>(*it);
if (!unicode_detail::is_surrogate(lead)) { if (!unicode_detail::is_surrogate(lead)) {
++it; ++it;
dr.codepoint = static_cast<char32_t>(lead); dr.codepoint = static_cast<char32_t>(lead);
@ -9137,7 +9137,7 @@ namespace sol {
dr.next = it; dr.next = it;
return dr; return dr;
} }
dr.codepoint = unicode_detail::combine_surrogates(lead, trail); dr.codepoint = unicode_detail::combine_surrogates(lead, trail);
dr.next = ++it; dr.next = ++it;
dr.error = error_code::ok; dr.error = error_code::ok;
@ -10074,10 +10074,10 @@ namespace stack {
template <typename T> template <typename T>
struct qualified_getter<T, std::enable_if_t< struct qualified_getter<T, std::enable_if_t<
!std::is_reference<T>::value !std::is_reference<T>::value
&& is_container<meta::unqualified_t<T>>::value && is_container<meta::unqualified_t<T>>::value
&& !is_lua_primitive<T>::value && !is_lua_primitive<T>::value
&& !is_transparent_argument<T>::value && !is_transparent_argument<T>::value
>> { >> {
static T get(lua_State* L, int index, record& tracking) { static T get(lua_State* L, int index, record& tracking) {
if (type_of(L, index) == type::userdata) { if (type_of(L, index) == type::userdata) {
@ -13463,7 +13463,7 @@ namespace sol {
const auto& meta = usertype_traits<T>::metatable(); const auto& meta = usertype_traits<T>::metatable();
T* obj = detail::usertype_allocate<T>(L); T* obj = detail::usertype_allocate<T>(L);
reference userdataref(L, -1); reference userdataref(L, -1);
auto& func = std::get<I>(f.functions); auto& func = std::get<I>(f.functions);
stack::call_into_lua<checked, clean_stack>(r, a, L, boost + start, func, detail::implicit_wrapper<T>(obj)); stack::call_into_lua<checked, clean_stack>(r, a, L, boost + start, func, detail::implicit_wrapper<T>(obj));
@ -14421,7 +14421,7 @@ namespace sol {
template <bool is_yielding, typename Fx, typename C> template <bool is_yielding, typename Fx, typename C>
static void select_member_variable(std::true_type, lua_State* L, Fx&& fx, function_detail::class_indicator<C>) { static void select_member_variable(std::true_type, lua_State* L, Fx&& fx, function_detail::class_indicator<C>) {
lua_CFunction freefunc = &function_detail::upvalue_this_member_variable<C, Fx, is_yielding>::call; lua_CFunction freefunc = &function_detail::upvalue_this_member_variable<C, Fx, is_yielding>::call;
int upvalues = 0; int upvalues = 0;
upvalues += stack::push(L, nullptr); upvalues += stack::push(L, nullptr);
upvalues += stack::stack_detail::push_as_upvalues(L, fx); upvalues += stack::stack_detail::push_as_upvalues(L, fx);
@ -14432,7 +14432,7 @@ namespace sol {
static void select_member_variable(std::true_type, lua_State* L, Fx&& fx) { static void select_member_variable(std::true_type, lua_State* L, Fx&& fx) {
typedef typename meta::bind_traits<meta::unqualified_t<Fx>>::object_type C; typedef typename meta::bind_traits<meta::unqualified_t<Fx>>::object_type C;
lua_CFunction freefunc = &function_detail::upvalue_this_member_variable<C, Fx, is_yielding>::call; lua_CFunction freefunc = &function_detail::upvalue_this_member_variable<C, Fx, is_yielding>::call;
int upvalues = 0; int upvalues = 0;
upvalues += stack::push(L, nullptr); upvalues += stack::push(L, nullptr);
upvalues += stack::stack_detail::push_as_upvalues(L, fx); upvalues += stack::stack_detail::push_as_upvalues(L, fx);
@ -14474,7 +14474,7 @@ namespace sol {
template <bool is_yielding, typename Fx, typename C> template <bool is_yielding, typename Fx, typename C>
static void select_member_function(std::true_type, lua_State* L, Fx&& fx, function_detail::class_indicator<C>) { static void select_member_function(std::true_type, lua_State* L, Fx&& fx, function_detail::class_indicator<C>) {
lua_CFunction freefunc = &function_detail::upvalue_this_member_function<C, Fx, is_yielding>::call; lua_CFunction freefunc = &function_detail::upvalue_this_member_function<C, Fx, is_yielding>::call;
int upvalues = 0; int upvalues = 0;
upvalues += stack::push(L, nullptr); upvalues += stack::push(L, nullptr);
upvalues += stack::stack_detail::push_as_upvalues(L, fx); upvalues += stack::stack_detail::push_as_upvalues(L, fx);
@ -14485,7 +14485,7 @@ namespace sol {
static void select_member_function(std::true_type, lua_State* L, Fx&& fx) { static void select_member_function(std::true_type, lua_State* L, Fx&& fx) {
typedef typename meta::bind_traits<meta::unqualified_t<Fx>>::object_type C; typedef typename meta::bind_traits<meta::unqualified_t<Fx>>::object_type C;
lua_CFunction freefunc = &function_detail::upvalue_this_member_function<C, Fx, is_yielding>::call; lua_CFunction freefunc = &function_detail::upvalue_this_member_function<C, Fx, is_yielding>::call;
int upvalues = 0; int upvalues = 0;
upvalues += stack::push(L, nullptr); upvalues += stack::push(L, nullptr);
upvalues += stack::stack_detail::push_as_upvalues(L, fx); upvalues += stack::stack_detail::push_as_upvalues(L, fx);
@ -15133,7 +15133,7 @@ namespace sol {
} }
#if (!defined(SOL_EXCEPTIONS_SAFE_PROPAGATION) || !SOL_NO_EXCEPTIONS_SAFE_PROPAGATION) #if (!defined(SOL_EXCEPTIONS_SAFE_PROPAGATION) || !SOL_NO_EXCEPTIONS_SAFE_PROPAGATION)
// LuaJIT cannot have the catchall when the safe propagation is on // LuaJIT cannot have the catchall when the safe propagation is on
// but LuaJIT will swallow all C++ errors // but LuaJIT will swallow all C++ errors
// if we don't at least catch std::exception ones // if we don't at least catch std::exception ones
catch (...) { catch (...) {
onexcept(optional<const std::exception&>(nullopt), "caught (...) unknown error during protected_function call"); onexcept(optional<const std::exception&>(nullopt), "caught (...) unknown error during protected_function call");
@ -15220,7 +15220,7 @@ namespace sol {
stack::check<basic_protected_function>(lua_state(), -1, handler); stack::check<basic_protected_function>(lua_state(), -1, handler);
#endif // Safety #endif // Safety
} }
basic_protected_function(lua_nil_t n) basic_protected_function(lua_nil_t n)
: base_t(n), error_handler(n) { : base_t(n), error_handler(n) {
} }
@ -16571,25 +16571,25 @@ namespace sol {
struct error_result { struct error_result {
int results; int results;
const char* fmt; const char* fmt_;
std::array<const char*, 4> args; std::array<const char*, 4> args;
error_result() : results(0), fmt(nullptr) { error_result() : results(0), fmt_(nullptr) {
} }
error_result(int results) : results(results), fmt(nullptr) { error_result(int results) : results(results), fmt_(nullptr) {
} }
error_result(const char* fmt, const char* msg) : results(0), fmt(fmt) { error_result(const char* fmt_, const char* msg) : results(0), fmt_(fmt_) {
args[0] = msg; args[0] = msg;
} }
}; };
inline int handle_errors(lua_State* L, const error_result& er) { inline int handle_errors(lua_State* L, const error_result& er) {
if (er.fmt == nullptr) { if (er.fmt_ == nullptr) {
return er.results; return er.results;
} }
return luaL_error(L, er.fmt, er.args[0], er.args[1], er.args[2], er.args[3]); return luaL_error(L, er.fmt_, er.args[0], er.args[1], er.args[2], er.args[3]);
} }
template <typename X, typename = void> template <typename X, typename = void>
@ -16684,7 +16684,7 @@ namespace sol {
typedef meta::is_matched_lookup<T> is_matched_lookup; typedef meta::is_matched_lookup<T> is_matched_lookup;
typedef typename T::iterator iterator; typedef typename T::iterator iterator;
typedef typename T::value_type value_type; typedef typename T::value_type value_type;
typedef std::conditional_t<is_matched_lookup::value, typedef std::conditional_t<is_matched_lookup::value,
std::pair<value_type, value_type>, std::pair<value_type, value_type>,
std::conditional_t<is_associative::value || is_lookup::value, std::conditional_t<is_associative::value || is_lookup::value,
value_type, value_type,
@ -17242,7 +17242,7 @@ namespace sol {
static bool empty_start(lua_State* L, T& self) { static bool empty_start(lua_State* L, T& self) {
return empty_has(has_empty<T>(), L, self); return empty_has(has_empty<T>(), L, self);
} }
static error_result erase_start(lua_State* L, T& self, K& key) { static error_result erase_start(lua_State* L, T& self, K& key) {
return erase_has(has_erase<T>(), L, self, key); return erase_has(has_erase<T>(), L, self, key);
} }
@ -17892,7 +17892,7 @@ namespace sol {
std::remove_pointer_t<T>>> std::remove_pointer_t<T>>>
meta_cumt; meta_cumt;
static const char* metakey = is_shim ? &usertype_traits<as_container_t<std::remove_pointer_t<T>>>::metatable()[0] : &usertype_traits<T>::metatable()[0]; static const char* metakey = is_shim ? &usertype_traits<as_container_t<std::remove_pointer_t<T>>>::metatable()[0] : &usertype_traits<T>::metatable()[0];
static const std::array<luaL_Reg, 19> reg = { { static const std::array<luaL_Reg, 19> reg = { {
{ "__pairs", &meta_cumt::pairs_call }, { "__pairs", &meta_cumt::pairs_call },
{ "__ipairs", &meta_cumt::ipairs_call }, { "__ipairs", &meta_cumt::ipairs_call },
{ "__len", &meta_cumt::length_call }, { "__len", &meta_cumt::length_call },
@ -17911,7 +17911,7 @@ namespace sol {
{ "find", &meta_cumt::find_call }, { "find", &meta_cumt::find_call },
{ "erase", &meta_cumt::erase_call }, { "erase", &meta_cumt::erase_call },
std::is_pointer<T>::value ? luaL_Reg{ nullptr, nullptr } : luaL_Reg{ "__gc", &detail::usertype_alloc_destruct<T> }, std::is_pointer<T>::value ? luaL_Reg{ nullptr, nullptr } : luaL_Reg{ "__gc", &detail::usertype_alloc_destruct<T> },
{ nullptr, nullptr } { nullptr, nullptr }
} }; } };
if (luaL_newmetatable(L, metakey) == 1) { if (luaL_newmetatable(L, metakey) == 1) {
@ -18298,7 +18298,7 @@ namespace sol {
: index(index), new_index(newindex), runtime_target(runtimetarget) { : index(index), new_index(newindex), runtime_target(runtimetarget) {
} }
}; };
typedef map_t<std::string, call_information> mapping_t; typedef map_t<std::string, call_information> mapping_t;
struct variable_wrapper { struct variable_wrapper {
@ -22062,7 +22062,7 @@ namespace sol {
#else #else
#define check(expr) { CA_ASSUME(expr); } #define check(expr) { CA_ASSUME(expr); }
#endif #endif
#endif #endif
#endif // Unreal Engine 4 Bullshit #endif // Unreal Engine 4 Bullshit
#endif // SOL_HPP #endif // SOL_HPP

18
sol/container_traits.hpp
View File

@ -1,4 +1,4 @@
// sol2 // sol2
// The MIT License (MIT) // The MIT License (MIT)
@ -456,25 +456,25 @@ namespace sol {
struct error_result { struct error_result {
int results; int results;
const char* fmt; const char* fmt_;
std::array<const char*, 4> args; std::array<const char*, 4> args;
error_result() : results(0), fmt(nullptr) { error_result() : results(0), fmt_(nullptr) {
} }
error_result(int results) : results(results), fmt(nullptr) { error_result(int results) : results(results), fmt_(nullptr) {
} }
error_result(const char* fmt, const char* msg) : results(0), fmt(fmt) { error_result(const char* fmt_, const char* msg) : results(0), fmt_(fmt_) {
args[0] = msg; args[0] = msg;
} }
}; };
inline int handle_errors(lua_State* L, const error_result& er) { inline int handle_errors(lua_State* L, const error_result& er) {
if (er.fmt == nullptr) { if (er.fmt_ == nullptr) {
return er.results; return er.results;
} }
return luaL_error(L, er.fmt, er.args[0], er.args[1], er.args[2], er.args[3]); return luaL_error(L, er.fmt_, er.args[0], er.args[1], er.args[2], er.args[3]);
} }
template <typename X, typename = void> template <typename X, typename = void>
@ -569,7 +569,7 @@ namespace sol {
typedef meta::is_matched_lookup<T> is_matched_lookup; typedef meta::is_matched_lookup<T> is_matched_lookup;
typedef typename T::iterator iterator; typedef typename T::iterator iterator;
typedef typename T::value_type value_type; typedef typename T::value_type value_type;
typedef std::conditional_t<is_matched_lookup::value, typedef std::conditional_t<is_matched_lookup::value,
std::pair<value_type, value_type>, std::pair<value_type, value_type>,
std::conditional_t<is_associative::value || is_lookup::value, std::conditional_t<is_associative::value || is_lookup::value,
value_type, value_type,
@ -1127,7 +1127,7 @@ namespace sol {
static bool empty_start(lua_State* L, T& self) { static bool empty_start(lua_State* L, T& self) {
return empty_has(has_empty<T>(), L, self); return empty_has(has_empty<T>(), L, self);
} }
static error_result erase_start(lua_State* L, T& self, K& key) { static error_result erase_start(lua_State* L, T& self, K& key) {
return erase_has(has_erase<T>(), L, self, key); return erase_has(has_erase<T>(), L, self, key);
} }