mirror/openmw
1
0
Fork 0
mirror of https://github.com/OpenMW/openmw.git synced 2025-10-16 23:46:34 +00:00
Code Issues Releases Wiki Activity

Update sol3 to v3.5.0

Browse source 
To fix warning (silenced by 3b97af0ac417c6f5ee2d16fa4c2cab2885409352):

In file included from ../../../extern/sol3/sol/stack_check_get.hpp:28,
                 from ../../../extern/sol3/sol/stack.hpp:32,
                 from ../../../extern/sol3/sol/sol.hpp:52,
                 from ../../../components/lua/luastate.hpp:8,
                 from ../../../apps/openmw/mwlua/context.hpp:4,
                 from ../../../apps/openmw/mwlua/soundbindings.hpp:6,
                 from ../../../apps/openmw/mwlua/soundbindings.cpp:1:
In function 'OptionalType sol::stack::stack_detail::get_optional(lua_State*, int, Handler&&, sol::stack::record&) [with OptionalType = sol::optional<float>; T = float; Handler = int (*)(lua_State*, int, sol::type, sol::type, const char*) noexcept]',
    inlined from 'static Optional sol::stack::qualified_getter<Optional, typename std::enable_if<is_optional_v<Optional>, void>::type>::get(lua_State*, int, sol::stack::record&) [with Optional = sol::optional<float>]' at ../../../extern/sol3/sol/stack_check_get_qualified.hpp:133:50,
    inlined from 'decltype(auto) sol::stack::stack_detail::unchecked_get(lua_State*, int, sol::stack::record&) [with T = sol::optional<float>]' at ../../../extern/sol3/sol/stack_core.hpp:725:18,
    inlined from 'decltype (unchecked_get<T>(L, index, tracking)) sol::stack::get(lua_State*, int, record&) [with T = sol::optional<float>]' at ../../../extern/sol3/sol/stack_core.hpp:1186:41,
    inlined from 'decltype(auto) sol::stack::get(lua_State*, int) [with T = sol::optional<float>]' at ../../../extern/sol3/sol/stack_core.hpp:1193:17:
../../../extern/sol3/sol/stack_check_get_qualified.hpp:112:49: error: '*(float*)((char*)&<unnamed> + offsetof(sol::optional<float>,sol::optional<float>::<unnamed>.sol::detail::optional_move_assign_base<float, true>::<unnamed>.sol::detail::optional_copy_assign_base<float, true>::<unnamed>.sol::detail::optional_move_base<float, true>::<unnamed>.sol::detail::optional_copy_base<float, true>::<unnamed>.sol::detail::optional_operations_base<float>::<unnamed>.sol::detail::optional_storage_base<float, true>::<unnamed>))' may be used uninitialized [-Werror=maybe-uninitialized]
  112 |                                         return {};
      |                                                 ^
../../../extern/sol3/sol/stack_check_get_qualified.hpp: In function 'decltype(auto) sol::stack::get(lua_State*, int) [with T = sol::optional<float>]':
../../../extern/sol3/sol/stack_check_get_qualified.hpp:112:49: note: '<anonymous>' declared here
  112 |                                         return {};
      |                                                 ^
This commit is contained in:
elsid 2025-02-21 19:28:01 +01:00
parent 32605a4c33
commit 1af8fd87d9
No known key found for this signature in database
GPG key ID: B845CB9FEE18AB40
116 changed files with 1407 additions and 712 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
extern/sol3/README.md vendored
View file

@ -1,5 +1,3 @@
The code in this directory is copied from https://github.com/ThePhD/sol2.git (64096348465b980e2f1d0e5ba9cbeea8782e8f27) The code in this directory is copied from https://github.com/ThePhD/sol2.git (9190880c593dfb018ccf5cc9729ab87739709862)
Additional changes include cherry-picking upstream commit d805d027e0a0a7222e936926139f06e23828ce9f to fix compilation under Clang 19.
License: MIT License: MIT

47
extern/sol3/sol/abort.hpp vendored Normal file
View file

@ -0,0 +1,47 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in
// the Software without restriction, including without limitation the rights to
// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
// the Software, and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#ifndef SOL_ABORT_HPP
#define SOL_ABORT_HPP
#include <sol/version.hpp>
#include <sol/base_traits.hpp>
#include <cstdlib>
// clang-format off
#if SOL_IS_ON(SOL_DEBUG_BUILD)
#if SOL_IS_ON(SOL_COMPILER_VCXX)
#define SOL_DEBUG_ABORT() \
if (true) { ::std::abort(); } \
static_assert(true, "")
#else
#define SOL_DEBUG_ABORT() ::std::abort()
#endif
#else
#define SOL_DEBUG_ABORT() static_assert(true, "")
#endif
// clang-format on
#endif // SOL_ABORT_HPP

2
extern/sol3/sol/as_args.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in

2
extern/sol3/sol/as_returns.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in

24
extern/sol3/sol/assert.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -28,7 +28,7 @@
#include <sol/forward.hpp> #include <sol/forward.hpp>
#if SOL_IS_ON(SOL2_CI_I_) #if SOL_IS_ON(SOL2_CI)
struct pre_main { struct pre_main {
pre_main() { pre_main() {
@ -43,15 +43,15 @@ struct pre_main {
// clang-format off // clang-format off
#if SOL_IS_ON(SOL_USER_C_ASSERT_I_) #if SOL_IS_ON(SOL_USER_ASSERT)
#define sol_c_assert(...) SOL_C_ASSERT(__VA_ARGS__) #define SOL_ASSERT(...) SOL_C_ASSERT(__VA_ARGS__)
#else #else
#if SOL_IS_ON(SOL_DEBUG_BUILD_I_) #if SOL_IS_ON(SOL_DEBUG_BUILD)
#include <exception> #include <exception>
#include <iostream> #include <iostream>
#include <cstdlib> #include <cstdlib>
#define sol_c_assert(...) \ #define SOL_ASSERT(...) \
do { \ do { \
if (!(__VA_ARGS__)) { \ if (!(__VA_ARGS__)) { \
std::cerr << "Assertion `" #__VA_ARGS__ "` failed in " << __FILE__ << " line " << __LINE__ << std::endl; \ std::cerr << "Assertion `" #__VA_ARGS__ "` failed in " << __FILE__ << " line " << __LINE__ << std::endl; \
@ -59,7 +59,7 @@ struct pre_main {
} \ } \
} while (false) } while (false)
#else #else
#define sol_c_assert(...) \ #define SOL_ASSERT(...) \
do { \ do { \
if (false) { \ if (false) { \
(void)(__VA_ARGS__); \ (void)(__VA_ARGS__); \
@ -68,15 +68,15 @@ struct pre_main {
#endif #endif
#endif #endif
#if SOL_IS_ON(SOL_USER_M_ASSERT_I_) #if SOL_IS_ON(SOL_USER_ASSERT_MSG)
#define sol_m_assert(message, ...) SOL_M_ASSERT(message, __VA_ARGS__) #define SOL_ASSERT_MSG(message, ...) SOL_ASSERT_MSG(message, __VA_ARGS__)
#else #else
#if SOL_IS_ON(SOL_DEBUG_BUILD_I_) #if SOL_IS_ON(SOL_DEBUG_BUILD)
#include <exception> #include <exception>
#include <iostream> #include <iostream>
#include <cstdlib> #include <cstdlib>
#define sol_m_assert(message, ...) \ #define SOL_ASSERT_MSG(message, ...) \
do { \ do { \
if (!(__VA_ARGS__)) { \ if (!(__VA_ARGS__)) { \
std::cerr << "Assertion `" #__VA_ARGS__ "` failed in " << __FILE__ << " line " << __LINE__ << ": " << message << std::endl; \ std::cerr << "Assertion `" #__VA_ARGS__ "` failed in " << __FILE__ << " line " << __LINE__ << ": " << message << std::endl; \
@ -84,7 +84,7 @@ struct pre_main {
} \ } \
} while (false) } while (false)
#else #else
#define sol_m_assert(message, ...) \ #define SOL_ASSERT_MSG(message, ...) \
do { \ do { \
if (false) { \ if (false) { \
(void)(__VA_ARGS__); \ (void)(__VA_ARGS__); \

35
extern/sol3/sol/base_traits.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -62,6 +62,39 @@ namespace sol {
template <template <class...> class Trait, class... Args> template <template <class...> class Trait, class... Args>
constexpr inline bool is_detected_v = is_detected<Trait, Args...>::value; constexpr inline bool is_detected_v = is_detected<Trait, Args...>::value;
template <typename _Default, typename _Void, template <typename...> typename _Op, typename... _Args>
class detector {
public:
using value_t = ::std::false_type;
using type = _Default;
};
template <typename _Default, template <typename...> typename _Op, typename... _Args>
class detector<_Default, void_t<_Op<_Args...>>, _Op, _Args...> {
public:
using value_t = ::std::true_type;
using type = _Op<_Args...>;
};
class nonesuch {
public:
~nonesuch() = delete;
nonesuch(nonesuch const&) = delete;
nonesuch& operator=(nonesuch const&) = delete;
};
template <template <typename...> typename _Op, typename... _Args>
using detected_t = typename detector<nonesuch, void, _Op, _Args...>::type;
template <typename _Default, template <typename...> typename _Op, typename... _Args>
using detected_or = detector<_Default, void, _Op, _Args...>;
template <typename _Default, template <typename...> typename _Op, typename... _Args>
using detected_or_t = typename detector<_Default, void, _Op, _Args...>::type;
template <typename _Default, template <typename...> typename _Op, typename... _Args>
constexpr inline bool detected_or_v = detector<_Default, void, _Op, _Args...>::value;
template <std::size_t I> template <std::size_t I>
using index_value = std::integral_constant<std::size_t, I>; using index_value = std::integral_constant<std::size_t, I>;

10
extern/sol3/sol/bind_traits.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -31,7 +31,7 @@
namespace sol { namespace meta { namespace sol { namespace meta {
namespace meta_detail { namespace meta_detail {
template <typename F> template <typename F>
using detect_deducible_signature = decltype(&F::operator(), void()); using detect_deducible_signature = decltype(&F::operator());
} // namespace meta_detail } // namespace meta_detail
template <typename F> template <typename F>
@ -196,7 +196,7 @@ namespace sol { namespace meta {
typedef R (T::*function_pointer_type)(Args..., ...) const volatile&&; typedef R (T::*function_pointer_type)(Args..., ...) const volatile&&;
}; };
#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_) #if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
template <typename R, typename... Args> template <typename R, typename... Args>
struct fx_traits<R(Args...) noexcept, false> : public basic_traits<true, false, void, R, Args...> { struct fx_traits<R(Args...) noexcept, false> : public basic_traits<true, false, void, R, Args...> {
@ -311,7 +311,7 @@ namespace sol { namespace meta {
#endif // noexcept is part of a function's type #endif // noexcept is part of a function's type
#if SOL_IS_ON(SOL_COMPILER_VCXX_I_) && SOL_IS_ON(SOL_PLATFORM_X86_I_) #if SOL_IS_ON(SOL_COMPILER_VCXX) && SOL_IS_ON(SOL_PLATFORM_X86)
template <typename R, typename... Args> template <typename R, typename... Args>
struct fx_traits<R __stdcall(Args...), false> : public basic_traits<false, false, void, R, Args...> { struct fx_traits<R __stdcall(Args...), false> : public basic_traits<false, false, void, R, Args...> {
typedef R(__stdcall* function_pointer_type)(Args...); typedef R(__stdcall* function_pointer_type)(Args...);
@ -369,7 +369,7 @@ namespace sol { namespace meta {
typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile&&; typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile&&;
}; };
#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_) #if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
template <typename R, typename... Args> template <typename R, typename... Args>
struct fx_traits<R __stdcall(Args...) noexcept, false> : public basic_traits<true, false, void, R, Args...> { struct fx_traits<R __stdcall(Args...) noexcept, false> : public basic_traits<true, false, void, R, Args...> {

4
extern/sol3/sol/bytecode.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -99,7 +99,7 @@ namespace sol {
using storage_t = Container; using storage_t = Container;
const std::byte* p_code = static_cast<const std::byte*>(memory); const std::byte* p_code = static_cast<const std::byte*>(memory);
storage_t& bc = *static_cast<storage_t*>(userdata_pointer); storage_t& bc = *static_cast<storage_t*>(userdata_pointer);
#if SOL_IS_OFF(SOL_EXCEPTIONS_I_) #if SOL_IS_OFF(SOL_EXCEPTIONS)
bc.insert(bc.cend(), p_code, p_code + memory_size); bc.insert(bc.cend(), p_code, p_code + memory_size);
#else #else
try { try {

32
extern/sol3/sol/call.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -54,7 +54,7 @@ namespace sol {
lua_createtable(L, static_cast<int>(sizeof...(In)), 0); lua_createtable(L, static_cast<int>(sizeof...(In)), 0);
stack_reference deps(L, -1); stack_reference deps(L, -1);
auto per_dep = [&L, &deps](int i) { auto per_dep = [&L, &deps](int i) {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic); luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
lua_pushvalue(L, i); lua_pushvalue(L, i);
@ -79,7 +79,7 @@ namespace sol {
} }
lua_createtable(L, static_cast<int>(sdeps.size()), 0); lua_createtable(L, static_cast<int>(sdeps.size()), 0);
stack_reference deps(L, -1); stack_reference deps(L, -1);
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, static_cast<int>(sdeps.size()), detail::not_enough_stack_space_generic); luaL_checkstack(L, static_cast<int>(sdeps.size()), detail::not_enough_stack_space_generic);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
for (std::size_t i = 0; i < sdeps.size(); ++i) { for (std::size_t i = 0; i < sdeps.size(); ++i) {
@ -429,7 +429,7 @@ namespace sol {
} }
}; };
#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_) #if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
template <bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C> template <bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
struct agnostic_lua_call_wrapper<detail::lua_CFunction_noexcept, is_index, is_variable, checked, boost, clean_stack, C> { struct agnostic_lua_call_wrapper<detail::lua_CFunction_noexcept, is_index, is_variable, checked, boost, clean_stack, C> {
static int call(lua_State* L, detail::lua_CFunction_noexcept f) { static int call(lua_State* L, detail::lua_CFunction_noexcept f) {
@ -478,12 +478,13 @@ namespace sol {
using object_type = typename wrap::object_type; using object_type = typename wrap::object_type;
if constexpr (sizeof...(Args) < 1) { if constexpr (sizeof...(Args) < 1) {
using Ta = meta::conditional_t<std::is_void_v<T>, object_type, T>; using Ta = meta::conditional_t<std::is_void_v<T>, object_type, T>;
static_assert(std::is_base_of_v<object_type, Ta>, static_assert(std::is_same_v<object_type, Ta> || std::is_base_of_v<object_type, Ta>,
"It seems like you might have accidentally bound a class type with a member function method that does not correspond to the " "It seems like you might have accidentally bound a class type with a member function method that does not correspond to the "
"class. For example, there could be a small type in your new_usertype<T>(...) binding, where you specify one class \"T\" " "class. For example, there could be a small type in your new_usertype<T>(...) binding, where you specify one class \"T\" "
"but then bind member methods from a complete unrelated class. Check things over!"); "but then bind member methods from a complete unrelated class. Check things over!");
#if SOL_IS_ON(SOL_SAFE_USERTYPE_I_) #if SOL_IS_ON(SOL_SAFE_USERTYPE)
auto maybeo = stack::check_get<Ta*>(L, 1); stack::record tracking {};
auto maybeo = stack::stack_detail::check_get_arg<Ta*>(L, 1, &no_panic, tracking);
if (!maybeo || maybeo.value() == nullptr) { if (!maybeo || maybeo.value() == nullptr) {
return luaL_error(L, return luaL_error(L,
"sol: received nil for 'self' argument (use ':' for accessing member functions, make sure member variables are " "sol: received nil for 'self' argument (use ':' for accessing member functions, make sure member variables are "
@ -511,12 +512,13 @@ namespace sol {
if constexpr (is_index) { if constexpr (is_index) {
if constexpr (sizeof...(Args) < 1) { if constexpr (sizeof...(Args) < 1) {
using Ta = meta::conditional_t<std::is_void_v<T>, object_type, T>; using Ta = meta::conditional_t<std::is_void_v<T>, object_type, T>;
static_assert(std::is_base_of_v<object_type, Ta>, static_assert(std::is_same_v<object_type, Ta> || std::is_base_of_v<object_type, Ta>,
"It seems like you might have accidentally bound a class type with a member function method that does not correspond " "It seems like you might have accidentally bound a class type with a member function method that does not correspond "
"to the class. For example, there could be a small type in your new_usertype<T>(...) binding, where you specify one " "to the class. For example, there could be a small type in your new_usertype<T>(...) binding, where you specify one "
"class \"T\" but then bind member methods from a complete unrelated class. Check things over!"); "class \"T\" but then bind member methods from a complete unrelated class. Check things over!");
#if SOL_IS_ON(SOL_SAFE_USERTYPE_I_) #if SOL_IS_ON(SOL_SAFE_USERTYPE)
auto maybeo = stack::check_get<Ta*>(L, 1); stack::record tracking {};
auto maybeo = stack::stack_detail::check_get_arg<Ta*>(L, 1, &no_panic, tracking);
if (!maybeo || maybeo.value() == nullptr) { if (!maybeo || maybeo.value() == nullptr) {
if (is_variable) { if (is_variable) {
return luaL_error(L, "sol: 'self' argument is lua_nil (bad '.' access?)"); return luaL_error(L, "sol: 'self' argument is lua_nil (bad '.' access?)");
@ -573,8 +575,9 @@ namespace sol {
} }
else { else {
using Ta = meta::conditional_t<std::is_void_v<T>, object_type, T>; using Ta = meta::conditional_t<std::is_void_v<T>, object_type, T>;
#if SOL_IS_ON(SOL_SAFE_USERTYPE_I_) #if SOL_IS_ON(SOL_SAFE_USERTYPE)
auto maybeo = stack::check_get<Ta*>(L, 1); stack::record tracking {};
auto maybeo = stack::stack_detail::check_get_arg<Ta*>(L, 1, &no_panic, tracking);
if (!maybeo || maybeo.value() == nullptr) { if (!maybeo || maybeo.value() == nullptr) {
if (is_variable) { if (is_variable) {
return luaL_error(L, "sol: received nil for 'self' argument (bad '.' access?)"); return luaL_error(L, "sol: received nil for 'self' argument (bad '.' access?)");
@ -811,8 +814,9 @@ namespace sol {
using args_list = meta::pop_front_type_t<typename traits_type::free_args_list>; using args_list = meta::pop_front_type_t<typename traits_type::free_args_list>;
using Ta = T; using Ta = T;
using Oa = std::remove_pointer_t<object_type>; using Oa = std::remove_pointer_t<object_type>;
#if SOL_IS_ON(SOL_SAFE_USERTYPE_I_) #if SOL_IS_ON(SOL_SAFE_USERTYPE)
auto maybeo = stack::check_get<Ta*>(L, 1); stack::record tracking {};
auto maybeo = stack::stack_detail::check_get_arg<Ta*>(L, 1, &no_panic, tracking);
if (!maybeo || maybeo.value() == nullptr) { if (!maybeo || maybeo.value() == nullptr) {
if (is_variable) { if (is_variable) {
return luaL_error(L, "sol: 'self' argument is lua_nil (bad '.' access?)"); return luaL_error(L, "sol: 'self' argument is lua_nil (bad '.' access?)");

26
extern/sol3/sol/compatibility.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -32,20 +32,20 @@
#include <sol/version.hpp> #include <sol/version.hpp>
#include <sol/compatibility/lua_version.hpp> #include <sol/compatibility/lua_version.hpp>
#if SOL_IS_ON(SOL_USE_COMPATIBILITY_LAYER_I_) #if SOL_IS_ON(SOL_USE_COMPATIBILITY_LAYER)
#if SOL_IS_ON(SOL_USE_CXX_LUA_I_) || SOL_IS_ON(SOL_USE_CXX_LUAJIT_I_) // clang-format off
#ifndef COMPAT53_LUA_CPP #if SOL_IS_ON(SOL_USING_CXX_LUA) || SOL_IS_ON(SOL_USING_CXX_LUAJIT)
#define COMPAT53_LUA_CPP 1 #ifndef COMPAT53_LUA_CPP
#endif // Build Lua Compat layer as C++ #define COMPAT53_LUA_CPP 1
#endif // Build Lua Compat layer as C++
#endif #endif
#ifndef COMPAT53_INCLUDE_SOURCE #ifndef COMPAT53_INCLUDE_SOURCE
#define COMPAT53_INCLUDE_SOURCE 1 #define COMPAT53_INCLUDE_SOURCE 1
#endif // Build Compat Layer Inline #endif // Build Compat Layer Inline
#include <sol/compatibility/compat-5.3.h>
#include <sol/compatibility/compat-5.3.h> #include <sol/compatibility/compat-5.4.h>
#include <sol/compatibility/compat-5.4.h>
#endif #endif
// clang-format on
#endif // SOL_COMPATIBILITY_HPP #endif // SOL_COMPATIBILITY_HPP

12
extern/sol3/sol/compatibility/compat-5.3.h vendored
View file

@ -7,9 +7,15 @@
#if defined(__cplusplus) && !defined(COMPAT53_LUA_CPP) #if defined(__cplusplus) && !defined(COMPAT53_LUA_CPP)
extern "C" { extern "C" {
#endif #endif
#include <lua.h> #if __has_include(<lua/lua.h>)
#include <lauxlib.h> #include <lua/lua.h>
#include <lualib.h> #include <lua/lauxlib.h>
#include <lua/lualib.h>
#else
#include <lua.h>
#include <lauxlib.h>
#include <lualib.h>
#endif
#if defined(__cplusplus) && !defined(COMPAT53_LUA_CPP) #if defined(__cplusplus) && !defined(COMPAT53_LUA_CPP)
} }
#endif #endif

12
extern/sol3/sol/compatibility/compat-5.4.h vendored
View file

@ -4,9 +4,15 @@
#if defined(__cplusplus) && !defined(COMPAT53_LUA_CPP) #if defined(__cplusplus) && !defined(COMPAT53_LUA_CPP)
extern "C" { extern "C" {
#endif #endif
#include <lua.h> #if __has_include(<lua/lua.h>)
#include <lauxlib.h> #include <lua/lua.h>
#include <lualib.h> #include <lua/lauxlib.h>
#include <lua/lualib.h>
#else
#include <lua.h>
#include <lauxlib.h>
#include <lualib.h>
#endif
#if defined(__cplusplus) && !defined(COMPAT53_LUA_CPP) #if defined(__cplusplus) && !defined(COMPAT53_LUA_CPP)
} }
#endif #endif

99
extern/sol3/sol/compatibility/lua_version.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -21,24 +21,40 @@
// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN // IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. // CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#ifndef SOL_COMPATIBILITY_VERSION_HPP #ifndef SOL_COMPATIBILITY_LUA_VERSION_HPP
#define SOL_COMPATIBILITY_VERSION_HPP #define SOL_COMPATIBILITY_LUA_VERSION_HPP
#include <sol/version.hpp> #include <sol/version.hpp>
// clang-format off // clang-format off
#if SOL_IS_ON(SOL_USE_CXX_LUA_I_) #if SOL_IS_ON(SOL_USING_CXX_LUA)
#include <lua.h> #if __has_include(<lua/lua.h>)
#include <lualib.h> #include <lua/lua.h>
#include <lauxlib.h> #include <lua/lauxlib.h>
#elif SOL_IS_ON(SOL_USE_LUA_HPP_I_) #include <lua/lualib.h>
#include <lua.hpp> #else
#else
extern "C" {
#include <lua.h> #include <lua.h>
#include <lauxlib.h> #include <lauxlib.h>
#include <lualib.h> #include <lualib.h>
#endif
#elif SOL_IS_ON(SOL_USE_LUA_HPP)
#if __has_include(<lua/lua.hpp>)
#include <lua/lua.hpp>
#else
#include <lua.hpp>
#endif
#else
extern "C" {
#if __has_include(<lua/lua.h>)
#include <lua/lua.h>
#include <lua/lauxlib.h>
#include <lua/lualib.h>
#else
#include <lua.h>
#include <lauxlib.h>
#include <lualib.h>
#endif
} }
#endif // C++ Mangling for Lua vs. Not #endif // C++ Mangling for Lua vs. Not
@ -50,13 +66,15 @@
#endif #endif
#elif defined(LUAJIT_VERSION) #elif defined(LUAJIT_VERSION)
#define SOL_USE_LUAJIT_I_ SOL_ON #define SOL_USE_LUAJIT_I_ SOL_ON
#elif SOL_IS_ON(SOL_USING_CXX_LUAJIT)
#define SOL_USE_LUAJIT_I_ SOL_ON
#else #else
#define SOL_USE_LUAJIT_I_ SOL_DEFAULT_OFF #define SOL_USE_LUAJIT_I_ SOL_DEFAULT_OFF
#endif // luajit #endif // luajit
#if SOL_IS_ON(SOL_USE_CXX_LUAJIT_I_) #if SOL_IS_ON(SOL_USING_CXX_LUAJIT)
#include <luajit.h> #include <luajit.h>
#elif SOL_IS_ON(SOL_USE_LUAJIT_I_) #elif SOL_IS_ON(SOL_USE_LUAJIT)
extern "C" { extern "C" {
#include <luajit.h> #include <luajit.h>
} }
@ -64,7 +82,7 @@
#if defined(SOL_LUAJIT_VERSION) #if defined(SOL_LUAJIT_VERSION)
#define SOL_LUAJIT_VERSION_I_ SOL_LUAJIT_VERSION #define SOL_LUAJIT_VERSION_I_ SOL_LUAJIT_VERSION
#elif SOL_IS_ON(SOL_USE_LUAJIT_I_) #elif SOL_IS_ON(SOL_USE_LUAJIT)
#define SOL_LUAJIT_VERSION_I_ LUAJIT_VERSION_NUM #define SOL_LUAJIT_VERSION_I_ LUAJIT_VERSION_NUM
#else #else
#define SOL_LUAJIT_VERSION_I_ 0 #define SOL_LUAJIT_VERSION_I_ 0
@ -118,21 +136,25 @@
#else #else
#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_OFF #define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_OFF
#endif #endif
#elif SOL_LUAJIT_VERSION_I_ >= 20100
// LuaJIT 2.1.0-beta3 and better have exception support locked in for all platforms (mostly)
#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_DEFAULT_ON
#elif SOL_LUAJIT_VERSION_I_ >= 20000
// LuaJIT 2.0.x have exception support only on x64 builds
#if SOL_IS_ON(SOL_PLATFORM_X64_I_)
#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_DEFAULT_ON
#else
#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_OFF
#endif
#else #else
// otherwise, there is no exception safety for #if SOL_IS_ON(SOL_USE_LUAJIT)
// shoving exceptions through Lua and errors should #if SOL_USE(SOL_LUAJIT_VERSION) >= 20100
// always be serialized // LuaJIT 2.1.0-beta3 and better have exception support locked in for all platforms (mostly)
#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_DEFAULT_OFF #define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_DEFAULT_ON
#elif SOL_USE(SOL_LUAJIT_VERSION) >= 20000
// LuaJIT 2.0.x have exception support only on x64 builds
#if SOL_IS_ON(SOL_PLATFORM_X64)
#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_DEFAULT_ON
#else
#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_DEFAULT_OFF
#endif
#endif
#else
// otherwise, there is no exception safety for
// shoving exceptions through Lua and errors should
// always be serialized
#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_DEFAULT_OFF
#endif
#endif #endif
// Some configurations work with exceptions, // Some configurations work with exceptions,
@ -144,13 +166,14 @@
#define SOL_EXCEPTIONS_CATCH_ALL_I_ SOL_OFF #define SOL_EXCEPTIONS_CATCH_ALL_I_ SOL_OFF
#endif #endif
#else #else
#if SOL_IS_ON(SOL_USE_LUAJIT_I_) #if SOL_IS_ON(SOL_USE_LUAJIT) || SOL_IS_ON(SOL_USING_CXX_LUAJIT)
#define SOL_EXCEPTIONS_CATCH_ALL_I_ SOL_DEFAULT_OFF #define SOL_EXCEPTIONS_CATCH_ALL_I_ SOL_DEFAULT_OFF
#elif SOL_IS_ON(SOL_USE_CXX_LUAJIT_I_) #elif SOL_IS_ON(SOL_USING_CXX_LUA)
#define SOL_EXCEPTIONS_CATCH_ALL_I_ SOL_DEFAULT_OFF // C++ builds of Lua will throw an exception to implement its `yield` behavior;
#elif SOL_IS_ON(SOL_USE_CXX_LUA_I_) // it is irresponsible to "catch all" on this setting.
#define SOL_EXCEPTIONS_CATCH_ALL_I_ SOL_DEFAULT_OFF #define SOL_EXCEPTIONS_CATCH_ALL_I_ SOL_DEFAULT_OFF
#else #else
// Otherwise, by default, everyhting should be caught.
#define SOL_EXCEPTIONS_CATCH_ALL_I_ SOL_DEFAULT_ON #define SOL_EXCEPTIONS_CATCH_ALL_I_ SOL_DEFAULT_ON
#endif #endif
#endif #endif
@ -162,7 +185,7 @@
#define SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE_I_ SOL_OFF #define SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE_I_ SOL_OFF
#endif #endif
#else #else
#if SOL_IS_OFF(SOL_PROPAGATE_EXCEPTIONS_I_) && SOL_IS_ON(SOL_USE_LUAJIT_I_) #if SOL_IS_OFF(SOL_PROPAGATE_EXCEPTIONS) && SOL_IS_ON(SOL_USE_LUAJIT)
#define SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE_I_ SOL_ON #define SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE_I_ SOL_ON
#else #else
#define SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE_I_ SOL_DEFAULT_OFF #define SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE_I_ SOL_DEFAULT_OFF
@ -176,7 +199,7 @@
#define SOL_LUAL_STREAM_USE_CLOSE_FUNCTION_I_ SOL_OFF #define SOL_LUAL_STREAM_USE_CLOSE_FUNCTION_I_ SOL_OFF
#endif #endif
#else #else
#if SOL_IS_OFF(SOL_USE_LUAJIT_I_) && (SOL_LUA_VERSION > 501) #if SOL_IS_OFF(SOL_USE_LUAJIT) && (SOL_LUA_VERSION > 501)
#define SOL_LUAL_STREAM_USE_CLOSE_FUNCTION_I_ SOL_ON #define SOL_LUAL_STREAM_USE_CLOSE_FUNCTION_I_ SOL_ON
#else #else
#define SOL_LUAL_STREAM_USE_CLOSE_FUNCTION_I_ SOL_DEFAULT_OFF #define SOL_LUAL_STREAM_USE_CLOSE_FUNCTION_I_ SOL_DEFAULT_OFF
@ -192,7 +215,11 @@
#else #else
// Lua 5.2 only (deprecated in 5.3 (503)) (Can be turned on with Compat flags) // Lua 5.2 only (deprecated in 5.3 (503)) (Can be turned on with Compat flags)
// Lua 5.2, or other versions of Lua with the compat flag, or Lua that is not 5.2 with the specific define (5.4.1 either removed it entirely or broke it) // Lua 5.2, or other versions of Lua with the compat flag, or Lua that is not 5.2 with the specific define (5.4.1 either removed it entirely or broke it)
#if (SOL_LUA_VERSION_I_ == 502) || (defined(LUA_COMPAT_BITLIB) && (LUA_COMPAT_BITLIB != 0)) || (SOL_LUA_VERSION_I_ < 504 && (defined(LUA_COMPAT_5_2) && (LUA_COMPAT_5_2 != 0))) #if (SOL_LUA_VERSION_I_ == 502)
#define SOL_LUA_BIT32_LIB_I_ SOL_ON
#elif defined(LUA_COMPAT_BITLIB)
#define SOL_LUA_BIT32_LIB_I_ SOL_ON
#elif (SOL_LUA_VERSION_I_ < 504 && defined(LUA_COMPAT_5_2))
#define SOL_LUA_BIT32_LIB_I_ SOL_ON #define SOL_LUA_BIT32_LIB_I_ SOL_ON
#else #else
#define SOL_LUA_BIT32_LIB_I_ SOL_DEFAULT_OFF #define SOL_LUA_BIT32_LIB_I_ SOL_DEFAULT_OFF
@ -215,4 +242,4 @@
// clang-format on // clang-format on
#endif // SOL_COMPATIBILITY_VERSION_HPP #endif // SOL_COMPATIBILITY_LUA_VERSION_HPP

50
extern/sol3/sol/config.hpp vendored Normal file
View file

@ -0,0 +1,50 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in
// the Software without restriction, including without limitation the rights to
// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
// the Software, and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#ifndef SOL_CONFIG_HPP
#define SOL_CONFIG_HPP
/* Base, empty configuration file!
To override, place a file in your include paths of the form:
. (your include path here)
| sol (directory, or equivalent)
| config.hpp (your config.hpp file)
So that when sol2 includes the file
#include <sol/config.hpp>
it gives you the configuration values you desire. Configuration values can be
seen in the safety.rst of the doc/src, or at
https://sol2.readthedocs.io/en/latest/safety.html ! You can also pass them through
the build system, or the command line options of your compiler.
*/
#endif // SOL_CONFIG_HPP

12
extern/sol3/sol/coroutine.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -94,7 +94,7 @@ namespace sol {
meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler> meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
basic_coroutine(T&& r) noexcept basic_coroutine(T&& r) noexcept
: base_t(std::forward<T>(r)), m_error_handler(detail::get_default_handler<reference, is_main_threaded<base_t>::value>(r.lua_state())) { : base_t(std::forward<T>(r)), m_error_handler(detail::get_default_handler<reference, is_main_threaded<base_t>::value>(r.lua_state())) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
if (!is_function<meta::unqualified_t<T>>::value) { if (!is_function<meta::unqualified_t<T>>::value) {
auto pp = stack::push_pop(*this); auto pp = stack::push_pop(*this);
constructor_handler handler {}; constructor_handler handler {};
@ -157,7 +157,7 @@ namespace sol {
} }
template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler> template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
basic_coroutine(lua_State* L, T&& r, handler_t eh) : base_t(L, std::forward<T>(r)), m_error_handler(std::move(eh)) { basic_coroutine(lua_State* L, T&& r, handler_t eh) : base_t(L, std::forward<T>(r)), m_error_handler(std::move(eh)) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
auto pp = stack::push_pop(*this); auto pp = stack::push_pop(*this);
constructor_handler handler {}; constructor_handler handler {};
stack::check<basic_coroutine>(lua_state(), -1, handler); stack::check<basic_coroutine>(lua_state(), -1, handler);
@ -180,7 +180,7 @@ namespace sol {
: basic_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) { : basic_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
} }
basic_coroutine(lua_State* L, absolute_index index, handler_t eh) : base_t(L, index), m_error_handler(std::move(eh)) { basic_coroutine(lua_State* L, absolute_index index, handler_t eh) : base_t(L, index), m_error_handler(std::move(eh)) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
constructor_handler handler {}; constructor_handler handler {};
stack::check<basic_coroutine>(L, index, handler); stack::check<basic_coroutine>(L, index, handler);
#endif // Safety #endif // Safety
@ -189,7 +189,7 @@ namespace sol {
: basic_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) { : basic_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
} }
basic_coroutine(lua_State* L, raw_index index, handler_t eh) : base_t(L, index), m_error_handler(std::move(eh)) { basic_coroutine(lua_State* L, raw_index index, handler_t eh) : base_t(L, index), m_error_handler(std::move(eh)) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
constructor_handler handler {}; constructor_handler handler {};
stack::check<basic_coroutine>(L, index, handler); stack::check<basic_coroutine>(L, index, handler);
#endif // Safety #endif // Safety
@ -198,7 +198,7 @@ namespace sol {
: basic_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) { : basic_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
} }
basic_coroutine(lua_State* L, ref_index index, handler_t eh) : base_t(L, index), m_error_handler(std::move(eh)) { basic_coroutine(lua_State* L, ref_index index, handler_t eh) : base_t(L, index), m_error_handler(std::move(eh)) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
auto pp = stack::push_pop(*this); auto pp = stack::push_pop(*this);
constructor_handler handler {}; constructor_handler handler {};
stack::check<basic_coroutine>(lua_state(), -1, handler); stack::check<basic_coroutine>(lua_state(), -1, handler);

13
extern/sol3/sol/debug.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -47,6 +47,17 @@ namespace sol { namespace detail { namespace debug {
inline void print_section(const std::string& message, lua_State* L) { inline void print_section(const std::string& message, lua_State* L) {
std::cout << "-- " << message << " -- [ " << dump_types(L) << " ]" << std::endl; std::cout << "-- " << message << " -- [ " << dump_types(L) << " ]" << std::endl;
} }
inline void print_lua_information(lua_State* L) {
std::cout << "Lua Version: " << SOL_USE(SOL_LUA_VERSION) << std::endl;
std::cout << "Lua (C++): " << SOL_IS_ON(SOL_USING_CXX_LUA) << std::endl;
std::cout << "Trampoline Propagate Exceptions?: " << SOL_IS_ON(SOL_PROPAGATE_EXCEPTIONS) << std::endl;
std::cout << "Catch-all Exceptions?: " << SOL_IS_ON(SOL_EXCEPTIONS_CATCH_ALL) << std::endl;
std::cout << "LuaJIT: " << SOL_IS_ON(SOL_USE_LUAJIT) << std::endl;
std::cout << "LuaJIT Version: " << SOL_USE(SOL_LUAJIT_VERSION) << std::endl;
std::cout << "LuaJIT (C++): " << SOL_IS_ON(SOL_USING_CXX_LUAJIT) << std::endl;
std::cout << "LuaJIT Exception Trampoline: " << SOL_IS_ON(SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE) << std::endl;
}
}}} // namespace sol::detail::debug }}} // namespace sol::detail::debug
#endif // SOL_DEBUG_HPP #endif // SOL_DEBUG_HPP

8
extern/sol3/sol/demangle.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -28,7 +28,7 @@
#include <string> #include <string>
#include <array> #include <array>
#include <cctype> #include <cctype>
#if SOL_IS_ON(SOL_MINGW_CCTYPE_IS_POISONED_I_) #if SOL_IS_ON(SOL_MINGW_CCTYPE_IS_POISONED)
extern "C" { extern "C" {
#include <ctype.h> #include <ctype.h>
} }
@ -47,7 +47,7 @@ namespace sol { namespace detail {
"`anonymous namespace'" } }; "`anonymous namespace'" } };
#if SOL_IS_ON(SOL_COMPILER_GCC_I_) || SOL_IS_ON(SOL_COMPILER_CLANG_I_) #if SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
inline std::string ctti_get_type_name_from_sig(std::string name) { inline std::string ctti_get_type_name_from_sig(std::string name) {
// cardinal sins from MINGW // cardinal sins from MINGW
using namespace std; using namespace std;
@ -85,7 +85,7 @@ namespace sol { namespace detail {
inline std::string ctti_get_type_name() { inline std::string ctti_get_type_name() {
return ctti_get_type_name_from_sig(__PRETTY_FUNCTION__); return ctti_get_type_name_from_sig(__PRETTY_FUNCTION__);
} }
#elif SOL_IS_ON(SOL_COMPILER_VCXX_I_) #elif SOL_IS_ON(SOL_COMPILER_VCXX)
inline std::string ctti_get_type_name_from_sig(std::string name) { inline std::string ctti_get_type_name_from_sig(std::string name) {
std::size_t start = name.find("get_type_name"); std::size_t start = name.find("get_type_name");
if (start == std::string::npos) if (start == std::string::npos)

2
extern/sol3/sol/deprecate.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in

64
extern/sol3/sol/detail/build_version.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -36,7 +36,7 @@
#else #else
#define SOL_DLL_I_ SOL_OFF #define SOL_DLL_I_ SOL_OFF
#endif #endif
#elif SOL_IS_ON(SOL_COMPILER_VCXX_I_) && (defined(DLL_) || defined(_DLL)) #elif SOL_IS_ON(SOL_COMPILER_VCXX) && (defined(DLL_) || defined(_DLL))
#define SOL_DLL_I_ SOL_DEFAULT_ON #define SOL_DLL_I_ SOL_DEFAULT_ON
#else #else
#define SOL_DLL_I_ SOL_DEFAULT_OFF #define SOL_DLL_I_ SOL_DEFAULT_OFF
@ -58,7 +58,7 @@
#else #else
#define SOL_BUILD_I_ SOL_OFF #define SOL_BUILD_I_ SOL_OFF
#endif #endif
#elif SOL_IS_ON(SOL_HEADER_ONLY_I_) #elif SOL_IS_ON(SOL_HEADER_ONLY)
#define SOL_BUILD_I_ SOL_DEFAULT_OFF #define SOL_BUILD_I_ SOL_DEFAULT_OFF
#else #else
#define SOL_BUILD_I_ SOL_DEFAULT_ON #define SOL_BUILD_I_ SOL_DEFAULT_ON
@ -77,7 +77,7 @@
#if defined(SOL_C_FUNCTION_LINKAGE) #if defined(SOL_C_FUNCTION_LINKAGE)
#define SOL_C_FUNCTION_LINKAGE_I_ SOL_C_FUNCTION_LINKAGE #define SOL_C_FUNCTION_LINKAGE_I_ SOL_C_FUNCTION_LINKAGE
#else #else
#if SOL_IS_ON(SOL_BUILD_CXX_MODE_I_) #if SOL_IS_ON(SOL_BUILD_CXX_MODE)
// C++ // C++
#define SOL_C_FUNCTION_LINKAGE_I_ extern "C" #define SOL_C_FUNCTION_LINKAGE_I_ extern "C"
#else #else
@ -89,12 +89,12 @@
#if defined(SOL_API_LINKAGE) #if defined(SOL_API_LINKAGE)
#define SOL_API_LINKAGE_I_ SOL_API_LINKAGE #define SOL_API_LINKAGE_I_ SOL_API_LINKAGE
#else #else
#if SOL_IS_ON(SOL_DLL_I_) #if SOL_IS_ON(SOL_DLL)
#if SOL_IS_ON(SOL_COMPILER_VCXX_I_) || SOL_IS_ON(SOL_PLATFORM_WINDOWS_I_) || SOL_IS_ON(SOL_PLATFORM_CYGWIN_I_) #if SOL_IS_ON(SOL_COMPILER_VCXX) || SOL_IS_ON(SOL_PLATFORM_WINDOWS) || SOL_IS_ON(SOL_PLATFORM_CYGWIN)
// MSVC Compiler; or, Windows, or Cygwin platforms // MSVC Compiler; or, Windows, or Cygwin platforms
#if SOL_IS_ON(SOL_BUILD_I_) #if SOL_IS_ON(SOL_BUILD)
// Building the library // Building the library
#if SOL_IS_ON(SOL_COMPILER_GCC_I_) #if SOL_IS_ON(SOL_COMPILER_GCC)
// Using GCC // Using GCC
#define SOL_API_LINKAGE_I_ __attribute__((dllexport)) #define SOL_API_LINKAGE_I_ __attribute__((dllexport))
#else #else
@ -102,7 +102,7 @@
#define SOL_API_LINKAGE_I_ __declspec(dllexport) #define SOL_API_LINKAGE_I_ __declspec(dllexport)
#endif #endif
#else #else
#if SOL_IS_ON(SOL_COMPILER_GCC_I_) #if SOL_IS_ON(SOL_COMPILER_GCC)
#define SOL_API_LINKAGE_I_ __attribute__((dllimport)) #define SOL_API_LINKAGE_I_ __attribute__((dllimport))
#else #else
#define SOL_API_LINKAGE_I_ __declspec(dllimport) #define SOL_API_LINKAGE_I_ __declspec(dllimport)
@ -112,9 +112,9 @@
// extern if building normally on non-MSVC // extern if building normally on non-MSVC
#define SOL_API_LINKAGE_I_ extern #define SOL_API_LINKAGE_I_ extern
#endif #endif
#elif SOL_IS_ON(SOL_UNITY_BUILD_I_) #elif SOL_IS_ON(SOL_UNITY_BUILD)
// Built-in library, like how stb typical works // Built-in library, like how stb typical works
#if SOL_IS_ON(SOL_HEADER_ONLY_I_) #if SOL_IS_ON(SOL_HEADER_ONLY)
// Header only, so functions are defined "inline" // Header only, so functions are defined "inline"
#define SOL_API_LINKAGE_I_ inline #define SOL_API_LINKAGE_I_ inline
#else #else
@ -123,7 +123,7 @@
#endif #endif
#else #else
// Normal static library // Normal static library
#if SOL_IS_ON(SOL_BUILD_CXX_MODE_I_) #if SOL_IS_ON(SOL_BUILD_CXX_MODE)
#define SOL_API_LINKAGE_I_ #define SOL_API_LINKAGE_I_
#else #else
#define SOL_API_LINKAGE_I_ extern #define SOL_API_LINKAGE_I_ extern
@ -157,16 +157,16 @@
#if defined(SOL_FUNC_DECL) #if defined(SOL_FUNC_DECL)
#define SOL_FUNC_DECL_I_ SOL_FUNC_DECL #define SOL_FUNC_DECL_I_ SOL_FUNC_DECL
#elif SOL_IS_ON(SOL_HEADER_ONLY_I_) #elif SOL_IS_ON(SOL_HEADER_ONLY)
#define SOL_FUNC_DECL_I_ #define SOL_FUNC_DECL_I_
#elif SOL_IS_ON(SOL_DLL_I_) #elif SOL_IS_ON(SOL_DLL)
#if SOL_IS_ON(SOL_COMPILER_VCXX_I_) #if SOL_IS_ON(SOL_COMPILER_VCXX)
#if SOL_IS_ON(SOL_BUILD_I_) #if SOL_IS_ON(SOL_BUILD)
#define SOL_FUNC_DECL_I_ extern __declspec(dllexport) #define SOL_FUNC_DECL_I_ extern __declspec(dllexport)
#else #else
#define SOL_FUNC_DECL_I_ extern __declspec(dllimport) #define SOL_FUNC_DECL_I_ extern __declspec(dllimport)
#endif #endif
#elif SOL_IS_ON(SOL_COMPILER_GCC_I_) || SOL_IS_ON(SOL_COMPILER_CLANG_I_) #elif SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
#define SOL_FUNC_DECL_I_ extern __attribute__((visibility("default"))) #define SOL_FUNC_DECL_I_ extern __attribute__((visibility("default")))
#else #else
#define SOL_FUNC_DECL_I_ extern #define SOL_FUNC_DECL_I_ extern
@ -175,16 +175,16 @@
#if defined(SOL_FUNC_DEFN) #if defined(SOL_FUNC_DEFN)
#define SOL_FUNC_DEFN_I_ SOL_FUNC_DEFN #define SOL_FUNC_DEFN_I_ SOL_FUNC_DEFN
#elif SOL_IS_ON(SOL_HEADER_ONLY_I_) #elif SOL_IS_ON(SOL_HEADER_ONLY)
#define SOL_FUNC_DEFN_I_ inline #define SOL_FUNC_DEFN_I_ inline
#elif SOL_IS_ON(SOL_DLL_I_) #elif SOL_IS_ON(SOL_DLL)
#if SOL_IS_ON(SOL_COMPILER_VCXX_I_) #if SOL_IS_ON(SOL_COMPILER_VCXX)
#if SOL_IS_ON(SOL_BUILD_I_) #if SOL_IS_ON(SOL_BUILD)
#define SOL_FUNC_DEFN_I_ __declspec(dllexport) #define SOL_FUNC_DEFN_I_ __declspec(dllexport)
#else #else
#define SOL_FUNC_DEFN_I_ __declspec(dllimport) #define SOL_FUNC_DEFN_I_ __declspec(dllimport)
#endif #endif
#elif SOL_IS_ON(SOL_COMPILER_GCC_I_) || SOL_IS_ON(SOL_COMPILER_CLANG_I_) #elif SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
#define SOL_FUNC_DEFN_I_ __attribute__((visibility("default"))) #define SOL_FUNC_DEFN_I_ __attribute__((visibility("default")))
#else #else
#define SOL_FUNC_DEFN_I_ #define SOL_FUNC_DEFN_I_
@ -193,16 +193,16 @@
#if defined(SOL_HIDDEN_FUNC_DECL) #if defined(SOL_HIDDEN_FUNC_DECL)
#define SOL_HIDDEN_FUNC_DECL_I_ SOL_HIDDEN_FUNC_DECL #define SOL_HIDDEN_FUNC_DECL_I_ SOL_HIDDEN_FUNC_DECL
#elif SOL_IS_ON(SOL_HEADER_ONLY_I_) #elif SOL_IS_ON(SOL_HEADER_ONLY)
#define SOL_HIDDEN_FUNC_DECL_I_ #define SOL_HIDDEN_FUNC_DECL_I_
#elif SOL_IS_ON(SOL_DLL_I_) #elif SOL_IS_ON(SOL_DLL)
#if SOL_IS_ON(SOL_COMPILER_VCXX_I_) #if SOL_IS_ON(SOL_COMPILER_VCXX)
#if SOL_IS_ON(SOL_BUILD_I_) #if SOL_IS_ON(SOL_BUILD)
#define SOL_HIDDEN_FUNC_DECL_I_ extern __declspec(dllexport) #define SOL_HIDDEN_FUNC_DECL_I_ extern __declspec(dllexport)
#else #else
#define SOL_HIDDEN_FUNC_DECL_I_ extern __declspec(dllimport) #define SOL_HIDDEN_FUNC_DECL_I_ extern __declspec(dllimport)
#endif #endif
#elif SOL_IS_ON(SOL_COMPILER_GCC_I_) || SOL_IS_ON(SOL_COMPILER_CLANG_I_) #elif SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
#define SOL_HIDDEN_FUNC_DECL_I_ extern __attribute__((visibility("default"))) #define SOL_HIDDEN_FUNC_DECL_I_ extern __attribute__((visibility("default")))
#else #else
#define SOL_HIDDEN_FUNC_DECL_I_ extern #define SOL_HIDDEN_FUNC_DECL_I_ extern
@ -211,16 +211,16 @@
#if defined(SOL_HIDDEN_FUNC_DEFN) #if defined(SOL_HIDDEN_FUNC_DEFN)
#define SOL_HIDDEN_FUNC_DEFN_I_ SOL_HIDDEN_FUNC_DEFN #define SOL_HIDDEN_FUNC_DEFN_I_ SOL_HIDDEN_FUNC_DEFN
#elif SOL_IS_ON(SOL_HEADER_ONLY_I_) #elif SOL_IS_ON(SOL_HEADER_ONLY)
#define SOL_HIDDEN_FUNC_DEFN_I_ inline #define SOL_HIDDEN_FUNC_DEFN_I_ inline
#elif SOL_IS_ON(SOL_DLL_I_) #elif SOL_IS_ON(SOL_DLL)
#if SOL_IS_ON(SOL_COMPILER_VCXX_I_) #if SOL_IS_ON(SOL_COMPILER_VCXX)
#if SOL_IS_ON(SOL_BUILD_I_) #if SOL_IS_ON(SOL_BUILD)
#define SOL_HIDDEN_FUNC_DEFN_I_ #define SOL_HIDDEN_FUNC_DEFN_I_
#else #else
#define SOL_HIDDEN_FUNC_DEFN_I_ #define SOL_HIDDEN_FUNC_DEFN_I_
#endif #endif
#elif SOL_IS_ON(SOL_COMPILER_GCC_I_) || SOL_IS_ON(SOL_COMPILER_CLANG_I_) #elif SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
#define SOL_HIDDEN_FUNC_DEFN_I_ __attribute__((visibility("hidden"))) #define SOL_HIDDEN_FUNC_DEFN_I_ __attribute__((visibility("hidden")))
#else #else
#define SOL_HIDDEN_FUNC_DEFN_I_ #define SOL_HIDDEN_FUNC_DEFN_I_

4
extern/sol3/sol/dump_handler.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -61,7 +61,7 @@ namespace sol {
} }
inline int dump_throw_on_error(lua_State* L_, int result_code, lua_Writer writer_function, void* userdata_pointer_, bool strip) { inline int dump_throw_on_error(lua_State* L_, int result_code, lua_Writer writer_function, void* userdata_pointer_, bool strip) {
#if SOL_IS_OFF(SOL_EXCEPTIONS_I_) #if SOL_IS_OFF(SOL_EXCEPTIONS)
return dump_panic_on_error(L_, result_code, writer_function, userdata_pointer_, strip); return dump_panic_on_error(L_, result_code, writer_function, userdata_pointer_, strip);
#else #else
(void)L_; (void)L_;

3
extern/sol3/sol/ebco.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -26,6 +26,7 @@
#include <type_traits> #include <type_traits>
#include <utility> #include <utility>
#include <memory>
namespace sol { namespace detail { namespace sol { namespace detail {

23
extern/sol3/sol/environment.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -58,29 +58,29 @@ namespace sol {
basic_environment(env_key_t, const stack_reference& extraction_target) basic_environment(env_key_t, const stack_reference& extraction_target)
: base_t(detail::no_safety, extraction_target.lua_state(), (stack::push_environment_of(extraction_target), -1)) { : base_t(detail::no_safety, extraction_target.lua_state(), (stack::push_environment_of(extraction_target), -1)) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
constructor_handler handler {}; constructor_handler handler {};
stack::check<env_key_t>(this->lua_state(), -1, handler); stack::check<env_key_t>(this->lua_state(), -1, handler);
#endif // Safety #endif // Safety
lua_pop(this->lua_state(), 2); lua_pop(this->lua_state(), 1);
} }
template <bool b> template <bool b>
basic_environment(env_key_t, const basic_reference<b>& extraction_target) basic_environment(env_key_t, const basic_reference<b>& extraction_target)
: base_t(detail::no_safety, extraction_target.lua_state(), (stack::push_environment_of(extraction_target), -1)) { : base_t(detail::no_safety, extraction_target.lua_state(), (stack::push_environment_of(extraction_target), -1)) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
constructor_handler handler {}; constructor_handler handler {};
stack::check<env_key_t>(this->lua_state(), -1, handler); stack::check<env_key_t>(this->lua_state(), -1, handler);
#endif // Safety #endif // Safety
lua_pop(this->lua_state(), 2); lua_pop(this->lua_state(), 1);
} }
basic_environment(lua_State* L, int index = -1) : base_t(detail::no_safety, L, index) { basic_environment(lua_State* L, int index = -1) : base_t(detail::no_safety, L, index) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
constructor_handler handler {}; constructor_handler handler {};
stack::check<basic_environment>(L, index, handler); stack::check<basic_environment>(L, index, handler);
#endif // Safety #endif // Safety
} }
basic_environment(lua_State* L, ref_index index) : base_t(detail::no_safety, L, index) { basic_environment(lua_State* L, ref_index index) : base_t(detail::no_safety, L, index) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
auto pp = stack::push_pop(*this); auto pp = stack::push_pop(*this);
constructor_handler handler {}; constructor_handler handler {};
stack::check<basic_environment>(L, -1, handler); stack::check<basic_environment>(L, -1, handler);
@ -90,7 +90,7 @@ namespace sol {
meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_environment>>, meta::neg<std::is_same<base_type, stack_reference>>, meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_environment>>, meta::neg<std::is_same<base_type, stack_reference>>,
meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler> meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
basic_environment(T&& r) noexcept : base_t(detail::no_safety, std::forward<T>(r)) { basic_environment(T&& r) noexcept : base_t(detail::no_safety, std::forward<T>(r)) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
if (!is_environment<meta::unqualified_t<T>>::value) { if (!is_environment<meta::unqualified_t<T>>::value) {
auto pp = stack::push_pop(*this); auto pp = stack::push_pop(*this);
constructor_handler handler {}; constructor_handler handler {};
@ -103,7 +103,7 @@ namespace sol {
template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler> template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
basic_environment(lua_State* L, T&& r) noexcept : base_t(detail::no_safety, L, std::forward<T>(r)) { basic_environment(lua_State* L, T&& r) noexcept : base_t(detail::no_safety, L, std::forward<T>(r)) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
if (!is_environment<meta::unqualified_t<T>>::value) { if (!is_environment<meta::unqualified_t<T>>::value) {
auto pp = stack::push_pop(*this); auto pp = stack::push_pop(*this);
constructor_handler handler {}; constructor_handler handler {};
@ -136,11 +136,13 @@ namespace sol {
const char* success = lua_setupvalue(L, target_index, 1); const char* success = lua_setupvalue(L, target_index, 1);
if (success == nullptr) { if (success == nullptr) {
// left things alone on the stack, pop them off // left things alone on the stack, pop them off
lua_pop(L, 1); lua_pop(L, 2);
return false; return false;
} }
lua_pop(L, 1);
return true; return true;
} }
lua_pop(L, 1);
return false; return false;
} }
else { else {
@ -152,6 +154,7 @@ namespace sol {
} }
string_view upvalue_name(maybe_upvalue_name); string_view upvalue_name(maybe_upvalue_name);
if (upvalue_name == "_ENV") { if (upvalue_name == "_ENV") {
lua_pop(L, 1);
this->push(); this->push();
const char* success = lua_setupvalue(L, target_index, upvalue_index); const char* success = lua_setupvalue(L, target_index, upvalue_index);
if (success == nullptr) { if (success == nullptr) {

4
extern/sol3/sol/epilogue.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -31,7 +31,7 @@
#undef SOL_PROLOGUE_I_ #undef SOL_PROLOGUE_I_
#endif #endif
#if SOL_IS_ON(SOL_BUILD_CXX_MODE_I_) #if SOL_IS_ON(SOL_BUILD_CXX_MODE)
#undef _FWD #undef _FWD
#undef _MOVE #undef _MOVE
#endif #endif

27
extern/sol3/sol/error.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -57,6 +57,23 @@ namespace sol {
} }
return luaL_error(L, er.format_string, er.argument_strings[0], er.argument_strings[1], er.argument_strings[2], er.argument_strings[3]); return luaL_error(L, er.format_string, er.argument_strings[0], er.argument_strings[1], er.argument_strings[2], er.argument_strings[3]);
} }
class error_exception : public std::runtime_error {
public:
error_exception(const std::string& str) : error_exception(detail::direct_error, "lua: error: " + str) {
}
error_exception(std::string&& str) : error_exception(detail::direct_error, "lua: error: " + std::move(str)) {
}
error_exception(detail::direct_error_tag, const std::string& str) : std::runtime_error(str) {
}
error_exception(detail::direct_error_tag, std::string&& str) : std::runtime_error(str) {
}
error_exception(const error_exception& e) = default;
error_exception(error_exception&& e) = default;
error_exception& operator=(const error_exception& e) = default;
error_exception& operator=(error_exception&& e) = default;
};
} // namespace detail } // namespace detail
class error : public std::runtime_error { class error : public std::runtime_error {
@ -69,19 +86,15 @@ namespace sol {
} }
error(std::string&& str) : error(detail::direct_error, "lua: error: " + std::move(str)) { error(std::string&& str) : error(detail::direct_error, "lua: error: " + std::move(str)) {
} }
error(detail::direct_error_tag, const std::string& str) : std::runtime_error(""), what_reason(str) { error(detail::direct_error_tag, const std::string& str) : std::runtime_error(str) {
} }
error(detail::direct_error_tag, std::string&& str) : std::runtime_error(""), what_reason(std::move(str)) { error(detail::direct_error_tag, std::string&& str) : std::runtime_error(str) {
} }
error(const error& e) = default; error(const error& e) = default;
error(error&& e) = default; error(error&& e) = default;
error& operator=(const error& e) = default; error& operator=(const error& e) = default;
error& operator=(error&& e) = default; error& operator=(error&& e) = default;
virtual const char* what() const noexcept override {
return what_reason.c_str();
}
}; };
} // namespace sol } // namespace sol

27
extern/sol3/sol/error_handler.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -24,6 +24,7 @@
#ifndef SOL_ERROR_HANDLER_HPP #ifndef SOL_ERROR_HANDLER_HPP
#define SOL_ERROR_HANDLER_HPP #define SOL_ERROR_HANDLER_HPP
#include <sol/config.hpp>
#include <sol/types.hpp> #include <sol/types.hpp>
#include <sol/demangle.hpp> #include <sol/demangle.hpp>
@ -62,7 +63,7 @@ namespace sol {
case type::poly: case type::poly:
return "anything"; return "anything";
case type::userdata: { case type::userdata: {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 2, "not enough space to push get the type name"); luaL_checkstack(L, 2, "not enough space to push get the type name");
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
if (lua_getmetatable(L, index) == 0) { if (lua_getmetatable(L, index) == 0) {
@ -84,7 +85,7 @@ namespace sol {
inline int push_type_panic_string(lua_State* L, int index, type expected, type actual, string_view message, string_view aux_message) noexcept { inline int push_type_panic_string(lua_State* L, int index, type expected, type actual, string_view message, string_view aux_message) noexcept {
const char* err = message.size() == 0 const char* err = message.size() == 0
? (aux_message.size() == 0 ? "stack index %d, expected %s, received %s" : "stack index %d, expected %s, received %s: %s") ? (aux_message.size() == 0 ? "stack index %d, expected %s, received %s" : "stack index %d, expected %s, received %s: %s%s")
: "stack index %d, expected %s, received %s: %s %s"; : "stack index %d, expected %s, received %s: %s %s";
const char* type_name = expected == type::poly ? "anything" : lua_typename(L, static_cast<int>(expected)); const char* type_name = expected == type::poly ? "anything" : lua_typename(L, static_cast<int>(expected));
{ {
@ -96,12 +97,16 @@ namespace sol {
inline int type_panic_string(lua_State* L, int index, type expected, type actual, string_view message = "") noexcept(false) { inline int type_panic_string(lua_State* L, int index, type expected, type actual, string_view message = "") noexcept(false) {
push_type_panic_string(L, index, expected, actual, message, ""); push_type_panic_string(L, index, expected, actual, message, "");
return lua_error(L); size_t str_size = 0;
const char* str = lua_tolstring(L, -1, &str_size);
return luaL_error(L, str);
} }
inline int type_panic_c_str(lua_State* L, int index, type expected, type actual, const char* message = nullptr) noexcept(false) { inline int type_panic_c_str(lua_State* L, int index, type expected, type actual, const char* message = nullptr) noexcept(false) {
push_type_panic_string(L, index, expected, actual, message == nullptr ? "" : message, ""); push_type_panic_string(L, index, expected, actual, message == nullptr ? "" : message, "");
return lua_error(L); size_t str_size = 0;
const char* str = lua_tolstring(L, -1, &str_size);
return luaL_error(L, str);
} }
struct type_panic_t { struct type_panic_t {
@ -118,7 +123,9 @@ namespace sol {
struct constructor_handler { struct constructor_handler {
int operator()(lua_State* L, int index, type expected, type actual, string_view message) const noexcept(false) { int operator()(lua_State* L, int index, type expected, type actual, string_view message) const noexcept(false) {
push_type_panic_string(L, index, expected, actual, message, "(type check failed in constructor)"); push_type_panic_string(L, index, expected, actual, message, "(type check failed in constructor)");
return lua_error(L); size_t str_size = 0;
const char* str = lua_tolstring(L, -1, &str_size);
return luaL_error(L, str);
} }
}; };
@ -126,7 +133,9 @@ namespace sol {
struct argument_handler { struct argument_handler {
int operator()(lua_State* L, int index, type expected, type actual, string_view message) const noexcept(false) { int operator()(lua_State* L, int index, type expected, type actual, string_view message) const noexcept(false) {
push_type_panic_string(L, index, expected, actual, message, "(bad argument to variable or function call)"); push_type_panic_string(L, index, expected, actual, message, "(bad argument to variable or function call)");
return lua_error(L); size_t str_size = 0;
const char* str = lua_tolstring(L, -1, &str_size);
return luaL_error(L, str);
} }
}; };
@ -142,7 +151,9 @@ namespace sol {
aux_message += ")')"; aux_message += ")')";
push_type_panic_string(L, index, expected, actual, message, aux_message); push_type_panic_string(L, index, expected, actual, message, aux_message);
} }
return lua_error(L); size_t str_size = 0;
const char* str = lua_tolstring(L, -1, &str_size);
return luaL_error(L, str);
} }
}; };

14
extern/sol3/sol/forward.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -30,7 +30,7 @@
#include <type_traits> #include <type_traits>
#include <string_view> #include <string_view>
#if SOL_IS_ON(SOL_USE_CXX_LUA_I_) || SOL_IS_ON(SOL_USE_CXX_LUAJIT_I_) #if SOL_IS_ON(SOL_USING_CXX_LUA) || SOL_IS_ON(SOL_USING_CXX_LUAJIT)
struct lua_State; struct lua_State;
#else #else
extern "C" { extern "C" {
@ -117,7 +117,7 @@ namespace sol {
using main_protected_function = main_safe_function; using main_protected_function = main_safe_function;
using stack_protected_function = stack_safe_function; using stack_protected_function = stack_safe_function;
using stack_aligned_protected_function = stack_aligned_safe_function; using stack_aligned_protected_function = stack_aligned_safe_function;
#if SOL_IS_ON(SOL_SAFE_FUNCTION_OBJECTS_I_) #if SOL_IS_ON(SOL_SAFE_FUNCTION_OBJECTS)
using function = protected_function; using function = protected_function;
using main_function = main_protected_function; using main_function = main_protected_function;
using stack_function = stack_protected_function; using stack_function = stack_protected_function;
@ -133,7 +133,7 @@ namespace sol {
struct unsafe_function_result; struct unsafe_function_result;
struct protected_function_result; struct protected_function_result;
using safe_function_result = protected_function_result; using safe_function_result = protected_function_result;
#if SOL_IS_ON(SOL_SAFE_FUNCTION_OBJECTS_I_) #if SOL_IS_ON(SOL_SAFE_FUNCTION_OBJECTS)
using function_result = safe_function_result; using function_result = safe_function_result;
#else #else
using function_result = unsafe_function_result; using function_result = unsafe_function_result;
@ -234,7 +234,7 @@ namespace sol {
struct record; struct record;
} }
#if SOL_IS_OFF(SOL_USE_BOOST_I_) #if SOL_IS_OFF(SOL_USE_BOOST)
template <class T> template <class T>
class optional; class optional;
@ -253,7 +253,7 @@ namespace sol {
typedef ::sol::types<__VA_ARGS__> type; \ typedef ::sol::types<__VA_ARGS__> type; \
}; \ }; \
} \ } \
void a_sol3_detail_function_decl_please_no_collide() static_assert(true, "")
#define SOL_DERIVED_CLASSES(T, ...) \ #define SOL_DERIVED_CLASSES(T, ...) \
namespace sol { \ namespace sol { \
template <> \ template <> \
@ -261,6 +261,6 @@ namespace sol {
typedef ::sol::types<__VA_ARGS__> type; \ typedef ::sol::types<__VA_ARGS__> type; \
}; \ }; \
} \ } \
void a_sol3_detail_function_decl_please_no_collide() static_assert(true, "")
#endif // SOL_FORWARD_HPP #endif // SOL_FORWARD_HPP

44
extern/sol3/sol/forward_as.hpp vendored Normal file
View file

@ -0,0 +1,44 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in
// the Software without restriction, including without limitation the rights to
// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
// the Software, and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#ifndef SOL_FORWARD_AS_HPP
#define SOL_FORWARD_AS_HPP
#include <sol/version.hpp>
#include <utility>
#include <type_traits>
namespace sol {
template <typename T, typename U>
constexpr decltype(auto) forward_as(U&& value) noexcept {
if constexpr (::std::is_lvalue_reference_v<T>) {
return value;
}
else {
return ::std::move(value);
}
}
}
#endif // SOL_FORWARD_AS_HPP

4
extern/sol3/sol/forward_detail.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -32,7 +32,7 @@
namespace sol { namespace sol {
namespace detail { namespace detail {
const bool default_safe_function_calls = const bool default_safe_function_calls =
#if SOL_IS_ON(SOL_SAFE_FUNCTION_CALLS_I_) #if SOL_IS_ON(SOL_SAFE_FUNCTION_CALLS)
true; true;
#else #else
false; false;

2
extern/sol3/sol/function.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in

2
extern/sol3/sol/function_result.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in

14
extern/sol3/sol/function_types.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -217,7 +217,7 @@ namespace sol {
int upvalues = 0; int upvalues = 0;
upvalues += stack::push(L, nullptr); upvalues += stack::push(L, nullptr);
upvalues += stack::push(L, std::forward<Fx>(fx)); upvalues += stack::push(L, std::forward<Fx>(fx));
#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_) #if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
if constexpr (std::is_nothrow_invocable_r_v<int, uFx, lua_State*>) { if constexpr (std::is_nothrow_invocable_r_v<int, uFx, lua_State*>) {
detail::lua_CFunction_noexcept cf = &lua_c_noexcept_wrapper<true>; detail::lua_CFunction_noexcept cf = &lua_c_noexcept_wrapper<true>;
lua_pushcclosure(L, reinterpret_cast<lua_CFunction>(cf), upvalues); lua_pushcclosure(L, reinterpret_cast<lua_CFunction>(cf), upvalues);
@ -237,7 +237,7 @@ namespace sol {
int upvalues = 0; int upvalues = 0;
upvalues += stack::push(L, nullptr); upvalues += stack::push(L, nullptr);
upvalues += stack::push(L, std::forward<Fx>(fx)); upvalues += stack::push(L, std::forward<Fx>(fx));
#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_) #if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
if constexpr (std::is_nothrow_invocable_r_v<int, uFx, lua_State*>) { if constexpr (std::is_nothrow_invocable_r_v<int, uFx, lua_State*>) {
detail::lua_CFunction_noexcept cf = &lua_c_noexcept_wrapper<is_yielding>; detail::lua_CFunction_noexcept cf = &lua_c_noexcept_wrapper<is_yielding>;
lua_pushcclosure(L, reinterpret_cast<lua_CFunction>(cf), upvalues); lua_pushcclosure(L, reinterpret_cast<lua_CFunction>(cf), upvalues);
@ -398,7 +398,7 @@ namespace sol {
struct unqualified_pusher<Signature, struct unqualified_pusher<Signature,
std::enable_if_t<meta::all<std::is_function<std::remove_pointer_t<Signature>>, meta::neg<std::is_same<Signature, lua_CFunction>>, std::enable_if_t<meta::all<std::is_function<std::remove_pointer_t<Signature>>, meta::neg<std::is_same<Signature, lua_CFunction>>,
meta::neg<std::is_same<Signature, std::remove_pointer_t<lua_CFunction>>> meta::neg<std::is_same<Signature, std::remove_pointer_t<lua_CFunction>>>
#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_) #if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
, ,
meta::neg<std::is_same<Signature, detail::lua_CFunction_noexcept>>, meta::neg<std::is_same<Signature, detail::lua_CFunction_noexcept>>,
meta::neg<std::is_same<Signature, std::remove_pointer_t<detail::lua_CFunction_noexcept>>> meta::neg<std::is_same<Signature, std::remove_pointer_t<detail::lua_CFunction_noexcept>>>
@ -711,7 +711,7 @@ namespace sol {
namespace stack_detail { namespace stack_detail {
template <typename Function, typename Handler> template <typename Function, typename Handler>
bool check_function_pointer(lua_State* L, int index, Handler&& handler, record& tracking) noexcept { bool check_function_pointer(lua_State* L, int index, Handler&& handler, record& tracking) noexcept {
#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE_I_) #if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE)
tracking.use(1); tracking.use(1);
bool success = lua_iscfunction(L, index) == 1; bool success = lua_iscfunction(L, index) == 1;
if (success) { if (success) {
@ -737,7 +737,7 @@ namespace sol {
template <typename Function> template <typename Function>
Function* get_function_pointer(lua_State* L, int index, record& tracking) noexcept { Function* get_function_pointer(lua_State* L, int index, record& tracking) noexcept {
#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE_I_) #if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE)
tracking.use(1); tracking.use(1);
auto udata = stack::stack_detail::get_as_upvalues_using_function<Function*>(L, index); auto udata = stack::stack_detail::get_as_upvalues_using_function<Function*>(L, index);
Function* fx = udata.first; Function* fx = udata.first;
@ -747,7 +747,7 @@ namespace sol {
(void)index; (void)index;
(void)tracking; (void)tracking;
static_assert(meta::meta_detail::always_true<Function>::value, static_assert(meta::meta_detail::always_true<Function>::value,
#if SOL_IS_DEFAULT_OFF(SOL_GET_FUNCTION_POINTER_UNSAFE_I_) #if SOL_IS_DEFAULT_OFF(SOL_GET_FUNCTION_POINTER_UNSAFE)
"You are attempting to retrieve a function pointer type. " "You are attempting to retrieve a function pointer type. "
"This is inherently unsafe in sol2. In order to do this, you must turn on the " "This is inherently unsafe in sol2. In order to do this, you must turn on the "
"SOL_GET_FUNCTION_POINTER_UNSAFE configuration macro, as detailed in the documentation. " "SOL_GET_FUNCTION_POINTER_UNSAFE configuration macro, as detailed in the documentation. "

2
extern/sol3/sol/function_types_core.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in

4
extern/sol3/sol/function_types_overloaded.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -62,4 +62,4 @@ namespace sol { namespace function_detail {
}; };
}} // namespace sol::function_detail }} // namespace sol::function_detail
#endif // SOL_FUNCTION_TYPES_OVERLOAD_HPP #endif // SOL_FUNCTION_TYPES_OVERLOAD_HPP

6
extern/sol3/sol/function_types_stateful.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -74,7 +74,7 @@ namespace sol { namespace function_detail {
} }
static int call(lua_State* L, member_function& self) static int call(lua_State* L, member_function& self)
#if SOL_IS_ON(SOL_COMPILER_VCXX_I_) #if SOL_IS_ON(SOL_COMPILER_VCXX)
// MSVC is broken, what a surprise... // MSVC is broken, what a surprise...
#else #else
noexcept(traits_type::is_noexcept) noexcept(traits_type::is_noexcept)
@ -90,7 +90,7 @@ namespace sol { namespace function_detail {
} }
int operator()(lua_State* L) int operator()(lua_State* L)
#if SOL_IS_ON(SOL_COMPILER_VCXX_I_) #if SOL_IS_ON(SOL_COMPILER_VCXX)
// MSVC is broken, what a surprise... // MSVC is broken, what a surprise...
#else #else
noexcept(traits_type::is_noexcept) noexcept(traits_type::is_noexcept)

28
extern/sol3/sol/function_types_stateless.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -35,7 +35,7 @@ namespace sol { namespace function_detail {
using traits_type = meta::bind_traits<function_type>; using traits_type = meta::bind_traits<function_type>;
static int real_call(lua_State* L) static int real_call(lua_State* L)
#if SOL_IS_ON(SOL_COMPILER_VCXX_I_) #if SOL_IS_ON(SOL_COMPILER_VCXX)
// MSVC is broken, what a surprise... // MSVC is broken, what a surprise...
#else #else
noexcept(traits_type::is_noexcept) noexcept(traits_type::is_noexcept)
@ -70,7 +70,7 @@ namespace sol { namespace function_detail {
typedef lua_bind_traits<function_type> traits_type; typedef lua_bind_traits<function_type> traits_type;
static int real_call(lua_State* L) static int real_call(lua_State* L)
#if SOL_IS_ON(SOL_COMPILER_VCXX_I_) #if SOL_IS_ON(SOL_COMPILER_VCXX)
// MSVC is broken, what a surprise... // MSVC is broken, what a surprise...
#else #else
noexcept(traits_type::is_noexcept) noexcept(traits_type::is_noexcept)
@ -88,7 +88,7 @@ namespace sol { namespace function_detail {
template <bool is_yielding, bool no_trampoline> template <bool is_yielding, bool no_trampoline>
static int call(lua_State* L) static int call(lua_State* L)
#if SOL_IS_ON(SOL_COMPILER_VCXX_I_) #if SOL_IS_ON(SOL_COMPILER_VCXX)
// MSVC is broken, what a surprise... // MSVC is broken, what a surprise...
#else #else
noexcept(traits_type::is_noexcept) noexcept(traits_type::is_noexcept)
@ -110,7 +110,7 @@ namespace sol { namespace function_detail {
} }
int operator()(lua_State* L) int operator()(lua_State* L)
#if SOL_IS_ON(SOL_COMPILER_VCXX_I_) #if SOL_IS_ON(SOL_COMPILER_VCXX)
// MSVC is broken, what a surprise... // MSVC is broken, what a surprise...
#else #else
noexcept(traits_type::is_noexcept) noexcept(traits_type::is_noexcept)
@ -126,7 +126,7 @@ namespace sol { namespace function_detail {
typedef lua_bind_traits<function_type> traits_type; typedef lua_bind_traits<function_type> traits_type;
static int real_call(lua_State* L) static int real_call(lua_State* L)
#if SOL_IS_ON(SOL_COMPILER_VCXX_I_) #if SOL_IS_ON(SOL_COMPILER_VCXX)
// MSVC is broken, what a surprise... // MSVC is broken, what a surprise...
#else #else
noexcept(traits_type::is_noexcept) noexcept(traits_type::is_noexcept)
@ -153,7 +153,7 @@ namespace sol { namespace function_detail {
template <bool is_yielding, bool no_trampoline> template <bool is_yielding, bool no_trampoline>
static int call(lua_State* L) static int call(lua_State* L)
#if SOL_IS_ON(SOL_COMPILER_VCXX_I_) #if SOL_IS_ON(SOL_COMPILER_VCXX)
// MSVC is broken, what a surprise... // MSVC is broken, what a surprise...
#else #else
noexcept(traits_type::is_noexcept) noexcept(traits_type::is_noexcept)
@ -175,7 +175,7 @@ namespace sol { namespace function_detail {
} }
int operator()(lua_State* L) int operator()(lua_State* L)
#if SOL_IS_ON(SOL_COMPILER_VCXX_I_) #if SOL_IS_ON(SOL_COMPILER_VCXX)
// MSVC is broken, what a surprise... // MSVC is broken, what a surprise...
#else #else
noexcept(traits_type::is_noexcept) noexcept(traits_type::is_noexcept)
@ -191,7 +191,7 @@ namespace sol { namespace function_detail {
typedef lua_bind_traits<function_type> traits_type; typedef lua_bind_traits<function_type> traits_type;
static int real_call(lua_State* L) static int real_call(lua_State* L)
#if SOL_IS_ON(SOL_COMPILER_VCXX_I_) #if SOL_IS_ON(SOL_COMPILER_VCXX)
// MSVC is broken, what a surprise... // MSVC is broken, what a surprise...
#else #else
noexcept(traits_type::is_noexcept) noexcept(traits_type::is_noexcept)
@ -216,7 +216,7 @@ namespace sol { namespace function_detail {
template <bool is_yielding, bool no_trampoline> template <bool is_yielding, bool no_trampoline>
static int call(lua_State* L) static int call(lua_State* L)
#if SOL_IS_ON(SOL_COMPILER_VCXX_I_) #if SOL_IS_ON(SOL_COMPILER_VCXX)
// MSVC is broken, what a surprise... // MSVC is broken, what a surprise...
#else #else
noexcept(traits_type::is_noexcept) noexcept(traits_type::is_noexcept)
@ -238,7 +238,7 @@ namespace sol { namespace function_detail {
} }
int operator()(lua_State* L) int operator()(lua_State* L)
#if SOL_IS_ON(SOL_COMPILER_VCXX_I_) #if SOL_IS_ON(SOL_COMPILER_VCXX)
// MSVC is broken, what a surprise... // MSVC is broken, what a surprise...
#else #else
noexcept(traits_type::is_noexcept) noexcept(traits_type::is_noexcept)
@ -254,7 +254,7 @@ namespace sol { namespace function_detail {
typedef lua_bind_traits<function_type> traits_type; typedef lua_bind_traits<function_type> traits_type;
static int real_call(lua_State* L) static int real_call(lua_State* L)
#if SOL_IS_ON(SOL_COMPILER_VCXX_I_) #if SOL_IS_ON(SOL_COMPILER_VCXX)
// MSVC is broken, what a surprise... // MSVC is broken, what a surprise...
#else #else
noexcept(traits_type::is_noexcept) noexcept(traits_type::is_noexcept)
@ -268,7 +268,7 @@ namespace sol { namespace function_detail {
template <bool is_yielding, bool no_trampoline> template <bool is_yielding, bool no_trampoline>
static int call(lua_State* L) static int call(lua_State* L)
#if SOL_IS_ON(SOL_COMPILER_VCXX_I_) #if SOL_IS_ON(SOL_COMPILER_VCXX)
// MSVC is broken, what a surprise... // MSVC is broken, what a surprise...
#else #else
noexcept(traits_type::is_noexcept) noexcept(traits_type::is_noexcept)
@ -290,7 +290,7 @@ namespace sol { namespace function_detail {
} }
int operator()(lua_State* L) int operator()(lua_State* L)
#if SOL_IS_ON(SOL_COMPILER_VCXX_I_) #if SOL_IS_ON(SOL_COMPILER_VCXX)
// MSVC is broken, what a surprise... // MSVC is broken, what a surprise...
#else #else
noexcept(traits_type::is_noexcept) noexcept(traits_type::is_noexcept)

4
extern/sol3/sol/function_types_templated.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -121,7 +121,7 @@ namespace sol {
typedef meta::unqualified_t<F> Fu; typedef meta::unqualified_t<F> Fu;
typedef std::integral_constant<bool, typedef std::integral_constant<bool,
std::is_same<Fu, lua_CFunction>::value std::is_same<Fu, lua_CFunction>::value
#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_) #if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
|| std::is_same<Fu, detail::lua_CFunction_noexcept>::value || std::is_same<Fu, detail::lua_CFunction_noexcept>::value
#endif #endif
> >

2
extern/sol3/sol/in_place.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in

2
extern/sol3/sol/inheritance.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in

16
extern/sol3/sol/load_result.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -39,7 +39,7 @@ namespace sol {
load_status err; load_status err;
public: public:
load_result() noexcept = default; load_result() noexcept : load_result(nullptr) {}
load_result(lua_State* Ls, int stackindex = -1, int retnum = 0, int popnum = 0, load_status lerr = load_status::ok) noexcept load_result(lua_State* Ls, int stackindex = -1, int retnum = 0, int popnum = 0, load_status lerr = load_status::ok) noexcept
: L(Ls), index(stackindex), returncount(retnum), popcount(popnum), err(lerr) { : L(Ls), index(stackindex), returncount(retnum), popcount(popnum), err(lerr) {
} }
@ -95,7 +95,7 @@ namespace sol {
if (valid()) { if (valid()) {
return UT(nullopt); return UT(nullopt);
} }
return error(detail::direct_error, stack::get<std::string>(L, index)); return stack::stack_detail::get_error(L, index);
} }
else { else {
if (!valid()) { if (!valid()) {
@ -106,15 +106,15 @@ namespace sol {
} }
else { else {
if constexpr (std::is_same_v<T, error>) { if constexpr (std::is_same_v<T, error>) {
#if SOL_IS_ON(SOL_SAFE_PROXIES_I_) #if SOL_IS_ON(SOL_SAFE_PROXIES)
if (valid()) { if (valid()) {
type_panic_c_str(L, index, type_of(L, index), type::none, "expecting an error type (a string, from Lua)"); type_panic_c_str(L, index, type_of(L, index), type::none, "expecting an error type (a string, from Lua)");
} }
#endif // Check proxy type's safety #endif // Check proxy type's safety
return error(detail::direct_error, stack::get<std::string>(L, index)); return stack::stack_detail::get_error(L, index);
} }
else { else {
#if SOL_IS_ON(SOL_SAFE_PROXIES_I_) #if SOL_IS_ON(SOL_SAFE_PROXIES)
if (!valid()) { if (!valid()) {
type_panic_c_str(L, index, type_of(L, index), type::none); type_panic_c_str(L, index, type_of(L, index), type::none);
} }
@ -142,7 +142,9 @@ namespace sol {
}; };
~load_result() { ~load_result() {
stack::remove(L, index, popcount); if (L != nullptr) {
stack::remove(L, index, popcount);
}
} }
}; };
} // namespace sol } // namespace sol

10
extern/sol3/sol/lua_table.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -50,7 +50,7 @@ namespace sol {
} }
template <typename T, meta::enable_any<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler> template <typename T, meta::enable_any<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
basic_lua_table(lua_State* L, T&& r) : base_t(L, std::forward<T>(r)) { basic_lua_table(lua_State* L, T&& r) : base_t(L, std::forward<T>(r)) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
auto pp = stack::push_pop(*this); auto pp = stack::push_pop(*this);
constructor_handler handler {}; constructor_handler handler {};
stack::check<basic_lua_table>(lua_state(), -1, handler); stack::check<basic_lua_table>(lua_state(), -1, handler);
@ -62,13 +62,13 @@ namespace sol {
} }
} }
basic_lua_table(lua_State* L, int index = -1) : base_t(detail::no_safety, L, index) { basic_lua_table(lua_State* L, int index = -1) : base_t(detail::no_safety, L, index) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
constructor_handler handler {}; constructor_handler handler {};
stack::check<basic_lua_table>(L, index, handler); stack::check<basic_lua_table>(L, index, handler);
#endif // Safety #endif // Safety
} }
basic_lua_table(lua_State* L, ref_index index) : base_t(detail::no_safety, L, index) { basic_lua_table(lua_State* L, ref_index index) : base_t(detail::no_safety, L, index) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
auto pp = stack::push_pop(*this); auto pp = stack::push_pop(*this);
constructor_handler handler {}; constructor_handler handler {};
stack::check<basic_lua_table>(lua_state(), -1, handler); stack::check<basic_lua_table>(lua_state(), -1, handler);
@ -78,7 +78,7 @@ namespace sol {
meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_lua_table>>, meta::neg<std::is_same<ref_t, stack_reference>>, meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_lua_table>>, meta::neg<std::is_same<ref_t, stack_reference>>,
meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler> meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
basic_lua_table(T&& r) noexcept : basic_lua_table(detail::no_safety, std::forward<T>(r)) { basic_lua_table(T&& r) noexcept : basic_lua_table(detail::no_safety, std::forward<T>(r)) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
if (!is_table<meta::unqualified_t<T>>::value) { if (!is_table<meta::unqualified_t<T>>::value) {
auto pp = stack::push_pop(*this); auto pp = stack::push_pop(*this);
constructor_handler handler {}; constructor_handler handler {};

4
extern/sol3/sol/lua_value.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -48,7 +48,7 @@ namespace sol {
using is_lua_value_single_constructible = meta::any<std::is_same<T, lua_value>, is_reference_or_lua_value_init_list<T>>; using is_lua_value_single_constructible = meta::any<std::is_same<T, lua_value>, is_reference_or_lua_value_init_list<T>>;
static lua_State*& thread_local_lua_state() { static lua_State*& thread_local_lua_state() {
#if SOL_IS_ON(SOL_USE_THREAD_LOCAL_I_) #if SOL_IS_ON(SOL_USE_THREAD_LOCAL)
static thread_local lua_State* L = nullptr; static thread_local lua_State* L = nullptr;
#else #else
static lua_State* L = nullptr; static lua_State* L = nullptr;

2
extern/sol3/sol/make_reference.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in

10
extern/sol3/sol/metatable.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -86,20 +86,20 @@ namespace sol {
} }
template <typename T, meta::enable_any<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler> template <typename T, meta::enable_any<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
basic_metatable(lua_State* L, T&& r) : base_t(L, std::forward<T>(r)) { basic_metatable(lua_State* L, T&& r) : base_t(L, std::forward<T>(r)) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
auto pp = stack::push_pop(*this); auto pp = stack::push_pop(*this);
constructor_handler handler {}; constructor_handler handler {};
stack::check<basic_metatable>(lua_state(), -1, handler); stack::check<basic_metatable>(lua_state(), -1, handler);
#endif // Safety #endif // Safety
} }
basic_metatable(lua_State* L, int index = -1) : basic_metatable(detail::no_safety, L, index) { basic_metatable(lua_State* L, int index = -1) : basic_metatable(detail::no_safety, L, index) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
constructor_handler handler {}; constructor_handler handler {};
stack::check<basic_metatable>(L, index, handler); stack::check<basic_metatable>(L, index, handler);
#endif // Safety #endif // Safety
} }
basic_metatable(lua_State* L, ref_index index) : basic_metatable(detail::no_safety, L, index) { basic_metatable(lua_State* L, ref_index index) : basic_metatable(detail::no_safety, L, index) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
auto pp = stack::push_pop(*this); auto pp = stack::push_pop(*this);
constructor_handler handler {}; constructor_handler handler {};
stack::check<basic_metatable>(lua_state(), -1, handler); stack::check<basic_metatable>(lua_state(), -1, handler);
@ -109,7 +109,7 @@ namespace sol {
meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_metatable>>, meta::neg<std::is_same<base_type, stack_reference>>, meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_metatable>>, meta::neg<std::is_same<base_type, stack_reference>>,
meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler> meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
basic_metatable(T&& r) noexcept : basic_metatable(detail::no_safety, std::forward<T>(r)) { basic_metatable(T&& r) noexcept : basic_metatable(detail::no_safety, std::forward<T>(r)) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
if (!is_table<meta::unqualified_t<T>>::value) { if (!is_table<meta::unqualified_t<T>>::value) {
auto pp = stack::push_pop(*this); auto pp = stack::push_pop(*this);
constructor_handler handler {}; constructor_handler handler {};

2
extern/sol3/sol/object.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in

2
extern/sol3/sol/object_base.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in

12
extern/sol3/sol/optional.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -27,7 +27,7 @@
#include <sol/forward.hpp> #include <sol/forward.hpp>
#include <sol/in_place.hpp> #include <sol/in_place.hpp>
#include <sol/traits.hpp> #include <sol/traits.hpp>
#if SOL_IS_ON(SOL_USE_BOOST_I_) #if SOL_IS_ON(SOL_USE_BOOST)
#include <boost/optional.hpp> #include <boost/optional.hpp>
#else #else
#include <sol/optional_implementation.hpp> #include <sol/optional_implementation.hpp>
@ -38,7 +38,7 @@
namespace sol { namespace sol {
#if SOL_IS_ON(SOL_USE_BOOST_I_) #if SOL_IS_ON(SOL_USE_BOOST)
template <typename T> template <typename T>
using optional = boost::optional<T>; using optional = boost::optional<T>;
using nullopt_t = boost::none_t; using nullopt_t = boost::none_t;
@ -59,14 +59,14 @@ namespace sol {
inline static constexpr std::nullopt_t value = std::nullopt; inline static constexpr std::nullopt_t value = std::nullopt;
}; };
#if SOL_IS_ON(SOL_USE_BOOST_I_) #if SOL_IS_ON(SOL_USE_BOOST)
template <typename T> template <typename T>
struct associated_nullopt<boost::optional<T>> { struct associated_nullopt<boost::optional<T>> {
inline static SOL_BOOST_NONE_CONSTEXPR_I_ boost::none_t value = boost::none; inline static SOL_BOOST_NONE_CONSTEXPR_I_ boost::none_t value = boost::none;
}; };
#endif // Boost nullopt #endif // Boost nullopt
#if SOL_IS_ON(SOL_USE_BOOST_I_) #if SOL_IS_ON(SOL_USE_BOOST)
template <typename T> template <typename T>
inline SOL_BOOST_NONE_CONSTEXPR_I_ auto associated_nullopt_v = associated_nullopt<T>::value; inline SOL_BOOST_NONE_CONSTEXPR_I_ auto associated_nullopt_v = associated_nullopt<T>::value;
#else #else
@ -76,7 +76,7 @@ namespace sol {
} // namespace detail } // namespace detail
} // namespace sol } // namespace sol
#if SOL_IS_ON(SOL_USE_BOOST_I_) #if SOL_IS_ON(SOL_USE_BOOST)
#undef SOL_BOOST_NONE_CONSTEXPR_I_ #undef SOL_BOOST_NONE_CONSTEXPR_I_
#endif #endif

14
extern/sol3/sol/optional_implementation.hpp vendored
View file

@ -1,6 +1,6 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -1375,7 +1375,7 @@ namespace sol {
SOL_TL_OPTIONAL_11_CONSTEXPR T& value() & { SOL_TL_OPTIONAL_11_CONSTEXPR T& value() & {
if (has_value()) if (has_value())
return this->m_value; return this->m_value;
#if SOL_IS_OFF(SOL_EXCEPTIONS_I_) #if SOL_IS_OFF(SOL_EXCEPTIONS)
std::abort(); std::abort();
#else #else
throw bad_optional_access(); throw bad_optional_access();
@ -1386,7 +1386,7 @@ namespace sol {
SOL_TL_OPTIONAL_11_CONSTEXPR const T& value() const& { SOL_TL_OPTIONAL_11_CONSTEXPR const T& value() const& {
if (has_value()) if (has_value())
return this->m_value; return this->m_value;
#if SOL_IS_OFF(SOL_EXCEPTIONS_I_) #if SOL_IS_OFF(SOL_EXCEPTIONS)
std::abort(); std::abort();
#else #else
throw bad_optional_access(); throw bad_optional_access();
@ -1396,7 +1396,7 @@ namespace sol {
SOL_TL_OPTIONAL_11_CONSTEXPR T&& value() && { SOL_TL_OPTIONAL_11_CONSTEXPR T&& value() && {
if (has_value()) if (has_value())
return std::move(this->m_value); return std::move(this->m_value);
#if SOL_IS_OFF(SOL_EXCEPTIONS_I_) #if SOL_IS_OFF(SOL_EXCEPTIONS)
std::abort(); std::abort();
#else #else
throw bad_optional_access(); throw bad_optional_access();
@ -1408,7 +1408,7 @@ namespace sol {
SOL_TL_OPTIONAL_11_CONSTEXPR const T&& value() const&& { SOL_TL_OPTIONAL_11_CONSTEXPR const T&& value() const&& {
if (has_value()) if (has_value())
return std::move(this->m_value); return std::move(this->m_value);
#if SOL_IS_OFF(SOL_EXCEPTIONS_I_) #if SOL_IS_OFF(SOL_EXCEPTIONS)
std::abort(); std::abort();
#else #else
throw bad_optional_access(); throw bad_optional_access();
@ -2251,7 +2251,7 @@ namespace sol {
SOL_TL_OPTIONAL_11_CONSTEXPR T& value() { SOL_TL_OPTIONAL_11_CONSTEXPR T& value() {
if (has_value()) if (has_value())
return *m_value; return *m_value;
#if SOL_IS_OFF(SOL_EXCEPTIONS_I_) #if SOL_IS_OFF(SOL_EXCEPTIONS)
std::abort(); std::abort();
#else #else
throw bad_optional_access(); throw bad_optional_access();
@ -2262,7 +2262,7 @@ namespace sol {
SOL_TL_OPTIONAL_11_CONSTEXPR const T& value() const { SOL_TL_OPTIONAL_11_CONSTEXPR const T& value() const {
if (has_value()) if (has_value())
return *m_value; return *m_value;
#if SOL_IS_OFF(SOL_EXCEPTIONS_I_) #if SOL_IS_OFF(SOL_EXCEPTIONS)
std::abort(); std::abort();
#else #else
throw bad_optional_access(); throw bad_optional_access();

4
extern/sol3/sol/overload.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -46,4 +46,4 @@ namespace sol {
} }
} // namespace sol } // namespace sol
#endif // SOL_OVERLOAD_HPP #endif // SOL_OVERLOAD_HPP

12
extern/sol3/sol/packaged_coroutine.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -96,7 +96,7 @@ namespace sol {
meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler> meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
basic_packaged_coroutine(T&& r) noexcept basic_packaged_coroutine(T&& r) noexcept
: base_t(std::forward<T>(r)), m_error_handler(detail::get_default_handler<reference, is_main_threaded<base_t>::value>(r.lua_state())) { : base_t(std::forward<T>(r)), m_error_handler(detail::get_default_handler<reference, is_main_threaded<base_t>::value>(r.lua_state())) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
if (!is_function<meta::unqualified_t<T>>::value) { if (!is_function<meta::unqualified_t<T>>::value) {
auto pp = stack::push_pop(*this); auto pp = stack::push_pop(*this);
constructor_handler handler {}; constructor_handler handler {};
@ -160,7 +160,7 @@ namespace sol {
} }
template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler> template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
basic_packaged_coroutine(lua_State* L, T&& r, handler_t eh) : base_t(L, std::forward<T>(r)), m_error_handler(std::move(eh)) { basic_packaged_coroutine(lua_State* L, T&& r, handler_t eh) : base_t(L, std::forward<T>(r)), m_error_handler(std::move(eh)) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
auto pp = stack::push_pop(*this); auto pp = stack::push_pop(*this);
constructor_handler handler {}; constructor_handler handler {};
stack::check<basic_packaged_coroutine>(lua_state(), -1, handler); stack::check<basic_packaged_coroutine>(lua_state(), -1, handler);
@ -183,7 +183,7 @@ namespace sol {
: basic_packaged_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) { : basic_packaged_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
} }
basic_packaged_coroutine(lua_State* L, absolute_index index, handler_t eh) : base_t(L, index), m_error_handler(std::move(eh)) { basic_packaged_coroutine(lua_State* L, absolute_index index, handler_t eh) : base_t(L, index), m_error_handler(std::move(eh)) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
constructor_handler handler {}; constructor_handler handler {};
stack::check<basic_packaged_coroutine>(L, index, handler); stack::check<basic_packaged_coroutine>(L, index, handler);
#endif // Safety #endif // Safety
@ -192,7 +192,7 @@ namespace sol {
: basic_packaged_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) { : basic_packaged_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
} }
basic_packaged_coroutine(lua_State* L, raw_index index, handler_t eh) : base_t(L, index), m_error_handler(std::move(eh)) { basic_packaged_coroutine(lua_State* L, raw_index index, handler_t eh) : base_t(L, index), m_error_handler(std::move(eh)) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
constructor_handler handler {}; constructor_handler handler {};
stack::check<basic_packaged_coroutine>(L, index, handler); stack::check<basic_packaged_coroutine>(L, index, handler);
#endif // Safety #endif // Safety
@ -201,7 +201,7 @@ namespace sol {
: basic_packaged_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) { : basic_packaged_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
} }
basic_packaged_coroutine(lua_State* L, ref_index index, handler_t eh) : base_t(L, index), m_error_handler(std::move(eh)) { basic_packaged_coroutine(lua_State* L, ref_index index, handler_t eh) : base_t(L, index), m_error_handler(std::move(eh)) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
auto pp = stack::push_pop(*this); auto pp = stack::push_pop(*this);
constructor_handler handler {}; constructor_handler handler {};
stack::check<basic_packaged_coroutine>(lua_state(), -1, handler); stack::check<basic_packaged_coroutine>(lua_state(), -1, handler);

2
extern/sol3/sol/pairs_iterator.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in

3
extern/sol3/sol/pointer_like.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -28,6 +28,7 @@
#include <utility> #include <utility>
#include <type_traits> #include <type_traits>
#include <memory>
namespace sol { namespace sol {

2
extern/sol3/sol/policies.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in

6
extern/sol3/sol/prologue.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -32,10 +32,10 @@
#define SOL_PROLOGUE_I_ 1 #define SOL_PROLOGUE_I_ 1
#if SOL_IS_ON(SOL_BUILD_CXX_MODE_I_) #if SOL_IS_ON(SOL_BUILD_CXX_MODE)
#define _FWD(...) static_cast<decltype( __VA_ARGS__ )&&>( __VA_ARGS__ ) #define _FWD(...) static_cast<decltype( __VA_ARGS__ )&&>( __VA_ARGS__ )
#if SOL_IS_ON(SOL_COMPILER_GCC_I_) || SOL_IS_ON(SOL_COMPILER_CLANG_I_) #if SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
#define _MOVE(...) static_cast<__typeof( __VA_ARGS__ )&&>( __VA_ARGS__ ) #define _MOVE(...) static_cast<__typeof( __VA_ARGS__ )&&>( __VA_ARGS__ )
#else #else
#include <type_traits> #include <type_traits>

2
extern/sol3/sol/property.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in

2
extern/sol3/sol/protect.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in

20
extern/sol3/sol/protected_function.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -75,7 +75,7 @@ namespace sol {
meta::neg<std::is_base_of<proxy_base_tag, meta::unqualified_t<T>>>, meta::neg<std::is_same<base_t, stack_reference>>, meta::neg<std::is_base_of<proxy_base_tag, meta::unqualified_t<T>>>, meta::neg<std::is_same<base_t, stack_reference>>,
meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler> meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
basic_protected_function(T&& r) noexcept : base_t(std::forward<T>(r)), m_error_handler(get_default_handler(r.lua_state())) { basic_protected_function(T&& r) noexcept : base_t(std::forward<T>(r)), m_error_handler(get_default_handler(r.lua_state())) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
if (!is_function<meta::unqualified_t<T>>::value) { if (!is_function<meta::unqualified_t<T>>::value) {
auto pp = stack::push_pop(*this); auto pp = stack::push_pop(*this);
constructor_handler handler {}; constructor_handler handler {};
@ -133,7 +133,7 @@ namespace sol {
} }
template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler> template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
basic_protected_function(lua_State* L_, T&& r, handler_t eh) : base_t(L_, std::forward<T>(r)), m_error_handler(std::move(eh)) { basic_protected_function(lua_State* L_, T&& r, handler_t eh) : base_t(L_, std::forward<T>(r)), m_error_handler(std::move(eh)) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
auto pp = stack::push_pop(*this); auto pp = stack::push_pop(*this);
constructor_handler handler {}; constructor_handler handler {};
stack::check<basic_protected_function>(lua_state(), -1, handler); stack::check<basic_protected_function>(lua_state(), -1, handler);
@ -146,7 +146,7 @@ namespace sol {
basic_protected_function(lua_State* L_, int index_ = -1) : basic_protected_function(L_, index_, get_default_handler(L_)) { basic_protected_function(lua_State* L_, int index_ = -1) : basic_protected_function(L_, index_, get_default_handler(L_)) {
} }
basic_protected_function(lua_State* L_, int index_, handler_t eh) : base_t(L_, index_), m_error_handler(std::move(eh)) { basic_protected_function(lua_State* L_, int index_, handler_t eh) : base_t(L_, index_), m_error_handler(std::move(eh)) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
constructor_handler handler {}; constructor_handler handler {};
stack::check<basic_protected_function>(L_, index_, handler); stack::check<basic_protected_function>(L_, index_, handler);
#endif // Safety #endif // Safety
@ -154,7 +154,7 @@ namespace sol {
basic_protected_function(lua_State* L_, absolute_index index_) : basic_protected_function(L_, index_, get_default_handler(L_)) { basic_protected_function(lua_State* L_, absolute_index index_) : basic_protected_function(L_, index_, get_default_handler(L_)) {
} }
basic_protected_function(lua_State* L_, absolute_index index_, handler_t eh) : base_t(L_, index_), m_error_handler(std::move(eh)) { basic_protected_function(lua_State* L_, absolute_index index_, handler_t eh) : base_t(L_, index_), m_error_handler(std::move(eh)) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
constructor_handler handler {}; constructor_handler handler {};
stack::check<basic_protected_function>(L_, index_, handler); stack::check<basic_protected_function>(L_, index_, handler);
#endif // Safety #endif // Safety
@ -162,7 +162,7 @@ namespace sol {
basic_protected_function(lua_State* L_, raw_index index_) : basic_protected_function(L_, index_, get_default_handler(L_)) { basic_protected_function(lua_State* L_, raw_index index_) : basic_protected_function(L_, index_, get_default_handler(L_)) {
} }
basic_protected_function(lua_State* L_, raw_index index_, handler_t eh) : base_t(L_, index_), m_error_handler(std::move(eh)) { basic_protected_function(lua_State* L_, raw_index index_, handler_t eh) : base_t(L_, index_), m_error_handler(std::move(eh)) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
constructor_handler handler {}; constructor_handler handler {};
stack::check<basic_protected_function>(L_, index_, handler); stack::check<basic_protected_function>(L_, index_, handler);
#endif // Safety #endif // Safety
@ -170,7 +170,7 @@ namespace sol {
basic_protected_function(lua_State* L_, ref_index index_) : basic_protected_function(L_, index_, get_default_handler(L_)) { basic_protected_function(lua_State* L_, ref_index index_) : basic_protected_function(L_, index_, get_default_handler(L_)) {
} }
basic_protected_function(lua_State* L_, ref_index index_, handler_t eh) : base_t(L_, index_), m_error_handler(std::move(eh)) { basic_protected_function(lua_State* L_, ref_index index_, handler_t eh) : base_t(L_, index_), m_error_handler(std::move(eh)) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
auto pp = stack::push_pop(*this); auto pp = stack::push_pop(*this);
constructor_handler handler {}; constructor_handler handler {};
stack::check<basic_protected_function>(lua_state(), -1, handler); stack::check<basic_protected_function>(lua_state(), -1, handler);
@ -339,14 +339,14 @@ namespace sol {
int firstreturn = 1; int firstreturn = 1;
int returncount = 0; int returncount = 0;
call_status code = call_status::ok; call_status code = call_status::ok;
#if SOL_IS_ON(SOL_EXCEPTIONS_I_) && SOL_IS_OFF(SOL_PROPAGATE_EXCEPTIONS_I_) #if SOL_IS_ON(SOL_EXCEPTIONS) && SOL_IS_OFF(SOL_PROPAGATE_EXCEPTIONS)
try { try {
#endif // No Exceptions #endif // No Exceptions
firstreturn = (std::max)(1, static_cast<int>(stacksize - n - static_cast<int>(h.valid() && !is_stack_handler_v))); firstreturn = (std::max)(1, static_cast<int>(stacksize - n - static_cast<int>(h.valid() && !is_stack_handler_v)));
code = luacall(n, LUA_MULTRET, h); code = luacall(n, LUA_MULTRET, h);
poststacksize = lua_gettop(lua_state()) - static_cast<int>(h.valid() && !is_stack_handler_v); poststacksize = lua_gettop(lua_state()) - static_cast<int>(h.valid() && !is_stack_handler_v);
returncount = poststacksize - (firstreturn - 1); returncount = poststacksize - (firstreturn - 1);
#if SOL_IS_ON(SOL_EXCEPTIONS_I_) && SOL_IS_OFF(SOL_PROPAGATE_EXCEPTIONS_I_) #if SOL_IS_ON(SOL_EXCEPTIONS) && SOL_IS_OFF(SOL_PROPAGATE_EXCEPTIONS)
} }
// Handle C++ errors thrown from C++ functions bound inside of lua // Handle C++ errors thrown from C++ functions bound inside of lua
catch (const char* error) { catch (const char* error) {
@ -364,7 +364,7 @@ namespace sol {
firstreturn = lua_gettop(lua_state()); firstreturn = lua_gettop(lua_state());
return protected_function_result(lua_state(), firstreturn, 0, 1, call_status::runtime); return protected_function_result(lua_state(), firstreturn, 0, 1, call_status::runtime);
} }
#if SOL_IS_ON(SOL_EXCEPTIONS_CATCH_ALL_I_) #if SOL_IS_ON(SOL_EXCEPTIONS_CATCH_ALL)
// 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

25
extern/sol3/sol/protected_function_result.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -54,7 +54,7 @@ namespace sol {
typedef std::reverse_iterator<iterator> reverse_iterator; typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator; typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
protected_function_result() noexcept = default; protected_function_result() noexcept : protected_function_result(nullptr) {}
protected_function_result(lua_State* Ls, int idx = -1, int retnum = 0, int popped = 0, call_status pferr = call_status::ok) noexcept protected_function_result(lua_State* Ls, int idx = -1, int retnum = 0, int popped = 0, call_status pferr = call_status::ok) noexcept
: L(Ls), index(idx), returncount(retnum), popcount(popped), err(pferr) { : L(Ls), index(idx), returncount(retnum), popcount(popped), err(pferr) {
} }
@ -99,6 +99,13 @@ namespace sol {
return status() == call_status::ok || status() == call_status::yielded; return status() == call_status::ok || status() == call_status::yielded;
} }
#if SOL_IS_ON(SOL_COMPILER_GCC)
#pragma GCC diagnostic push
#if !SOL_IS_ON(SOL_COMPILER_CLANG)
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#endif
#endif
template <typename T> template <typename T>
decltype(auto) get(int index_offset = 0) const { decltype(auto) get(int index_offset = 0) const {
using UT = meta::unqualified_t<T>; using UT = meta::unqualified_t<T>;
@ -109,7 +116,7 @@ namespace sol {
if (valid()) { if (valid()) {
return UT(); return UT();
} }
return UT(error(detail::direct_error, stack::get<std::string>(L, target))); return UT(stack::stack_detail::get_error(L, target));
} }
else { else {
if (!valid()) { if (!valid()) {
@ -120,16 +127,16 @@ namespace sol {
} }
else { else {
if constexpr (std::is_same_v<T, error>) { if constexpr (std::is_same_v<T, error>) {
#if SOL_IS_ON(SOL_SAFE_PROXIES_I_) #if SOL_IS_ON(SOL_SAFE_PROXIES)
if (valid()) { if (valid()) {
type t = type_of(L, target); type t = type_of(L, target);
type_panic_c_str(L, target, t, type::none, "bad get from protected_function_result (is an error)"); type_panic_c_str(L, target, t, type::none, "bad get from protected_function_result (is an error)");
} }
#endif // Check Argument Safety #endif // Check Argument Safety
return error(detail::direct_error, stack::get<std::string>(L, target)); return stack::stack_detail::get_error(L, target);
} }
else { else {
#if SOL_IS_ON(SOL_SAFE_PROXIES_I_) #if SOL_IS_ON(SOL_SAFE_PROXIES)
if (!valid()) { if (!valid()) {
type t = type_of(L, target); type t = type_of(L, target);
type_panic_c_str(L, target, t, type::none, "bad get from protected_function_result (is not an error)"); type_panic_c_str(L, target, t, type::none, "bad get from protected_function_result (is not an error)");
@ -140,6 +147,10 @@ namespace sol {
} }
} }
#if SOL_IS_ON(SOL_COMPILER_GCC)
#pragma GCC diagnostic pop
#endif
type get_type(int index_offset = 0) const noexcept { type get_type(int index_offset = 0) const noexcept {
return type_of(L, index + static_cast<int>(index_offset)); return type_of(L, index + static_cast<int>(index_offset));
} }
@ -216,7 +227,7 @@ namespace sol {
template <> template <>
struct unqualified_pusher<protected_function_result> { struct unqualified_pusher<protected_function_result> {
static int push(lua_State* L, const protected_function_result& pfr) { static int push(lua_State* L, const protected_function_result& pfr) {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, static_cast<int>(pfr.pop_count()), detail::not_enough_stack_space_generic); luaL_checkstack(L, static_cast<int>(pfr.pop_count()), detail::not_enough_stack_space_generic);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
int p = 0; int p = 0;

4
extern/sol3/sol/protected_handler.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -92,7 +92,7 @@ namespace sol { namespace detail {
return; return;
} }
if (!ref.valid()) { if (!ref.valid()) {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic); luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
lua_pushnil(L); lua_pushnil(L);

2
extern/sol3/sol/proxy_base.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in

2
extern/sol3/sol/raii.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in

14
extern/sol3/sol/reference.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -289,7 +289,7 @@ namespace sol {
} }
stateless_reference(lua_State* L_, global_tag_t) noexcept { stateless_reference(lua_State* L_, global_tag_t) noexcept {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L_, 1, "not enough Lua stack space to push this reference value"); luaL_checkstack(L_, 1, "not enough Lua stack space to push this reference value");
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
lua_pushglobaltable(L_); lua_pushglobaltable(L_);
@ -352,7 +352,7 @@ namespace sol {
} }
stateless_reference(lua_State* L_, int index = -1) noexcept { stateless_reference(lua_State* L_, int index = -1) noexcept {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L_, 1, "not enough Lua stack space to push this reference value"); luaL_checkstack(L_, 1, "not enough Lua stack space to push this reference value");
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
lua_pushvalue(L_, index); lua_pushvalue(L_, index);
@ -383,7 +383,7 @@ namespace sol {
} }
int push(lua_State* L_) const noexcept { int push(lua_State* L_) const noexcept {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L_, 1, "not enough Lua stack space to push this reference value"); luaL_checkstack(L_, 1, "not enough Lua stack space to push this reference value");
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
lua_rawgeti(L_, LUA_REGISTRYINDEX, ref); lua_rawgeti(L_, LUA_REGISTRYINDEX, ref);
@ -407,7 +407,7 @@ namespace sol {
void reset(lua_State* L_, int index_) noexcept { void reset(lua_State* L_, int index_) noexcept {
reset(L_); reset(L_);
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L_, 1, "not enough Lua stack space to push this reference value"); luaL_checkstack(L_, 1, "not enough Lua stack space to push this reference value");
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
lua_pushvalue(L_, index_); lua_pushvalue(L_, index_);
@ -616,7 +616,7 @@ namespace sol {
} }
basic_reference(lua_State* L_, int index = -1) noexcept : luastate(detail::pick_main_thread<main_only>(L_, L_)) { basic_reference(lua_State* L_, int index = -1) noexcept : luastate(detail::pick_main_thread<main_only>(L_, L_)) {
// use L_ to stick with that state's execution stack // use L_ to stick with that state's execution stack
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L_, 1, "not enough Lua stack space to push this reference value"); luaL_checkstack(L_, 1, "not enough Lua stack space to push this reference value");
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
lua_pushvalue(L_, index); lua_pushvalue(L_, index);
@ -693,7 +693,7 @@ namespace sol {
} }
int push(lua_State* L_) const noexcept { int push(lua_State* L_) const noexcept {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L_, 1, "not enough Lua stack space to push this reference value"); luaL_checkstack(L_, 1, "not enough Lua stack space to push this reference value");
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
if (lua_state() == nullptr) { if (lua_state() == nullptr) {

2
extern/sol3/sol/resolve.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in

18
extern/sol3/sol/sol.hpp vendored
View file

@ -1,6 +1,6 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -24,23 +24,23 @@
#include <sol/version.hpp> #include <sol/version.hpp>
#if SOL_IS_ON(SOL_INSIDE_UNREAL_ENGINE_I_) #if SOL_IS_ON(SOL_INSIDE_UNREAL_ENGINE)
#ifdef check #ifdef check
#pragma push_macro("check") #pragma push_macro("check")
#undef check #undef check
#endif #endif
#endif // Unreal Engine 4 Bullshit #endif // Unreal Engine 4 Bullshit
#if SOL_IS_ON(SOL_COMPILER_GCC_I_) #if SOL_IS_ON(SOL_COMPILER_GCC)
#pragma GCC diagnostic push #pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wshadow" #pragma GCC diagnostic ignored "-Wshadow"
#pragma GCC diagnostic ignored "-Wconversion" #pragma GCC diagnostic ignored "-Wconversion"
#if __GNUC__ > 6 #if __GNUC__ > 6
#pragma GCC diagnostic ignored "-Wnoexcept-type" #pragma GCC diagnostic ignored "-Wnoexcept-type"
#endif #endif
#elif SOL_IS_ON(SOL_COMPILER_CLANG_I_) #elif SOL_IS_ON(SOL_COMPILER_CLANG)
// we'll just let this alone for now // we'll just let this alone for now
#elif SOL_IS_ON(SOL_COMPILER_VCXX_I_) #elif SOL_IS_ON(SOL_COMPILER_VCXX)
#pragma warning(push) #pragma warning(push)
#pragma warning(disable : 4505) // unreferenced local function has been removed GEE THANKS #pragma warning(disable : 4505) // unreferenced local function has been removed GEE THANKS
#endif // clang++ vs. g++ vs. VC++ #endif // clang++ vs. g++ vs. VC++
@ -65,13 +65,15 @@
#include <sol/variadic_results.hpp> #include <sol/variadic_results.hpp>
#include <sol/lua_value.hpp> #include <sol/lua_value.hpp>
#if SOL_IS_ON(SOL_COMPILER_GCC_I_) #if SOL_IS_ON(SOL_COMPILER_GCC)
#pragma GCC diagnostic pop #pragma GCC diagnostic pop
#elif SOL_IS_ON(SOL_COMPILER_VCXX_I_) #elif SOL_IS_ON(SOL_COMPILER_CLANG)
// we'll just let this alone for now
#elif SOL_IS_ON(SOL_COMPILER_VCXX)
#pragma warning(pop) #pragma warning(pop)
#endif // g++ #endif // g++
#if SOL_IS_ON(SOL_INSIDE_UNREAL_ENGINE_I_) #if SOL_IS_ON(SOL_INSIDE_UNREAL_ENGINE)
#undef check #undef check
#pragma pop_macro("check") #pragma pop_macro("check")
#endif // Unreal Engine 4 Bullshit #endif // Unreal Engine 4 Bullshit

47
extern/sol3/sol/stack.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -34,6 +34,8 @@
#include <sol/stack_pop.hpp> #include <sol/stack_pop.hpp>
#include <sol/stack_field.hpp> #include <sol/stack_field.hpp>
#include <sol/stack_probe.hpp> #include <sol/stack_probe.hpp>
#include <sol/error.hpp>
#include <sol/assert.hpp>
#include <cstring> #include <cstring>
#include <array> #include <array>
@ -149,7 +151,10 @@ namespace sol {
template <bool checked, typename Arg, typename... Args, std::size_t I, std::size_t... Is, typename Handler, typename Fx, typename... FxArgs> template <bool checked, typename Arg, typename... Args, std::size_t I, std::size_t... Is, typename Handler, typename Fx, typename... FxArgs>
static decltype(auto) eval(types<Arg, Args...>, std::index_sequence<I, Is...>, lua_State* L_, int start_index_, Handler&& handler_, static decltype(auto) eval(types<Arg, Args...>, std::index_sequence<I, Is...>, lua_State* L_, int start_index_, Handler&& handler_,
record& tracking_, Fx&& fx_, FxArgs&&... fxargs_) { record& tracking_, Fx&& fx_, FxArgs&&... fxargs_) {
#if SOL_IS_ON(SOL_PROPAGATE_EXCEPTIONS_I_) #if 0 && SOL_IS_ON(SOL_PROPAGATE_EXCEPTIONS)
// NOTE: THIS IS TERMPORARILY TURNED OFF BECAUSE IT IMPACTS ACTUAL SEMANTICS W.R.T. THINGS LIKE LUAJIT,
// SO IT MUST REMAIN OFF UNTIL WE CAN ESTABLISH SIMILAR BEHAVIOR IN MODES WHERE `checked == false`!
// We can save performance/time by letting errors unwind produced arguments // We can save performance/time by letting errors unwind produced arguments
// rather than checking everything once, and then potentially re-doing work // rather than checking everything once, and then potentially re-doing work
if constexpr (checked) { if constexpr (checked) {
@ -186,7 +191,7 @@ namespace sol {
"a reference and std::move it manually if this was your intention."); "a reference and std::move it manually if this was your intention.");
argument_handler<types<R, Args...>> handler {}; argument_handler<types<R, Args...>> handler {};
record tracking {}; record tracking {};
#if SOL_IS_OFF(SOL_PROPAGATE_EXCEPTIONS_I_) #if SOL_IS_OFF(SOL_PROPAGATE_EXCEPTIONS)
if constexpr (checkargs) { if constexpr (checkargs) {
multi_check<Args...>(L_, start_index_, handler); multi_check<Args...>(L_, start_index_, handler);
} }
@ -200,11 +205,21 @@ namespace sol {
argument_types_, argument_indices_, L_, start_index_, handler, tracking, std::forward<Fx>(fx_), std::forward<FxArgs>(args_)...); argument_types_, argument_indices_, L_, start_index_, handler, tracking, std::forward<Fx>(fx_), std::forward<FxArgs>(args_)...);
} }
} }
template <typename T>
void raw_table_set(lua_State* L, T&& arg, int tableindex = -2) {
int push_count = push(L, std::forward<T>(arg));
SOL_ASSERT(push_count == 1);
std::size_t unique_index = static_cast<std::size_t>(luaL_len(L, tableindex) + 1u);
lua_rawseti(L, tableindex, static_cast<int>(unique_index));
}
} // namespace stack_detail } // namespace stack_detail
template <typename T> template <typename T>
int set_ref(lua_State* L, T&& arg, int tableindex = -2) { int set_ref(lua_State* L, T&& arg, int tableindex = -2) {
push(L, std::forward<T>(arg)); int push_count = push(L, std::forward<T>(arg));
SOL_ASSERT(push_count == 1);
return luaL_ref(L, tableindex); return luaL_ref(L, tableindex);
} }
@ -319,11 +334,11 @@ namespace sol {
} }
inline void luajit_exception_handler(lua_State* L, int (*handler)(lua_State*, lua_CFunction) = detail::c_trampoline) { inline void luajit_exception_handler(lua_State* L, int (*handler)(lua_State*, lua_CFunction) = detail::c_trampoline) {
#if SOL_IS_ON(SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE_I_) #if SOL_IS_ON(SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE)
if (L == nullptr) { if (L == nullptr) {
return; return;
} }
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic); luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
lua_pushlightuserdata(L, (void*)handler); lua_pushlightuserdata(L, (void*)handler);
@ -336,7 +351,7 @@ namespace sol {
} }
inline void luajit_exception_off(lua_State* L) { inline void luajit_exception_off(lua_State* L) {
#if SOL_IS_ON(SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE_I_) #if SOL_IS_ON(SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE)
if (L == nullptr) { if (L == nullptr) {
return; return;
} }
@ -345,6 +360,24 @@ namespace sol {
(void)L; (void)L;
#endif #endif
} }
namespace stack_detail {
inline error get_error(lua_State* L, int target) {
auto maybe_exc = stack::check_get<error&>(L, target);
if (maybe_exc.has_value()) {
return maybe_exc.value();
}
return error(detail::direct_error, stack::get<std::string>(L, target));
}
inline detail::error_exception get_error_exception(lua_State* L, int target) {
auto maybe_exc = stack::check_get<detail::error_exception&>(L, target);
if (maybe_exc.has_value()) {
return maybe_exc.value();
}
return detail::error_exception(detail::direct_error, stack::get<std::string>(L, target));
}
}
} // namespace stack } // namespace stack
} // namespace sol } // namespace sol

4
extern/sol3/sol/stack/detail/pairs.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -84,7 +84,7 @@ namespace sol { namespace stack { namespace stack_detail {
pushed += 1; pushed += 1;
} }
int metatable_exists = lua_getmetatable(L_, 1); int metatable_exists = lua_getmetatable(L_, 1);
sol_c_assert(metatable_exists == 1); SOL_ASSERT(metatable_exists == 1);
const auto& index_key = to_string(sol::meta_function::index); const auto& index_key = to_string(sol::meta_function::index);
lua_getfield(L_, lua_gettop(L_), index_key.c_str()); lua_getfield(L_, lua_gettop(L_), index_key.c_str());
lua_remove(L_, -2); lua_remove(L_, -2);

2
extern/sol3/sol/stack_check.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in

2
extern/sol3/sol/stack_check_get.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in

21
extern/sol3/sol/stack_check_get_qualified.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -30,6 +30,13 @@
namespace sol { namespace stack { namespace sol { namespace stack {
#if SOL_IS_ON(SOL_COMPILER_GCC)
#pragma GCC diagnostic push
#if !SOL_IS_ON(SOL_COMPILER_CLANG)
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#endif
#endif
namespace stack_detail { namespace stack_detail {
template <typename OptionalType, typename T, typename Handler> template <typename OptionalType, typename T, typename Handler>
OptionalType get_optional(lua_State* L, int index, Handler&& handler, record& tracking) { OptionalType get_optional(lua_State* L, int index, Handler&& handler, record& tracking) {
@ -70,9 +77,8 @@ namespace sol { namespace stack {
actual* mem = static_cast<actual*>(memory); actual* mem = static_cast<actual*>(memory);
return static_cast<actual>(*mem); return static_cast<actual>(*mem);
} }
actual r {};
if constexpr (!derive<element>::value) { if constexpr (!derive<element>::value) {
return {}; return OptionalType();
} }
else { else {
memory = detail::align_usertype_unique_tag<true, false>(memory); memory = detail::align_usertype_unique_tag<true, false>(memory);
@ -80,6 +86,7 @@ namespace sol { namespace stack {
memory = detail::align_usertype_unique<actual, true, false>(memory); memory = detail::align_usertype_unique<actual, true, false>(memory);
string_view ti = usertype_traits<element>::qualified_name(); string_view ti = usertype_traits<element>::qualified_name();
int cast_operation; int cast_operation;
actual r {};
if constexpr (is_actual_type_rebindable_for_v<Tu>) { if constexpr (is_actual_type_rebindable_for_v<Tu>) {
using rebound_actual_type = unique_usertype_rebind_actual_t<Tu, void>; using rebound_actual_type = unique_usertype_rebind_actual_t<Tu, void>;
string_view rebind_ti = usertype_traits<rebound_actual_type>::qualified_name(); string_view rebind_ti = usertype_traits<rebound_actual_type>::qualified_name();
@ -103,19 +110,23 @@ namespace sol { namespace stack {
default: default:
break; break;
} }
return {}; return OptionalType();
} }
} }
else { else {
if (!check<T>(L, index, std::forward<Handler>(handler))) { if (!check<T>(L, index, std::forward<Handler>(handler))) {
tracking.use(static_cast<int>(!lua_isnone(L, index))); tracking.use(static_cast<int>(!lua_isnone(L, index)));
return {}; return OptionalType();
} }
return OptionalType(stack_detail::unchecked_get<T>(L, index, tracking)); return OptionalType(stack_detail::unchecked_get<T>(L, index, tracking));
} }
} }
} // namespace stack_detail } // namespace stack_detail
#if SOL_IS_ON(SOL_COMPILER_GCC)
#pragma GCC diagnostic pop
#endif
template <typename T, typename> template <typename T, typename>
struct qualified_check_getter { struct qualified_check_getter {
typedef decltype(stack_detail::unchecked_get<T>(nullptr, -1, std::declval<record&>())) R; typedef decltype(stack_detail::unchecked_get<T>(nullptr, -1, std::declval<record&>())) R;

8
extern/sol3/sol/stack_check_get_unqualified.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -32,7 +32,7 @@
#include <cstdlib> #include <cstdlib>
#include <cmath> #include <cmath>
#include <optional> #include <optional>
#if SOL_IS_ON(SOL_STD_VARIANT_I_) #if SOL_IS_ON(SOL_STD_VARIANT)
#include <variant> #include <variant>
#endif // variant shenanigans (thanks, Mac OSX) #endif // variant shenanigans (thanks, Mac OSX)
@ -76,7 +76,7 @@ namespace sol { namespace stack {
int isnum = 0; int isnum = 0;
const lua_Number value = lua_tonumberx(L, index, &isnum); const lua_Number value = lua_tonumberx(L, index, &isnum);
if (isnum != 0) { if (isnum != 0) {
#if SOL_IS_ON(SOL_NUMBER_PRECISION_CHECKS_I_) #if SOL_IS_ON(SOL_NUMBER_PRECISION_CHECKS)
const auto integer_value = llround(value); const auto integer_value = llround(value);
if (static_cast<lua_Number>(integer_value) == value) { if (static_cast<lua_Number>(integer_value) == value) {
tracking.use(1); tracking.use(1);
@ -139,7 +139,7 @@ namespace sol { namespace stack {
} }
}; };
#if SOL_IS_ON(SOL_STD_VARIANT_I_) #if SOL_IS_ON(SOL_STD_VARIANT)
template <typename... Tn, typename C> template <typename... Tn, typename C>
struct unqualified_check_getter<std::variant<Tn...>, C> { struct unqualified_check_getter<std::variant<Tn...>, C> {
typedef std::variant<Tn...> V; typedef std::variant<Tn...> V;

2
extern/sol3/sol/stack_check_qualified.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in

131
extern/sol3/sol/stack_check_unqualified.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -32,7 +32,7 @@
#include <utility> #include <utility>
#include <cmath> #include <cmath>
#include <optional> #include <optional>
#if SOL_IS_ON(SOL_STD_VARIANT_I_) #if SOL_IS_ON(SOL_STD_VARIANT)
#include <variant> #include <variant>
#endif // variant shenanigans #endif // variant shenanigans
@ -116,7 +116,7 @@ namespace sol { namespace stack {
} }
else if constexpr (meta::any_same_v<T, else if constexpr (meta::any_same_v<T,
char char
#if SOL_IS_ON(SOL_CHAR8_T_I_) #if SOL_IS_ON(SOL_CHAR8_T)
, ,
char8_t char8_t
#endif #endif
@ -129,7 +129,7 @@ namespace sol { namespace stack {
tracking.use(1); tracking.use(1);
#if SOL_LUA_VERSION_I_ >= 503 #if SOL_LUA_VERSION_I_ >= 503
// Lua 5.3 and greater checks for numeric precision // Lua 5.3 and greater checks for numeric precision
#if SOL_IS_ON(SOL_STRINGS_ARE_NUMBERS_I_) #if SOL_IS_ON(SOL_STRINGS_ARE_NUMBERS)
// imprecise, sloppy conversions // imprecise, sloppy conversions
int isnum = 0; int isnum = 0;
lua_tointegerx(L_, index, &isnum); lua_tointegerx(L_, index, &isnum);
@ -138,7 +138,7 @@ namespace sol { namespace stack {
// expected type, actual type // expected type, actual type
handler(L_, index, type::number, type_of(L_, index), detail::not_a_number_or_number_string_integral); handler(L_, index, type::number, type_of(L_, index), detail::not_a_number_or_number_string_integral);
} }
#elif SOL_IS_ON(SOL_NUMBER_PRECISION_CHECKS_I_) #elif SOL_IS_ON(SOL_NUMBER_PRECISION_CHECKS)
// this check is precise, do not convert // this check is precise, do not convert
if (lua_isinteger(L_, index) == 1) { if (lua_isinteger(L_, index) == 1) {
return true; return true;
@ -160,7 +160,7 @@ namespace sol { namespace stack {
return success; return success;
#else #else
// Lua 5.2 and below checks // Lua 5.2 and below checks
#if SOL_IS_OFF(SOL_STRINGS_ARE_NUMBERS_I_) #if SOL_IS_OFF(SOL_STRINGS_ARE_NUMBERS)
// must pre-check, because it will convert // must pre-check, because it will convert
type t = type_of(L_, index); type t = type_of(L_, index);
if (t != type::number) { if (t != type::number) {
@ -170,7 +170,7 @@ namespace sol { namespace stack {
} }
#endif // Do not allow strings to be numbers #endif // Do not allow strings to be numbers
#if SOL_IS_ON(SOL_NUMBER_PRECISION_CHECKS_I_) #if SOL_IS_ON(SOL_NUMBER_PRECISION_CHECKS)
int isnum = 0; int isnum = 0;
const lua_Number v = lua_tonumberx(L_, index, &isnum); const lua_Number v = lua_tonumberx(L_, index, &isnum);
const bool success = isnum != 0 && static_cast<lua_Number>(llround(v)) == v; const bool success = isnum != 0 && static_cast<lua_Number>(llround(v)) == v;
@ -179,9 +179,9 @@ namespace sol { namespace stack {
#endif // Safe numerics and number precision checking #endif // Safe numerics and number precision checking
if (!success) { if (!success) {
// Use defines to provide a better error message! // Use defines to provide a better error message!
#if SOL_IS_ON(SOL_STRINGS_ARE_NUMBERS_I_) #if SOL_IS_ON(SOL_STRINGS_ARE_NUMBERS)
handler(L_, index, type::number, type_of(L_, index), detail::not_a_number_or_number_string); handler(L_, index, type::number, type_of(L_, index), detail::not_a_number_or_number_string);
#elif SOL_IS_ON(SOL_NUMBER_PRECISION_CHECKS_I_) #elif SOL_IS_ON(SOL_NUMBER_PRECISION_CHECKS)
handler(L_, index, type::number, t, detail::not_a_number_or_number_string); handler(L_, index, type::number, t, detail::not_a_number_or_number_string);
#else #else
handler(L_, index, type::number, t, detail::not_a_number); handler(L_, index, type::number, t, detail::not_a_number);
@ -192,7 +192,7 @@ namespace sol { namespace stack {
} }
else if constexpr (std::is_floating_point_v<T> || std::is_same_v<T, lua_Number>) { else if constexpr (std::is_floating_point_v<T> || std::is_same_v<T, lua_Number>) {
tracking.use(1); tracking.use(1);
#if SOL_IS_ON(SOL_STRINGS_ARE_NUMBERS_I_) #if SOL_IS_ON(SOL_STRINGS_ARE_NUMBERS)
bool success = lua_isnumber(L_, index) == 1; bool success = lua_isnumber(L_, index) == 1;
if (!success) { if (!success) {
// expected type, actual type // expected type, actual type
@ -218,6 +218,7 @@ namespace sol { namespace stack {
} }
else if constexpr (is_unique_usertype_v<T>) { else if constexpr (is_unique_usertype_v<T>) {
using element = unique_usertype_element_t<T>; using element = unique_usertype_element_t<T>;
using element_no_cv = meta::unqualified_t<element>;
using actual = unique_usertype_actual_t<T>; using actual = unique_usertype_actual_t<T>;
const type indextype = type_of(L_, index); const type indextype = type_of(L_, index);
tracking.use(1); tracking.use(1);
@ -229,7 +230,7 @@ namespace sol { namespace stack {
return true; return true;
} }
int metatableindex = lua_gettop(L_); int metatableindex = lua_gettop(L_);
if (stack_detail::check_metatable<d::u<element>>(L_, metatableindex)) { if (stack_detail::check_metatable<d::u<element_no_cv>>(L_, metatableindex)) {
void* memory = lua_touserdata(L_, index); void* memory = lua_touserdata(L_, index);
memory = detail::align_usertype_unique_destructor(memory); memory = detail::align_usertype_unique_destructor(memory);
detail::unique_destructor& pdx = *static_cast<detail::unique_destructor*>(memory); detail::unique_destructor& pdx = *static_cast<detail::unique_destructor*>(memory);
@ -371,7 +372,7 @@ namespace sol { namespace stack {
} }
return stack::unqualified_check<ValueType>(L_, index, &no_panic, tracking); return stack::unqualified_check<ValueType>(L_, index, &no_panic, tracking);
} }
#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE_I_) #if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE)
else if constexpr (std::is_function_v<T> || (std::is_pointer_v<T> && std::is_function_v<std::remove_pointer_t<T>>)) { else if constexpr (std::is_function_v<T> || (std::is_pointer_v<T> && std::is_function_v<std::remove_pointer_t<T>>)) {
return stack_detail::check_function_pointer<std::remove_pointer_t<T>>(L_, index, std::forward<Handler>(handler), tracking); return stack_detail::check_function_pointer<std::remove_pointer_t<T>>(L_, index, std::forward<Handler>(handler), tracking);
} }
@ -508,13 +509,13 @@ namespace sol { namespace stack {
return true; return true;
} }
else { else {
#if SOL_IS_ON(SOL_USE_INTEROP_I_) #if SOL_IS_ON(SOL_USE_INTEROP)
if (stack_detail::interop_check<U>(L_, index, indextype, handler, tracking)) { if (stack_detail::interop_check<U>(L_, index, indextype, handler, tracking)) {
return true; return true;
} }
#endif // interop extensibility #endif // interop extensibility
tracking.use(1); tracking.use(1);
#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE_I_) #if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE)
if (lua_iscfunction(L_, index) != 0) { if (lua_iscfunction(L_, index) != 0) {
// a potential match... // a potential match...
return true; return true;
@ -539,7 +540,7 @@ namespace sol { namespace stack {
bool success = false; bool success = false;
bool has_derived = derive<T>::value || weak_derive<T>::value; bool has_derived = derive<T>::value || weak_derive<T>::value;
if (has_derived) { if (has_derived) {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L_, 1, detail::not_enough_stack_space_string); luaL_checkstack(L_, 1, detail::not_enough_stack_space_string);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
auto pn = stack::pop_n(L_, 1); auto pn = stack::pop_n(L_, 1);
@ -579,6 +580,104 @@ namespace sol { namespace stack {
} }
}; };
template <typename T, std::size_t N, type expect>
struct unqualified_checker<exhaustive_until<T, N>, expect> {
template <typename K, typename V, typename Handler>
static bool check_two(types<K, V>, lua_State* arg_L, int relindex, type, Handler&& handler, record& tracking) {
tracking.use(1);
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(arg_L, 3, detail::not_enough_stack_space_generic);
#endif // make sure stack doesn't overflow
int index = lua_absindex(arg_L, relindex);
lua_pushnil(arg_L);
while (lua_next(arg_L, index) != 0) {
const bool is_key_okay = stack::check<K>(arg_L, -2, std::forward<Handler>(handler), tracking);
if (!is_key_okay) {
lua_pop(arg_L, 2);
return false;
}
const bool is_value_okay = stack::check<V>(arg_L, -1, std::forward<Handler>(handler), tracking);
if (!is_value_okay) {
lua_pop(arg_L, 2);
return false;
}
lua_pop(arg_L, 1);
}
return true;
}
template <typename V, typename Handler>
static bool check_one(types<V>, lua_State* arg_L, int relindex, type, Handler&& handler, record& tracking) {
tracking.use(1);
size_t index = lua_absindex(arg_L, relindex);
// Zzzz slower but necessary thanks to the lower version API and missing functions qq
std::size_t idx = 0;
int vi = 0;
for (lua_Integer i = 0;; (void)(i += lua_size<V>::value), lua_pop(arg_L, static_cast<int>(vi))) {
vi = 0;
if (idx >= N) {
return true;
}
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(arg_L, 2, detail::not_enough_stack_space_generic);
#endif // make sure stack doesn't overflow
bool isnil = false;
for (; vi < static_cast<int>(lua_size<V>::value); ++vi) {
lua_pushinteger(arg_L, i);
lua_gettable(arg_L, static_cast<int>(index));
type vt = type_of(arg_L, -1);
isnil = vt == type::lua_nil;
if (isnil) {
if (i == 0) {
vi += 1;
goto loop_continue;
}
lua_pop(arg_L, static_cast<int>(vi + 1));
return true;
}
}
if (!stack::check<V>(arg_L, -lua_size<V>::value, std::forward<Handler>(handler), tracking)) {
lua_pop(arg_L, lua_size<V>::value);
return false;
}
++idx;
loop_continue:;
}
}
template <typename Handler>
static bool check(lua_State* arg_L, int index, Handler&& handler, record& tracking) {
using Tu = meta::unqualified_t<T>;
if constexpr (is_container_v<Tu>) {
if constexpr (meta::is_associative<Tu>::value) {
typedef typename Tu::value_type P;
typedef typename P::first_type K;
typedef typename P::second_type V;
return check_two(types<K, V>(), arg_L, index, expect, std::forward<Handler>(handler), tracking);
}
else {
typedef typename Tu::value_type V;
return check_one(types<V>(), arg_L, index, expect, std::forward<Handler>(handler), tracking);
}
}
else {
unqualified_checker<Tu, expect> c {};
return c.check(arg_L, index, std::forward<Handler>(handler), tracking);
}
}
};
template <typename T, type expect>
struct unqualified_checker<non_exhaustive<T>, expect> {
template <typename Handler>
static bool check(lua_State* arg_L, int index, Handler&& handler, record& tracking) {
return stack::check<T>(arg_L, index, std::forward<Handler>(handler), tracking);
}
};
template <typename... Args> template <typename... Args>
struct unqualified_checker<std::tuple<Args...>, type::poly> { struct unqualified_checker<std::tuple<Args...>, type::poly> {
template <typename Handler> template <typename Handler>
@ -595,7 +694,7 @@ namespace sol { namespace stack {
} }
}; };
#if SOL_IS_ON(SOL_STD_VARIANT_I_) #if SOL_IS_ON(SOL_STD_VARIANT)
template <typename... Tn> template <typename... Tn>
struct unqualified_checker<std::variant<Tn...>, type::poly> { struct unqualified_checker<std::variant<Tn...>, type::poly> {

48
extern/sol3/sol/stack_core.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -127,7 +127,7 @@ namespace sol {
inline void* align_usertype_pointer(void* ptr) { inline void* align_usertype_pointer(void* ptr) {
using use_align = std::integral_constant<bool, using use_align = std::integral_constant<bool,
#if SOL_IS_OFF(SOL_ALIGN_MEMORY_I_) #if SOL_IS_OFF(SOL_ALIGN_MEMORY)
false false
#else #else
(std::alignment_of<void*>::value > 1) (std::alignment_of<void*>::value > 1)
@ -143,7 +143,7 @@ namespace sol {
template <bool pre_aligned = false, bool pre_shifted = false> template <bool pre_aligned = false, bool pre_shifted = false>
void* align_usertype_unique_destructor(void* ptr) { void* align_usertype_unique_destructor(void* ptr) {
using use_align = std::integral_constant<bool, using use_align = std::integral_constant<bool,
#if SOL_IS_OFF(SOL_ALIGN_MEMORY_I_) #if SOL_IS_OFF(SOL_ALIGN_MEMORY)
false false
#else #else
(std::alignment_of<unique_destructor>::value > 1) (std::alignment_of<unique_destructor>::value > 1)
@ -165,7 +165,7 @@ namespace sol {
template <bool pre_aligned = false, bool pre_shifted = false> template <bool pre_aligned = false, bool pre_shifted = false>
void* align_usertype_unique_tag(void* ptr) { void* align_usertype_unique_tag(void* ptr) {
using use_align = std::integral_constant<bool, using use_align = std::integral_constant<bool,
#if SOL_IS_OFF(SOL_ALIGN_MEMORY_I_) #if SOL_IS_OFF(SOL_ALIGN_MEMORY)
false false
#else #else
(std::alignment_of<unique_tag>::value > 1) (std::alignment_of<unique_tag>::value > 1)
@ -187,7 +187,7 @@ namespace sol {
template <typename T, bool pre_aligned = false, bool pre_shifted = false> template <typename T, bool pre_aligned = false, bool pre_shifted = false>
void* align_usertype_unique(void* ptr) { void* align_usertype_unique(void* ptr) {
typedef std::integral_constant<bool, typedef std::integral_constant<bool,
#if SOL_IS_OFF(SOL_ALIGN_MEMORY_I_) #if SOL_IS_OFF(SOL_ALIGN_MEMORY)
false false
#else #else
(std::alignment_of_v<T> > 1) (std::alignment_of_v<T> > 1)
@ -210,7 +210,7 @@ namespace sol {
template <typename T> template <typename T>
void* align_user(void* ptr) { void* align_user(void* ptr) {
typedef std::integral_constant<bool, typedef std::integral_constant<bool,
#if SOL_IS_OFF(SOL_ALIGN_MEMORY_I_) #if SOL_IS_OFF(SOL_ALIGN_MEMORY)
false false
#else #else
(std::alignment_of_v<T> > 1) (std::alignment_of_v<T> > 1)
@ -227,7 +227,7 @@ namespace sol {
template <typename T> template <typename T>
T** usertype_allocate_pointer(lua_State* L) { T** usertype_allocate_pointer(lua_State* L) {
typedef std::integral_constant<bool, typedef std::integral_constant<bool,
#if SOL_IS_OFF(SOL_ALIGN_MEMORY_I_) #if SOL_IS_OFF(SOL_ALIGN_MEMORY)
false false
#else #else
(std::alignment_of<T*>::value > 1) (std::alignment_of<T*>::value > 1)
@ -311,7 +311,7 @@ namespace sol {
template <typename T> template <typename T>
T* usertype_allocate(lua_State* L) { T* usertype_allocate(lua_State* L) {
typedef std::integral_constant<bool, typedef std::integral_constant<bool,
#if SOL_IS_OFF(SOL_ALIGN_MEMORY_I_) #if SOL_IS_OFF(SOL_ALIGN_MEMORY)
false false
#else #else
(std::alignment_of<T*>::value > 1 || std::alignment_of_v<T> > 1) (std::alignment_of<T*>::value > 1 || std::alignment_of_v<T> > 1)
@ -352,7 +352,7 @@ namespace sol {
template <typename T, typename Real> template <typename T, typename Real>
Real* usertype_unique_allocate(lua_State* L, T**& pref, unique_destructor*& dx, unique_tag*& id) { Real* usertype_unique_allocate(lua_State* L, T**& pref, unique_destructor*& dx, unique_tag*& id) {
typedef std::integral_constant<bool, typedef std::integral_constant<bool,
#if SOL_IS_OFF(SOL_ALIGN_MEMORY_I_) #if SOL_IS_OFF(SOL_ALIGN_MEMORY)
false false
#else #else
(std::alignment_of<T*>::value > 1 || std::alignment_of<unique_tag>::value > 1 || std::alignment_of<unique_destructor>::value > 1 (std::alignment_of<T*>::value > 1 || std::alignment_of<unique_tag>::value > 1 || std::alignment_of<unique_destructor>::value > 1
@ -370,10 +370,10 @@ namespace sol {
constexpr std::size_t initial_size = aligned_space_for<T*, unique_destructor, unique_tag, Real>(); constexpr std::size_t initial_size = aligned_space_for<T*, unique_destructor, unique_tag, Real>();
void* pointer_adjusted; void* pointer_adjusted = nullptr;
void* dx_adjusted; void* dx_adjusted = nullptr;
void* id_adjusted; void* id_adjusted = nullptr;
void* data_adjusted; void* data_adjusted = nullptr;
bool result = attempt_alloc_unique(L, bool result = attempt_alloc_unique(L,
std::alignment_of_v<T*>, std::alignment_of_v<T*>,
sizeof(T*), sizeof(T*),
@ -406,7 +406,7 @@ namespace sol {
template <typename T> template <typename T>
T* user_allocate(lua_State* L) { T* user_allocate(lua_State* L) {
typedef std::integral_constant<bool, typedef std::integral_constant<bool,
#if SOL_IS_OFF(SOL_ALIGN_MEMORY_I_) #if SOL_IS_OFF(SOL_ALIGN_MEMORY)
false false
#else #else
(std::alignment_of_v<T> > 1) (std::alignment_of_v<T> > 1)
@ -709,7 +709,6 @@ namespace sol {
} }
else { else {
unqualified_getter<Tu> g {}; unqualified_getter<Tu> g {};
(void)g;
return g.get(L, index, tracking); return g.get(L, index, tracking);
} }
} }
@ -721,7 +720,6 @@ namespace sol {
} }
else { else {
qualified_getter<T> g {}; qualified_getter<T> g {};
(void)g;
return g.get(L, index, tracking); return g.get(L, index, tracking);
} }
} }
@ -877,7 +875,6 @@ namespace sol {
} }
else { else {
unqualified_pusher<Tu> p {}; unqualified_pusher<Tu> p {};
(void)p;
return p.push(L, std::forward<T>(t), std::forward<Args>(args)...); return p.push(L, std::forward<T>(t), std::forward<Args>(args)...);
} }
} }
@ -897,7 +894,6 @@ namespace sol {
} }
else { else {
unqualified_pusher<Tu> p {}; unqualified_pusher<Tu> p {};
(void)p;
return p.push(L, std::forward<Arg>(arg), std::forward<Args>(args)...); return p.push(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
} }
} }
@ -928,7 +924,7 @@ namespace sol {
using use_reference_tag = using use_reference_tag =
meta::all< meta::all<
meta::neg<is_value_semantic_for_function<T>> meta::neg<is_value_semantic_for_function<T>>
#if SOL_IS_OFF(SOL_FUNCTION_CALL_VALUE_SEMANTICS_I_) #if SOL_IS_OFF(SOL_FUNCTION_CALL_VALUE_SEMANTICS)
, std::is_lvalue_reference<T>, , std::is_lvalue_reference<T>,
meta::neg<std::is_const<std::remove_reference_t<T>>>, meta::neg<std::is_const<std::remove_reference_t<T>>>,
meta::neg<is_lua_primitive<meta::unqualified_t<T>>>, meta::neg<is_lua_primitive<meta::unqualified_t<T>>>,
@ -983,9 +979,7 @@ namespace sol {
return sol_lua_check(types<Tu>(), L, index, std::forward<Handler>(handler), tracking); return sol_lua_check(types<Tu>(), L, index, std::forward<Handler>(handler), tracking);
} }
else { else {
unqualified_checker<Tu, lua_type_of_v<Tu>> c; unqualified_checker<Tu, lua_type_of_v<Tu>> c{};
// VC++ has a bad warning here: shut it up
(void)c;
return c.check(L, index, std::forward<Handler>(handler), tracking); return c.check(L, index, std::forward<Handler>(handler), tracking);
} }
} }
@ -1009,9 +1003,7 @@ namespace sol {
} }
else { else {
using Tu = meta::unqualified_t<T>; using Tu = meta::unqualified_t<T>;
qualified_checker<T, lua_type_of_v<Tu>> c; qualified_checker<T, lua_type_of_v<Tu>> c{};
// VC++ has a bad warning here: shut it up
(void)c;
return c.check(L, index, std::forward<Handler>(handler), tracking); return c.check(L, index, std::forward<Handler>(handler), tracking);
} }
} }
@ -1065,7 +1057,6 @@ namespace sol {
} }
else { else {
unqualified_check_getter<Tu> cg {}; unqualified_check_getter<Tu> cg {};
(void)cg;
return cg.get(L, index, std::forward<Handler>(handler), tracking); return cg.get(L, index, std::forward<Handler>(handler), tracking);
} }
} }
@ -1089,7 +1080,6 @@ namespace sol {
} }
else { else {
qualified_check_getter<T> cg {}; qualified_check_getter<T> cg {};
(void)cg;
return cg.get(L, index, std::forward<Handler>(handler), tracking); return cg.get(L, index, std::forward<Handler>(handler), tracking);
} }
} }
@ -1145,7 +1135,7 @@ namespace sol {
template <typename T> template <typename T>
auto unqualified_get(lua_State* L, int index, record& tracking) -> decltype(stack_detail::unchecked_unqualified_get<T>(L, index, tracking)) { auto unqualified_get(lua_State* L, int index, record& tracking) -> decltype(stack_detail::unchecked_unqualified_get<T>(L, index, tracking)) {
#if SOL_IS_ON(SOL_SAFE_GETTER_I_) #if SOL_IS_ON(SOL_SAFE_GETTER)
static constexpr bool is_op = meta::is_optional_v<T>; static constexpr bool is_op = meta::is_optional_v<T>;
if constexpr (is_op) { if constexpr (is_op) {
return stack_detail::unchecked_unqualified_get<T>(L, index, tracking); return stack_detail::unchecked_unqualified_get<T>(L, index, tracking);
@ -1170,7 +1160,7 @@ namespace sol {
template <typename T> template <typename T>
auto get(lua_State* L, int index, record& tracking) -> decltype(stack_detail::unchecked_get<T>(L, index, tracking)) { auto get(lua_State* L, int index, record& tracking) -> decltype(stack_detail::unchecked_get<T>(L, index, tracking)) {
#if SOL_IS_ON(SOL_SAFE_GETTER_I_) #if SOL_IS_ON(SOL_SAFE_GETTER)
static constexpr bool is_op = meta::is_optional_v<T>; static constexpr bool is_op = meta::is_optional_v<T>;
if constexpr (is_op) { if constexpr (is_op) {
return stack_detail::unchecked_get<T>(L, index, tracking); return stack_detail::unchecked_get<T>(L, index, tracking);

2
extern/sol3/sol/stack_field.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in

2
extern/sol3/sol/stack_get.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in

2
extern/sol3/sol/stack_get_qualified.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in

99
extern/sol3/sol/stack_get_unqualified.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -24,12 +24,15 @@
#ifndef SOL_STACK_UNQUALIFIED_GET_HPP #ifndef SOL_STACK_UNQUALIFIED_GET_HPP
#define SOL_STACK_UNQUALIFIED_GET_HPP #define SOL_STACK_UNQUALIFIED_GET_HPP
#include <sol/version.hpp>
#include <sol/stack_core.hpp> #include <sol/stack_core.hpp>
#include <sol/usertype_traits.hpp> #include <sol/usertype_traits.hpp>
#include <sol/inheritance.hpp> #include <sol/inheritance.hpp>
#include <sol/overload.hpp> #include <sol/overload.hpp>
#include <sol/error.hpp> #include <sol/error.hpp>
#include <sol/unicode.hpp> #include <sol/unicode.hpp>
#include <sol/abort.hpp>
#include <memory> #include <memory>
#include <functional> #include <functional>
@ -37,7 +40,7 @@
#include <cstdlib> #include <cstdlib>
#include <cmath> #include <cmath>
#include <string_view> #include <string_view>
#if SOL_IS_ON(SOL_STD_VARIANT_I_) #if SOL_IS_ON(SOL_STD_VARIANT)
#include <variant> #include <variant>
#endif // Apple clang screwed up #endif // Apple clang screwed up
@ -169,7 +172,7 @@ namespace sol { namespace stack {
luaL_Stream* pstream = static_cast<luaL_Stream*>(lua_touserdata(L, index)); luaL_Stream* pstream = static_cast<luaL_Stream*>(lua_touserdata(L, index));
return *pstream; return *pstream;
} }
#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE_I_) #if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE)
else if constexpr (std::is_function_v<T> || (std::is_pointer_v<T> && std::is_function_v<std::remove_pointer_t<T>>)) { else if constexpr (std::is_function_v<T> || (std::is_pointer_v<T> && std::is_function_v<std::remove_pointer_t<T>>)) {
return stack_detail::get_function_pointer<std::remove_pointer_t<T>>(L, index, tracking); return stack_detail::get_function_pointer<std::remove_pointer_t<T>>(L, index, tracking);
} }
@ -184,10 +187,10 @@ namespace sol { namespace stack {
struct qualified_getter { struct qualified_getter {
static decltype(auto) get(lua_State* L, int index, record& tracking) { static decltype(auto) get(lua_State* L, int index, record& tracking) {
using Tu = meta::unqualified_t<X>; using Tu = meta::unqualified_t<X>;
static constexpr bool is_userdata_of_some_kind static constexpr bool is_maybe_userdata_of_some_kind
= !std::is_reference_v< = !std::is_reference_v<
X> && is_container_v<Tu> && std::is_default_constructible_v<Tu> && !is_lua_primitive_v<Tu> && !is_transparent_argument_v<Tu>; X> && is_container_v<Tu> && std::is_default_constructible_v<Tu> && !is_lua_primitive_v<Tu> && !is_transparent_argument_v<Tu>;
if constexpr (is_userdata_of_some_kind) { if constexpr (is_maybe_userdata_of_some_kind) {
if (type_of(L, index) == type::userdata) { if (type_of(L, index) == type::userdata) {
return static_cast<Tu>(stack_detail::unchecked_unqualified_get<Tu>(L, index, tracking)); return static_cast<Tu>(stack_detail::unchecked_unqualified_get<Tu>(L, index, tracking));
} }
@ -210,11 +213,9 @@ namespace sol { namespace stack {
} }
actual r {}; actual r {};
if constexpr (!derive<element>::value) { if constexpr (!derive<element>::value) {
#if SOL_IS_ON(SOL_DEBUG_BUILD_I_)
// In debug mode we would rather abort you for this grave failure rather // In debug mode we would rather abort you for this grave failure rather
// than let you deref a null pointer and fuck everything over // than let you deref a null pointer and fuck everything over
std::abort(); SOL_DEBUG_ABORT();
#endif
return static_cast<actual>(std::move(r)); return static_cast<actual>(std::move(r));
} }
else { else {
@ -247,11 +248,7 @@ namespace sol { namespace stack {
// uh oh.. // uh oh..
break; break;
} }
#if SOL_IS_ON(SOL_DEBUG_BUILD_I_) SOL_DEBUG_ABORT();
// In debug mode we would rather abort you for this grave failure rather
// than let you deref a null pointer and fuck everything over
std::abort();
#endif
return static_cast<actual>(r); return static_cast<actual>(r);
} }
} }
@ -355,8 +352,8 @@ namespace sol { namespace stack {
} }
bool isnil = false; bool isnil = false;
for (int vi = 0; vi < lua_size<V>::value; ++vi) { for (int vi = 0; vi < lua_size<V>::value; ++vi) {
#if SOL_IS_ON(SOL_LUA_NIL_IN_TABLES_I_) && SOL_LUA_VERSION_I_ >= 600 #if SOL_IS_ON(SOL_LUA_NIL_IN_TABLES) && SOL_LUA_VERSION_I_ >= 600
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic); luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
lua_pushinteger(L, static_cast<lua_Integer>(i + vi)); lua_pushinteger(L, static_cast<lua_Integer>(i + vi));
@ -376,7 +373,7 @@ namespace sol { namespace stack {
if (i == 0) { if (i == 0) {
break; break;
} }
#if SOL_IS_ON(SOL_LUA_NIL_IN_TABLES_I_) && SOL_LUA_VERSION_I_ >= 600 #if SOL_IS_ON(SOL_LUA_NIL_IN_TABLES) && SOL_LUA_VERSION_I_ >= 600
lua_pop(L, vi); lua_pop(L, vi);
#else #else
lua_pop(L, (vi + 1)); lua_pop(L, (vi + 1));
@ -386,7 +383,7 @@ namespace sol { namespace stack {
} }
} }
if (isnil) { if (isnil) {
#if SOL_IS_ON(SOL_LUA_NIL_IN_TABLES_I_) && SOL_LUA_VERSION_I_ >= 600 #if SOL_IS_ON(SOL_LUA_NIL_IN_TABLES) && SOL_LUA_VERSION_I_ >= 600
#else #else
lua_pop(L, lua_size<V>::value); lua_pop(L, lua_size<V>::value);
#endif #endif
@ -404,7 +401,7 @@ namespace sol { namespace stack {
// see above comment // see above comment
goto done; goto done;
} }
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 2, detail::not_enough_stack_space_generic); luaL_checkstack(L, 2, detail::not_enough_stack_space_generic);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
bool isnil = false; bool isnil = false;
@ -443,7 +440,7 @@ namespace sol { namespace stack {
static T get(types<K, V>, lua_State* L, int relindex, record& tracking) { static T get(types<K, V>, lua_State* L, int relindex, record& tracking) {
tracking.use(1); tracking.use(1);
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 3, detail::not_enough_stack_space_generic); luaL_checkstack(L, 3, detail::not_enough_stack_space_generic);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
@ -486,7 +483,7 @@ namespace sol { namespace stack {
template <typename V> template <typename V>
static C get(types<V>, lua_State* L, int relindex, record& tracking) { static C get(types<V>, lua_State* L, int relindex, record& tracking) {
tracking.use(1); tracking.use(1);
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 3, detail::not_enough_stack_space_generic); luaL_checkstack(L, 3, detail::not_enough_stack_space_generic);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
@ -551,7 +548,7 @@ namespace sol { namespace stack {
static C get(types<K, V>, lua_State* L, int relindex, record& tracking) { static C get(types<K, V>, lua_State* L, int relindex, record& tracking) {
tracking.use(1); tracking.use(1);
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 3, detail::not_enough_stack_space_generic); luaL_checkstack(L, 3, detail::not_enough_stack_space_generic);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
@ -578,26 +575,20 @@ namespace sol { namespace stack {
using Tu = meta::unqualified_t<T>; using Tu = meta::unqualified_t<T>;
if constexpr (is_container_v<Tu>) { if constexpr (is_container_v<Tu>) {
if constexpr (meta::is_associative<Tu>::value) { if constexpr (meta::is_associative<Tu>::value) {
typedef typename T::value_type P; typedef typename Tu::value_type P;
typedef typename P::first_type K; typedef typename P::first_type K;
typedef typename P::second_type V; typedef typename P::second_type V;
unqualified_getter<as_table_t<T>> g; unqualified_getter<as_table_t<T>> g {};
// VC++ has a bad warning here: shut it up
(void)g;
return g.get(types<K, nested<V>>(), L, index, tracking); return g.get(types<K, nested<V>>(), L, index, tracking);
} }
else { else {
typedef typename T::value_type V; typedef typename Tu::value_type V;
unqualified_getter<as_table_t<T>> g; unqualified_getter<as_table_t<T>> g {};
// VC++ has a bad warning here: shut it up
(void)g;
return g.get(types<nested<V>>(), L, index, tracking); return g.get(types<nested<V>>(), L, index, tracking);
} }
} }
else { else {
unqualified_getter<Tu> g; unqualified_getter<Tu> g {};
// VC++ has a bad warning here: shut it up
(void)g;
return g.get(L, index, tracking); return g.get(L, index, tracking);
} }
} }
@ -617,6 +608,20 @@ namespace sol { namespace stack {
} }
}; };
template <typename T>
struct unqualified_getter<exhaustive<T>> {
static decltype(auto) get(lua_State* arg_L, int index, record& tracking) {
return stack::get<T>(arg_L, index, tracking);
}
};
template <typename T>
struct unqualified_getter<non_exhaustive<T>> {
static decltype(auto) get(lua_State* arg_L, int index, record& tracking) {
return stack::get<T>(arg_L, index, tracking);
}
};
template <> template <>
struct unqualified_getter<userdata_value> { struct unqualified_getter<userdata_value> {
static userdata_value get(lua_State* L, int index, record& tracking) { static userdata_value get(lua_State* L, int index, record& tracking) {
@ -883,7 +888,7 @@ namespace sol { namespace stack {
struct unqualified_getter<detail::as_value_tag<T>> { struct unqualified_getter<detail::as_value_tag<T>> {
static T* get_no_lua_nil(lua_State* L, int index, record& tracking) { static T* get_no_lua_nil(lua_State* L, int index, record& tracking) {
void* memory = lua_touserdata(L, index); void* memory = lua_touserdata(L, index);
#if SOL_IS_ON(SOL_USE_INTEROP_I_) #if SOL_IS_ON(SOL_USE_INTEROP)
auto ugr = stack_detail::interop_get<T>(L, index, memory, tracking); auto ugr = stack_detail::interop_get<T>(L, index, memory, tracking);
if (ugr.first) { if (ugr.first) {
return ugr.second; return ugr.second;
@ -933,9 +938,7 @@ namespace sol { namespace stack {
tracking.use(1); tracking.use(1);
return nullptr; return nullptr;
} }
unqualified_getter<detail::as_value_tag<T>> g; unqualified_getter<detail::as_value_tag<T>> g{};
// Avoid VC++ warning
(void)g;
return g.get_no_lua_nil(L, index, tracking); return g.get_no_lua_nil(L, index, tracking);
} }
}; };
@ -943,9 +946,7 @@ namespace sol { namespace stack {
template <typename T> template <typename T>
struct unqualified_getter<non_null<T*>> { struct unqualified_getter<non_null<T*>> {
static T* get(lua_State* L, int index, record& tracking) { static T* get(lua_State* L, int index, record& tracking) {
unqualified_getter<detail::as_value_tag<T>> g; unqualified_getter<detail::as_value_tag<T>> g{};
// Avoid VC++ warning
(void)g;
return g.get_no_lua_nil(L, index, tracking); return g.get_no_lua_nil(L, index, tracking);
} }
}; };
@ -953,9 +954,7 @@ namespace sol { namespace stack {
template <typename T> template <typename T>
struct unqualified_getter<T&> { struct unqualified_getter<T&> {
static T& get(lua_State* L, int index, record& tracking) { static T& get(lua_State* L, int index, record& tracking) {
unqualified_getter<detail::as_value_tag<T>> g; unqualified_getter<detail::as_value_tag<T>> g{};
// Avoid VC++ warning
(void)g;
return g.get(L, index, tracking); return g.get(L, index, tracking);
} }
}; };
@ -963,9 +962,7 @@ namespace sol { namespace stack {
template <typename T> template <typename T>
struct unqualified_getter<std::reference_wrapper<T>> { struct unqualified_getter<std::reference_wrapper<T>> {
static T& get(lua_State* L, int index, record& tracking) { static T& get(lua_State* L, int index, record& tracking) {
unqualified_getter<T&> g; unqualified_getter<T&> g{};
// Avoid VC++ warning
(void)g;
return g.get(L, index, tracking); return g.get(L, index, tracking);
} }
}; };
@ -973,20 +970,16 @@ namespace sol { namespace stack {
template <typename T> template <typename T>
struct unqualified_getter<T*> { struct unqualified_getter<T*> {
static T* get(lua_State* L, int index, record& tracking) { static T* get(lua_State* L, int index, record& tracking) {
#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE_I_) #if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE)
if constexpr (std::is_function_v<T>) { if constexpr (std::is_function_v<T>) {
return stack_detail::get_function_pointer<T>(L, index, tracking); return stack_detail::get_function_pointer<T>(L, index, tracking);
} }
else { else {
unqualified_getter<detail::as_pointer_tag<T>> g; unqualified_getter<detail::as_pointer_tag<T>> g{};
// Avoid VC++ warning
(void)g;
return g.get(L, index, tracking); return g.get(L, index, tracking);
} }
#else #else
unqualified_getter<detail::as_pointer_tag<T>> g; unqualified_getter<detail::as_pointer_tag<T>> g{};
// Avoid VC++ warning
(void)g;
return g.get(L, index, tracking); return g.get(L, index, tracking);
#endif #endif
} }
@ -1022,7 +1015,7 @@ namespace sol { namespace stack {
} }
}; };
#if SOL_IS_ON(SOL_STD_VARIANT_I_) #if SOL_IS_ON(SOL_STD_VARIANT)
template <typename... Tn> template <typename... Tn>
struct unqualified_getter<std::variant<Tn...>> { struct unqualified_getter<std::variant<Tn...>> {

4
extern/sol3/sol/stack_guard.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -31,7 +31,7 @@
namespace sol { namespace sol {
namespace detail { namespace detail {
inline void stack_fail(int, int) { inline void stack_fail(int, int) {
#if SOL_IS_OFF(SOL_EXCEPTIONS_I_) #if SOL_IS_ON(SOL_EXCEPTIONS)
throw error(detail::direct_error, "imbalanced stack after operation finish"); throw error(detail::direct_error, "imbalanced stack after operation finish");
#else #else
// Lol, what do you want, an error printout? :3c // Lol, what do you want, an error printout? :3c

2
extern/sol3/sol/stack_iterator.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in

2
extern/sol3/sol/stack_pop.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in

4
extern/sol3/sol/stack_probe.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -91,4 +91,4 @@ namespace sol { namespace stack {
}; };
}} // namespace sol::stack }} // namespace sol::stack
#endif // SOL_STACK_PROBE_HPP #endif // SOL_STACK_PROBE_HPP

2
extern/sol3/sol/stack_proxy.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in

2
extern/sol3/sol/stack_proxy_base.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in

107
extern/sol3/sol/stack_push.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -30,6 +30,7 @@
#include <sol/usertype_traits.hpp> #include <sol/usertype_traits.hpp>
#include <sol/policies.hpp> #include <sol/policies.hpp>
#include <sol/unicode.hpp> #include <sol/unicode.hpp>
#include <sol/assert.hpp>
#include <memory> #include <memory>
#include <type_traits> #include <type_traits>
@ -37,7 +38,7 @@
#include <limits> #include <limits>
#include <cmath> #include <cmath>
#include <string_view> #include <string_view>
#if SOL_IS_ON(SOL_STD_VARIANT_I_) #if SOL_IS_ON(SOL_STD_VARIANT)
#include <variant> #include <variant>
#endif // Can use variant #endif // Can use variant
@ -52,7 +53,7 @@ namespace sol { namespace stack {
constexpr bool is_same_signedness constexpr bool is_same_signedness
= (std::is_signed_v<T> && std::is_signed_v<lua_Integer>) || (std::is_unsigned_v<T> && std::is_unsigned_v<lua_Integer>); = (std::is_signed_v<T> && std::is_signed_v<lua_Integer>) || (std::is_unsigned_v<T> && std::is_unsigned_v<lua_Integer>);
constexpr bool probaby_fits_within_lua_Integer = sizeof(T) == sizeof(lua_Integer) constexpr bool probaby_fits_within_lua_Integer = sizeof(T) == sizeof(lua_Integer)
#if SOL_IS_ON(SOL_ALL_INTEGER_VALUES_FIT_I_) #if SOL_IS_ON(SOL_ALL_INTEGER_VALUES_FIT)
&& ((std::has_unique_object_representations_v<T> && std::has_unique_object_representations_v<lua_Integer>) ? true : is_same_signedness) && ((std::has_unique_object_representations_v<T> && std::has_unique_object_representations_v<lua_Integer>) ? true : is_same_signedness)
#else #else
&& is_same_signedness && is_same_signedness
@ -75,7 +76,7 @@ namespace sol { namespace stack {
int msvc_is_ass_with_if_constexpr_push_enum(std::true_type, lua_State* L, const T& value) { int msvc_is_ass_with_if_constexpr_push_enum(std::true_type, lua_State* L, const T& value) {
if constexpr (meta::any_same_v<std::underlying_type_t<T>, if constexpr (meta::any_same_v<std::underlying_type_t<T>,
char char
#if SOL_IS_ON(SOL_CHAR8_T_I_) #if SOL_IS_ON(SOL_CHAR8_T)
, ,
char8_t char8_t
#endif #endif
@ -101,7 +102,7 @@ namespace sol { namespace stack {
} // namespace stack_detail } // namespace stack_detail
inline int push_environment_of(lua_State* L, int target_index = -1) { inline int push_environment_of(lua_State* L, int target_index = -1) {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_environment); luaL_checkstack(L, 1, detail::not_enough_stack_space_environment);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
#if SOL_LUA_VERSION_I_ < 502 #if SOL_LUA_VERSION_I_ < 502
@ -141,14 +142,18 @@ namespace sol { namespace stack {
int push_environment_of(const T& target) { int push_environment_of(const T& target) {
lua_State* target_L = target.lua_state(); lua_State* target_L = target.lua_state();
int target_index = absolute_index(target_L, -target.push()); int target_index = absolute_index(target_L, -target.push());
return push_environment_of(target_L, target_index); int env_count = push_environment_of(target_L, target_index);
SOL_ASSERT(env_count == 1);
lua_rotate(target_L, target_index, 1);
lua_pop(target_L, 1);
return env_count;
} }
template <typename T> template <typename T>
struct unqualified_pusher<detail::as_value_tag<T>> { struct unqualified_pusher<detail::as_value_tag<T>> {
template <typename F, typename... Args> template <typename F, typename... Args>
static int push_fx(lua_State* L, F&& f, Args&&... args) { static int push_fx(lua_State* L, F&& f, Args&&... args) {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_userdata); luaL_checkstack(L, 1, detail::not_enough_stack_space_userdata);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
// Basically, we store all user-data like this: // Basically, we store all user-data like this:
@ -193,7 +198,7 @@ namespace sol { namespace stack {
static int push_fx(lua_State* L, F&& f, T* obj) { static int push_fx(lua_State* L, F&& f, T* obj) {
if (obj == nullptr) if (obj == nullptr)
return stack::push(L, lua_nil); return stack::push(L, lua_nil);
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_userdata); luaL_checkstack(L, 1, detail::not_enough_stack_space_userdata);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
T** pref = detail::usertype_allocate_pointer<T>(L); T** pref = detail::usertype_allocate_pointer<T>(L);
@ -249,7 +254,7 @@ namespace sol { namespace stack {
template <typename... Args> template <typename... Args>
static int push_deep(lua_State* L, Args&&... args) { static int push_deep(lua_State* L, Args&&... args) {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_userdata); luaL_checkstack(L, 1, detail::not_enough_stack_space_userdata);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
element** pointer_to_memory = nullptr; element** pointer_to_memory = nullptr;
@ -295,7 +300,7 @@ namespace sol { namespace stack {
return p[0]; return p[0];
} }
else if constexpr (std::is_same_v<Tu, bool>) { else if constexpr (std::is_same_v<Tu, bool>) {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic); luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
lua_pushboolean(L, std::forward<Args>(args)...); lua_pushboolean(L, std::forward<Args>(args)...);
@ -303,7 +308,7 @@ namespace sol { namespace stack {
} }
else if constexpr (std::is_integral_v<Tu> || std::is_same_v<Tu, lua_Integer>) { else if constexpr (std::is_integral_v<Tu> || std::is_same_v<Tu, lua_Integer>) {
const Tu& value(std::forward<Args>(args)...); const Tu& value(std::forward<Args>(args)...);
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_integral); luaL_checkstack(L, 1, detail::not_enough_stack_space_integral);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
#if SOL_LUA_VERSION_I_ >= 503 #if SOL_LUA_VERSION_I_ >= 503
@ -312,11 +317,11 @@ namespace sol { namespace stack {
return 1; return 1;
} }
#endif // Lua 5.3 and above #endif // Lua 5.3 and above
#if SOL_IS_ON(SOL_NUMBER_PRECISION_CHECKS_I_) #if SOL_IS_ON(SOL_NUMBER_PRECISION_CHECKS)
if (static_cast<T>(llround(static_cast<lua_Number>(value))) != value) { if (static_cast<T>(llround(static_cast<lua_Number>(value))) != value) {
#if SOL_IS_OFF(SOL_EXCEPTIONS_I_) #if SOL_IS_OFF(SOL_EXCEPTIONS)
// Is this really worth it? // Is this really worth it?
assert(false && "integer value will be misrepresented in lua"); SOL_ASSERT_MSG(false, "integer value will be misrepresented in lua");
lua_pushinteger(L, static_cast<lua_Integer>(value)); lua_pushinteger(L, static_cast<lua_Integer>(value));
return 1; return 1;
#else #else
@ -328,7 +333,7 @@ namespace sol { namespace stack {
return 1; return 1;
} }
else if constexpr (std::is_floating_point_v<Tu> || std::is_same_v<Tu, lua_Number>) { else if constexpr (std::is_floating_point_v<Tu> || std::is_same_v<Tu, lua_Number>) {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_floating); luaL_checkstack(L, 1, detail::not_enough_stack_space_floating);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
lua_pushnumber(L, std::forward<Args>(args)...); lua_pushnumber(L, std::forward<Args>(args)...);
@ -338,7 +343,7 @@ namespace sol { namespace stack {
luaL_Stream* source { std::forward<Args>(args)... }; luaL_Stream* source { std::forward<Args>(args)... };
luaL_Stream* stream = static_cast<luaL_Stream*>(detail::alloc_newuserdata(L, sizeof(luaL_Stream))); luaL_Stream* stream = static_cast<luaL_Stream*>(detail::alloc_newuserdata(L, sizeof(luaL_Stream)));
stream->f = source->f; stream->f = source->f;
#if SOL_IS_ON(SOL_LUAL_STREAM_USE_CLOSE_FUNCTION_I_) #if SOL_IS_ON(SOL_LUAL_STREAM_USE_CLOSE_FUNCTION)
stream->closef = source->closef; stream->closef = source->closef;
#endif // LuaJIT and Lua 5.1 and below do not have #endif // LuaJIT and Lua 5.1 and below do not have
return 1; return 1;
@ -347,7 +352,7 @@ namespace sol { namespace stack {
luaL_Stream& source(std::forward<Args>(args)...); luaL_Stream& source(std::forward<Args>(args)...);
luaL_Stream* stream = static_cast<luaL_Stream*>(detail::alloc_newuserdata(L, sizeof(luaL_Stream))); luaL_Stream* stream = static_cast<luaL_Stream*>(detail::alloc_newuserdata(L, sizeof(luaL_Stream)));
stream->f = source.f; stream->f = source.f;
#if SOL_IS_ON(SOL_LUAL_STREAM_USE_CLOSE_FUNCTION_I_) #if SOL_IS_ON(SOL_LUAL_STREAM_USE_CLOSE_FUNCTION)
stream->closef = source.closef; stream->closef = source.closef;
#endif // LuaJIT and Lua 5.1 and below do not have #endif // LuaJIT and Lua 5.1 and below do not have
return 1; return 1;
@ -423,7 +428,7 @@ namespace sol { namespace stack {
lua_seti(L, tableindex, static_cast<lua_Integer>(index++)); lua_seti(L, tableindex, static_cast<lua_Integer>(index++));
} }
#else #else
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic); luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
lua_pushinteger(L, static_cast<lua_Integer>(index)); lua_pushinteger(L, static_cast<lua_Integer>(index));
@ -436,7 +441,7 @@ namespace sol { namespace stack {
int firstindex = tableindex + 1 + 1; int firstindex = tableindex + 1 + 1;
for (int pi = 0; pi < p; ++pi) { for (int pi = 0; pi < p; ++pi) {
stack::push(L, index); stack::push(L, index);
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic); luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
lua_pushvalue(L, firstindex); lua_pushvalue(L, firstindex);
@ -506,8 +511,6 @@ namespace sol { namespace stack {
struct unqualified_pusher<std::initializer_list<T>> { struct unqualified_pusher<std::initializer_list<T>> {
static int push(lua_State* L, const std::initializer_list<T>& il) noexcept { static int push(lua_State* L, const std::initializer_list<T>& il) noexcept {
unqualified_pusher<detail::as_table_tag<std::initializer_list<T>>> p {}; unqualified_pusher<detail::as_table_tag<std::initializer_list<T>>> p {};
// silence annoying VC++ warning
(void)p;
return p.push(L, il); return p.push(L, il);
} }
}; };
@ -515,7 +518,7 @@ namespace sol { namespace stack {
template <> template <>
struct unqualified_pusher<lua_nil_t> { struct unqualified_pusher<lua_nil_t> {
static int push(lua_State* L, lua_nil_t) noexcept { static int push(lua_State* L, lua_nil_t) noexcept {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic); luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
lua_pushnil(L); lua_pushnil(L);
@ -533,7 +536,7 @@ namespace sol { namespace stack {
template <> template <>
struct unqualified_pusher<metatable_key_t> { struct unqualified_pusher<metatable_key_t> {
static int push(lua_State* L, metatable_key_t) { static int push(lua_State* L, metatable_key_t) {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic); luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
lua_pushlstring(L, to_string(meta_function::metatable).c_str(), 4); lua_pushlstring(L, to_string(meta_function::metatable).c_str(), 4);
@ -544,7 +547,7 @@ namespace sol { namespace stack {
template <> template <>
struct unqualified_pusher<std::remove_pointer_t<lua_CFunction>> { struct unqualified_pusher<std::remove_pointer_t<lua_CFunction>> {
static int push(lua_State* L, lua_CFunction func, int n = 0) noexcept { static int push(lua_State* L, lua_CFunction func, int n = 0) noexcept {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic); luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
lua_pushcclosure(L, func, n); lua_pushcclosure(L, func, n);
@ -555,7 +558,7 @@ namespace sol { namespace stack {
template <> template <>
struct unqualified_pusher<lua_CFunction> { struct unqualified_pusher<lua_CFunction> {
static int push(lua_State* L, lua_CFunction func, int n = 0) { static int push(lua_State* L, lua_CFunction func, int n = 0) {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic); luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
lua_pushcclosure(L, func, n); lua_pushcclosure(L, func, n);
@ -563,11 +566,11 @@ namespace sol { namespace stack {
} }
}; };
#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_) #if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
template <> template <>
struct unqualified_pusher<std::remove_pointer_t<detail::lua_CFunction_noexcept>> { struct unqualified_pusher<std::remove_pointer_t<detail::lua_CFunction_noexcept>> {
static int push(lua_State* L, detail::lua_CFunction_noexcept func, int n = 0) { static int push(lua_State* L, detail::lua_CFunction_noexcept func, int n = 0) {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic); luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
lua_pushcclosure(L, func, n); lua_pushcclosure(L, func, n);
@ -578,7 +581,7 @@ namespace sol { namespace stack {
template <> template <>
struct unqualified_pusher<detail::lua_CFunction_noexcept> { struct unqualified_pusher<detail::lua_CFunction_noexcept> {
static int push(lua_State* L, detail::lua_CFunction_noexcept func, int n = 0) { static int push(lua_State* L, detail::lua_CFunction_noexcept func, int n = 0) {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic); luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
lua_pushcclosure(L, func, n); lua_pushcclosure(L, func, n);
@ -590,7 +593,7 @@ namespace sol { namespace stack {
template <> template <>
struct unqualified_pusher<c_closure> { struct unqualified_pusher<c_closure> {
static int push(lua_State* L, c_closure cc) { static int push(lua_State* L, c_closure cc) {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic); luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
lua_pushcclosure(L, cc.c_function, cc.upvalues); lua_pushcclosure(L, cc.c_function, cc.upvalues);
@ -616,7 +619,7 @@ namespace sol { namespace stack {
template <> template <>
struct unqualified_pusher<void*> { struct unqualified_pusher<void*> {
static int push(lua_State* L, void* userdata) noexcept { static int push(lua_State* L, void* userdata) noexcept {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic); luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
lua_pushlightuserdata(L, userdata); lua_pushlightuserdata(L, userdata);
@ -627,7 +630,7 @@ namespace sol { namespace stack {
template <> template <>
struct unqualified_pusher<const void*> { struct unqualified_pusher<const void*> {
static int push(lua_State* L, const void* userdata) noexcept { static int push(lua_State* L, const void* userdata) noexcept {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic); luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
lua_pushlightuserdata(L, const_cast<void*>(userdata)); lua_pushlightuserdata(L, const_cast<void*>(userdata));
@ -638,7 +641,7 @@ namespace sol { namespace stack {
template <> template <>
struct unqualified_pusher<lightuserdata_value> { struct unqualified_pusher<lightuserdata_value> {
static int push(lua_State* L, lightuserdata_value userdata) noexcept { static int push(lua_State* L, lightuserdata_value userdata) noexcept {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic); luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
lua_pushlightuserdata(L, userdata); lua_pushlightuserdata(L, userdata);
@ -649,10 +652,10 @@ namespace sol { namespace stack {
template <typename T> template <typename T>
struct unqualified_pusher<light<T>> { struct unqualified_pusher<light<T>> {
static int push(lua_State* L, light<T> l) noexcept { static int push(lua_State* L, light<T> l) noexcept {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic); luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
lua_pushlightuserdata(L, static_cast<void*>(l.value)); lua_pushlightuserdata(L, static_cast<void*>(l.value()));
return 1; return 1;
} }
}; };
@ -661,14 +664,14 @@ namespace sol { namespace stack {
struct unqualified_pusher<user<T>> { struct unqualified_pusher<user<T>> {
template <bool with_meta = true, typename Key, typename... Args> template <bool with_meta = true, typename Key, typename... Args>
static int push_with(lua_State* L, Key&& name, Args&&... args) { static int push_with(lua_State* L, Key&& name, Args&&... args) {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_userdata); luaL_checkstack(L, 1, detail::not_enough_stack_space_userdata);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
// A dumb pusher // A dumb pusher
T* data = detail::user_allocate<T>(L); T* data = detail::user_allocate<T>(L);
if (with_meta) { if (with_meta) {
// Make sure we have a plain GC set for this data // Make sure we have a plain GC set for this data
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic); luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
if (luaL_newmetatable(L, name) != 0) { if (luaL_newmetatable(L, name) != 0) {
@ -724,7 +727,7 @@ namespace sol { namespace stack {
template <> template <>
struct unqualified_pusher<userdata_value> { struct unqualified_pusher<userdata_value> {
static int push(lua_State* L, userdata_value data) { static int push(lua_State* L, userdata_value data) {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_userdata); luaL_checkstack(L, 1, detail::not_enough_stack_space_userdata);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
void** ud = detail::usertype_allocate_pointer<void>(L); void** ud = detail::usertype_allocate_pointer<void>(L);
@ -736,7 +739,7 @@ namespace sol { namespace stack {
template <> template <>
struct unqualified_pusher<const char*> { struct unqualified_pusher<const char*> {
static int push_sized(lua_State* L, const char* str, std::size_t len) { static int push_sized(lua_State* L, const char* str, std::size_t len) {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_string); luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
lua_pushlstring(L, str, len); lua_pushlstring(L, str, len);
@ -788,7 +791,7 @@ namespace sol { namespace stack {
template <size_t N> template <size_t N>
struct unqualified_pusher<char[N]> { struct unqualified_pusher<char[N]> {
static int push(lua_State* L, const char (&str)[N]) { static int push(lua_State* L, const char (&str)[N]) {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_string); luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
lua_pushlstring(L, str, std::char_traits<char>::length(str)); lua_pushlstring(L, str, std::char_traits<char>::length(str));
@ -796,7 +799,7 @@ namespace sol { namespace stack {
} }
static int push(lua_State* L, const char (&str)[N], std::size_t sz) { static int push(lua_State* L, const char (&str)[N], std::size_t sz) {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_string); luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
lua_pushlstring(L, str, sz); lua_pushlstring(L, str, sz);
@ -812,11 +815,11 @@ namespace sol { namespace stack {
} }
}; };
#if SOL_IS_ON(SOL_CHAR8_T_I_) #if SOL_IS_ON(SOL_CHAR8_T)
template <> template <>
struct unqualified_pusher<const char8_t*> { struct unqualified_pusher<const char8_t*> {
static int push_sized(lua_State* L, const char8_t* str, std::size_t len) { static int push_sized(lua_State* L, const char8_t* str, std::size_t len) {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_string); luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
lua_pushlstring(L, reinterpret_cast<const char*>(str), len); lua_pushlstring(L, reinterpret_cast<const char*>(str), len);
@ -868,7 +871,7 @@ namespace sol { namespace stack {
template <size_t N> template <size_t N>
struct unqualified_pusher<char8_t[N]> { struct unqualified_pusher<char8_t[N]> {
static int push(lua_State* L, const char8_t (&str)[N]) { static int push(lua_State* L, const char8_t (&str)[N]) {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_string); luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
const char* str_as_char = reinterpret_cast<const char*>(static_cast<const char8_t*>(str)); const char* str_as_char = reinterpret_cast<const char*>(static_cast<const char8_t*>(str));
@ -877,7 +880,7 @@ namespace sol { namespace stack {
} }
static int push(lua_State* L, const char8_t (&str)[N], std::size_t sz) { static int push(lua_State* L, const char8_t (&str)[N], std::size_t sz) {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_string); luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
lua_pushlstring(L, str, sz); lua_pushlstring(L, str, sz);
@ -902,7 +905,7 @@ namespace sol { namespace stack {
return stack::push(L, str.data(), str.size()); return stack::push(L, str.data(), str.size());
} }
else { else {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_string); luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
lua_pushlstring(L, str.c_str(), str.size()); lua_pushlstring(L, str.c_str(), str.size());
@ -915,7 +918,7 @@ namespace sol { namespace stack {
return stack::push(L, str.data(), sz); return stack::push(L, str.data(), sz);
} }
else { else {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_string); luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
lua_pushlstring(L, str.c_str(), sz); lua_pushlstring(L, str.c_str(), sz);
@ -938,7 +941,7 @@ namespace sol { namespace stack {
template <> template <>
struct unqualified_pusher<meta_function> { struct unqualified_pusher<meta_function> {
static int push(lua_State* L, meta_function m) { static int push(lua_State* L, meta_function m) {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_meta_function_name); luaL_checkstack(L, 1, detail::not_enough_stack_space_meta_function_name);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
const std::string& str = to_string(m); const std::string& str = to_string(m);
@ -950,7 +953,7 @@ namespace sol { namespace stack {
template <> template <>
struct unqualified_pusher<absolute_index> { struct unqualified_pusher<absolute_index> {
static int push(lua_State* L, absolute_index ai) { static int push(lua_State* L, absolute_index ai) {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic); luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
lua_pushvalue(L, ai); lua_pushvalue(L, ai);
@ -961,7 +964,7 @@ namespace sol { namespace stack {
template <> template <>
struct unqualified_pusher<raw_index> { struct unqualified_pusher<raw_index> {
static int push(lua_State* L, raw_index ri) { static int push(lua_State* L, raw_index ri) {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic); luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
lua_pushvalue(L, ri); lua_pushvalue(L, ri);
@ -972,7 +975,7 @@ namespace sol { namespace stack {
template <> template <>
struct unqualified_pusher<ref_index> { struct unqualified_pusher<ref_index> {
static int push(lua_State* L, ref_index ri) { static int push(lua_State* L, ref_index ri) {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, detail::not_enough_stack_space_generic); luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
lua_rawgeti(L, LUA_REGISTRYINDEX, ri); lua_rawgeti(L, LUA_REGISTRYINDEX, ri);
@ -1244,7 +1247,7 @@ namespace sol { namespace stack {
struct unqualified_pusher<std::tuple<Args...>> { struct unqualified_pusher<std::tuple<Args...>> {
template <std::size_t... I, typename T> template <std::size_t... I, typename T>
static int push(std::index_sequence<I...>, lua_State* L, T&& t) { static int push(std::index_sequence<I...>, lua_State* L, T&& t) {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, static_cast<int>(sizeof...(I)), detail::not_enough_stack_space_generic); luaL_checkstack(L, static_cast<int>(sizeof...(I)), detail::not_enough_stack_space_generic);
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
int pushcount = 0; int pushcount = 0;
@ -1348,7 +1351,7 @@ namespace sol { namespace stack {
} }
}; };
#if SOL_IS_ON(SOL_STD_VARIANT_I_) #if SOL_IS_ON(SOL_STD_VARIANT)
namespace stack_detail { namespace stack_detail {
struct push_function { struct push_function {

6
extern/sol3/sol/stack_reference.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -70,7 +70,7 @@ namespace sol {
stateless_stack_reference& operator=(const stateless_stack_reference&) noexcept = default; stateless_stack_reference& operator=(const stateless_stack_reference&) noexcept = default;
int push(lua_State* L_) const noexcept { int push(lua_State* L_) const noexcept {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L_, 1, "not enough Lua stack space to push a single reference value"); luaL_checkstack(L_, 1, "not enough Lua stack space to push a single reference value");
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
lua_pushvalue(L_, m_index); lua_pushvalue(L_, m_index);
@ -153,7 +153,7 @@ namespace sol {
} }
int i = r.stack_index(); int i = r.stack_index();
if (detail::xmovable(lua_state(), r.lua_state())) { if (detail::xmovable(lua_state(), r.lua_state())) {
#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_) #if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
luaL_checkstack(L, 1, "not enough Lua stack space to push a single reference value"); luaL_checkstack(L, 1, "not enough Lua stack space to push a single reference value");
#endif // make sure stack doesn't overflow #endif // make sure stack doesn't overflow
lua_pushvalue(r.lua_state(), r.stack_index()); lua_pushvalue(r.lua_state(), r.stack_index());

2
extern/sol3/sol/state.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in

18
extern/sol3/sol/state_handling.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -31,7 +31,7 @@
#include <sol/object.hpp> #include <sol/object.hpp>
#include <sol/lua_value.hpp> #include <sol/lua_value.hpp>
#if SOL_IS_ON(SOL_PRINT_ERRORS_I_) #if SOL_IS_ON(SOL_PRINT_ERRORS)
#include <iostream> #include <iostream>
#endif #endif
@ -51,7 +51,7 @@ namespace sol {
} }
inline int default_at_panic(lua_State* L) { inline int default_at_panic(lua_State* L) {
#if SOL_IS_OFF(SOL_EXCEPTIONS_I_) #if SOL_IS_OFF(SOL_EXCEPTIONS)
(void)L; (void)L;
return -1; return -1;
#else #else
@ -60,7 +60,7 @@ namespace sol {
if (message) { if (message) {
std::string err(message, messagesize); std::string err(message, messagesize);
lua_settop(L, 0); lua_settop(L, 0);
#if SOL_IS_ON(SOL_PRINT_ERRORS_I_) #if SOL_IS_ON(SOL_PRINT_ERRORS)
std::cerr << "[sol2] An error occurred and panic has been invoked: "; std::cerr << "[sol2] An error occurred and panic has been invoked: ";
std::cerr << err; std::cerr << err;
std::cerr << std::endl; std::cerr << std::endl;
@ -85,7 +85,7 @@ namespace sol {
const string_view& traceback = maybetraceback.value(); const string_view& traceback = maybetraceback.value();
msg.assign(traceback.data(), traceback.size()); msg.assign(traceback.data(), traceback.size());
} }
#if SOL_IS_ON(SOL_PRINT_ERRORS_I_) #if SOL_IS_ON(SOL_PRINT_ERRORS)
// std::cerr << "[sol2] An error occurred and was caught in traceback: "; // std::cerr << "[sol2] An error occurred and was caught in traceback: ";
// std::cerr << msg; // std::cerr << msg;
// std::cerr << std::endl; // std::cerr << std::endl;
@ -120,7 +120,7 @@ namespace sol {
std::string err = "sol: "; std::string err = "sol: ";
err += to_string(result.status()); err += to_string(result.status());
err += " error"; err += " error";
#if SOL_IS_ON(SOL_EXCEPTIONS_I_) #if SOL_IS_ON(SOL_EXCEPTIONS)
std::exception_ptr eptr = std::current_exception(); std::exception_ptr eptr = std::current_exception();
if (eptr) { if (eptr) {
err += " with a "; err += " with a ";
@ -149,7 +149,7 @@ namespace sol {
string_view serr = stack::unqualified_get<string_view>(L, result.stack_index()); string_view serr = stack::unqualified_get<string_view>(L, result.stack_index());
err.append(serr.data(), serr.size()); err.append(serr.data(), serr.size());
} }
#if SOL_IS_ON(SOL_PRINT_ERRORS_I_) #if SOL_IS_ON(SOL_PRINT_ERRORS)
std::cerr << "[sol2] An error occurred and has been passed to an error handler: "; std::cerr << "[sol2] An error occurred and has been passed to an error handler: ";
std::cerr << err; std::cerr << err;
std::cerr << std::endl; std::cerr << std::endl;
@ -165,7 +165,7 @@ namespace sol {
if (towards != 0) { if (towards != 0) {
lua_rotate(L, top, towards); lua_rotate(L, top, towards);
} }
#if SOL_IS_OFF(SOL_EXCEPTIONS_I_) #if SOL_IS_OFF(SOL_EXCEPTIONS)
return result; return result;
#else #else
// just throw our error // just throw our error
@ -174,7 +174,7 @@ namespace sol {
} }
inline protected_function_result script_default_on_error(lua_State* L, protected_function_result pfr) { inline protected_function_result script_default_on_error(lua_State* L, protected_function_result pfr) {
#if SOL_IS_ON(SOL_DEFAULT_PASS_ON_ERROR_I_) #if SOL_IS_ON(SOL_DEFAULT_PASS_ON_ERROR)
return script_pass_on_error(L, std::move(pfr)); return script_pass_on_error(L, std::move(pfr));
#else #else
return script_throw_on_error(L, std::move(pfr)); return script_throw_on_error(L, std::move(pfr));

18
extern/sol3/sol/state_view.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -129,7 +129,7 @@ namespace sol {
for (auto&& library : libraries) { for (auto&& library : libraries) {
switch (library) { switch (library) {
#if SOL_LUA_VERSION_I_ <= 501 && SOL_IS_ON(SOL_USE_LUAJIT_I_) #if SOL_LUA_VERSION_I_ <= 501 && SOL_IS_ON(SOL_USE_LUAJIT)
case lib::coroutine: case lib::coroutine:
#endif // luajit opens coroutine base stuff #endif // luajit opens coroutine base stuff
case lib::base: case lib::base:
@ -140,7 +140,7 @@ namespace sol {
luaL_requiref(L, "package", luaopen_package, 1); luaL_requiref(L, "package", luaopen_package, 1);
lua_pop(L, 1); lua_pop(L, 1);
break; break;
#if SOL_IS_OFF(SOL_USE_LUAJIT_I_) #if SOL_IS_OFF(SOL_USE_LUAJIT)
case lib::coroutine: case lib::coroutine:
#if SOL_LUA_VERSION_I_ > 501 #if SOL_LUA_VERSION_I_ > 501
luaL_requiref(L, "coroutine", luaopen_coroutine, 1); luaL_requiref(L, "coroutine", luaopen_coroutine, 1);
@ -161,10 +161,10 @@ namespace sol {
lua_pop(L, 1); lua_pop(L, 1);
break; break;
case lib::bit32: case lib::bit32:
#if SOL_IS_ON(SOL_USE_LUAJIT_I_) #if SOL_IS_ON(SOL_USE_LUAJIT)
luaL_requiref(L, "bit32", luaopen_bit, 1); luaL_requiref(L, "bit32", luaopen_bit, 1);
lua_pop(L, 1); lua_pop(L, 1);
#elif SOL_IS_ON(SOL_LUA_BIT32_LIB_I_) #elif SOL_IS_ON(SOL_LUA_BIT32_LIB)
luaL_requiref(L, "bit32", luaopen_bit32, 1); luaL_requiref(L, "bit32", luaopen_bit32, 1);
lua_pop(L, 1); lua_pop(L, 1);
#else #else
@ -183,19 +183,19 @@ namespace sol {
lua_pop(L, 1); lua_pop(L, 1);
break; break;
case lib::utf8: case lib::utf8:
#if SOL_LUA_VERSION_I_ > 502 && SOL_IS_OFF(SOL_USE_LUAJIT_I_) #if SOL_LUA_VERSION_I_ > 502 && SOL_IS_OFF(SOL_USE_LUAJIT)
luaL_requiref(L, "utf8", luaopen_utf8, 1); luaL_requiref(L, "utf8", luaopen_utf8, 1);
lua_pop(L, 1); lua_pop(L, 1);
#endif // Lua 5.3+ only #endif // Lua 5.3+ only
break; break;
case lib::ffi: case lib::ffi:
#if SOL_IS_ON(SOL_USE_LUAJIT_I_) && SOL_IS_OFF(SOL_LUAJIT_FFI_DISABLED_I_) #if SOL_IS_ON(SOL_USE_LUAJIT) && SOL_IS_OFF(SOL_LUAJIT_FFI_DISABLED)
luaL_requiref(L, "ffi", luaopen_ffi, 1); luaL_requiref(L, "ffi", luaopen_ffi, 1);
lua_pop(L, 1); lua_pop(L, 1);
#endif // LuaJIT only #endif // LuaJIT only
break; break;
case lib::jit: case lib::jit:
#if SOL_IS_ON(SOL_USE_LUAJIT_I_) #if SOL_IS_ON(SOL_USE_LUAJIT)
luaL_requiref(L, "jit", luaopen_jit, 0); luaL_requiref(L, "jit", luaopen_jit, 0);
lua_pop(L, 1); lua_pop(L, 1);
#endif // LuaJIT Only #endif // LuaJIT Only
@ -551,7 +551,7 @@ namespace sol {
return safe_script_file(filename, env, script_default_on_error, mode); return safe_script_file(filename, env, script_default_on_error, mode);
} }
#if SOL_IS_ON(SOL_SAFE_FUNCTION_OBJECTS_I_) #if SOL_IS_ON(SOL_SAFE_FUNCTION_OBJECTS)
protected_function_result script( protected_function_result script(
lua_Reader reader, void* data, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) { lua_Reader reader, void* data, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
return safe_script(reader, data, chunkname, mode); return safe_script(reader, data, chunkname, mode);

2
extern/sol3/sol/string_view.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in

2
extern/sol3/sol/table.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in

12
extern/sol3/sol/table_core.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -330,7 +330,7 @@ namespace sol {
template <typename T, meta::enable_any<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler> template <typename T, meta::enable_any<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
basic_table_core(lua_State* L, T&& r) : base_t(L, std::forward<T>(r)) { basic_table_core(lua_State* L, T&& r) : base_t(L, std::forward<T>(r)) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
auto pp = stack::push_pop(*this); auto pp = stack::push_pop(*this);
int table_index = pp.index_of(*this); int table_index = pp.index_of(*this);
constructor_handler handler {}; constructor_handler handler {};
@ -345,14 +345,14 @@ namespace sol {
} }
basic_table_core(lua_State* L, int index = -1) : basic_table_core(detail::no_safety, L, index) { basic_table_core(lua_State* L, int index = -1) : basic_table_core(detail::no_safety, L, index) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
constructor_handler handler {}; constructor_handler handler {};
stack::check<basic_table_core>(L, index, handler); stack::check<basic_table_core>(L, index, handler);
#endif // Safety #endif // Safety
} }
basic_table_core(lua_State* L, ref_index index) : basic_table_core(detail::no_safety, L, index) { basic_table_core(lua_State* L, ref_index index) : basic_table_core(detail::no_safety, L, index) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
auto pp = stack::push_pop(*this); auto pp = stack::push_pop(*this);
int table_index = pp.index_of(*this); int table_index = pp.index_of(*this);
constructor_handler handler {}; constructor_handler handler {};
@ -364,7 +364,7 @@ namespace sol {
meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_table_core>>, meta::neg<std::is_same<ref_t, stack_reference>>, meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_table_core>>, meta::neg<std::is_same<ref_t, stack_reference>>,
meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler> meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
basic_table_core(T&& r) noexcept : basic_table_core(detail::no_safety, std::forward<T>(r)) { basic_table_core(T&& r) noexcept : basic_table_core(detail::no_safety, std::forward<T>(r)) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
if (!is_table<meta::unqualified_t<T>>::value) { if (!is_table<meta::unqualified_t<T>>::value) {
auto pp = stack::push_pop(*this); auto pp = stack::push_pop(*this);
int table_index = pp.index_of(*this); int table_index = pp.index_of(*this);
@ -644,7 +644,7 @@ namespace sol {
auto pp = stack::push_pop(*this); auto pp = stack::push_pop(*this);
int table_index = pp.index_of(*this); int table_index = pp.index_of(*this);
lua_State* L = base_t::lua_state(); lua_State* L = base_t::lua_state();
(void)detail::swallow { 0, (stack::set_ref(L, std::forward<Args>(args), table_index), 0)... }; (void)detail::swallow { 0, (stack::stack_detail::raw_table_set(L, std::forward<Args>(args), table_index), 0)... };
return *this; return *this;
} }

2
extern/sol3/sol/table_iterator.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in

22
extern/sol3/sol/table_proxy.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -77,6 +77,15 @@ namespace sol {
table_proxy(Table table, T&& k) : tbl(table), key(std::forward<T>(k)) { table_proxy(Table table, T&& k) : tbl(table), key(std::forward<T>(k)) {
} }
table_proxy(const table_proxy&) = default;
table_proxy(table_proxy&&) = default;
table_proxy& operator=(const table_proxy& right) {
return set(right);
}
table_proxy& operator=(table_proxy&& right) {
return set(std::move(right));
}
template <typename T> template <typename T>
table_proxy& set(T&& item) & { table_proxy& set(T&& item) & {
tuple_set(std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>(), std::forward<T>(item)); tuple_set(std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>(), std::forward<T>(item));
@ -101,7 +110,7 @@ namespace sol {
return std::move(*this); return std::move(*this);
} }
template <typename T> template <typename T, std::enable_if_t<!std::is_same_v<meta::unqualified_t<T>, table_proxy>>* = nullptr>
table_proxy& operator=(T&& other) & { table_proxy& operator=(T&& other) & {
using Tu = meta::unwrap_unqualified_t<T>; using Tu = meta::unwrap_unqualified_t<T>;
if constexpr (!is_lua_reference_or_proxy_v<Tu> && meta::is_invocable_v<Tu>) { if constexpr (!is_lua_reference_or_proxy_v<Tu> && meta::is_invocable_v<Tu>) {
@ -112,7 +121,7 @@ namespace sol {
} }
} }
template <typename T> template <typename T, std::enable_if_t<!std::is_same_v<meta::unqualified_t<T>, table_proxy>>* = nullptr>
table_proxy&& operator=(T&& other) && { table_proxy&& operator=(T&& other) && {
using Tu = meta::unwrap_unqualified_t<T>; using Tu = meta::unwrap_unqualified_t<T>;
if constexpr (!is_lua_reference_or_proxy_v<Tu> && meta::is_invocable_v<Tu> && !detail::is_msvc_callable_rigged_v<T>) { if constexpr (!is_lua_reference_or_proxy_v<Tu> && meta::is_invocable_v<Tu> && !detail::is_msvc_callable_rigged_v<T>) {
@ -133,6 +142,13 @@ namespace sol {
return std::move(*this).set(std::move(other)); return std::move(*this).set(std::move(other));
} }
template <typename T>
bool is() const {
typedef decltype(get<T>()) U;
optional<U> option = this->get<optional<U>>();
return option.has_value();
}
template <typename T> template <typename T>
decltype(auto) get() const& { decltype(auto) get() const& {
using idx_seq = std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>; using idx_seq = std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>;

12
extern/sol3/sol/thread.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -94,7 +94,7 @@ namespace sol {
template <typename T, template <typename T,
meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_thread>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler> meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_thread>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
basic_thread(T&& r) : base_t(std::forward<T>(r)) { basic_thread(T&& r) : base_t(std::forward<T>(r)) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
auto pp = stack::push_pop(*this); auto pp = stack::push_pop(*this);
constructor_handler handler {}; constructor_handler handler {};
stack::check<basic_thread>(lua_state(), -1, handler); stack::check<basic_thread>(lua_state(), -1, handler);
@ -106,20 +106,20 @@ namespace sol {
basic_thread& operator=(basic_thread&&) = default; basic_thread& operator=(basic_thread&&) = default;
template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler> template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
basic_thread(lua_State* L, T&& r) : base_t(L, std::forward<T>(r)) { basic_thread(lua_State* L, T&& r) : base_t(L, std::forward<T>(r)) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
auto pp = stack::push_pop(*this); auto pp = stack::push_pop(*this);
constructor_handler handler {}; constructor_handler handler {};
stack::check<basic_thread>(lua_state(), -1, handler); stack::check<basic_thread>(lua_state(), -1, handler);
#endif // Safety #endif // Safety
} }
basic_thread(lua_State* L, int index = -1) : base_t(L, index) { basic_thread(lua_State* L, int index = -1) : base_t(L, index) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
constructor_handler handler {}; constructor_handler handler {};
stack::check<basic_thread>(L, index, handler); stack::check<basic_thread>(L, index, handler);
#endif // Safety #endif // Safety
} }
basic_thread(lua_State* L, ref_index index) : base_t(L, index) { basic_thread(lua_State* L, ref_index index) : base_t(L, index) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
auto pp = stack::push_pop(*this); auto pp = stack::push_pop(*this);
constructor_handler handler {}; constructor_handler handler {};
stack::check<basic_thread>(lua_state(), -1, handler); stack::check<basic_thread>(lua_state(), -1, handler);
@ -130,7 +130,7 @@ namespace sol {
basic_thread(lua_State* L, this_state actualthread) : basic_thread(L, lua_thread_state { actualthread.L }) { basic_thread(lua_State* L, this_state actualthread) : basic_thread(L, lua_thread_state { actualthread.L }) {
} }
basic_thread(lua_State* L, lua_thread_state actualthread) : base_t(L, -stack::push(L, actualthread)) { basic_thread(lua_State* L, lua_thread_state actualthread) : base_t(L, -stack::push(L, actualthread)) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_) #if SOL_IS_ON(SOL_SAFE_REFERENCES)
constructor_handler handler {}; constructor_handler handler {};
stack::check<basic_thread>(lua_state(), -1, handler); stack::check<basic_thread>(lua_state(), -1, handler);
#endif // Safety #endif // Safety

2
extern/sol3/sol/tie.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in

39
extern/sol3/sol/traits.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -37,7 +37,7 @@
#include <array> #include <array>
#include <iterator> #include <iterator>
#include <iosfwd> #include <iosfwd>
#if SOL_IS_ON(SOL_STD_VARIANT_I_) #if SOL_IS_ON(SOL_STD_VARIANT)
#include <variant> #include <variant>
#endif // variant is weird on XCode, thanks XCode #endif // variant is weird on XCode, thanks XCode
@ -479,7 +479,7 @@ namespace sol { namespace meta {
template <typename T, typename U> template <typename T, typename U>
class supports_op_less_test<T, U, void_t<decltype(std::declval<T&>() < std::declval<U&>())>> class supports_op_less_test<T, U, void_t<decltype(std::declval<T&>() < std::declval<U&>())>>
: public std::integral_constant<bool, : public std::integral_constant<bool,
#if SOL_IS_ON(SOL_STD_VARIANT_I_) #if SOL_IS_ON(SOL_STD_VARIANT)
!is_specialization_of_v<unqualified_t<T>, std::variant> && !is_specialization_of_v<unqualified_t<U>, std::variant> !is_specialization_of_v<unqualified_t<T>, std::variant> && !is_specialization_of_v<unqualified_t<U>, std::variant>
#else #else
true true
@ -492,7 +492,7 @@ namespace sol { namespace meta {
template <typename T, typename U> template <typename T, typename U>
class supports_op_equal_test<T, U, void_t<decltype(std::declval<T&>() == std::declval<U&>())>> class supports_op_equal_test<T, U, void_t<decltype(std::declval<T&>() == std::declval<U&>())>>
: public std::integral_constant<bool, : public std::integral_constant<bool,
#if SOL_IS_ON(SOL_STD_VARIANT_I_) #if SOL_IS_ON(SOL_STD_VARIANT)
!is_specialization_of_v<unqualified_t<T>, std::variant> && !is_specialization_of_v<unqualified_t<U>, std::variant> !is_specialization_of_v<unqualified_t<T>, std::variant> && !is_specialization_of_v<unqualified_t<U>, std::variant>
#else #else
true true
@ -505,7 +505,7 @@ namespace sol { namespace meta {
template <typename T, typename U> template <typename T, typename U>
class supports_op_less_equal_test<T, U, void_t<decltype(std::declval<T&>() <= std::declval<U&>())>> class supports_op_less_equal_test<T, U, void_t<decltype(std::declval<T&>() <= std::declval<U&>())>>
: public std::integral_constant<bool, : public std::integral_constant<bool,
#if SOL_IS_ON(SOL_STD_VARIANT_I_) #if SOL_IS_ON(SOL_STD_VARIANT)
!is_specialization_of_v<unqualified_t<T>, std::variant> && !is_specialization_of_v<unqualified_t<U>, std::variant> !is_specialization_of_v<unqualified_t<T>, std::variant> && !is_specialization_of_v<unqualified_t<U>, std::variant>
#else #else
true true
@ -530,8 +530,20 @@ namespace sol { namespace meta {
template <typename T> template <typename T>
using non_void_t = meta::conditional_t<std::is_void_v<T>, ::sol::detail::unchecked_t, T>; using non_void_t = meta::conditional_t<std::is_void_v<T>, ::sol::detail::unchecked_t, T>;
template <typename T>
using detect_sentinel = typename T::sentinel;
} // namespace meta_detail } // namespace meta_detail
template <typename T, typename Fallback>
class sentinel_or {
public:
using type = detected_or_t<Fallback, meta_detail::detect_sentinel, T>;
};
template <typename T, typename Fallback>
using sentinel_or_t = typename sentinel_or<T, Fallback>::type;
template <typename T, typename U = T> template <typename T, typename U = T>
class supports_op_less : public meta_detail::supports_op_less_test<T, U> { }; class supports_op_less : public meta_detail::supports_op_less_test<T, U> { };
@ -626,11 +638,12 @@ namespace sol { namespace meta {
constexpr inline bool is_string_literal_array_of_v = is_string_literal_array_of<T, CharT>::value; constexpr inline bool is_string_literal_array_of_v = is_string_literal_array_of<T, CharT>::value;
template <typename T> template <typename T>
using is_string_literal_array = boolean<std::is_array_v<T> && any_same_v<std::remove_all_extents_t<T>, char, using is_string_literal_array = boolean<std::is_array_v<T>
#if SOL_IS_ON(SOL_CHAR8_T_I_) && any_same_v<std::remove_all_extents_t<T>, char,
char8_t, #if SOL_IS_ON(SOL_CHAR8_T)
char8_t,
#endif #endif
char16_t, char32_t, wchar_t>>; char16_t, char32_t, wchar_t>>;
template <typename T> template <typename T>
constexpr inline bool is_string_literal_array_v = is_string_literal_array<T>::value; constexpr inline bool is_string_literal_array_v = is_string_literal_array<T>::value;
@ -661,9 +674,8 @@ namespace sol { namespace meta {
constexpr inline bool is_string_like_v = is_string_like<T>::value; constexpr inline bool is_string_like_v = is_string_like<T>::value;
template <typename T, typename CharT = char> template <typename T, typename CharT = char>
using is_string_constructible = meta::boolean< using is_string_constructible = meta::boolean<is_string_literal_array_of_v<T, CharT> || std::is_same_v<T, const CharT*> || std::is_same_v<T, CharT>
is_string_literal_array_of_v<T, || is_string_of_v<T, CharT> || std::is_same_v<T, std::initializer_list<CharT>> || is_string_view_of_v<T, CharT> || std::is_null_pointer_v<T>>;
CharT> || std::is_same_v<T, const CharT*> || std::is_same_v<T, CharT> || is_string_of_v<T, CharT> || std::is_same_v<T, std::initializer_list<CharT>> || is_string_view_of_v<T, CharT> || std::is_null_pointer_v<T>>;
template <typename T, typename CharT = char> template <typename T, typename CharT = char>
constexpr inline bool is_string_constructible_v = is_string_constructible<T, CharT>::value; constexpr inline bool is_string_constructible_v = is_string_constructible<T, CharT>::value;
@ -733,7 +745,6 @@ namespace sol { namespace meta {
struct iterator_tag<T, conditional_t<false, typename std::iterator_traits<T>::iterator_category, void>> { struct iterator_tag<T, conditional_t<false, typename std::iterator_traits<T>::iterator_category, void>> {
using type = typename std::iterator_traits<T>::iterator_category; using type = typename std::iterator_traits<T>::iterator_category;
}; };
}} // namespace sol::meta
}} // namespace sol::meta
#endif // SOL_TRAITS_HPP #endif // SOL_TRAITS_HPP

25
extern/sol3/sol/trampoline.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -29,7 +29,7 @@
#include <exception> #include <exception>
#include <cstring> #include <cstring>
#if SOL_IS_ON(SOL_PRINT_ERRORS_I_) #if SOL_IS_ON(SOL_PRINT_ERRORS)
#include <iostream> #include <iostream>
#endif #endif
@ -47,7 +47,7 @@ namespace sol {
// must push at least 1 object on the stack // must push at least 1 object on the stack
inline int default_exception_handler(lua_State* L, optional<const std::exception&>, string_view what) { inline int default_exception_handler(lua_State* L, optional<const std::exception&>, string_view what) {
#if SOL_IS_ON(SOL_PRINT_ERRORS_I_) #if SOL_IS_ON(SOL_PRINT_ERRORS)
std::cerr << "[sol2] An exception occurred: "; std::cerr << "[sol2] An exception occurred: ";
std::cerr.write(what.data(), static_cast<std::streamsize>(what.size())); std::cerr.write(what.data(), static_cast<std::streamsize>(what.size()));
std::cerr << std::endl; std::cerr << std::endl;
@ -72,13 +72,13 @@ namespace sol {
return exfunc(L, std::move(maybe_ex), std::move(what)); return exfunc(L, std::move(maybe_ex), std::move(what));
} }
#if SOL_IS_OFF(SOL_EXCEPTIONS_I_) #if SOL_IS_OFF(SOL_EXCEPTIONS)
template <lua_CFunction f> template <lua_CFunction f>
int static_trampoline(lua_State* L) noexcept { int static_trampoline(lua_State* L) noexcept {
return f(L); return f(L);
} }
#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_) #if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
template <lua_CFunction_noexcept f> template <lua_CFunction_noexcept f>
int static_trampoline_noexcept(lua_State* L) noexcept { int static_trampoline_noexcept(lua_State* L) noexcept {
return f(L); return f(L);
@ -101,7 +101,7 @@ namespace sol {
#else #else
inline int lua_cfunction_trampoline(lua_State* L, lua_CFunction f) { inline int lua_cfunction_trampoline(lua_State* L, lua_CFunction f) {
#if SOL_IS_ON(SOL_PROPAGATE_EXCEPTIONS_I_) #if SOL_IS_ON(SOL_PROPAGATE_EXCEPTIONS)
return f(L); return f(L);
#else #else
try { try {
@ -116,14 +116,14 @@ namespace sol {
catch (const std::exception& e) { catch (const std::exception& e) {
call_exception_handler(L, optional<const std::exception&>(e), e.what()); call_exception_handler(L, optional<const std::exception&>(e), e.what());
} }
#if SOL_IS_ON(SOL_EXCEPTIONS_CATCH_ALL_I_) #if SOL_IS_ON(SOL_EXCEPTIONS_CATCH_ALL)
// 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");
} }
#endif // LuaJIT cannot have the catchall, but we must catch std::exceps for it #endif
return lua_error(L); return lua_error(L);
#endif // Safe exceptions #endif // Safe exceptions
} }
@ -133,7 +133,7 @@ namespace sol {
return lua_cfunction_trampoline(L, f); return lua_cfunction_trampoline(L, f);
} }
#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_) #if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
template <lua_CFunction_noexcept f> template <lua_CFunction_noexcept f>
int static_trampoline_noexcept(lua_State* L) noexcept { int static_trampoline_noexcept(lua_State* L) noexcept {
return f(L); return f(L);
@ -151,7 +151,7 @@ namespace sol {
return f(L, std::forward<Args>(args)...); return f(L, std::forward<Args>(args)...);
} }
else { else {
#if SOL_IS_ON(SOL_PROPAGATE_EXCEPTIONS_I_) #if SOL_IS_ON(SOL_PROPAGATE_EXCEPTIONS)
return f(L, std::forward<Args>(args)...); return f(L, std::forward<Args>(args)...);
#else #else
try { try {
@ -166,7 +166,7 @@ namespace sol {
catch (const std::exception& e) { catch (const std::exception& e) {
call_exception_handler(L, optional<const std::exception&>(e), e.what()); call_exception_handler(L, optional<const std::exception&>(e), e.what());
} }
#if SOL_IS_ON(SOL_EXCEPTIONS_CATCH_ALL_I_) #if SOL_IS_ON(SOL_EXCEPTIONS_CATCH_ALL)
// 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
@ -187,11 +187,12 @@ namespace sol {
template <typename F, F fx> template <typename F, F fx>
inline int typed_static_trampoline(lua_State* L) { inline int typed_static_trampoline(lua_State* L) {
#if 0 #if 0
// TODO: you must evaluate the get/check_get of every // NOTE: you must evaluate the get/check_get of every
// argument, to ensure it doesn't throw // argument, to ensure it doesn't throw
// (e.g., for the sol_lua_check_access extension point!) // (e.g., for the sol_lua_check_access extension point!)
// This incluudes properly noexcept-ing all the above // This incluudes properly noexcept-ing all the above
// trampolines / safety nets // trampolines / safety nets
// This is currently not done properly because it's an enormous pain in the ass to attempt to accomplish.
if constexpr (meta::bind_traits<F>::is_noexcept) { if constexpr (meta::bind_traits<F>::is_noexcept) {
return static_trampoline_noexcept<fx>(L); return static_trampoline_noexcept<fx>(L);
} }

2
extern/sol3/sol/tuple.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in

97
extern/sol3/sol/types.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in
@ -39,8 +39,10 @@
#include <initializer_list> #include <initializer_list>
#include <string> #include <string>
#include <string_view> #include <string_view>
#include <limits>
#include <optional> #include <optional>
#if SOL_IS_ON(SOL_STD_VARIANT_I_) #include <memory>
#if SOL_IS_ON(SOL_STD_VARIANT)
#include <variant> #include <variant>
#endif // variant shenanigans (thanks, Mac OSX) #endif // variant shenanigans (thanks, Mac OSX)
@ -55,7 +57,7 @@ namespace sol {
} // namespace d } // namespace d
namespace detail { namespace detail {
#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_) #if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
typedef int (*lua_CFunction_noexcept)(lua_State* L) noexcept; typedef int (*lua_CFunction_noexcept)(lua_State* L) noexcept;
#else #else
typedef int (*lua_CFunction_noexcept)(lua_State* L); typedef int (*lua_CFunction_noexcept)(lua_State* L);
@ -92,7 +94,7 @@ namespace sol {
inline bool operator!=(lua_nil_t, lua_nil_t) { inline bool operator!=(lua_nil_t, lua_nil_t) {
return false; return false;
} }
#if SOL_IS_ON(SOL_NIL_I_) #if SOL_IS_ON(SOL_NIL)
using nil_t = lua_nil_t; using nil_t = lua_nil_t;
inline constexpr const nil_t& nil = lua_nil; inline constexpr const nil_t& nil = lua_nil;
#endif #endif
@ -465,6 +467,63 @@ namespace sol {
return as_container_t<T>(std::forward<T>(value)); return as_container_t<T>(std::forward<T>(value));
} }
template <typename T, std::size_t Limit = 15>
struct exhaustive_until : private detail::ebco<T> {
private:
using base_t = detail::ebco<T>;
public:
using base_t::base_t;
using base_t::value;
operator std::add_pointer_t<std::remove_reference_t<T>>() {
return std::addressof(this->base_t::value());
}
operator std::add_pointer_t<std::add_const_t<std::remove_reference_t<T>>>() const {
return std::addressof(this->base_t::value());
}
operator std::add_lvalue_reference_t<T>() {
return this->base_t::value();
}
operator std::add_const_t<std::add_lvalue_reference_t<T>>&() const {
return this->base_t::value();
}
};
template <typename T>
using exhaustive = exhaustive_until<T, (std::numeric_limits<size_t>::max)()>;
template <typename T>
struct non_exhaustive : private detail::ebco<T> {
private:
using base_t = detail::ebco<T>;
public:
using base_t::base_t;
using base_t::value;
operator std::add_pointer_t<std::remove_reference_t<T>>() {
return std::addressof(this->base_t::value());
}
operator std::add_pointer_t<std::add_const_t<std::remove_reference_t<T>>>() const {
return std::addressof(this->base_t::value());
}
operator std::add_lvalue_reference_t<T>() {
return this->base_t::value();
}
operator std::add_const_t<std::add_lvalue_reference_t<T>>&() const {
return this->base_t::value();
}
};
template <typename T> template <typename T>
struct push_invoke_t : private detail::ebco<T> { struct push_invoke_t : private detail::ebco<T> {
private: private:
@ -658,7 +717,7 @@ namespace sol {
enum class type : int { enum class type : int {
none = LUA_TNONE, none = LUA_TNONE,
lua_nil = LUA_TNIL, lua_nil = LUA_TNIL,
#if SOL_IS_ON(SOL_NIL_I_) #if SOL_IS_ON(SOL_NIL)
nil = lua_nil, nil = lua_nil,
#endif // Objective C/C++ Keyword that's found in OSX SDK and OBJC -- check for all forms to protect #endif // Objective C/C++ Keyword that's found in OSX SDK and OBJC -- check for all forms to protect
string = LUA_TSTRING, string = LUA_TSTRING,
@ -932,7 +991,7 @@ namespace sol {
template <std::size_t N> template <std::size_t N>
struct lua_type_of<wchar_t[N]> : std::integral_constant<type, type::string> { }; struct lua_type_of<wchar_t[N]> : std::integral_constant<type, type::string> { };
#if SOL_IS_ON(SOL_CHAR8_T_I_) #if SOL_IS_ON(SOL_CHAR8_T)
template <std::size_t N> template <std::size_t N>
struct lua_type_of<char8_t[N]> : std::integral_constant<type, type::string> { }; struct lua_type_of<char8_t[N]> : std::integral_constant<type, type::string> { };
#endif #endif
@ -949,7 +1008,7 @@ namespace sol {
template <> template <>
struct lua_type_of<wchar_t> : std::integral_constant<type, type::string> { }; struct lua_type_of<wchar_t> : std::integral_constant<type, type::string> { };
#if SOL_IS_ON(SOL_CHAR8_T_I_) #if SOL_IS_ON(SOL_CHAR8_T)
template <> template <>
struct lua_type_of<char8_t> : std::integral_constant<type, type::string> { }; struct lua_type_of<char8_t> : std::integral_constant<type, type::string> { };
#endif #endif
@ -966,7 +1025,7 @@ namespace sol {
template <> template <>
struct lua_type_of<const wchar_t*> : std::integral_constant<type, type::string> { }; struct lua_type_of<const wchar_t*> : std::integral_constant<type, type::string> { };
#if SOL_IS_ON(SOL_CHAR8_T_I_) #if SOL_IS_ON(SOL_CHAR8_T)
template <> template <>
struct lua_type_of<const char8_t*> : std::integral_constant<type, type::string> { }; struct lua_type_of<const char8_t*> : std::integral_constant<type, type::string> { };
#endif #endif
@ -1115,7 +1174,7 @@ namespace sol {
template <> template <>
struct lua_type_of<type> : std::integral_constant<type, type::poly> { }; struct lua_type_of<type> : std::integral_constant<type, type::poly> { };
#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE_I_) #if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE)
template <typename T> template <typename T>
struct lua_type_of<T*> : std::integral_constant<type, std::is_function_v<T> ? type::function : type::userdata> { }; struct lua_type_of<T*> : std::integral_constant<type, std::is_function_v<T> ? type::function : type::userdata> { };
#else #else
@ -1136,7 +1195,7 @@ namespace sol {
template <> template <>
struct lua_type_of<meta_function> : std::integral_constant<type, type::string> { }; struct lua_type_of<meta_function> : std::integral_constant<type, type::string> { };
#if SOL_IS_ON(SOL_STD_VARIANT_I_) #if SOL_IS_ON(SOL_STD_VARIANT)
template <typename... Tn> template <typename... Tn>
struct lua_type_of<std::variant<Tn...>> : std::integral_constant<type, type::poly> { }; struct lua_type_of<std::variant<Tn...>> : std::integral_constant<type, type::poly> { };
#endif // std::variant deployment sucks on Clang #endif // std::variant deployment sucks on Clang
@ -1193,19 +1252,21 @@ namespace sol {
} // namespace detail } // namespace detail
template <typename T> template <typename T>
struct is_lua_primitive struct is_lua_primitive : std::integral_constant<bool,
: std::integral_constant<bool, type::userdata != lua_type_of_v<T> // cf
type::userdata || ((type::userdata == lua_type_of_v<T>) // cf
!= lua_type_of_v< &&meta::meta_detail::has_internal_marker_v<lua_type_of<T>> // cf
T> || ((type::userdata == lua_type_of_v<T>)&&meta::meta_detail::has_internal_marker_v<lua_type_of<T>> && !meta::meta_detail::has_internal_marker_v<lua_size<T>>) && !meta::meta_detail::has_internal_marker_v<lua_size<T>>) // cf
|| is_lua_reference_or_proxy_v<T> || meta::is_specialization_of_v<T, std::tuple> || meta::is_specialization_of_v<T, std::pair>> { }; || is_lua_reference_or_proxy_v<T> // cf
|| meta::is_specialization_of_v<T, std::tuple> // cf
|| meta::is_specialization_of_v<T, std::pair>> { };
template <typename T> template <typename T>
constexpr inline bool is_lua_primitive_v = is_lua_primitive<T>::value; constexpr inline bool is_lua_primitive_v = is_lua_primitive<T>::value;
template <typename T> template <typename T>
struct is_value_semantic_for_function struct is_value_semantic_for_function
#if SOL_IS_ON(SOL_FUNCTION_CALL_VALUE_SEMANTICS_I_) #if SOL_IS_ON(SOL_FUNCTION_CALL_VALUE_SEMANTICS)
: std::true_type { : std::true_type {
}; };
#else #else
@ -1360,7 +1421,7 @@ namespace sol {
template <typename T> template <typename T>
struct is_automagical struct is_automagical
: std::integral_constant<bool, : std::integral_constant<bool,
(SOL_IS_ON(SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_)) (SOL_IS_ON(SOL_DEFAULT_AUTOMAGICAL_USERTYPES))
|| (std::is_array_v< || (std::is_array_v<
meta::unqualified_t<T>> || (!std::is_same_v<meta::unqualified_t<T>, state> && !std::is_same_v<meta::unqualified_t<T>, state_view>))> { meta::unqualified_t<T>> || (!std::is_same_v<meta::unqualified_t<T>, state> && !std::is_same_v<meta::unqualified_t<T>, state_view>))> {
}; };

2
extern/sol3/sol/unique_usertype_traits.hpp vendored
View file

@ -2,7 +2,7 @@
// The MIT License (MIT) // The MIT License (MIT)
// Copyright (c) 2013-2021 Rapptz, ThePhD and contributors // Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of // Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in // this software and associated documentation files (the "Software"), to deal in

37
extern/sol3/sol/unreachable.hpp vendored Normal file
View file

@ -0,0 +1,37 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2022 Rapptz, ThePhD and contributors
// Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in
// the Software without restriction, including without limitation the rights to
// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
// the Software, and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#ifndef SOL_UNREACHABLE_HPP
#define SOL_UNREACHABLE_HPP
#include <sol/version.hpp>
#if SOL_HAS_BUILTIN_I_(__builtin_unreachable)
#define SOL_UNREACHABLE() __builtin_unreachable();
#elif SOL_IS_ON(SOL_COMPILER_VCXX)
#define SOL_UNREACHABLE() __assume(false);
#else
#define SOL_UNREACHABLE() __builtin_unreachable();
#endif
#endif

Some files were not shown because too many files have changed in this diff Show more