summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/sol2/sol
diff options
context:
space:
mode:
author Vas Crabb <vas@vastheman.com>2020-11-15 03:53:47 +1100
committer Vas Crabb <vas@vastheman.com>2020-11-15 03:53:47 +1100
commit55b8ca317ab1f77850f498c1523355e1f5dd8d03 (patch)
treebada7948236b18684609f47024cc9ca227a5ef89 /3rdparty/sol2/sol
parent4db7f0439c3b841eb07d2320e39be38269e6cd56 (diff)
-Switch to building MAME as C++17.
* Updated sol2 to 3.2.2 * Updated pugixml to 1.10 * Increased minimum clang version to 6 * Cleaned up some stuff that can use new features
Diffstat (limited to '3rdparty/sol2/sol')
-rw-r--r--3rdparty/sol2/sol/as_args.hpp52
-rw-r--r--3rdparty/sol2/sol/bind_traits.hpp243
-rw-r--r--3rdparty/sol2/sol/call.hpp615
-rw-r--r--3rdparty/sol2/sol/compatibility.hpp47
-rw-r--r--3rdparty/sol2/sol/compatibility/5.0.0.h44
-rw-r--r--3rdparty/sol2/sol/compatibility/5.1.0.h175
-rw-r--r--3rdparty/sol2/sol/compatibility/5.2.0.h43
-rw-r--r--3rdparty/sol2/sol/compatibility/5.x.x.h57
-rw-r--r--3rdparty/sol2/sol/compatibility/5.x.x.inl708
-rw-r--r--3rdparty/sol2/sol/compatibility/version.hpp127
-rw-r--r--3rdparty/sol2/sol/config.hpp (renamed from 3rdparty/sol2/sol/protect.hpp)50
-rw-r--r--3rdparty/sol2/sol/container_usertype_metatable.hpp513
-rw-r--r--3rdparty/sol2/sol/coroutine.hpp134
-rw-r--r--3rdparty/sol2/sol/debug.hpp54
-rw-r--r--3rdparty/sol2/sol/demangle.hpp158
-rw-r--r--3rdparty/sol2/sol/deprecate.hpp44
-rw-r--r--3rdparty/sol2/sol/error.hpp56
-rw-r--r--3rdparty/sol2/sol/forward.hpp828
-rw-r--r--3rdparty/sol2/sol/function.hpp159
-rw-r--r--3rdparty/sol2/sol/function_result.hpp88
-rw-r--r--3rdparty/sol2/sol/function_types.hpp342
-rw-r--r--3rdparty/sol2/sol/function_types_core.hpp39
-rw-r--r--3rdparty/sol2/sol/function_types_overloaded.hpp59
-rw-r--r--3rdparty/sol2/sol/function_types_stateful.hpp100
-rw-r--r--3rdparty/sol2/sol/function_types_stateless.hpp163
-rw-r--r--3rdparty/sol2/sol/function_types_templated.hpp132
-rw-r--r--3rdparty/sol2/sol/in_place.hpp50
-rw-r--r--3rdparty/sol2/sol/inheritance.hpp117
-rw-r--r--3rdparty/sol2/sol/load_result.hpp139
-rw-r--r--3rdparty/sol2/sol/object.hpp154
-rw-r--r--3rdparty/sol2/sol/optional.hpp44
-rw-r--r--3rdparty/sol2/sol/optional_implementation.hpp1135
-rw-r--r--3rdparty/sol2/sol/overload.hpp45
-rw-r--r--3rdparty/sol2/sol/property.hpp105
-rw-r--r--3rdparty/sol2/sol/protected_function.hpp198
-rw-r--r--3rdparty/sol2/sol/protected_function_result.hpp130
-rw-r--r--3rdparty/sol2/sol/proxy.hpp179
-rw-r--r--3rdparty/sol2/sol/proxy_base.hpp51
-rw-r--r--3rdparty/sol2/sol/raii.hpp132
-rw-r--r--3rdparty/sol2/sol/reference.hpp191
-rw-r--r--3rdparty/sol2/sol/resolve.hpp173
-rw-r--r--3rdparty/sol2/sol/simple_usertype_metatable.hpp559
-rw-r--r--3rdparty/sol2/sol/sol.hpp26674
-rw-r--r--3rdparty/sol2/sol/stack.hpp229
-rw-r--r--3rdparty/sol2/sol/stack_check.hpp385
-rw-r--r--3rdparty/sol2/sol/stack_check_get.hpp114
-rw-r--r--3rdparty/sol2/sol/stack_core.hpp410
-rw-r--r--3rdparty/sol2/sol/stack_field.hpp261
-rw-r--r--3rdparty/sol2/sol/stack_get.hpp551
-rw-r--r--3rdparty/sol2/sol/stack_guard.hpp63
-rw-r--r--3rdparty/sol2/sol/stack_pop.hpp49
-rw-r--r--3rdparty/sol2/sol/stack_probe.hpp87
-rw-r--r--3rdparty/sol2/sol/stack_proxy.hpp128
-rw-r--r--3rdparty/sol2/sol/stack_push.hpp694
-rw-r--r--3rdparty/sol2/sol/stack_reference.hpp96
-rw-r--r--3rdparty/sol2/sol/state.hpp94
-rw-r--r--3rdparty/sol2/sol/state_view.hpp491
-rw-r--r--3rdparty/sol2/sol/string_shim.hpp88
-rw-r--r--3rdparty/sol2/sol/table.hpp31
-rw-r--r--3rdparty/sol2/sol/table_core.hpp475
-rw-r--r--3rdparty/sol2/sol/table_iterator.hpp120
-rw-r--r--3rdparty/sol2/sol/thread.hpp158
-rw-r--r--3rdparty/sol2/sol/tie.hpp101
-rw-r--r--3rdparty/sol2/sol/traits.hpp428
-rw-r--r--3rdparty/sol2/sol/tuple.hpp80
-rw-r--r--3rdparty/sol2/sol/types.hpp806
-rw-r--r--3rdparty/sol2/sol/userdata.hpp98
-rw-r--r--3rdparty/sol2/sol/usertype.hpp97
-rw-r--r--3rdparty/sol2/sol/usertype_metatable.hpp609
-rw-r--r--3rdparty/sol2/sol/usertype_traits.hpp59
-rw-r--r--3rdparty/sol2/sol/variadic_args.hpp243
-rw-r--r--3rdparty/sol2/sol/wrapper.hpp233
72 files changed, 27528 insertions, 14856 deletions
diff --git a/3rdparty/sol2/sol/as_args.hpp b/3rdparty/sol2/sol/as_args.hpp
deleted file mode 100644
index 2b5092cc9cf..00000000000
--- a/3rdparty/sol2/sol/as_args.hpp
+++ /dev/null
@@ -1,52 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_TO_ARGS_HPP
-#define SOL_TO_ARGS_HPP
-
-#include "stack.hpp"
-
-namespace sol {
- template <typename T>
- struct to_args_t {
- T src;
- };
-
- template <typename Source>
- auto as_args(Source&& source) {
- return to_args_t<Source>{ std::forward<Source>(source) };
- }
-
- namespace stack {
- template <typename T>
- struct pusher<to_args_t<T>> {
- int push(lua_State* L, const to_args_t<T>& e) {
- int p = 0;
- for (const auto& i : e.src) {
- p += stack::push(L, i);
- }
- return p;
- }
- };
- }
-} // sol
-
-#endif // SOL_TO_ARGS_HPP
diff --git a/3rdparty/sol2/sol/bind_traits.hpp b/3rdparty/sol2/sol/bind_traits.hpp
deleted file mode 100644
index a78cb6a3ee1..00000000000
--- a/3rdparty/sol2/sol/bind_traits.hpp
+++ /dev/null
@@ -1,243 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 Rappt1101010z, 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_BIND_TRAITS_HPP
-#define SOL_BIND_TRAITS_HPP
-
-#include "tuple.hpp"
-
-namespace sol {
- namespace meta {
- namespace meta_detail {
-
- template<class F>
- struct check_deducible_signature {
- struct nat {};
- template<class G>
- static auto test(int) -> decltype(&G::operator(), void());
- template<class>
- static auto test(...)->nat;
-
- using type = std::is_void<decltype(test<F>(0))>;
- };
- } // meta_detail
-
- template<class F>
- struct has_deducible_signature : meta_detail::check_deducible_signature<F>::type { };
-
- namespace meta_detail {
-
- template <std::size_t I, typename T>
- struct void_tuple_element : meta::tuple_element<I, T> {};
-
- template <std::size_t I>
- struct void_tuple_element<I, std::tuple<>> { typedef void type; };
-
- template <std::size_t I, typename T>
- using void_tuple_element_t = typename void_tuple_element<I, T>::type;
-
- template <bool has_c_variadic, typename T, typename R, typename... Args>
- struct basic_traits {
- private:
- typedef std::conditional_t<std::is_void<T>::value, int, T>& first_type;
-
- public:
- static const bool is_member_function = std::is_void<T>::value;
- static const bool has_c_var_arg = has_c_variadic;
- static const std::size_t arity = sizeof...(Args);
- static const std::size_t free_arity = sizeof...(Args)+static_cast<std::size_t>(!std::is_void<T>::value);
- typedef types<Args...> args_list;
- typedef std::tuple<Args...> args_tuple;
- typedef T object_type;
- typedef R return_type;
- typedef tuple_types<R> returns_list;
- typedef R(function_type)(Args...);
- typedef std::conditional_t<std::is_void<T>::value, args_list, types<first_type, Args...>> free_args_list;
- typedef std::conditional_t<std::is_void<T>::value, R(Args...), R(first_type, Args...)> free_function_type;
- typedef std::conditional_t<std::is_void<T>::value, R(*)(Args...), R(*)(first_type, Args...)> free_function_pointer_type;
- typedef std::remove_pointer_t<free_function_pointer_type> signature_type;
- template<std::size_t i>
- using arg_at = void_tuple_element_t<i, args_tuple>;
- };
-
- template<typename Signature, bool b = has_deducible_signature<Signature>::value>
- struct fx_traits : basic_traits<false, void, void> {};
-
- // Free Functions
- template<typename R, typename... Args>
- struct fx_traits<R(Args...), false> : basic_traits<false, void, R, Args...> {
- typedef R(*function_pointer_type)(Args...);
- };
-
- template<typename R, typename... Args>
- struct fx_traits<R(*)(Args...), false> : basic_traits<false, void, R, Args...> {
- typedef R(*function_pointer_type)(Args...);
- };
-
- template<typename R, typename... Args>
- struct fx_traits<R(Args..., ...), false> : basic_traits<true, void, R, Args...> {
- typedef R(*function_pointer_type)(Args..., ...);
- };
-
- template<typename R, typename... Args>
- struct fx_traits<R(*)(Args..., ...), false> : basic_traits<true, void, R, Args...> {
- typedef R(*function_pointer_type)(Args..., ...);
- };
-
- // Member Functions
- /* C-Style Variadics */
- template<typename T, typename R, typename... Args>
- struct fx_traits<R(T::*)(Args...), false> : basic_traits<false, T, R, Args...> {
- typedef R(T::* function_pointer_type)(Args...);
- };
-
- template<typename T, typename R, typename... Args>
- struct fx_traits<R(T::*)(Args..., ...), false> : basic_traits<true, T, R, Args...> {
- typedef R(T::* function_pointer_type)(Args..., ...);
- };
-
- /* Const Volatile */
- template<typename T, typename R, typename... Args>
- struct fx_traits<R(T::*)(Args...) const, false> : basic_traits<false, T, R, Args...> {
- typedef R(T::* function_pointer_type)(Args...) const;
- };
-
- template<typename T, typename R, typename... Args>
- struct fx_traits<R(T::*)(Args..., ...) const, false> : basic_traits<true, T, R, Args...> {
- typedef R(T::* function_pointer_type)(Args..., ...) const;
- };
-
- template<typename T, typename R, typename... Args>
- struct fx_traits<R(T::*)(Args...) const volatile, false> : basic_traits<false, T, R, Args...> {
- typedef R(T::* function_pointer_type)(Args...) const volatile;
- };
-
- template<typename T, typename R, typename... Args>
- struct fx_traits<R(T::*)(Args..., ...) const volatile, false> : basic_traits<true, T, R, Args...> {
- typedef R(T::* function_pointer_type)(Args..., ...) const volatile;
- };
-
- /* Member Function Qualifiers */
- template<typename T, typename R, typename... Args>
- struct fx_traits<R(T::*)(Args...) &, false> : basic_traits<false, T, R, Args...> {
- typedef R(T::* function_pointer_type)(Args...) &;
- };
-
- template<typename T, typename R, typename... Args>
- struct fx_traits<R(T::*)(Args..., ...) &, false> : basic_traits<true, T, R, Args...> {
- typedef R(T::* function_pointer_type)(Args..., ...) &;
- };
-
- template<typename T, typename R, typename... Args>
- struct fx_traits<R(T::*)(Args...) const &, false> : basic_traits<false, T, R, Args...> {
- typedef R(T::* function_pointer_type)(Args...) const &;
- };
-
- template<typename T, typename R, typename... Args>
- struct fx_traits<R(T::*)(Args..., ...) const &, false> : basic_traits<true, T, R, Args...> {
- typedef R(T::* function_pointer_type)(Args..., ...) const &;
- };
-
- template<typename T, typename R, typename... Args>
- struct fx_traits<R(T::*)(Args...) const volatile &, false> : basic_traits<false, T, R, Args...> {
- typedef R(T::* function_pointer_type)(Args...) const volatile &;
- };
-
- template<typename T, typename R, typename... Args>
- struct fx_traits<R(T::*)(Args..., ...) const volatile &, false> : basic_traits<true, T, R, Args...> {
- typedef R(T::* function_pointer_type)(Args..., ...) const volatile &;
- };
-
- template<typename T, typename R, typename... Args>
- struct fx_traits<R(T::*)(Args...) && , false> : basic_traits<false, T, R, Args...> {
- typedef R(T::* function_pointer_type)(Args...) && ;
- };
-
- template<typename T, typename R, typename... Args>
- struct fx_traits<R(T::*)(Args..., ...) && , false> : basic_traits<true, T, R, Args...> {
- typedef R(T::* function_pointer_type)(Args..., ...) && ;
- };
-
- template<typename T, typename R, typename... Args>
- struct fx_traits<R(T::*)(Args...) const &&, false> : basic_traits<false, T, R, Args...> {
- typedef R(T::* function_pointer_type)(Args...) const &&;
- };
-
- template<typename T, typename R, typename... Args>
- struct fx_traits<R(T::*)(Args..., ...) const &&, false> : basic_traits<true, T, R, Args...> {
- typedef R(T::* function_pointer_type)(Args..., ...) const &&;
- };
-
- template<typename T, typename R, typename... Args>
- struct fx_traits<R(T::*)(Args...) const volatile &&, false> : basic_traits<false, T, R, Args...> {
- typedef R(T::* function_pointer_type)(Args...) const volatile &&;
- };
-
- template<typename T, typename R, typename... Args>
- struct fx_traits<R(T::*)(Args..., ...) const volatile &&, false> : basic_traits<true, T, R, Args...> {
- typedef R(T::* function_pointer_type)(Args..., ...) const volatile &&;
- };
-
- template<typename Signature>
- struct fx_traits<Signature, true> : fx_traits<typename fx_traits<decltype(&Signature::operator())>::function_type, false> {};
-
- template<typename Signature, bool b = std::is_member_object_pointer<Signature>::value>
- struct callable_traits : fx_traits<std::decay_t<Signature>> {
-
- };
-
- template<typename R, typename T>
- struct callable_traits<R(T::*), true> {
- typedef R Arg;
- typedef T object_type;
- using signature_type = R(T::*);
- static const bool is_member_function = false;
- static const std::size_t arity = 1;
- static const std::size_t free_arity = 2;
- typedef std::tuple<Arg> args_tuple;
- typedef R return_type;
- typedef types<Arg> args_list;
- typedef types<T, Arg> free_args_list;
- typedef meta::tuple_types<R> returns_list;
- typedef R(function_type)(T&, R);
- typedef R(*function_pointer_type)(T&, R);
- typedef R(*free_function_pointer_type)(T&, R);
- template<std::size_t i>
- using arg_at = void_tuple_element_t<i, args_tuple>;
- };
- } // meta_detail
-
- template<typename Signature>
- struct bind_traits : meta_detail::callable_traits<Signature> {};
-
- template<typename Signature>
- using function_args_t = typename bind_traits<Signature>::args_list;
-
- template<typename Signature>
- using function_signature_t = typename bind_traits<Signature>::signature_type;
-
- template<typename Signature>
- using function_return_t = typename bind_traits<Signature>::return_type;
-
- } // meta
-} // sol
-
-#endif // SOL_BIND_TRAITS_HPP
diff --git a/3rdparty/sol2/sol/call.hpp b/3rdparty/sol2/sol/call.hpp
deleted file mode 100644
index d09cc023b70..00000000000
--- a/3rdparty/sol2/sol/call.hpp
+++ /dev/null
@@ -1,615 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_CALL_HPP
-#define SOL_CALL_HPP
-
-#include "protect.hpp"
-#include "wrapper.hpp"
-#include "property.hpp"
-#include "stack.hpp"
-
-namespace sol {
- namespace call_detail {
-
- template <typename R, typename W>
- inline auto& pick(std::true_type, property_wrapper<R, W>& f) {
- return f.read;
- }
-
- template <typename R, typename W>
- inline auto& pick(std::false_type, property_wrapper<R, W>& f) {
- return f.write;
- }
-
- template <typename T, typename List>
- struct void_call;
-
- template <typename T, typename... Args>
- struct void_call<T, types<Args...>> {
- static void call(Args...) {}
- };
-
- template <typename T>
- struct constructor_match {
- T* obj;
-
- constructor_match(T* o) : obj(o) {}
-
- template <typename Fx, std::size_t I, typename... R, typename... Args>
- int operator()(types<Fx>, index_value<I>, types<R...> r, types<Args...> a, lua_State* L, int, int start) const {
- detail::default_construct func{};
- return stack::call_into_lua<stack::stack_detail::default_check_arguments>(r, a, L, start, func, obj);
- }
- };
-
- namespace overload_detail {
- template <std::size_t... M, typename Match, typename... Args>
- inline int overload_match_arity(types<>, std::index_sequence<>, std::index_sequence<M...>, Match&&, lua_State* L, int, int, Args&&...) {
- return luaL_error(L, "sol: no matching function call takes this number of arguments and the specified types");
- }
-
- template <typename Fx, typename... Fxs, std::size_t I, std::size_t... In, std::size_t... M, typename Match, typename... Args>
- inline int overload_match_arity(types<Fx, Fxs...>, std::index_sequence<I, In...>, std::index_sequence<M...>, Match&& matchfx, lua_State* L, int fxarity, int start, Args&&... args) {
- typedef lua_bind_traits<meta::unqualified_t<Fx>> traits;
- typedef meta::tuple_types<typename traits::return_type> return_types;
- typedef typename traits::free_args_list args_list;
- // compile-time eliminate any functions that we know ahead of time are of improper arity
- if (meta::find_in_pack_v<index_value<traits::free_arity>, index_value<M>...>::value) {
- return overload_match_arity(types<Fxs...>(), std::index_sequence<In...>(), std::index_sequence<M...>(), std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
- }
- if (!traits::runtime_variadics_t::value && traits::free_arity != fxarity) {
- return overload_match_arity(types<Fxs...>(), std::index_sequence<In...>(), std::index_sequence<traits::free_arity, M...>(), std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
- }
- stack::record tracking{};
- if (!stack::stack_detail::check_types<true>{}.check(args_list(), L, start, no_panic, tracking)) {
- return overload_match_arity(types<Fxs...>(), std::index_sequence<In...>(), std::index_sequence<M...>(), std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
- }
- return matchfx(types<Fx>(), index_value<I>(), return_types(), args_list(), L, fxarity, start, std::forward<Args>(args)...);
- }
-
- template <std::size_t... M, typename Match, typename... Args>
- inline int overload_match_arity_single(types<>, std::index_sequence<>, std::index_sequence<M...>, Match&& matchfx, lua_State* L, int fxarity, int start, Args&&... args) {
- return overload_match_arity(types<>(), std::index_sequence<>(), std::index_sequence<M...>(), std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
- }
-
- template <typename Fx, std::size_t I, std::size_t... M, typename Match, typename... Args>
- inline int overload_match_arity_single(types<Fx>, std::index_sequence<I>, std::index_sequence<M...>, Match&& matchfx, lua_State* L, int fxarity, int start, Args&&... args) {
- typedef lua_bind_traits<meta::unqualified_t<Fx>> traits;
- typedef meta::tuple_types<typename traits::return_type> return_types;
- typedef typename traits::free_args_list args_list;
- // compile-time eliminate any functions that we know ahead of time are of improper arity
- if (meta::find_in_pack_v<index_value<traits::free_arity>, index_value<M>...>::value) {
- return overload_match_arity(types<>(), std::index_sequence<>(), std::index_sequence<M...>(), std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
- }
- if (!traits::runtime_variadics_t::value && traits::free_arity != fxarity) {
- return overload_match_arity(types<>(), std::index_sequence<>(), std::index_sequence<traits::free_arity, M...>(), std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
- }
- return matchfx(types<Fx>(), index_value<I>(), return_types(), args_list(), L, fxarity, start, std::forward<Args>(args)...);
- }
-
- template <typename Fx, typename Fx1, typename... Fxs, std::size_t I, std::size_t I1, std::size_t... In, std::size_t... M, typename Match, typename... Args>
- inline int overload_match_arity_single(types<Fx, Fx1, Fxs...>, std::index_sequence<I, I1, In...>, std::index_sequence<M...>, Match&& matchfx, lua_State* L, int fxarity, int start, Args&&... args) {
- typedef lua_bind_traits<meta::unqualified_t<Fx>> traits;
- typedef meta::tuple_types<typename traits::return_type> return_types;
- typedef typename traits::free_args_list args_list;
- // compile-time eliminate any functions that we know ahead of time are of improper arity
- if (meta::find_in_pack_v<index_value<traits::free_arity>, index_value<M>...>::value) {
- return overload_match_arity(types<Fx1, Fxs...>(), std::index_sequence<I1, In...>(), std::index_sequence<M...>(), std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
- }
- if (!traits::runtime_variadics_t::value && traits::free_arity != fxarity) {
- return overload_match_arity(types<Fx1, Fxs...>(), std::index_sequence<I1, In...>(), std::index_sequence<traits::free_arity, M...>(), std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
- }
- stack::record tracking{};
- if (!stack::stack_detail::check_types<true>{}.check(args_list(), L, start, no_panic, tracking)) {
- return overload_match_arity(types<Fx1, Fxs...>(), std::index_sequence<I1, In...>(), std::index_sequence<M...>(), std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
- }
- return matchfx(types<Fx>(), index_value<I>(), return_types(), args_list(), L, fxarity, start, std::forward<Args>(args)...);
- }
- } // overload_detail
-
- template <typename... Functions, typename Match, typename... Args>
- inline int overload_match_arity(Match&& matchfx, lua_State* L, int fxarity, int start, Args&&... args) {
- return overload_detail::overload_match_arity_single(types<Functions...>(), std::make_index_sequence<sizeof...(Functions)>(), std::index_sequence<>(), std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
- }
-
- template <typename... Functions, typename Match, typename... Args>
- inline int overload_match(Match&& matchfx, lua_State* L, int start, Args&&... args) {
- int fxarity = lua_gettop(L) - (start - 1);
- return overload_match_arity<Functions...>(std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
- }
-
- template <typename T, typename... TypeLists, typename Match, typename... Args>
- inline int construct_match(Match&& matchfx, lua_State* L, int fxarity, int start, Args&&... args) {
- // use same overload resolution matching as all other parts of the framework
- return overload_match_arity<decltype(void_call<T, TypeLists>::call)...>(std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
- }
-
- template <typename T, typename... TypeLists>
- inline int construct(lua_State* L) {
- static const auto& meta = usertype_traits<T>::metatable();
- int argcount = lua_gettop(L);
- call_syntax syntax = argcount > 0 ? stack::get_call_syntax(L, &usertype_traits<T>::user_metatable()[0], 1) : call_syntax::dot;
- argcount -= static_cast<int>(syntax);
-
- T** pointerpointer = reinterpret_cast<T**>(lua_newuserdata(L, sizeof(T*) + sizeof(T)));
- T*& referencepointer = *pointerpointer;
- T* obj = reinterpret_cast<T*>(pointerpointer + 1);
- referencepointer = obj;
- reference userdataref(L, -1);
- userdataref.pop();
-
- construct_match<T, TypeLists...>(constructor_match<T>(obj), L, argcount, 1 + static_cast<int>(syntax));
-
- userdataref.push();
- luaL_getmetatable(L, &meta[0]);
- if (type_of(L, -1) == type::lua_nil) {
- lua_pop(L, 1);
- return luaL_error(L, "sol: unable to get usertype metatable");
- }
-
- lua_setmetatable(L, -2);
- return 1;
- }
-
- template <typename F, bool is_index, bool is_variable, bool checked, int boost, typename = void>
- struct agnostic_lua_call_wrapper {
- template <typename Fx, typename... Args>
- static int call(lua_State* L, Fx&& f, Args&&... args) {
- typedef wrapper<meta::unqualified_t<F>> wrap;
- typedef typename wrap::returns_list returns_list;
- typedef typename wrap::free_args_list args_list;
- typedef typename wrap::caller caller;
- return stack::call_into_lua<checked>(returns_list(), args_list(), L, boost + 1, caller(), std::forward<Fx>(f), std::forward<Args>(args)...);
- }
- };
-
- template <typename T, bool is_variable, bool checked, int boost, typename C>
- struct agnostic_lua_call_wrapper<var_wrapper<T>, true, is_variable, checked, boost, C> {
- template <typename F>
- static int call(lua_State* L, F&& f) {
- return stack::push_reference(L, detail::unwrap(f.value));
- }
- };
-
- template <typename T, bool is_variable, bool checked, int boost, typename C>
- struct agnostic_lua_call_wrapper<var_wrapper<T>, false, is_variable, checked, boost, C> {
- template <typename V>
- static int call_assign(std::true_type, lua_State* L, V&& f) {
- detail::unwrap(f.value) = stack::get<meta::unwrapped_t<T>>(L, boost + (is_variable ? 3 : 1));
- return 0;
- }
-
- template <typename... Args>
- static int call_assign(std::false_type, lua_State* L, Args&&...) {
- return luaL_error(L, "sol: cannot write to this variable: copy assignment/constructor not available");
- }
-
- template <typename... Args>
- static int call_const(std::false_type, lua_State* L, Args&&... args) {
- typedef meta::unwrapped_t<T> R;
- return call_assign(std::is_assignable<std::add_lvalue_reference_t<meta::unqualified_t<R>>, R>(), L, std::forward<Args>(args)...);
- }
-
- template <typename... Args>
- static int call_const(std::true_type, lua_State* L, Args&&...) {
- return luaL_error(L, "sol: cannot write to a readonly (const) variable");
- }
-
- template <typename V>
- static int call(lua_State* L, V&& f) {
- return call_const(std::is_const<meta::unwrapped_t<T>>(), L, f);
- }
- };
-
- template <bool is_index, bool is_variable, bool checked, int boost, typename C>
- struct agnostic_lua_call_wrapper<lua_r_CFunction, is_index, is_variable, checked, boost, C> {
- static int call(lua_State* L, lua_r_CFunction f) {
- return f(L);
- }
- };
-
- template <bool is_index, bool is_variable, bool checked, int boost, typename C>
- struct agnostic_lua_call_wrapper<lua_CFunction, is_index, is_variable, checked, boost, C> {
- static int call(lua_State* L, lua_CFunction f) {
- return f(L);
- }
- };
-
- template <bool is_index, bool is_variable, bool checked, int boost, typename C>
- struct agnostic_lua_call_wrapper<no_prop, is_index, is_variable, checked, boost, C> {
- static int call(lua_State* L, const no_prop&) {
- return luaL_error(L, is_index ? "sol: cannot read from a writeonly property" : "sol: cannot write to a readonly property");
- }
- };
-
- template <bool is_index, bool is_variable, bool checked, int boost, typename C>
- struct agnostic_lua_call_wrapper<no_construction, is_index, is_variable, checked, boost, C> {
- static int call(lua_State* L, const no_construction&) {
- return luaL_error(L, "sol: cannot call this constructor (tagged as non-constructible)");
- }
- };
-
- template <typename... Args, bool is_index, bool is_variable, bool checked, int boost, typename C>
- struct agnostic_lua_call_wrapper<bases<Args...>, is_index, is_variable, checked, boost, C> {
- static int call(lua_State*, const bases<Args...>&) {
- // Uh. How did you even call this, lul
- return 0;
- }
- };
-
- template <typename T, typename F, bool is_index, bool is_variable, bool checked = stack::stack_detail::default_check_arguments, int boost = 0, typename = void>
- struct lua_call_wrapper : agnostic_lua_call_wrapper<F, is_index, is_variable, checked, boost> {};
-
- template <typename T, typename F, bool is_index, bool is_variable, bool checked, int boost>
- struct lua_call_wrapper<T, F, is_index, is_variable, checked, boost, std::enable_if_t<std::is_member_function_pointer<F>::value>> {
- typedef wrapper<meta::unqualified_t<F>> wrap;
- typedef typename wrap::object_type object_type;
-
- template <typename Fx>
- static int call(lua_State* L, Fx&& f, object_type& o) {
- typedef typename wrap::returns_list returns_list;
- typedef typename wrap::args_list args_list;
- typedef typename wrap::caller caller;
- return stack::call_into_lua<checked>(returns_list(), args_list(), L, boost + ( is_variable ? 3 : 2 ), caller(), std::forward<Fx>(f), o);
- }
-
- template <typename Fx>
- static int call(lua_State* L, Fx&& f) {
- typedef std::conditional_t<std::is_void<T>::value, object_type, T> Ta;
-#ifdef SOL_SAFE_USERTYPE
- auto maybeo = stack::check_get<Ta*>(L, 1);
- if (!maybeo || maybeo.value() == nullptr) {
- return luaL_error(L, "sol: received nil for 'self' argument (use ':' for accessing member functions, make sure member variables are preceeded by the actual object with '.' syntax)");
- }
- object_type* o = static_cast<object_type*>(maybeo.value());
- return call(L, std::forward<Fx>(f), *o);
-#else
- object_type& o = static_cast<object_type&>(*stack::get<non_null<Ta*>>(L, 1));
- return call(L, std::forward<Fx>(f), o);
-#endif // Safety
- }
- };
-
- template <typename T, typename F, bool is_variable, bool checked, int boost>
- struct lua_call_wrapper<T, F, false, is_variable, checked, boost, std::enable_if_t<std::is_member_object_pointer<F>::value>> {
- typedef lua_bind_traits<F> traits_type;
- typedef wrapper<meta::unqualified_t<F>> wrap;
- typedef typename wrap::object_type object_type;
-
- template <typename V>
- static int call_assign(std::true_type, lua_State* L, V&& f, object_type& o) {
- typedef typename wrap::args_list args_list;
- typedef typename wrap::caller caller;
- return stack::call_into_lua<checked>(types<void>(), args_list(), L, boost + ( is_variable ? 3 : 2 ), caller(), f, o);
- }
-
- template <typename V>
- static int call_assign(std::true_type, lua_State* L, V&& f) {
- typedef std::conditional_t<std::is_void<T>::value, object_type, T> Ta;
-#ifdef SOL_SAFE_USERTYPE
- auto maybeo = stack::check_get<Ta*>(L, 1);
- if (!maybeo || maybeo.value() == nullptr) {
- 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 (pass 'self' as first argument)");
- }
- object_type* o = static_cast<object_type*>(maybeo.value());
- return call_assign(std::true_type(), L, f, *o);
-#else
- object_type& o = static_cast<object_type&>(*stack::get<non_null<Ta*>>(L, 1));
- return call_assign(std::true_type(), L, f, o);
-#endif // Safety
- }
-
- template <typename... Args>
- static int call_assign(std::false_type, lua_State* L, Args&&...) {
- return luaL_error(L, "sol: cannot write to this variable: copy assignment/constructor not available");
- }
-
- template <typename... Args>
- static int call_const(std::false_type, lua_State* L, Args&&... args) {
- typedef typename traits_type::return_type R;
- return call_assign(std::is_assignable<std::add_lvalue_reference_t<meta::unqualified_t<R>>, R>(), L, std::forward<Args>(args)...);
- }
-
- template <typename... Args>
- static int call_const(std::true_type, lua_State* L, Args&&...) {
- return luaL_error(L, "sol: cannot write to a readonly (const) variable");
- }
-
- template <typename V>
- static int call(lua_State* L, V&& f) {
- return call_const(std::is_const<typename traits_type::return_type>(), L, f);
- }
-
- template <typename V>
- static int call(lua_State* L, V&& f, object_type& o) {
- return call_const(std::is_const<typename traits_type::return_type>(), L, f, o);
- }
- };
-
- template <typename T, typename F, bool is_variable, bool checked, int boost>
- struct lua_call_wrapper<T, F, true, is_variable, checked, boost, std::enable_if_t<std::is_member_object_pointer<F>::value>> {
- typedef lua_bind_traits<F> traits_type;
- typedef wrapper<meta::unqualified_t<F>> wrap;
- typedef typename wrap::object_type object_type;
-
- template <typename V>
- static int call(lua_State* L, V&& f, object_type& o) {
- typedef typename wrap::returns_list returns_list;
- typedef typename wrap::caller caller;
- return stack::call_into_lua<checked>(returns_list(), types<>(), L, boost + ( is_variable ? 3 : 2 ), caller(), f, o);
- }
-
- template <typename V>
- static int call(lua_State* L, V&& f) {
- typedef std::conditional_t<std::is_void<T>::value, object_type, T> Ta;
-#ifdef SOL_SAFE_USERTYPE
- auto maybeo = stack::check_get<Ta*>(L, 1);
- if (!maybeo || maybeo.value() == nullptr) {
- 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 (pass 'self' as first argument)");
- }
- object_type* o = static_cast<object_type*>(maybeo.value());
- return call(L, f, *o);
-#else
- object_type& o = static_cast<object_type&>(*stack::get<non_null<Ta*>>(L, 1));
- return call(L, f, o);
-#endif // Safety
- }
- };
-
- template <typename T, typename... Args, bool is_index, bool is_variable, bool checked, int boost, typename C>
- struct lua_call_wrapper<T, constructor_list<Args...>, is_index, is_variable, checked, boost, C> {
- typedef constructor_list<Args...> F;
-
- static int call(lua_State* L, F&) {
- const auto& metakey = usertype_traits<T>::metatable();
- int argcount = lua_gettop(L);
- call_syntax syntax = argcount > 0 ? stack::get_call_syntax(L, &usertype_traits<T>::user_metatable()[0], 1) : call_syntax::dot;
- argcount -= static_cast<int>(syntax);
-
- T** pointerpointer = reinterpret_cast<T**>(lua_newuserdata(L, sizeof(T*) + sizeof(T)));
- reference userdataref(L, -1);
- T*& referencepointer = *pointerpointer;
- T* obj = reinterpret_cast<T*>(pointerpointer + 1);
- referencepointer = obj;
-
- construct_match<T, Args...>(constructor_match<T>(obj), L, argcount, boost + 1 + static_cast<int>(syntax));
-
- userdataref.push();
- luaL_getmetatable(L, &metakey[0]);
- if (type_of(L, -1) == type::lua_nil) {
- lua_pop(L, 1);
- return luaL_error(L, "sol: unable to get usertype metatable");
- }
-
- lua_setmetatable(L, -2);
- return 1;
- }
- };
-
- template <typename T, typename... Cxs, bool is_index, bool is_variable, bool checked, int boost, typename C>
- struct lua_call_wrapper<T, constructor_wrapper<Cxs...>, is_index, is_variable, checked, boost, C> {
- typedef constructor_wrapper<Cxs...> F;
-
- struct onmatch {
- template <typename Fx, std::size_t I, typename... R, typename... Args>
- int operator()(types<Fx>, index_value<I>, types<R...> r, types<Args...> a, lua_State* L, int, int start, F& f) {
- const auto& metakey = usertype_traits<T>::metatable();
- T** pointerpointer = reinterpret_cast<T**>(lua_newuserdata(L, sizeof(T*) + sizeof(T)));
- reference userdataref(L, -1);
- T*& referencepointer = *pointerpointer;
- T* obj = reinterpret_cast<T*>(pointerpointer + 1);
- referencepointer = obj;
-
- auto& func = std::get<I>(f.functions);
- stack::call_into_lua<checked>(r, a, L, boost + start, func, detail::implicit_wrapper<T>(obj));
-
- userdataref.push();
- luaL_getmetatable(L, &metakey[0]);
- if (type_of(L, -1) == type::lua_nil) {
- lua_pop(L, 1);
- std::string err = "sol: unable to get usertype metatable for ";
- err += usertype_traits<T>::name();
- return luaL_error(L, err.c_str());
- }
- lua_setmetatable(L, -2);
-
- return 1;
- }
- };
-
- static int call(lua_State* L, F& f) {
- call_syntax syntax = stack::get_call_syntax(L, &usertype_traits<T>::user_metatable()[0], 1);
- int syntaxval = static_cast<int>(syntax);
- int argcount = lua_gettop(L) - syntaxval;
- return construct_match<T, meta::pop_front_type_t<meta::function_args_t<Cxs>>...>(onmatch(), L, argcount, 1 + syntaxval, f);
- }
-
- };
-
- template <typename T, typename Fx, bool is_index, bool is_variable, bool checked, int boost>
- struct lua_call_wrapper<T, destructor_wrapper<Fx>, is_index, is_variable, checked, boost, std::enable_if_t<std::is_void<Fx>::value>> {
- typedef destructor_wrapper<Fx> F;
-
- static int call(lua_State* L, const F&) {
- return detail::usertype_alloc_destroy<T>(L);
- }
- };
-
- template <typename T, typename Fx, bool is_index, bool is_variable, bool checked, int boost>
- struct lua_call_wrapper<T, destructor_wrapper<Fx>, is_index, is_variable, checked, boost, std::enable_if_t<!std::is_void<Fx>::value>> {
- typedef destructor_wrapper<Fx> F;
-
- static int call(lua_State* L, const F& f) {
- T& obj = stack::get<T>(L);
- f.fx(detail::implicit_wrapper<T>(obj));
- return 0;
- }
- };
-
- template <typename T, typename... Fs, bool is_index, bool is_variable, bool checked, int boost, typename C>
- struct lua_call_wrapper<T, overload_set<Fs...>, is_index, is_variable, checked, boost, C> {
- typedef overload_set<Fs...> F;
-
- struct on_match {
- template <typename Fx, std::size_t I, typename... R, typename... Args>
- int operator()(types<Fx>, index_value<I>, types<R...>, types<Args...>, lua_State* L, int, int, F& fx) {
- auto& f = std::get<I>(fx.functions);
- return lua_call_wrapper<T, Fx, is_index, is_variable, checked, boost>{}.call(L, f);
- }
- };
-
- static int call(lua_State* L, F& fx) {
- return overload_match_arity<Fs...>(on_match(), L, lua_gettop(L), 1, fx);
- }
- };
-
- template <typename T, typename... Fs, bool is_index, bool is_variable, bool checked, int boost, typename C>
- struct lua_call_wrapper<T, factory_wrapper<Fs...>, is_index, is_variable, checked, boost, C> {
- typedef factory_wrapper<Fs...> F;
-
- struct on_match {
- template <typename Fx, std::size_t I, typename... R, typename... Args>
- int operator()(types<Fx>, index_value<I>, types<R...>, types<Args...>, lua_State* L, int, int, F& fx) {
- auto& f = std::get<I>(fx.functions);
- return lua_call_wrapper<T, Fx, is_index, is_variable, checked, boost>{}.call(L, f);
- }
- };
-
- static int call(lua_State* L, F& fx) {
- return overload_match_arity<Fs...>(on_match(), L, lua_gettop(L) - boost, 1 + boost, fx);
- }
- };
-
- template <typename T, typename R, typename W, bool is_index, bool is_variable, bool checked, int boost, typename C>
- struct lua_call_wrapper<T, property_wrapper<R, W>, is_index, is_variable, checked, boost, C> {
- typedef std::conditional_t<is_index, R, W> P;
- typedef meta::unqualified_t<P> U;
- typedef lua_bind_traits<U> traits_type;
-
- template <typename F>
- static int self_call(lua_State* L, F&& f) {
- typedef wrapper<U> wrap;
- typedef meta::unqualified_t<typename traits_type::template arg_at<0>> object_type;
- typedef meta::pop_front_type_t<typename traits_type::free_args_list> args_list;
- typedef T Ta;
-#ifdef SOL_SAFE_USERTYPE
- auto maybeo = stack::check_get<Ta*>(L, 1);
- if (!maybeo || maybeo.value() == nullptr) {
- 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 (pass 'self' as first argument)");
- }
- object_type* o = static_cast<object_type*>(maybeo.value());
-#else
- object_type* o = static_cast<object_type*>(stack::get<non_null<Ta*>>(L, 1));
-#endif // Safety
- typedef typename wrap::returns_list returns_list;
- typedef typename wrap::caller caller;
- return stack::call_into_lua<checked>(returns_list(), args_list(), L, boost + (is_variable ? 3 : 2), caller(), f, *o);
- }
-
- template <typename F, typename... Args>
- static int defer_call(std::false_type, lua_State* L, F&& f, Args&&... args) {
- return self_call(L, pick(meta::boolean<is_index>(), f), std::forward<Args>(args)...);
- }
-
- template <typename F, typename... Args>
- static int defer_call(std::true_type, lua_State* L, F&& f, Args&&... args) {
- auto& p = pick(meta::boolean<is_index>(), std::forward<F>(f));
- return lua_call_wrapper<T, meta::unqualified_t<decltype(p)>, is_index, is_variable, checked, boost>{}.call(L, p, std::forward<Args>(args)...);
- }
-
- template <typename F, typename... Args>
- static int call(lua_State* L, F&& f, Args&&... args) {
- typedef meta::any<
- std::is_void<U>,
- std::is_same<U, no_prop>,
- meta::is_specialization_of<var_wrapper, U>,
- meta::is_specialization_of<constructor_wrapper, U>,
- meta::is_specialization_of<constructor_list, U>,
- std::is_member_pointer<U>
- > is_specialized;
- return defer_call(is_specialized(), L, std::forward<F>(f), std::forward<Args>(args)...);
- }
- };
-
- template <typename T, typename V, bool is_index, bool is_variable, bool checked, int boost, typename C>
- struct lua_call_wrapper<T, protect_t<V>, is_index, is_variable, checked, boost, C> {
- typedef protect_t<V> F;
-
- template <typename... Args>
- static int call(lua_State* L, F& fx, Args&&... args) {
- return lua_call_wrapper<T, V, is_index, is_variable, true, boost>{}.call(L, fx.value, std::forward<Args>(args)...);
- }
- };
-
- template <typename T, typename Sig, typename P, bool is_index, bool is_variable, bool checked, int boost, typename C>
- struct lua_call_wrapper<T, function_arguments<Sig, P>, is_index, is_variable, checked, boost, C> {
- template <typename F>
- static int call(lua_State* L, F&& f) {
- return lua_call_wrapper<T, meta::unqualified_t<P>, is_index, is_variable, stack::stack_detail::default_check_arguments, boost>{}.call(L, std::get<0>(f.arguments));
- }
- };
-
- template <typename T, bool is_index, bool is_variable, int boost = 0, typename Fx, typename... Args>
- inline int call_wrapped(lua_State* L, Fx&& fx, Args&&... args) {
- return lua_call_wrapper<T, meta::unqualified_t<Fx>, is_index, is_variable, stack::stack_detail::default_check_arguments, boost>{}.call(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
- }
-
- template <typename T, bool is_index, bool is_variable, typename F>
- inline int call_user(lua_State* L) {
- auto& fx = stack::get<user<F>>(L, upvalue_index(1));
- return call_wrapped<T, is_index, is_variable>(L, fx);
- }
-
- template <typename T, typename = void>
- struct is_var_bind : std::false_type {};
-
- template <typename T>
- struct is_var_bind<T, std::enable_if_t<std::is_member_object_pointer<T>::value>> : std::true_type {};
-
- template <>
- struct is_var_bind<no_prop> : std::true_type {};
-
- template <typename R, typename W>
- struct is_var_bind<property_wrapper<R, W>> : std::true_type {};
-
- template <typename T>
- struct is_var_bind<var_wrapper<T>> : std::true_type {};
- } // call_detail
-
- template <typename T>
- struct is_variable_binding : call_detail::is_var_bind<meta::unqualified_t<T>> {};
-
- template <typename T>
- struct is_function_binding : meta::neg<is_variable_binding<T>> {};
-
-} // sol
-
-#endif // SOL_CALL_HPP
diff --git a/3rdparty/sol2/sol/compatibility.hpp b/3rdparty/sol2/sol/compatibility.hpp
deleted file mode 100644
index 81e7742df0c..00000000000
--- a/3rdparty/sol2/sol/compatibility.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_COMPATIBILITY_HPP
-#define SOL_COMPATIBILITY_HPP
-
-// The various pieces of the compatibility layer
-// comes from https://github.com/keplerproject/lua-compat-5.2
-// but has been modified in many places for use with Sol and luajit,
-// though the core abstractions remain the same
-
-#include "compatibility/version.hpp"
-
-#ifndef SOL_NO_COMPAT
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-#include "compatibility/5.1.0.h"
-#include "compatibility/5.0.0.h"
-#include "compatibility/5.x.x.h"
-#include "compatibility/5.x.x.inl"
-#ifdef __cplusplus
-}
-#endif
-
-#endif // SOL_NO_COMPAT
-
-#endif // SOL_COMPATIBILITY_HPP
diff --git a/3rdparty/sol2/sol/compatibility/5.0.0.h b/3rdparty/sol2/sol/compatibility/5.0.0.h
deleted file mode 100644
index 549badba962..00000000000
--- a/3rdparty/sol2/sol/compatibility/5.0.0.h
+++ /dev/null
@@ -1,44 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_5_0_0_H
-#define SOL_5_0_0_H
-
-#include "version.hpp"
-
-#if SOL_LUA_VERSION < 501
-/* Lua 5.0 */
-
-#define LUA_QL(x) "'" x "'"
-#define LUA_QS LUA_QL("%s")
-
-#define luaL_Reg luaL_reg
-
-#define luaL_opt(L, f, n, d) \
- (lua_isnoneornil(L, n) ? (d) : f(L, n))
-
-#define luaL_addchar(B,c) \
- ((void)((B)->p < ((B)->buffer+LUAL_BUFFERSIZE) || luaL_prepbuffer(B)), \
- (*(B)->p++ = (char)(c)))
-
-#endif // Lua 5.0
-
-#endif // SOL_5_0_0_H
diff --git a/3rdparty/sol2/sol/compatibility/5.1.0.h b/3rdparty/sol2/sol/compatibility/5.1.0.h
deleted file mode 100644
index 45225a0a805..00000000000
--- a/3rdparty/sol2/sol/compatibility/5.1.0.h
+++ /dev/null
@@ -1,175 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_5_1_0_H
-#define SOL_5_1_0_H
-
-#include "version.hpp"
-
-#if SOL_LUA_VERSION == 501
-/* Lua 5.1 */
-
-#include <lua.hpp>
-#include <stddef.h>
-#include <string.h>
-#include <stdio.h>
-
-/* LuaJIT doesn't define these unofficial macros ... */
-#if !defined(LUAI_INT32)
-#include <limits.h>
-#if INT_MAX-20 < 32760
-#define LUAI_INT32 long
-#define LUAI_UINT32 unsigned long
-#elif INT_MAX > 2147483640L
-#define LUAI_INT32 int
-#define LUAI_UINT32 unsigned int
-#else
-#error "could not detect suitable lua_Unsigned datatype"
-#endif
-#endif
-
-/* LuaJIT does not have the updated error codes for thread status/function returns */
-#ifndef LUA_ERRGCMM
-#define LUA_ERRGCMM (LUA_ERRERR + 1)
-#endif // LUA_ERRGCMM
-
-/* LuaJIT does not support continuation contexts / return error codes? */
-#ifndef LUA_KCONTEXT
-#define LUA_KCONTEXT std::ptrdiff_t
-typedef LUA_KCONTEXT lua_KContext;
-typedef int(*lua_KFunction) (lua_State *L, int status, lua_KContext ctx);
-#endif // LUA_KCONTEXT
-
-#define LUA_OPADD 0
-#define LUA_OPSUB 1
-#define LUA_OPMUL 2
-#define LUA_OPDIV 3
-#define LUA_OPMOD 4
-#define LUA_OPPOW 5
-#define LUA_OPUNM 6
-#define LUA_OPEQ 0
-#define LUA_OPLT 1
-#define LUA_OPLE 2
-
-typedef LUAI_UINT32 lua_Unsigned;
-
-typedef struct luaL_Buffer_52 {
- luaL_Buffer b; /* make incorrect code crash! */
- char *ptr;
- size_t nelems;
- size_t capacity;
- lua_State *L2;
-} luaL_Buffer_52;
-#define luaL_Buffer luaL_Buffer_52
-
-#define lua_tounsigned(L, i) lua_tounsignedx(L, i, NULL)
-
-#define lua_rawlen(L, i) lua_objlen(L, i)
-
-inline void lua_callk(lua_State *L, int nargs, int nresults, lua_KContext, lua_KFunction) {
- // should probably warn the user of Lua 5.1 that continuation isn't supported...
- lua_call(L, nargs, nresults);
-}
-inline int lua_pcallk(lua_State *L, int nargs, int nresults, int errfunc, lua_KContext, lua_KFunction) {
- // should probably warn the user of Lua 5.1 that continuation isn't supported...
- return lua_pcall(L, nargs, nresults, errfunc);
-}
-void lua_arith(lua_State *L, int op);
-int lua_compare(lua_State *L, int idx1, int idx2, int op);
-void lua_pushunsigned(lua_State *L, lua_Unsigned n);
-lua_Unsigned luaL_checkunsigned(lua_State *L, int i);
-lua_Unsigned lua_tounsignedx(lua_State *L, int i, int *isnum);
-lua_Unsigned luaL_optunsigned(lua_State *L, int i, lua_Unsigned def);
-lua_Integer lua_tointegerx(lua_State *L, int i, int *isnum);
-void lua_len(lua_State *L, int i);
-int luaL_len(lua_State *L, int i);
-const char *luaL_tolstring(lua_State *L, int idx, size_t *len);
-void luaL_requiref(lua_State *L, char const* modname, lua_CFunction openf, int glb);
-
-#define luaL_buffinit luaL_buffinit_52
-void luaL_buffinit(lua_State *L, luaL_Buffer_52 *B);
-
-#define luaL_prepbuffsize luaL_prepbuffsize_52
-char *luaL_prepbuffsize(luaL_Buffer_52 *B, size_t s);
-
-#define luaL_addlstring luaL_addlstring_52
-void luaL_addlstring(luaL_Buffer_52 *B, const char *s, size_t l);
-
-#define luaL_addvalue luaL_addvalue_52
-void luaL_addvalue(luaL_Buffer_52 *B);
-
-#define luaL_pushresult luaL_pushresult_52
-void luaL_pushresult(luaL_Buffer_52 *B);
-
-#undef luaL_buffinitsize
-#define luaL_buffinitsize(L, B, s) \
- (luaL_buffinit(L, B), luaL_prepbuffsize(B, s))
-
-#undef luaL_prepbuffer
-#define luaL_prepbuffer(B) \
- luaL_prepbuffsize(B, LUAL_BUFFERSIZE)
-
-#undef luaL_addchar
-#define luaL_addchar(B, c) \
- ((void)((B)->nelems < (B)->capacity || luaL_prepbuffsize(B, 1)), \
- ((B)->ptr[(B)->nelems++] = (c)))
-
-#undef luaL_addsize
-#define luaL_addsize(B, s) \
- ((B)->nelems += (s))
-
-#undef luaL_addstring
-#define luaL_addstring(B, s) \
- luaL_addlstring(B, s, strlen(s))
-
-#undef luaL_pushresultsize
-#define luaL_pushresultsize(B, s) \
- (luaL_addsize(B, s), luaL_pushresult(B))
-
-typedef struct kepler_lua_compat_get_string_view {
- const char *s;
- size_t size;
-} kepler_lua_compat_get_string_view;
-
-inline const char* kepler_lua_compat_get_string(lua_State* L, void* ud, size_t* size) {
- kepler_lua_compat_get_string_view* ls = (kepler_lua_compat_get_string_view*) ud;
- (void)L;
- if (ls->size == 0) return NULL;
- *size = ls->size;
- ls->size = 0;
- return ls->s;
-}
-
-#if !defined(SOL_LUAJIT) || (SOL_LUAJIT_VERSION < 20100)
-// Luajit 2.1.0 has this function already
-
-inline int luaL_loadbufferx(lua_State* L, const char* buff, size_t size, const char* name, const char*) {
- kepler_lua_compat_get_string_view ls;
- ls.s = buff;
- ls.size = size;
- return lua_load(L, kepler_lua_compat_get_string, &ls, name/*, mode*/);
-}
-
-#endif // LuaJIT 2.1.x beta and beyond
-
-#endif /* Lua 5.1 */
-
-#endif // SOL_5_1_0_H
diff --git a/3rdparty/sol2/sol/compatibility/5.2.0.h b/3rdparty/sol2/sol/compatibility/5.2.0.h
deleted file mode 100644
index 7068f2a3291..00000000000
--- a/3rdparty/sol2/sol/compatibility/5.2.0.h
+++ /dev/null
@@ -1,43 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_5_2_0_H
-#define SOL_5_2_0_H
-#include "version.hpp"
-
-#if SOL_LUA_VERSION < 503
-
-inline int lua_isinteger(lua_State* L, int idx) {
- if (lua_type(L, idx) != LUA_TNUMBER)
- return 0;
- // This is a very slipshod way to do the testing
- // but lua_totingerx doesn't play ball nicely
- // on older versions...
- lua_Number n = lua_tonumber(L, idx);
- lua_Integer i = lua_tointeger(L, idx);
- if (i != n)
- return 0;
- // it's DEFINITELY an integer
- return 1;
-}
-
-#endif // SOL_LUA_VERSION == 502
-#endif // SOL_5_2_0_H
diff --git a/3rdparty/sol2/sol/compatibility/5.x.x.h b/3rdparty/sol2/sol/compatibility/5.x.x.h
deleted file mode 100644
index 95f48792a00..00000000000
--- a/3rdparty/sol2/sol/compatibility/5.x.x.h
+++ /dev/null
@@ -1,57 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_5_X_X_H
-#define SOL_5_X_X_H
-
-#include "version.hpp"
-
-#if SOL_LUA_VERSION < 502
-
-#define LUA_RIDX_GLOBALS LUA_GLOBALSINDEX
-
-#define LUA_OK 0
-
-#define lua_pushglobaltable(L) \
- lua_pushvalue(L, LUA_GLOBALSINDEX)
-
-#define luaL_newlib(L, l) \
- (lua_newtable((L)),luaL_setfuncs((L), (l), 0))
-
-void luaL_checkversion(lua_State *L);
-
-int lua_absindex(lua_State *L, int i);
-void lua_copy(lua_State *L, int from, int to);
-void lua_rawgetp(lua_State *L, int i, const void *p);
-void lua_rawsetp(lua_State *L, int i, const void *p);
-void *luaL_testudata(lua_State *L, int i, const char *tname);
-lua_Number lua_tonumberx(lua_State *L, int i, int *isnum);
-void lua_getuservalue(lua_State *L, int i);
-void lua_setuservalue(lua_State *L, int i);
-void luaL_setfuncs(lua_State *L, const luaL_Reg *l, int nup);
-void luaL_setmetatable(lua_State *L, const char *tname);
-int luaL_getsubtable(lua_State *L, int i, const char *name);
-void luaL_traceback(lua_State *L, lua_State *L1, const char *msg, int level);
-int luaL_fileresult(lua_State *L, int stat, const char *fname);
-
-#endif // Lua 5.1 and below
-
-#endif // SOL_5_X_X_H
diff --git a/3rdparty/sol2/sol/compatibility/5.x.x.inl b/3rdparty/sol2/sol/compatibility/5.x.x.inl
deleted file mode 100644
index b32cb7f26f7..00000000000
--- a/3rdparty/sol2/sol/compatibility/5.x.x.inl
+++ /dev/null
@@ -1,708 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_5_X_X_INL
-#define SOL_5_X_X_INL
-
-#include "version.hpp"
-#include "5.2.0.h"
-#include "5.1.0.h"
-#include "5.0.0.h"
-#include "5.x.x.h"
-
-#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM == 501
-
-#include <errno.h>
-#include <string.h>
-
-#define PACKAGE_KEY "_sol.package"
-
-inline int lua_absindex(lua_State *L, int i) {
- if (i < 0 && i > LUA_REGISTRYINDEX)
- i += lua_gettop(L) + 1;
- return i;
-}
-
-inline void lua_copy(lua_State *L, int from, int to) {
- int abs_to = lua_absindex(L, to);
- luaL_checkstack(L, 1, "not enough stack slots");
- lua_pushvalue(L, from);
- lua_replace(L, abs_to);
-}
-
-inline void lua_rawgetp(lua_State *L, int i, const void *p) {
- int abs_i = lua_absindex(L, i);
- lua_pushlightuserdata(L, (void*)p);
- lua_rawget(L, abs_i);
-}
-
-inline void lua_rawsetp(lua_State *L, int i, const void *p) {
- int abs_i = lua_absindex(L, i);
- luaL_checkstack(L, 1, "not enough stack slots");
- lua_pushlightuserdata(L, (void*)p);
- lua_insert(L, -2);
- lua_rawset(L, abs_i);
-}
-
-inline void *luaL_testudata(lua_State *L, int i, const char *tname) {
- void *p = lua_touserdata(L, i);
- luaL_checkstack(L, 2, "not enough stack slots");
- if (p == NULL || !lua_getmetatable(L, i))
- return NULL;
- else {
- int res = 0;
- luaL_getmetatable(L, tname);
- res = lua_rawequal(L, -1, -2);
- lua_pop(L, 2);
- if (!res)
- p = NULL;
- }
- return p;
-}
-
-inline lua_Number lua_tonumberx(lua_State *L, int i, int *isnum) {
- lua_Number n = lua_tonumber(L, i);
- if (isnum != NULL) {
- *isnum = (n != 0 || lua_isnumber(L, i));
- }
- return n;
-}
-
-inline static void push_package_table(lua_State *L) {
- lua_pushliteral(L, PACKAGE_KEY);
- lua_rawget(L, LUA_REGISTRYINDEX);
- if (!lua_istable(L, -1)) {
- lua_pop(L, 1);
- /* try to get package table from globals */
- lua_pushliteral(L, "package");
- lua_rawget(L, LUA_GLOBALSINDEX);
- if (lua_istable(L, -1)) {
- lua_pushliteral(L, PACKAGE_KEY);
- lua_pushvalue(L, -2);
- lua_rawset(L, LUA_REGISTRYINDEX);
- }
- }
-}
-
-inline void lua_getuservalue(lua_State *L, int i) {
- luaL_checktype(L, i, LUA_TUSERDATA);
- luaL_checkstack(L, 2, "not enough stack slots");
- lua_getfenv(L, i);
- lua_pushvalue(L, LUA_GLOBALSINDEX);
- if (lua_rawequal(L, -1, -2)) {
- lua_pop(L, 1);
- lua_pushnil(L);
- lua_replace(L, -2);
- }
- else {
- lua_pop(L, 1);
- push_package_table(L);
- if (lua_rawequal(L, -1, -2)) {
- lua_pop(L, 1);
- lua_pushnil(L);
- lua_replace(L, -2);
- }
- else
- lua_pop(L, 1);
- }
-}
-
-inline void lua_setuservalue(lua_State *L, int i) {
- luaL_checktype(L, i, LUA_TUSERDATA);
- if (lua_isnil(L, -1)) {
- luaL_checkstack(L, 1, "not enough stack slots");
- lua_pushvalue(L, LUA_GLOBALSINDEX);
- lua_replace(L, -2);
- }
- lua_setfenv(L, i);
-}
-
-/*
-** Adapted from Lua 5.2.0
-*/
-inline void luaL_setfuncs(lua_State *L, const luaL_Reg *l, int nup) {
- luaL_checkstack(L, nup + 1, "too many upvalues");
- for (; l->name != NULL; l++) { /* fill the table with given functions */
- int i;
- lua_pushstring(L, l->name);
- for (i = 0; i < nup; i++) /* copy upvalues to the top */
- lua_pushvalue(L, -(nup + 1));
- lua_pushcclosure(L, l->func, nup); /* closure with those upvalues */
- lua_settable(L, -(nup + 3)); /* table must be below the upvalues, the name and the closure */
- }
- lua_pop(L, nup); /* remove upvalues */
-}
-
-inline void luaL_setmetatable(lua_State *L, const char *tname) {
- luaL_checkstack(L, 1, "not enough stack slots");
- luaL_getmetatable(L, tname);
- lua_setmetatable(L, -2);
-}
-
-inline int luaL_getsubtable(lua_State *L, int i, const char *name) {
- int abs_i = lua_absindex(L, i);
- luaL_checkstack(L, 3, "not enough stack slots");
- lua_pushstring(L, name);
- lua_gettable(L, abs_i);
- if (lua_istable(L, -1))
- return 1;
- lua_pop(L, 1);
- lua_newtable(L);
- lua_pushstring(L, name);
- lua_pushvalue(L, -2);
- lua_settable(L, abs_i);
- return 0;
-}
-
-#ifndef SOL_LUAJIT
-inline static int countlevels(lua_State *L) {
- lua_Debug ar;
- int li = 1, le = 1;
- /* find an upper bound */
- while (lua_getstack(L, le, &ar)) { li = le; le *= 2; }
- /* do a binary search */
- while (li < le) {
- int m = (li + le) / 2;
- if (lua_getstack(L, m, &ar)) li = m + 1;
- else le = m;
- }
- return le - 1;
-}
-
-inline static int findfield(lua_State *L, int objidx, int level) {
- if (level == 0 || !lua_istable(L, -1))
- return 0; /* not found */
- lua_pushnil(L); /* start 'next' loop */
- while (lua_next(L, -2)) { /* for each pair in table */
- if (lua_type(L, -2) == LUA_TSTRING) { /* ignore non-string keys */
- if (lua_rawequal(L, objidx, -1)) { /* found object? */
- lua_pop(L, 1); /* remove value (but keep name) */
- return 1;
- }
- else if (findfield(L, objidx, level - 1)) { /* try recursively */
- lua_remove(L, -2); /* remove table (but keep name) */
- lua_pushliteral(L, ".");
- lua_insert(L, -2); /* place '.' between the two names */
- lua_concat(L, 3);
- return 1;
- }
- }
- lua_pop(L, 1); /* remove value */
- }
- return 0; /* not found */
-}
-
-inline static int pushglobalfuncname(lua_State *L, lua_Debug *ar) {
- int top = lua_gettop(L);
- lua_getinfo(L, "f", ar); /* push function */
- lua_pushvalue(L, LUA_GLOBALSINDEX);
- if (findfield(L, top + 1, 2)) {
- lua_copy(L, -1, top + 1); /* move name to proper place */
- lua_pop(L, 2); /* remove pushed values */
- return 1;
- }
- else {
- lua_settop(L, top); /* remove function and global table */
- return 0;
- }
-}
-
-inline static void pushfuncname(lua_State *L, lua_Debug *ar) {
- if (*ar->namewhat != '\0') /* is there a name? */
- lua_pushfstring(L, "function " LUA_QS, ar->name);
- else if (*ar->what == 'm') /* main? */
- lua_pushliteral(L, "main chunk");
- else if (*ar->what == 'C') {
- if (pushglobalfuncname(L, ar)) {
- lua_pushfstring(L, "function " LUA_QS, lua_tostring(L, -1));
- lua_remove(L, -2); /* remove name */
- }
- else
- lua_pushliteral(L, "?");
- }
- else
- lua_pushfstring(L, "function <%s:%d>", ar->short_src, ar->linedefined);
-}
-
-#define LEVELS1 12 /* size of the first part of the stack */
-#define LEVELS2 10 /* size of the second part of the stack */
-
-inline void luaL_traceback(lua_State *L, lua_State *L1,
- const char *msg, int level) {
- lua_Debug ar;
- int top = lua_gettop(L);
- int numlevels = countlevels(L1);
- int mark = (numlevels > LEVELS1 + LEVELS2) ? LEVELS1 : 0;
- if (msg) lua_pushfstring(L, "%s\n", msg);
- lua_pushliteral(L, "stack traceback:");
- while (lua_getstack(L1, level++, &ar)) {
- if (level == mark) { /* too many levels? */
- lua_pushliteral(L, "\n\t..."); /* add a '...' */
- level = numlevels - LEVELS2; /* and skip to last ones */
- }
- else {
- lua_getinfo(L1, "Slnt", &ar);
- lua_pushfstring(L, "\n\t%s:", ar.short_src);
- if (ar.currentline > 0)
- lua_pushfstring(L, "%d:", ar.currentline);
- lua_pushliteral(L, " in ");
- pushfuncname(L, &ar);
- lua_concat(L, lua_gettop(L) - top);
- }
- }
- lua_concat(L, lua_gettop(L) - top);
-}
-#endif
-
-inline const lua_Number *lua_version(lua_State *L) {
- static const lua_Number version = LUA_VERSION_NUM;
- if (L == NULL) return &version;
- // TODO: wonky hacks to get at the inside of the incomplete type lua_State?
- //else return L->l_G->version;
- else return &version;
-}
-
-inline static void luaL_checkversion_(lua_State *L, lua_Number ver) {
- const lua_Number* v = lua_version(L);
- if (v != lua_version(NULL))
- luaL_error(L, "multiple Lua VMs detected");
- else if (*v != ver)
- luaL_error(L, "version mismatch: app. needs %f, Lua core provides %f",
- ver, *v);
- /* check conversions number -> integer types */
- lua_pushnumber(L, -(lua_Number)0x1234);
- if (lua_tointeger(L, -1) != -0x1234 ||
- lua_tounsigned(L, -1) != (lua_Unsigned)-0x1234)
- luaL_error(L, "bad conversion number->int;"
- " must recompile Lua with proper settings");
- lua_pop(L, 1);
-}
-
-inline void luaL_checkversion(lua_State* L) {
- luaL_checkversion_(L, LUA_VERSION_NUM);
-}
-
-#ifndef SOL_LUAJIT
-inline int luaL_fileresult(lua_State *L, int stat, const char *fname) {
- int en = errno; /* calls to Lua API may change this value */
- if (stat) {
- lua_pushboolean(L, 1);
- return 1;
- }
- else {
- char buf[1024];
-#if defined(__GLIBC__) || defined(_POSIX_VERSION)
- strerror_r(en, buf, 1024);
-#else
- strerror_s(buf, 1024, en);
-#endif
- lua_pushnil(L);
- if (fname)
- lua_pushfstring(L, "%s: %s", fname, buf);
- else
- lua_pushstring(L, buf);
- lua_pushnumber(L, (lua_Number)en);
- return 3;
- }
-}
-#endif // luajit
-#endif // Lua 5.0 or Lua 5.1
-
-
-#if SOL_LUA_VERSION == 501
-#include <limits.h>
-
-typedef LUAI_INT32 LUA_INT32;
-
-/********************************************************************/
-/* extract of 5.2's luaconf.h */
-/* detects proper defines for faster unsigned<->number conversion */
-/* see copyright notice at the end of this file */
-/********************************************************************/
-
-#if !defined(LUA_ANSI) && defined(_WIN32) && !defined(_WIN32_WCE)
-#define LUA_WIN /* enable goodies for regular Windows platforms */
-#endif
-
-
-#if defined(LUA_NUMBER_DOUBLE) && !defined(LUA_ANSI) /* { */
-
-/* Microsoft compiler on a Pentium (32 bit) ? */
-#if defined(LUA_WIN) && defined(_MSC_VER) && defined(_M_IX86) /* { */
-
-#define LUA_MSASMTRICK
-#define LUA_IEEEENDIAN 0
-#define LUA_NANTRICK
-
-/* pentium 32 bits? */
-#elif defined(__i386__) || defined(__i386) || defined(__X86__) /* }{ */
-
-#define LUA_IEEE754TRICK
-#define LUA_IEEELL
-#define LUA_IEEEENDIAN 0
-#define LUA_NANTRICK
-
-/* pentium 64 bits? */
-#elif defined(__x86_64) /* }{ */
-
-#define LUA_IEEE754TRICK
-#define LUA_IEEEENDIAN 0
-
-#elif defined(__POWERPC__) || defined(__ppc__) /* }{ */
-
-#define LUA_IEEE754TRICK
-#define LUA_IEEEENDIAN 1
-
-#else /* }{ */
-
-/* assume IEEE754 and a 32-bit integer type */
-#define LUA_IEEE754TRICK
-
-#endif /* } */
-
-#endif /* } */
-
-
-/********************************************************************/
-/* extract of 5.2's llimits.h */
-/* gives us lua_number2unsigned and lua_unsigned2number */
-/* see copyright notice just below this one here */
-/********************************************************************/
-
-/*********************************************************************
-* This file contains parts of Lua 5.2's source code:
-*
-* Copyright (C) 1994-2013 Lua.org, PUC-Rio.
-*
-* 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.
-*********************************************************************/
-
-#if defined(MS_ASMTRICK) || defined(LUA_MSASMTRICK) /* { */
-/* trick with Microsoft assembler for X86 */
-
-#define lua_number2unsigned(i,n) \
- {__int64 l; __asm {__asm fld n __asm fistp l} i = (unsigned int)l;}
-
-
-#elif defined(LUA_IEEE754TRICK) /* }{ */
-/* the next trick should work on any machine using IEEE754 with
-a 32-bit int type */
-
-union compat52_luai_Cast { double l_d; LUA_INT32 l_p[2]; };
-
-#if !defined(LUA_IEEEENDIAN) /* { */
-#define LUAI_EXTRAIEEE \
- static const union compat52_luai_Cast ieeeendian = {-(33.0 + 6755399441055744.0)};
-#define LUA_IEEEENDIANLOC (ieeeendian.l_p[1] == 33)
-#else
-#define LUA_IEEEENDIANLOC LUA_IEEEENDIAN
-#define LUAI_EXTRAIEEE /* empty */
-#endif /* } */
-
-#define lua_number2int32(i,n,t) \
- { LUAI_EXTRAIEEE \
- volatile union compat52_luai_Cast u; u.l_d = (n) + 6755399441055744.0; \
- (i) = (t)u.l_p[LUA_IEEEENDIANLOC]; }
-
-#define lua_number2unsigned(i,n) lua_number2int32(i, n, lua_Unsigned)
-
-#endif /* } */
-
-
-/* the following definitions always work, but may be slow */
-
-#if !defined(lua_number2unsigned) /* { */
-/* the following definition assures proper modulo behavior */
-#if defined(LUA_NUMBER_DOUBLE) || defined(LUA_NUMBER_FLOAT)
-#include <math.h>
-#define SUPUNSIGNED ((lua_Number)(~(lua_Unsigned)0) + 1)
-#define lua_number2unsigned(i,n) \
- ((i)=(lua_Unsigned)((n) - floor((n)/SUPUNSIGNED)*SUPUNSIGNED))
-#else
-#define lua_number2unsigned(i,n) ((i)=(lua_Unsigned)(n))
-#endif
-#endif /* } */
-
-
-#if !defined(lua_unsigned2number)
-/* on several machines, coercion from unsigned to double is slow,
-so it may be worth to avoid */
-#define lua_unsigned2number(u) \
- (((u) <= (lua_Unsigned)INT_MAX) ? (lua_Number)(int)(u) : (lua_Number)(u))
-#endif
-
-/********************************************************************/
-
-inline static void compat52_call_lua(lua_State *L, char const code[], size_t len,
- int nargs, int nret) {
- lua_rawgetp(L, LUA_REGISTRYINDEX, (void*)code);
- if (lua_type(L, -1) != LUA_TFUNCTION) {
- lua_pop(L, 1);
- if (luaL_loadbuffer(L, code, len, "=none"))
- lua_error(L);
- lua_pushvalue(L, -1);
- lua_rawsetp(L, LUA_REGISTRYINDEX, (void*)code);
- }
- lua_insert(L, -nargs - 1);
- lua_call(L, nargs, nret);
-}
-
-static const char compat52_arith_code[] = {
- "local op,a,b=...\n"
- "if op==0 then return a+b\n"
- "elseif op==1 then return a-b\n"
- "elseif op==2 then return a*b\n"
- "elseif op==3 then return a/b\n"
- "elseif op==4 then return a%b\n"
- "elseif op==5 then return a^b\n"
- "elseif op==6 then return -a\n"
- "end\n"
-};
-
-inline void lua_arith(lua_State *L, int op) {
- if (op < LUA_OPADD || op > LUA_OPUNM)
- luaL_error(L, "invalid 'op' argument for lua_arith");
- luaL_checkstack(L, 5, "not enough stack slots");
- if (op == LUA_OPUNM)
- lua_pushvalue(L, -1);
- lua_pushnumber(L, op);
- lua_insert(L, -3);
- compat52_call_lua(L, compat52_arith_code,
- sizeof(compat52_arith_code) - 1, 3, 1);
-}
-
-static const char compat52_compare_code[] = {
- "local a,b=...\n"
- "return a<=b\n"
-};
-
-inline int lua_compare(lua_State *L, int idx1, int idx2, int op) {
- int result = 0;
- switch (op) {
- case LUA_OPEQ:
- return lua_equal(L, idx1, idx2);
- case LUA_OPLT:
- return lua_lessthan(L, idx1, idx2);
- case LUA_OPLE:
- luaL_checkstack(L, 5, "not enough stack slots");
- idx1 = lua_absindex(L, idx1);
- idx2 = lua_absindex(L, idx2);
- lua_pushvalue(L, idx1);
- lua_pushvalue(L, idx2);
- compat52_call_lua(L, compat52_compare_code,
- sizeof(compat52_compare_code) - 1, 2, 1);
- result = lua_toboolean(L, -1);
- lua_pop(L, 1);
- return result;
- default:
- luaL_error(L, "invalid 'op' argument for lua_compare");
- }
- return 0;
-}
-
-inline void lua_pushunsigned(lua_State *L, lua_Unsigned n) {
- lua_pushnumber(L, lua_unsigned2number(n));
-}
-
-inline lua_Unsigned luaL_checkunsigned(lua_State *L, int i) {
- lua_Unsigned result;
- lua_Number n = lua_tonumber(L, i);
- if (n == 0 && !lua_isnumber(L, i))
- luaL_checktype(L, i, LUA_TNUMBER);
- lua_number2unsigned(result, n);
- return result;
-}
-
-inline lua_Unsigned lua_tounsignedx(lua_State *L, int i, int *isnum) {
- lua_Unsigned result;
- lua_Number n = lua_tonumberx(L, i, isnum);
- lua_number2unsigned(result, n);
- return result;
-}
-
-inline lua_Unsigned luaL_optunsigned(lua_State *L, int i, lua_Unsigned def) {
- return luaL_opt(L, luaL_checkunsigned, i, def);
-}
-
-inline lua_Integer lua_tointegerx(lua_State *L, int i, int *isnum) {
- lua_Integer n = lua_tointeger(L, i);
- if (isnum != NULL) {
- *isnum = (n != 0 || lua_isnumber(L, i));
- }
- return n;
-}
-
-inline void lua_len(lua_State *L, int i) {
- switch (lua_type(L, i)) {
- case LUA_TSTRING: /* fall through */
- case LUA_TTABLE:
- if (!luaL_callmeta(L, i, "__len"))
- lua_pushnumber(L, (int)lua_objlen(L, i));
- break;
- case LUA_TUSERDATA:
- if (luaL_callmeta(L, i, "__len"))
- break;
- /* maybe fall through */
- default:
- luaL_error(L, "attempt to get length of a %s value",
- lua_typename(L, lua_type(L, i)));
- }
-}
-
-inline int luaL_len(lua_State *L, int i) {
- int res = 0, isnum = 0;
- luaL_checkstack(L, 1, "not enough stack slots");
- lua_len(L, i);
- res = (int)lua_tointegerx(L, -1, &isnum);
- lua_pop(L, 1);
- if (!isnum)
- luaL_error(L, "object length is not a number");
- return res;
-}
-
-inline const char *luaL_tolstring(lua_State *L, int idx, size_t *len) {
- if (!luaL_callmeta(L, idx, "__tostring")) {
- int t = lua_type(L, idx);
- switch (t) {
- case LUA_TNIL:
- lua_pushliteral(L, "nil");
- break;
- case LUA_TSTRING:
- case LUA_TNUMBER:
- lua_pushvalue(L, idx);
- break;
- case LUA_TBOOLEAN:
- if (lua_toboolean(L, idx))
- lua_pushliteral(L, "true");
- else
- lua_pushliteral(L, "false");
- break;
- default:
- lua_pushfstring(L, "%s: %p", lua_typename(L, t),
- lua_topointer(L, idx));
- break;
- }
- }
- return lua_tolstring(L, -1, len);
-}
-
-inline void luaL_requiref(lua_State *L, char const* modname,
- lua_CFunction openf, int glb) {
- luaL_checkstack(L, 3, "not enough stack slots");
- lua_pushcfunction(L, openf);
- lua_pushstring(L, modname);
- lua_call(L, 1, 1);
- lua_getglobal(L, "package");
- if (lua_istable(L, -1) == 0) {
- lua_pop(L, 1);
- lua_createtable(L, 0, 16);
- lua_setglobal(L, "package");
- lua_getglobal(L, "package");
- }
- lua_getfield(L, -1, "loaded");
- if (lua_istable(L, -1) == 0) {
- lua_pop(L, 1);
- lua_createtable(L, 0, 1);
- lua_setfield(L, -2, "loaded");
- lua_getfield(L, -1, "loaded");
- }
- lua_replace(L, -2);
- lua_pushvalue(L, -2);
- lua_setfield(L, -2, modname);
- lua_pop(L, 1);
- if (glb) {
- lua_pushvalue(L, -1);
- lua_setglobal(L, modname);
- }
-}
-
-inline void luaL_buffinit(lua_State *L, luaL_Buffer_52 *B) {
- /* make it crash if used via pointer to a 5.1-style luaL_Buffer */
- B->b.p = NULL;
- B->b.L = NULL;
- B->b.lvl = 0;
- /* reuse the buffer from the 5.1-style luaL_Buffer though! */
- B->ptr = B->b.buffer;
- B->capacity = LUAL_BUFFERSIZE;
- B->nelems = 0;
- B->L2 = L;
-}
-
-inline char *luaL_prepbuffsize(luaL_Buffer_52 *B, size_t s) {
- if (B->capacity - B->nelems < s) { /* needs to grow */
- char* newptr = NULL;
- size_t newcap = B->capacity * 2;
- if (newcap - B->nelems < s)
- newcap = B->nelems + s;
- if (newcap < B->capacity) /* overflow */
- luaL_error(B->L2, "buffer too large");
- newptr = (char*)lua_newuserdata(B->L2, newcap);
- memcpy(newptr, B->ptr, B->nelems);
- if (B->ptr != B->b.buffer)
- lua_replace(B->L2, -2); /* remove old buffer */
- B->ptr = newptr;
- B->capacity = newcap;
- }
- return B->ptr + B->nelems;
-}
-
-inline void luaL_addlstring(luaL_Buffer_52 *B, const char *s, size_t l) {
- memcpy(luaL_prepbuffsize(B, l), s, l);
- luaL_addsize(B, l);
-}
-
-inline void luaL_addvalue(luaL_Buffer_52 *B) {
- size_t len = 0;
- const char *s = lua_tolstring(B->L2, -1, &len);
- if (!s)
- luaL_error(B->L2, "cannot convert value to string");
- if (B->ptr != B->b.buffer)
- lua_insert(B->L2, -2); /* userdata buffer must be at stack top */
- luaL_addlstring(B, s, len);
- lua_remove(B->L2, B->ptr != B->b.buffer ? -2 : -1);
-}
-
-inline void luaL_pushresult(luaL_Buffer_52 *B) {
- lua_pushlstring(B->L2, B->ptr, B->nelems);
- if (B->ptr != B->b.buffer)
- lua_replace(B->L2, -2); /* remove userdata buffer */
-}
-
-#endif /* SOL_LUA_VERSION == 501 */
-
-#endif // SOL_5_X_X_INL
diff --git a/3rdparty/sol2/sol/compatibility/version.hpp b/3rdparty/sol2/sol/compatibility/version.hpp
deleted file mode 100644
index 5397cbdb1b3..00000000000
--- a/3rdparty/sol2/sol/compatibility/version.hpp
+++ /dev/null
@@ -1,127 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_VERSION_HPP
-#define SOL_VERSION_HPP
-
-#ifdef SOL_USING_CXX_LUA
-#include <lua.h>
-#include <lualib.h>
-#include <lauxlib.h>
-#else
-#include <lua.hpp>
-#endif // C++-compiler Lua
-
-#if defined(_WIN32) || defined(_MSC_VER)
-#ifndef SOL_CODECVT_SUPPORT
-#define SOL_CODECVT_SUPPORT 1
-#endif // sol codecvt support
-#elif defined(__GNUC__)
-#if __GNUC__ >= 5
-#ifndef SOL_CODECVT_SUPPORT
-#define SOL_CODECVT_SUPPORT 1
-#endif // codecvt support
-#endif // g++ 5.x.x (MinGW too)
-#else
-// Clang sucks and doesn't really utilize codecvt support,
-// not without checking the library versions explicitly (and we're not gonna do that, so fuck you)
-#endif // Windows/VC++ vs. g++ vs Others
-
-#ifdef LUAJIT_VERSION
-#ifndef SOL_LUAJIT
-#define SOL_LUAJIT
-#define SOL_LUAJIT_VERSION LUAJIT_VERSION_NUM
-#endif // sol luajit
-#endif // luajit
-
-#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 502
-#define SOL_LUA_VERSION LUA_VERSION_NUM
-#elif defined(LUA_VERSION_NUM) && LUA_VERSION_NUM == 501
-#define SOL_LUA_VERSION LUA_VERSION_NUM
-#elif !defined(LUA_VERSION_NUM)
-// Definitely 5.0
-#define SOL_LUA_VERSION 500
-#else
-// ??? Not sure, assume 502?
-#define SOL_LUA_VERSION 502
-#endif // Lua Version 502, 501 || luajit, 500
-
-#ifdef _MSC_VER
-#ifdef _DEBUG
-#ifndef NDEBUG
-#ifndef SOL_CHECK_ARGUMENTS
-// Do not define by default: let user turn it on
-//#define SOL_CHECK_ARGUMENTS
-#endif // Check Arguments
-#ifndef SOL_SAFE_USERTYPE
-#define SOL_SAFE_USERTYPE
-#endif // Safe Usertypes
-#endif // NDEBUG
-#endif // Debug
-
-#ifndef _CPPUNWIND
-#ifndef SOL_NO_EXCEPTIONS
-#define SOL_NO_EXCEPTIONS 1
-#endif
-#endif // Automatic Exceptions
-
-#ifndef _CPPRTTI
-#ifndef SOL_NO_RTTI
-#define SOL_NO_RTTI 1
-#endif
-#endif // Automatic RTTI
-
-#elif defined(__GNUC__) || defined(__clang__)
-
-#ifndef NDEBUG
-#ifndef __OPTIMIZE__
-#ifndef SOL_CHECK_ARGUMENTS
-// Do not define by default: let user choose
-//#define SOL_CHECK_ARGUMENTS
-// But do check userdata by default:
-#endif // Check Arguments
-#ifndef SOL_SAFE_USERTYPE
-#define SOL_SAFE_USERTYPE
-#endif // Safe Usertypes
-#endif // g++ optimizer flag
-#endif // Not Debug
-
-#ifndef __EXCEPTIONS
-#ifndef SOL_NO_EXCEPTIONS
-#define SOL_NO_EXCEPTIONS 1
-#endif
-#endif // No Exceptions
-
-#ifndef __GXX_RTTI
-#ifndef SOL_NO_RTII
-#define SOL_NO_RTTI 1
-#endif
-#endif // No RTTI
-
-#endif // vc++ || clang++/g++
-
-#ifndef SOL_SAFE_USERTYPE
-#ifdef SOL_CHECK_ARGUMENTS
-#define SOL_SAFE_USERTYPE
-#endif // Turn on Safety for all
-#endif // Safe Usertypes
-
-#endif // SOL_VERSION_HPP
diff --git a/3rdparty/sol2/sol/protect.hpp b/3rdparty/sol2/sol/config.hpp
index 42655c6b74b..5fb4f925fb1 100644
--- a/3rdparty/sol2/sol/protect.hpp
+++ b/3rdparty/sol2/sol/config.hpp
@@ -1,6 +1,6 @@
-// The MIT License (MIT)
+// The MIT License (MIT)
-// Copyright (c) 2013-2016 Rapptz, ThePhD and contributors
+// Copyright (c) 2013-2020 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
@@ -19,33 +19,35 @@
// 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_PROTECT_HPP
-#define SOL_PROTECT_HPP
+// This file was generated with a script.
+// Generated 2020-10-03 21:34:25.034794 UTC
+// This header was generated with sol v3.2.1 (revision 48eea7b5)
+// https://github.com/ThePhD/sol2
-#include "traits.hpp"
-#include <utility>
+#ifndef SOL_SINGLE_CONFIG_HPP
+#define SOL_SINGLE_CONFIG_HPP
-namespace sol {
-
- template <typename T>
- struct protect_t {
- T value;
+// beginning of sol/config.hpp
- template <typename Arg, typename... Args, meta::disable<std::is_same<protect_t, meta::unqualified_t<Arg>>> = meta::enabler>
- protect_t(Arg&& arg, Args&&... args) : value(std::forward<Arg>(arg), std::forward<Args>(args)...) {}
+/* Base, empty configuration file!
- protect_t(const protect_t&) = default;
- protect_t(protect_t&&) = default;
- protect_t& operator=(const protect_t&) = default;
- protect_t& operator=(protect_t&&) = default;
+ 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)
- template <typename T>
- auto protect(T&& value) {
- return protect_t<std::decay_t<T>>(std::forward<T>(value));
- }
+ So that when sol2 includes the file
-} // sol
+#include <sol/config.hpp>
-#endif // SOL_PROTECT_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.
+
+*/
+
+// end of sol/config.hpp
+
+#endif // SOL_SINGLE_CONFIG_HPP
diff --git a/3rdparty/sol2/sol/container_usertype_metatable.hpp b/3rdparty/sol2/sol/container_usertype_metatable.hpp
deleted file mode 100644
index 9e1b67b7506..00000000000
--- a/3rdparty/sol2/sol/container_usertype_metatable.hpp
+++ /dev/null
@@ -1,513 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_CONTAINER_USERTYPE_HPP
-#define SOL_CONTAINER_USERTYPE_HPP
-
-#include "stack.hpp"
-
-namespace sol {
-
- namespace detail {
-
- template <typename T>
- struct has_find {
- private:
- typedef std::array<char, 1> one;
- typedef std::array<char, 2> two;
-
- template <typename C> static one test(decltype(&C::find));
- template <typename C> static two test(...);
-
- public:
- static const bool value = sizeof(test<T>(0)) == sizeof(char);
- };
-
- template <typename T>
- struct has_push_back {
- private:
- typedef std::array<char, 1> one;
- typedef std::array<char, 2> two;
-
- template <typename C> static one test(decltype(std::declval<C>().push_back(std::declval<std::add_rvalue_reference_t<typename C::value_type>>()))*);
- template <typename C> static two test(...);
-
- public:
- static const bool value = sizeof(test<T>(0)) == sizeof(char);
- };
-
- template <typename T>
- struct has_clear {
- private:
- typedef std::array<char, 1> one;
- typedef std::array<char, 2> two;
-
- template <typename C> static one test(decltype(&C::clear));
- template <typename C> static two test(...);
-
- public:
- static const bool value = sizeof(test<T>(0)) == sizeof(char);
- };
-
- template <typename T>
- struct has_insert {
- private:
- typedef std::array<char, 1> one;
- typedef std::array<char, 2> two;
-
- template <typename C> static one test(decltype(std::declval<C>().insert(std::declval<std::add_rvalue_reference_t<typename C::const_iterator>>(), std::declval<std::add_rvalue_reference_t<typename C::value_type>>()))*);
- template <typename C> static two test(...);
-
- public:
- static const bool value = sizeof(test<T>(0)) == sizeof(char);
- };
-
- template <typename T>
- T& get_first(const T& t) {
- return std::forward<T>(t);
- }
-
- template <typename A, typename B>
- decltype(auto) get_first(const std::pair<A, B>& t) {
- return t.first;
- }
-
- template <typename C, typename I, meta::enable<has_find<meta::unqualified_t<C>>> = meta::enabler>
- auto find(C& c, I&& i) {
- return c.find(std::forward<I>(i));
- }
-
- template <typename C, typename I, meta::disable<has_find<meta::unqualified_t<C>>> = meta::enabler>
- auto find(C& c, I&& i) {
- using std::begin;
- using std::end;
- return std::find_if(begin(c), end(c), [&i](auto&& x) {
- return i == get_first(x);
- });
- }
-
- }
-
- template <typename Raw, typename C = void>
- struct container_usertype_metatable {
- typedef meta::has_key_value_pair<meta::unqualified_t<Raw>> is_associative;
- typedef meta::unqualified_t<Raw> T;
- typedef typename T::iterator I;
- typedef std::conditional_t<is_associative::value, typename T::value_type, std::pair<std::size_t, typename T::value_type>> KV;
- typedef typename KV::first_type K;
- typedef typename KV::second_type V;
- typedef std::remove_reference_t<decltype(*std::declval<I&>())> IR;
-
- struct iter {
- T& source;
- I it;
-
- iter(T& source, I it) : source(source), it(std::move(it)) {}
- };
-
- static auto& get_src(lua_State* L) {
-#ifdef SOL_SAFE_USERTYPE
- auto p = stack::check_get<T*>(L, 1);
- if (!p || p.value() == nullptr) {
- luaL_error(L, "sol: 'self' argument is not the proper type (pass 'self' as first argument with ':' or call on proper type)");
- }
- return *p.value();
-#else
- return stack::get<T>(L, 1);
-#endif
- }
-
- static int real_index_call_associative(std::true_type, lua_State* L) {
- auto k = stack::check_get<K>(L, 2);
- if (k) {
- auto& src = get_src(L);
- using std::end;
- auto it = detail::find(src, *k);
- if (it != end(src)) {
- auto& v = *it;
- return stack::push_reference(L, v.second);
- }
- }
- else {
- auto maybename = stack::check_get<string_detail::string_shim>(L, 2);
- if (maybename) {
- auto& name = *maybename;
- if (name == "add") {
- return stack::push(L, &add_call);
- }
- else if (name == "insert") {
- return stack::push(L, &insert_call);
- }
- else if (name == "clear") {
- return stack::push(L, &clear_call);
- }
- }
- }
- return stack::push(L, lua_nil);
- }
-
- static int real_index_call_associative(std::false_type, lua_State* L) {
- auto& src = get_src(L);
- auto maybek = stack::check_get<K>(L, 2);
- if (maybek) {
- using std::begin;
- auto it = begin(src);
- K k = *maybek;
-#ifdef SOL_SAFE_USERTYPE
- if (k > src.size() || k < 1) {
- return stack::push(L, lua_nil);
- }
-#else
-#endif // Safety
- --k;
- std::advance(it, k);
- return stack::push_reference(L, *it);
- }
- else {
- auto maybename = stack::check_get<string_detail::string_shim>(L, 2);
- if (maybename) {
- auto& name = *maybename;
- if (name == "add") {
- return stack::push(L, &add_call);
- }
- else if (name == "insert") {
- return stack::push(L, &insert_call);
- }
- else if (name == "clear") {
- return stack::push(L, &clear_call);
- }
- }
- }
-
- return stack::push(L, lua_nil);
- }
-
- static int real_index_call(lua_State* L) {
- return real_index_call_associative(is_associative(), L);
- }
-
- static int real_new_index_call_const(std::false_type, std::false_type, lua_State* L) {
- return luaL_error(L, "sol: cannot write to a const value type or an immutable iterator (e.g., std::set)");
- }
-
- static int real_new_index_call_const(std::false_type, std::true_type, lua_State* L) {
- return luaL_error(L, "sol: cannot write to a const value type or an immutable iterator (e.g., std::set)");
- }
-
- static int real_new_index_call_const(std::true_type, std::true_type, lua_State* L) {
- auto& src = get_src(L);
- auto k = stack::check_get<K>(L, 2);
- if (k) {
- using std::end;
- auto it = detail::find(src, *k);
- if (it != end(src)) {
- auto& v = *it;
- v.second = stack::get<V>(L, 3);
- }
- else {
- src.insert(it, { std::move(*k), stack::get<V>(L, 3) });
- }
- }
- return 0;
- }
-
- static int real_new_index_call_const(std::true_type, std::false_type, lua_State* L) {
- auto& src = get_src(L);
-#ifdef SOL_SAFE_USERTYPE
- auto maybek = stack::check_get<K>(L, 2);
- if (!maybek) {
- return stack::push(L, lua_nil);
- }
- K k = *maybek;
-#else
- K k = stack::get<K>(L, 2);
-#endif
- using std::begin;
- auto it = begin(src);
- if (k == src.size()) {
- real_add_call_push(std::integral_constant<bool, detail::has_push_back<T>::value>(), L, src, 1);
- return 0;
- }
- --k;
- std::advance(it, k);
- *it = stack::get<V>(L, 3);
- return 0;
- }
-
- static int real_new_index_call(lua_State* L) {
- return real_new_index_call_const(meta::neg<meta::any<std::is_const<V>, std::is_const<IR>>>(), is_associative(), L);
- }
-
- static int real_pairs_next_call_assoc(std::true_type, lua_State* L) {
- using std::end;
- iter& i = stack::get<user<iter>>(L, 1);
- auto& source = i.source;
- auto& it = i.it;
- if (it == end(source)) {
- return 0;
- }
- int p = stack::multi_push_reference(L, it->first, it->second);
- std::advance(it, 1);
- return p;
- }
-
- static int real_pairs_call_assoc(std::true_type, lua_State* L) {
- auto& src = get_src(L);
- using std::begin;
- stack::push(L, pairs_next_call);
- stack::push_specific<user<iter>>(L, src, begin(src));
- stack::push(L, 1);
- return 3;
- }
-
- static int real_pairs_next_call_assoc(std::false_type, lua_State* L) {
- using std::end;
- iter& i = stack::get<user<iter>>(L, 1);
- auto& source = i.source;
- auto& it = i.it;
- K k = stack::get<K>(L, 2);
- if (it == end(source)) {
- return 0;
- }
- int p = stack::multi_push_reference(L, k + 1, *it);
- std::advance(it, 1);
- return p;
- }
-
- static int real_pairs_call_assoc(std::false_type, lua_State* L) {
- auto& src = get_src(L);
- using std::begin;
- stack::push(L, pairs_next_call);
- stack::push_specific<user<iter>>(L, src, begin(src));
- stack::push(L, 0);
- return 3;
- }
-
- static int real_pairs_next_call(lua_State* L) {
- return real_pairs_next_call_assoc(is_associative(), L);
- }
-
- static int real_pairs_call(lua_State* L) {
- return real_pairs_call_assoc(is_associative(), L);
- }
-
- static int real_length_call(lua_State*L) {
- auto& src = get_src(L);
- return stack::push(L, src.size());
- }
-
- static int real_add_call_insert(std::true_type, lua_State*L, T& src, int boost = 0) {
- using std::end;
- src.insert(end(src), stack::get<V>(L, 2 + boost));
- return 0;
- }
-
- static int real_add_call_insert(std::false_type, lua_State*L, T&, int = 0) {
- static const std::string& s = detail::demangle<T>();
- return luaL_error(L, "sol: cannot call insert on type %s", s.c_str());
- }
-
- static int real_add_call_push(std::true_type, lua_State*L, T& src, int boost = 0) {
- src.push_back(stack::get<V>(L, 2 + boost));
- return 0;
- }
-
- static int real_add_call_push(std::false_type, lua_State*L, T& src, int boost = 0) {
- return real_add_call_insert(std::integral_constant<bool, detail::has_insert<T>::value>(), L, src, boost);
- }
-
- static int real_add_call_associative(std::true_type, lua_State* L) {
- return real_insert_call(L);
- }
-
- static int real_add_call_associative(std::false_type, lua_State* L) {
- auto& src = get_src(L);
- return real_add_call_push(std::integral_constant<bool, detail::has_push_back<T>::value>(), L, src);
- }
-
- static int real_add_call_capable(std::true_type, lua_State* L) {
- return real_add_call_associative(is_associative(), L);
- }
-
- static int real_add_call_capable(std::false_type, lua_State* L) {
- static const std::string& s = detail::demangle<T>();
- return luaL_error(L, "sol: cannot call add on type %s", s.c_str());
- }
-
- static int real_add_call(lua_State* L) {
- return real_add_call_capable(std::integral_constant<bool, detail::has_push_back<T>::value || detail::has_insert<T>::value>(), L);
- }
-
- static int real_insert_call_capable(std::false_type, std::false_type, lua_State*L) {
- static const std::string& s = detail::demangle<T>();
- return luaL_error(L, "sol: cannot call insert on type %s", s.c_str());
- }
-
- static int real_insert_call_capable(std::false_type, std::true_type, lua_State*L) {
- return real_insert_call_capable(std::false_type(), std::false_type(), L);
- }
-
- static int real_insert_call_capable(std::true_type, std::false_type, lua_State* L) {
- using std::begin;
- auto& src = get_src(L);
- src.insert(std::next(begin(src), stack::get<K>(L, 2)), stack::get<V>(L, 3));
- return 0;
- }
-
- static int real_insert_call_capable(std::true_type, std::true_type, lua_State* L) {
- return real_new_index_call(L);
- }
-
- static int real_insert_call(lua_State*L) {
- return real_insert_call_capable(std::integral_constant<bool, detail::has_insert<T>::value>(), is_associative(), L);
- }
-
- static int real_clear_call_capable(std::false_type, lua_State* L) {
- static const std::string& s = detail::demangle<T>();
- return luaL_error(L, "sol: cannot call clear on type %s", s.c_str());
- }
-
- static int real_clear_call_capable(std::true_type, lua_State* L) {
- auto& src = get_src(L);
- src.clear();
- return 0;
- }
-
- static int real_clear_call(lua_State*L) {
- return real_clear_call_capable(std::integral_constant<bool, detail::has_clear<T>::value>(), L);
- }
-
- static int add_call(lua_State*L) {
- return detail::static_trampoline<(&real_add_call)>(L);
- }
-
- static int insert_call(lua_State*L) {
- return detail::static_trampoline<(&real_insert_call)>(L);
- }
-
- static int clear_call(lua_State*L) {
- return detail::static_trampoline<(&real_clear_call)>(L);
- }
-
- static int length_call(lua_State*L) {
- return detail::static_trampoline<(&real_length_call)>(L);
- }
-
- static int pairs_next_call(lua_State*L) {
- return detail::static_trampoline<(&real_pairs_next_call)>(L);
- }
-
- static int pairs_call(lua_State*L) {
- return detail::static_trampoline<(&real_pairs_call)>(L);
- }
-
- static int index_call(lua_State*L) {
- return detail::static_trampoline<(&real_index_call)>(L);
- }
-
- static int new_index_call(lua_State*L) {
- return detail::static_trampoline<(&real_new_index_call)>(L);
- }
- };
-
- namespace stack {
- namespace stack_detail {
- template <typename T>
- inline auto container_metatable() {
- typedef container_usertype_metatable<std::remove_pointer_t<T>> meta_cumt;
- std::array<luaL_Reg, 10> reg = { {
- { "__index", &meta_cumt::index_call },
- { "__newindex", &meta_cumt::new_index_call },
- { "__pairs", &meta_cumt::pairs_call },
- { "__ipairs", &meta_cumt::pairs_call },
- { "__len", &meta_cumt::length_call },
- { "clear", &meta_cumt::clear_call },
- { "insert", &meta_cumt::insert_call },
- { "add", &meta_cumt::add_call },
- std::is_pointer<T>::value ? luaL_Reg{ nullptr, nullptr } : luaL_Reg{ "__gc", &detail::usertype_alloc_destroy<T> },
- { nullptr, nullptr }
- } };
- return reg;
- }
-
- template <typename T>
- inline auto container_metatable_behind() {
- typedef container_usertype_metatable<std::remove_pointer_t<T>> meta_cumt;
- std::array<luaL_Reg, 3> reg = { {
- { "__index", &meta_cumt::index_call },
- { "__newindex", &meta_cumt::new_index_call },
- { nullptr, nullptr }
- } };
- return reg;
- }
-
- template <typename T>
- struct metatable_setup {
- lua_State* L;
-
- metatable_setup(lua_State* L) : L(L) {}
-
- void operator()() {
- static const auto reg = container_metatable<T>();
- static const auto containerreg = container_metatable_behind<T>();
- static const char* metakey = &usertype_traits<T>::metatable()[0];
-
- if (luaL_newmetatable(L, metakey) == 1) {
- stack_reference metatable(L, -1);
- luaL_setfuncs(L, reg.data(), 0);
-
- lua_createtable(L, 0, static_cast<int>(containerreg.size()));
- stack_reference metabehind(L, -1);
- luaL_setfuncs(L, containerreg.data(), 0);
-
- stack::set_field(L, metatable_key, metabehind, metatable.stack_index());
- metabehind.pop();
- }
- lua_setmetatable(L, -2);
- }
- };
- }
-
- template<typename T>
- struct pusher<T, std::enable_if_t<meta::all<is_container<meta::unqualified_t<T>>, meta::neg<meta::any<std::is_base_of<reference, meta::unqualified_t<T>>, std::is_base_of<stack_reference, meta::unqualified_t<T>>>>>::value>> {
- static int push(lua_State* L, const T& cont) {
- stack_detail::metatable_setup<T> fx(L);
- return pusher<detail::as_value_tag<T>>{}.push_fx(L, fx, cont);
- }
-
- static int push(lua_State* L, T&& cont) {
- stack_detail::metatable_setup<T> fx(L);
- return pusher<detail::as_value_tag<T>>{}.push_fx(L, fx, std::move(cont));
- }
- };
-
- template<typename T>
- struct pusher<T*, std::enable_if_t<meta::all<is_container<meta::unqualified_t<T>>, meta::neg<meta::any<std::is_base_of<reference, meta::unqualified_t<T>>, std::is_base_of<stack_reference, meta::unqualified_t<T>>>>>::value>> {
- static int push(lua_State* L, T* cont) {
- stack_detail::metatable_setup<meta::unqualified_t<std::remove_pointer_t<T>>*> fx(L);
- return pusher<detail::as_pointer_tag<T>>{}.push_fx(L, fx, cont);
- }
- };
- } // stack
-
-} // sol
-
-#endif // SOL_CONTAINER_USERTYPE_HPP
diff --git a/3rdparty/sol2/sol/coroutine.hpp b/3rdparty/sol2/sol/coroutine.hpp
deleted file mode 100644
index 17294aa5dc6..00000000000
--- a/3rdparty/sol2/sol/coroutine.hpp
+++ /dev/null
@@ -1,134 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_COROUTINE_HPP
-#define SOL_COROUTINE_HPP
-
-#include "reference.hpp"
-#include "stack.hpp"
-#include "function_result.hpp"
-#include "thread.hpp"
-
-namespace sol {
- class coroutine : public reference {
- private:
- call_status stats = call_status::yielded;
-
- void luacall(std::ptrdiff_t argcount, std::ptrdiff_t) {
-#if SOL_LUA_VERSION < 502
- stats = static_cast<call_status>(lua_resume(lua_state(), static_cast<int>(argcount)));
-#else
- stats = static_cast<call_status>(lua_resume(lua_state(), nullptr, static_cast<int>(argcount)));
-#endif // Lua 5.1 compat
- }
-
- template<std::size_t... I, typename... Ret>
- auto invoke(types<Ret...>, std::index_sequence<I...>, std::ptrdiff_t n) {
- luacall(n, sizeof...(Ret));
- return stack::pop<std::tuple<Ret...>>(lua_state());
- }
-
- template<std::size_t I, typename Ret>
- Ret invoke(types<Ret>, std::index_sequence<I>, std::ptrdiff_t n) {
- luacall(n, 1);
- return stack::pop<Ret>(lua_state());
- }
-
- template <std::size_t I>
- void invoke(types<void>, std::index_sequence<I>, std::ptrdiff_t n) {
- luacall(n, 0);
- }
-
- protected_function_result invoke(types<>, std::index_sequence<>, std::ptrdiff_t n) {
- int stacksize = lua_gettop(lua_state());
- int firstreturn = (std::max)(1, stacksize - static_cast<int>(n));
- luacall(n, LUA_MULTRET);
- int poststacksize = lua_gettop(lua_state());
- int returncount = poststacksize - (firstreturn - 1);
- if (error()) {
- return protected_function_result(lua_state(), lua_absindex(lua_state(), -1), 1, returncount, status());
- }
- return protected_function_result(lua_state(), firstreturn, returncount, returncount, status());
- }
-
- public:
- coroutine() noexcept = default;
- coroutine(const coroutine&) noexcept = default;
- coroutine(coroutine&&) noexcept = default;
- coroutine& operator=(const coroutine&) noexcept = default;
- coroutine& operator=(coroutine&&) noexcept = default;
- template <typename T, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, coroutine>>, std::is_base_of<reference, meta::unqualified_t<T>>> = meta::enabler>
- coroutine(T&& r) : reference(std::forward<T>(r)) {}
- coroutine(lua_nil_t r) : reference(r) {}
- coroutine(const stack_reference& r) noexcept : coroutine(r.lua_state(), r.stack_index()) {}
- coroutine(stack_reference&& r) noexcept : coroutine(r.lua_state(), r.stack_index()) {}
- template <typename T, meta::enable<meta::neg<std::is_integral<meta::unqualified_t<T>>>, meta::neg<std::is_same<T, ref_index>>> = meta::enabler>
- coroutine(lua_State* L, T&& r) : coroutine(L, sol::ref_index(r.registry_index())) {}
- coroutine(lua_State* L, int index = -1) : reference(L, index) {
-#ifdef SOL_CHECK_ARGUMENTS
- stack::check<coroutine>(L, index, type_panic);
-#endif // Safety
- }
- coroutine(lua_State* L, ref_index index) : reference(L, index) {
-#ifdef SOL_CHECK_ARGUMENTS
- auto pp = stack::push_pop(*this);
- stack::check<coroutine>(L, -1, type_panic);
-#endif // Safety
- }
-
- call_status status() const noexcept {
- return stats;
- }
-
- bool error() const noexcept {
- call_status cs = status();
- return cs != call_status::ok && cs != call_status::yielded;
- }
-
- bool runnable() const noexcept {
- return valid()
- && (status() == call_status::yielded);
- }
-
- explicit operator bool() const noexcept {
- return runnable();
- }
-
- template<typename... Args>
- protected_function_result operator()(Args&&... args) {
- return call<>(std::forward<Args>(args)...);
- }
-
- template<typename... Ret, typename... Args>
- decltype(auto) operator()(types<Ret...>, Args&&... args) {
- return call<Ret...>(std::forward<Args>(args)...);
- }
-
- template<typename... Ret, typename... Args>
- decltype(auto) call(Args&&... args) {
- push();
- int pushcount = stack::multi_push(lua_state(), std::forward<Args>(args)...);
- return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), pushcount);
- }
- };
-} // sol
-
-#endif // SOL_COUROUTINE_HPP
diff --git a/3rdparty/sol2/sol/debug.hpp b/3rdparty/sol2/sol/debug.hpp
deleted file mode 100644
index 1219484df3b..00000000000
--- a/3rdparty/sol2/sol/debug.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_DEBUG_HPP
-#define SOL_DEBUG_HPP
-
-#include "stack.hpp"
-#include <iostream>
-
-namespace sol {
- namespace detail {
- namespace debug {
- inline std::string dump_types(lua_State* L) {
- std::string visual;
- std::size_t size = lua_gettop(L) + 1;
- for (std::size_t i = 1; i < size; ++i) {
- if (i != 1) {
- visual += " | ";
- }
- visual += type_name(L, stack::get<type>(L, static_cast<int>(i)));
- }
- return visual;
- }
-
- inline void print_stack(lua_State* L) {
- std::cout << dump_types(L) << std::endl;
- }
-
- inline void print_section(const std::string& message, lua_State* L) {
- std::cout << "-- " << message << " -- [ " << dump_types(L) << " ]" << std::endl;
- }
- } // detail
- } // debug
-} // sol
-
-#endif // SOL_DEBUG_HPP
diff --git a/3rdparty/sol2/sol/demangle.hpp b/3rdparty/sol2/sol/demangle.hpp
deleted file mode 100644
index be9aa30594c..00000000000
--- a/3rdparty/sol2/sol/demangle.hpp
+++ /dev/null
@@ -1,158 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_DEMANGLE_HPP
-#define SOL_DEMANGLE_HPP
-
-#include <string>
-#include <array>
-#include <cctype>
-
-namespace sol {
- namespace detail {
-#ifdef _MSC_VER
- template <typename T>
- inline std::string ctti_get_type_name() {
- const static std::array<std::string, 7> removals = { { "public:", "private:", "protected:", "struct ", "class ", "`anonymous-namespace'", "`anonymous namespace'" } };
- std::string name = __FUNCSIG__;
- std::size_t start = name.find("get_type_name");
- if (start == std::string::npos)
- start = 0;
- else
- start += 13;
- if (start < name.size() - 1)
- start += 1;
- std::size_t end = name.find_last_of('>');
- if (end == std::string::npos)
- end = name.size();
- name = name.substr(start, end - start);
- if (name.find("struct", 0) == 0)
- name.replace(0, 6, "", 0);
- if (name.find("class", 0) == 0)
- name.replace(0, 5, "", 0);
- while (!name.empty() && std::isblank(name.front())) name.erase(name.begin());
- while (!name.empty() && std::isblank(name.back())) name.pop_back();
-
- for (std::size_t r = 0; r < removals.size(); ++r) {
- auto found = name.find(removals[r]);
- while (found != std::string::npos) {
- name.erase(found, removals[r].size());
- found = name.find(removals[r]);
- }
- }
-
- return name;
- }
-#elif defined(__GNUC__) || defined(__clang__)
- template <typename T, class seperator_mark = int>
- inline std::string ctti_get_type_name() {
- const static std::array<std::string, 2> removals = { { "{anonymous}", "(anonymous namespace)" } };
- std::string name = __PRETTY_FUNCTION__;
- std::size_t start = name.find_first_of('[');
- start = name.find_first_of('=', start);
- std::size_t end = name.find_last_of(']');
- if (end == std::string::npos)
- end = name.size();
- if (start == std::string::npos)
- start = 0;
- if (start < name.size() - 1)
- start += 1;
- name = name.substr(start, end - start);
- start = name.rfind("seperator_mark");
- if (start != std::string::npos) {
- name.erase(start - 2, name.length());
- }
- while (!name.empty() && std::isblank(name.front())) name.erase(name.begin());
- while (!name.empty() && std::isblank(name.back())) name.pop_back();
-
- for (std::size_t r = 0; r < removals.size(); ++r) {
- auto found = name.find(removals[r]);
- while (found != std::string::npos) {
- name.erase(found, removals[r].size());
- found = name.find(removals[r]);
- }
- }
-
- return name;
- }
-#else
-#error Compiler not supported for demangling
-#endif // compilers
-
- template <typename T>
- inline std::string demangle_once() {
- std::string realname = ctti_get_type_name<T>();
- return realname;
- }
-
- template <typename T>
- inline std::string short_demangle_once() {
- std::string realname = ctti_get_type_name<T>();
- // This isn't the most complete but it'll do for now...?
- static const std::array<std::string, 10> ops = { { "operator<", "operator<<", "operator<<=", "operator<=", "operator>", "operator>>", "operator>>=", "operator>=", "operator->", "operator->*" } };
- int level = 0;
- std::ptrdiff_t idx = 0;
- for (idx = static_cast<std::ptrdiff_t>(realname.empty() ? 0 : realname.size() - 1); idx > 0; --idx) {
- if (level == 0 && realname[idx] == ':') {
- break;
- }
- bool isleft = realname[idx] == '<';
- bool isright = realname[idx] == '>';
- if (!isleft && !isright)
- continue;
- bool earlybreak = false;
- for (const auto& op : ops) {
- std::size_t nisop = realname.rfind(op, idx);
- if (nisop == std::string::npos)
- continue;
- std::size_t nisopidx = idx - op.size() + 1;
- if (nisop == nisopidx) {
- idx = static_cast<std::ptrdiff_t>(nisopidx);
- earlybreak = true;
- }
- break;
- }
- if (earlybreak) {
- continue;
- }
- level += isleft ? -1 : 1;
- }
- if (idx > 0) {
- realname.erase(0, realname.length() < static_cast<std::size_t>(idx) ? realname.length() : idx + 1);
- }
- return realname;
- }
-
- template <typename T>
- inline const std::string& demangle() {
- static const std::string d = demangle_once<T>();
- return d;
- }
-
- template <typename T>
- inline const std::string& short_demangle() {
- static const std::string d = short_demangle_once<T>();
- return d;
- }
- } // detail
-} // sol
-
-#endif // SOL_DEMANGLE_HPP
diff --git a/3rdparty/sol2/sol/deprecate.hpp b/3rdparty/sol2/sol/deprecate.hpp
deleted file mode 100644
index 0d9551a33b0..00000000000
--- a/3rdparty/sol2/sol/deprecate.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_DEPRECATE_HPP
-#define SOL_DEPRECATE_HPP
-
-#ifndef SOL_DEPRECATED
- #ifdef _MSC_VER
- #define SOL_DEPRECATED __declspec(deprecated)
- #elif __GNUC__
- #define SOL_DEPRECATED __attribute__((deprecated))
- #else
- #define SOL_DEPRECATED [[deprecated]]
- #endif // compilers
-#endif // SOL_DEPRECATED
-
-namespace sol {
- namespace detail {
- template <typename T>
- struct SOL_DEPRECATED deprecate_type {
- using type = T;
- };
- } // detail
-} // sol
-
-#endif // SOL_DEPRECATE_HPP
diff --git a/3rdparty/sol2/sol/error.hpp b/3rdparty/sol2/sol/error.hpp
deleted file mode 100644
index e24861effe9..00000000000
--- a/3rdparty/sol2/sol/error.hpp
+++ /dev/null
@@ -1,56 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_ERROR_HPP
-#define SOL_ERROR_HPP
-
-#include <stdexcept>
-#include <string>
-
-namespace sol {
- namespace detail {
- struct direct_error_tag {};
- const auto direct_error = direct_error_tag{};
- } // detail
-
- class error : public std::runtime_error {
- private:
- // Because VC++ is a fuccboi
- std::string w;
- public:
- error(const std::string& str) : error(detail::direct_error, "lua: error: " + 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(""), w(str) {}
- error(detail::direct_error_tag, std::string&& str) : std::runtime_error(""), w(std::move(str)) {}
-
- error(const error& e) = default;
- error(error&& e) = default;
- error& operator=(const error& e) = default;
- error& operator=(error&& e) = default;
-
- virtual const char* what() const noexcept override {
- return w.c_str();
- }
- };
-
-} // sol
-
-#endif // SOL_ERROR_HPP
diff --git a/3rdparty/sol2/sol/forward.hpp b/3rdparty/sol2/sol/forward.hpp
new file mode 100644
index 00000000000..c41b4ac8707
--- /dev/null
+++ b/3rdparty/sol2/sol/forward.hpp
@@ -0,0 +1,828 @@
+// The MIT License (MIT)
+
+// Copyright (c) 2013-2020 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.
+
+// This file was generated with a script.
+// Generated 2020-10-03 21:34:25.022965 UTC
+// This header was generated with sol v3.2.1 (revision 48eea7b5)
+// https://github.com/ThePhD/sol2
+
+#ifndef SOL_SINGLE_INCLUDE_FORWARD_HPP
+#define SOL_SINGLE_INCLUDE_FORWARD_HPP
+
+// beginning of sol/forward.hpp
+
+#ifndef SOL_FORWARD_HPP
+#define SOL_FORWARD_HPP
+
+// beginning of sol/version.hpp
+
+#include <sol/config.hpp>
+
+#include <cstdint>
+
+#define SOL_VERSION_MAJOR 3
+#define SOL_VERSION_MINOR 5
+#define SOL_VERSION_PATCH 0
+#define SOL_VERSION_STRING "3.5.0"
+#define SOL_VERSION ((SOL_VERSION_MAJOR * 100000) + (SOL_VERSION_MINOR * 100) + (SOL_VERSION_PATCH))
+
+#define SOL_IS_ON(OP_SYMBOL) ((3 OP_SYMBOL 3) != 0)
+#define SOL_IS_OFF(OP_SYMBOL) ((3 OP_SYMBOL 3) == 0)
+#define SOL_IS_DEFAULT_ON(OP_SYMBOL) ((3 OP_SYMBOL 3) > 3)
+#define SOL_IS_DEFAULT_OFF(OP_SYMBOL) ((3 OP_SYMBOL 3 OP_SYMBOL 3) < 0)
+
+#define SOL_ON |
+#define SOL_OFF ^
+#define SOL_DEFAULT_ON +
+#define SOL_DEFAULT_OFF -
+
+#if defined(_MSC_VER)
+ #define SOL_COMPILER_CLANG_I_ SOL_OFF
+ #define SOL_COMPILER_GCC_I_ SOL_OFF
+ #define SOL_COMPILER_EDG_I_ SOL_OFF
+ #define SOL_COMPILER_VCXX_I_ SOL_ON
+#elif defined(__clang__)
+ #define SOL_COMPILER_CLANG_I_ SOL_ON
+ #define SOL_COMPILER_GCC_I_ SOL_OFF
+ #define SOL_COMPILER_EDG_I_ SOL_OFF
+ #define SOL_COMPILER_VCXX_I_ SOL_OFF
+#elif defined(__GNUC__)
+ #define SOL_COMPILER_CLANG_I_ SOL_OFF
+ #define SOL_COMPILER_GCC_I_ SOL_ON
+ #define SOL_COMPILER_EDG_I_ SOL_OFF
+ #define SOL_COMPILER_VCXX_I_ SOL_OFF
+#else
+ #define SOL_COMPILER_CLANG_I_ SOL_OFF
+ #define SOL_COMPILER_GCC_I_ SOL_OFF
+ #define SOL_COMPILER_EDG_I_ SOL_OFF
+ #define SOL_COMPILER_VCXX_I_ SOL_OFF
+#endif
+
+#if defined(__MINGW32__)
+ #define SOL_COMPILER_FRONTEND_MINGW_I_ SOL_ON
+#else
+ #define SOL_COMPILER_FRONTEND_MINGW_I_ SOL_OFF
+#endif
+
+#if SIZE_MAX <= 0xFFFFULL
+ #define SOL_PLATFORM_X16_I_ SOL_ON
+ #define SOL_PLATFORM_X86_I_ SOL_OFF
+ #define SOL_PLATFORM_X64_I_ SOL_OFF
+#elif SIZE_MAX <= 0xFFFFFFFFULL
+ #define SOL_PLATFORM_X16_I_ SOL_OFF
+ #define SOL_PLATFORM_X86_I_ SOL_ON
+ #define SOL_PLATFORM_X64_I_ SOL_OFF
+#else
+ #define SOL_PLATFORM_X16_I_ SOL_OFF
+ #define SOL_PLATFORM_X86_I_ SOL_OFF
+ #define SOL_PLATFORM_X64_I_ SOL_ON
+#endif
+
+#define SOL_PLATFORM_ARM32_I_ SOL_OFF
+#define SOL_PLATFORM_ARM64_I_ SOL_OFF
+
+#if defined(_WIN32)
+ #define SOL_PLATFORM_WINDOWS_I_ SOL_ON
+#else
+ #define SOL_PLATFORM_WINDOWS_I_ SOL_OFF
+#endif
+#if defined(__APPLE__)
+ #define SOL_PLATFORM_APPLE_I_ SOL_ON
+#else
+ #define SOL_PLATFORM_APPLE_I_ SOL_OFF
+#endif
+#if defined(__unix__)
+ #define SOL_PLATFORM_UNIXLIKE_I_ SOL_ON
+#else
+ #define SOL_PLATFORM_UNIXLIKE_I_ SOL_OFF
+#endif
+#if defined(__linux__)
+ #define SOL_PLATFORM_LINUXLIKE_I_ SOL_ON
+#else
+ #define SOL_PLATFORM_LINUXLIKE_I_ SOL_OFF
+#endif
+
+#define SOL_PLATFORM_APPLE_IPHONE_I_ SOL_OFF
+#define SOL_PLATFORM_BSDLIKE_I_ SOL_OFF
+
+#if defined(SOL_IN_DEBUG_DETECTED)
+ #if SOL_IN_DEBUG_DETECTED != 0
+ #define SOL_DEBUG_BUILD_I_ SOL_ON
+ #else
+ #define SOL_DEBUG_BUILD_I_ SOL_OFF
+ #endif
+#elif !defined(NDEBUG)
+ #if SOL_IS_ON(SOL_COMPILER_VCXX_I_) && defined(_DEBUG)
+ #define SOL_DEBUG_BUILD_I_ SOL_ON
+ #elif (SOL_IS_ON(SOL_COMPILER_CLANG_I_) || SOL_IS_ON(SOL_COMPILER_GCC_I_)) && !defined(__OPTIMIZE__)
+ #define SOL_DEBUG_BUILD_I_ SOL_ON
+ #else
+ #define SOL_DEBUG_BUILD_I_ SOL_OFF
+ #endif
+#else
+ #define SOL_DEBUG_BUILD_I_ SOL_DEFAULT_OFF
+#endif // We are in a debug mode of some sort
+
+#if defined(SOL_NO_EXCEPTIONS)
+ #if (SOL_NO_EXCEPTIONS != 0)
+ #define SOL_EXCEPTIONS_I_ SOL_OFF
+ #else
+ #define SOL_EXCEPTIONS_I_ SOL_ON
+ #endif
+#elif SOL_IS_ON(SOL_COMPILER_VCXX_I_)
+ #if !defined(_CPPUNWIND)
+ #define SOL_EXCEPTIONS_I_ SOL_OFF
+ #else
+ #define SOL_EXCEPTIONS_I_ SOL_ON
+ #endif
+#elif SOL_IS_ON(SOL_COMPILER_CLANG_I_) || SOL_IS_ON(SOL_COMPILER_GCC_I_)
+ #if !defined(__EXCEPTIONS)
+ #define SOL_EXCEPTIONS_I_ SOL_OFF
+ #else
+ #define SOL_EXCEPTIONS_I_ SOL_ON
+ #endif
+#else
+ #define SOL_EXCEPTIONS_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_NO_RTTI)
+ #if (SOL_NO_RTTI != 0)
+ #define SOL_RTTI_I_ SOL_OFF
+ #else
+ #define SOL_RTTI_I_ SOL_ON
+ #endif
+#elif SOL_IS_ON(SOL_COMPILER_VCXX_I_)
+ #if !defined(_CPPRTTI)
+ #define SOL_RTTI_I_ SOL_OFF
+ #else
+ #define SOL_RTTI_I_ SOL_ON
+ #endif
+#elif SOL_IS_ON(SOL_COMPILER_CLANG_I_) || SOL_IS_ON(SOL_COMPILER_GCC_I_)
+ #if !defined(__GXX_RTTI)
+ #define SOL_RTTI_I_ SOL_OFF
+ #else
+ #define SOL_RTTI_I_ SOL_ON
+ #endif
+#else
+ #define SOL_RTTI_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_NO_THREAD_LOCAL) && (SOL_NO_THREAD_LOCAL != 0)
+ #define SOL_USE_THREAD_LOCAL_I_ SOL_OFF
+#else
+ #define SOL_USE_THREAD_LOCAL_I_ SOL_DEFAULT_ON
+#endif // thread_local keyword is bjorked on some platforms
+
+#if defined(SOL_ALL_SAFETIES_ON) && (SOL_ALL_SAFETIES_ON != 0)
+ #define SOL_ALL_SAFETIES_ON_I_ SOL_ON
+#else
+ #define SOL_ALL_SAFETIES_ON_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_SAFE_GETTER) && (SOL_SAFE_GETTER != 0)
+ #define SOL_SAFE_GETTER_I_ SOL_ON
+#else
+ #if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+ #define SOL_SAFE_GETTER_I_ SOL_ON
+ #elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+ #define SOL_SAFE_GETTER_I_ SOL_DEFAULT_ON
+ #else
+ #define SOL_SAFE_GETTER_I_ SOL_DEFAULT_OFF
+ #endif
+#endif
+
+#if defined(SOL_SAFE_USERTYPE) && (SOL_SAFE_USERTYPE != 0)
+ #define SOL_SAFE_USERTYPE_I_ SOL_ON
+#else
+ #if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+ #define SOL_SAFE_USERTYPE_I_ SOL_ON
+ #elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+ #define SOL_SAFE_USERTYPE_I_ SOL_DEFAULT_ON
+ #else
+ #define SOL_SAFE_USERTYPE_I_ SOL_DEFAULT_OFF
+ #endif
+#endif
+
+#if defined(SOL_SAFE_REFERENCES) && (SOL_SAFE_REFERENCES != 0)
+ #define SOL_SAFE_REFERENCES_I_ SOL_ON
+#else
+ #if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+ #define SOL_SAFE_REFERENCES_I_ SOL_ON
+ #elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+ #define SOL_SAFE_REFERENCES_I_ SOL_DEFAULT_ON
+ #else
+ #define SOL_SAFE_REFERENCES_I_ SOL_DEFAULT_OFF
+ #endif
+#endif
+
+#if (defined(SOL_SAFE_FUNCTIONS) && (SOL_SAFE_FUNCTIONS != 0)) \
+ || (defined(SOL_SAFE_FUNCTION_OBJECTS) && (SOL_SAFE_FUNCTION_OBJECTS != 0))
+ #define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_ON
+#else
+ #if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+ #define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_ON
+ #elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+ #define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_DEFAULT_ON
+ #else
+ #define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_DEFAULT_OFF
+ #endif
+#endif
+
+#if defined(SOL_SAFE_FUNCTION_CALLS) && (SOL_SAFE_FUNCTION_CALLS != 0)
+ #define SOL_SAFE_FUNCTION_CALLS_I_ SOL_ON
+#else
+ #if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+ #define SOL_SAFE_FUNCTION_CALLS_I_ SOL_ON
+ #elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+ #define SOL_SAFE_FUNCTION_CALLS_I_ SOL_DEFAULT_ON
+ #else
+ #define SOL_SAFE_FUNCTION_CALLS_I_ SOL_DEFAULT_OFF
+ #endif
+#endif
+
+#if defined(SOL_SAFE_PROXIES) && (SOL_SAFE_PROXIES != 0)
+ #define SOL_SAFE_PROXIES_I_ SOL_ON
+#else
+ #if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+ #define SOL_SAFE_PROXIES_I_ SOL_ON
+ #elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+ #define SOL_SAFE_PROXIES_I_ SOL_DEFAULT_ON
+ #else
+ #define SOL_SAFE_PROXIES_I_ SOL_DEFAULT_OFF
+ #endif
+#endif
+
+#if defined(SOL_SAFE_NUMERICS) && (SOL_SAFE_NUMERICS != 0)
+ #define SOL_SAFE_NUMERICS_I_ SOL_ON
+#else
+ #if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+ #define SOL_SAFE_NUMERICS_I_ SOL_ON
+ #elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+ #define SOL_SAFE_NUMERICS_I_ SOL_DEFAULT_ON
+ #else
+ #define SOL_SAFE_NUMERICS_I_ SOL_DEFAULT_OFF
+ #endif
+#endif
+
+#if defined(SOL_SAFE_STACK_CHECK) && (SOL_SAFE_STACK_CHECK != 0)
+ #define SOL_SAFE_STACK_CHECK_I_ SOL_ON
+#else
+ #if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+ #define SOL_SAFE_STACK_CHECK_I_ SOL_ON
+ #elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+ #define SOL_SAFE_STACK_CHECK_I_ SOL_DEFAULT_ON
+ #else
+ #define SOL_SAFE_STACK_CHECK_I_ SOL_DEFAULT_OFF
+ #endif
+#endif
+
+#if (defined(SOL_NO_CHECK_NUMBER_PRECISION) && (SOL_NO_CHECK_NUMBER_PRECISION != 0)) \
+ || (defined(SOL_NO_CHECKING_NUMBER_PRECISION) && (SOL_NO_CHECKING_NUMBER_PRECISION != 0))
+ #define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_OFF
+#else
+ #if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+ #define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_ON
+ #elif SOL_IS_ON(SOL_SAFE_NUMERICS_I_)
+ #define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_ON
+ #elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+ #define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_DEFAULT_ON
+ #else
+ #define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_DEFAULT_OFF
+ #endif
+#endif
+
+#if defined(SOL_STRINGS_ARE_NUMBERS)
+ #if (SOL_STRINGS_ARE_NUMBERS != 0)
+ #define SOL_STRINGS_ARE_NUMBERS_I_ SOL_ON
+ #else
+ #define SOL_STRINGS_ARE_NUMBERS_I_ SOL_OFF
+ #endif
+#else
+ #define SOL_STRINGS_ARE_NUMBERS_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_ENABLE_INTEROP) && (SOL_ENABLE_INTEROP != 0) \
+ || defined(SOL_USE_INTEROP) && (SOL_USE_INTEROP != 0)
+ #define SOL_USE_INTEROP_I_ SOL_ON
+#else
+ #define SOL_USE_INTEROP_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_NO_NIL)
+ #if (SOL_NO_NIL != 0)
+ #define SOL_NIL_I_ SOL_OFF
+ #else
+ #define SOL_NIL_I_ SOL_ON
+ #endif
+#elif defined(__MAC_OS_X_VERSION_MAX_ALLOWED) || defined(__OBJC__) || defined(nil)
+ #define SOL_NIL_I_ SOL_DEFAULT_OFF
+#else
+ #define SOL_NIL_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_USERTYPE_TYPE_BINDING_INFO)
+ #if (SOL_USERTYPE_TYPE_BINDING_INFO != 0)
+ #define SOL_USERTYPE_TYPE_BINDING_INFO_I_ SOL_ON
+ #else
+ #define SOL_USERTYPE_TYPE_BINDING_INFO_I_ SOL_OFF
+ #endif
+#else
+ #define SOL_USERTYPE_TYPE_BINDING_INFO_I_ SOL_DEFAULT_ON
+#endif // We should generate a my_type.__type table with lots of class information for usertypes
+
+#if defined(SOL_AUTOMAGICAL_TYPES_BY_DEFAULT)
+ #if (SOL_AUTOMAGICAL_TYPES_BY_DEFAULT != 0)
+ #define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_ON
+ #else
+ #define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_OFF
+ #endif
+#elif defined(SOL_DEFAULT_AUTOMAGICAL_USERTYPES)
+ #if (SOL_DEFAULT_AUTOMAGICAL_USERTYPES != 0)
+ #define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_ON
+ #else
+ #define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_OFF
+ #endif
+#else
+ #define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_DEFAULT_ON
+#endif // make is_automagical on/off by default
+
+#if defined(SOL_STD_VARIANT)
+ #if (SOL_STD_VARIANT != 0)
+ #define SOL_STD_VARIANT_I_ SOL_ON
+ #else
+ #define SOL_STD_VARIANT_I_ SOL_OFF
+ #endif
+#else
+ #if SOL_IS_ON(SOL_COMPILER_CLANG_I_) && SOL_IS_ON(SOL_PLATFORM_APPLE_I_)
+ #if defined(__has_include)
+ #if __has_include(<variant>)
+ #define SOL_STD_VARIANT_I_ SOL_ON
+ #else
+ #define SOL_STD_VARIANT_I_ SOL_OFF
+ #endif
+ #else
+ #define SOL_STD_VARIANT_I_ SOL_OFF
+ #endif
+ #else
+ #define SOL_STD_VARIANT_I_ SOL_DEFAULT_ON
+ #endif
+#endif // make is_automagical on/off by default
+
+#if defined(SOL_NOEXCEPT_FUNCTION_TYPE)
+ #if (SOL_NOEXCEPT_FUNCTION_TYPE != 0)
+ #define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_ON
+ #else
+ #define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_OFF
+ #endif
+#else
+ #if defined(__cpp_noexcept_function_type)
+ #define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_ON
+ #elif SOL_IS_ON(SOL_COMPILER_VCXX_I_) && (defined(_MSVC_LANG) && (_MSVC_LANG < 201403L))
+ // There is a bug in the VC++ compiler??
+ // on /std:c++latest under x86 conditions (VS 15.5.2),
+ // compiler errors are tossed for noexcept markings being on function types
+ // that are identical in every other way to their non-noexcept marked types function types...
+ // VS 2019: There is absolutely a bug.
+ #define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_OFF
+ #else
+ #define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_DEFAULT_ON
+ #endif
+#endif // noexcept is part of a function's type
+
+#if defined(SOL_STACK_STRING_OPTIMIZATION_SIZE) && SOL_STACK_STRING_OPTIMIZATION_SIZE > 0
+ #define SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_ SOL_STACK_STRING_OPTIMIZATION_SIZE
+#else
+ #define SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_ 1024
+#endif
+
+#if defined(SOL_ID_SIZE) && SOL_ID_SIZE > 0
+ #define SOL_ID_SIZE_I_ SOL_ID_SIZE
+#else
+ #define SOL_ID_SIZE_I_ 512
+#endif
+
+#if defined(LUA_IDSIZE) && LUA_IDSIZE > 0
+ #define SOL_FILE_ID_SIZE_I_ LUA_IDSIZE
+#elif defined(SOL_ID_SIZE) && SOL_ID_SIZE > 0
+ #define SOL_FILE_ID_SIZE_I_ SOL_FILE_ID_SIZE
+#else
+ #define SOL_FILE_ID_SIZE_I_ 2048
+#endif
+
+#if defined(SOL_PRINT_ERRORS)
+ #if (SOL_PRINT_ERRORS != 0)
+ #define SOL_PRINT_ERRORS_I_ SOL_ON
+ #else
+ #define SOL_PRINT_ERRORS_I_ SOL_OFF
+ #endif
+#else
+ #if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+ #define SOL_PRINT_ERRORS_I_ SOL_ON
+ #elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+ #define SOL_PRINT_ERRORS_I_ SOL_DEFAULT_ON
+ #else
+ #define SOL_PRINT_ERRORS_I_ SOL_OFF
+ #endif
+#endif
+
+#if defined(SOL_DEFAULT_PASS_ON_ERROR) && (SOL_DEFAULT_PASS_ON_ERROR != 0)
+ #define SOL_DEFAULT_PASS_ON_ERROR_I_ SOL_ON
+#else
+ #if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+ #define SOL_DEFAULT_PASS_ON_ERROR_I_ SOL_ON
+ #elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+ #define SOL_DEFAULT_PASS_ON_ERROR_I_ SOL_DEFAULT_ON
+ #else
+ #define SOL_DEFAULT_PASS_ON_ERROR_I_ SOL_OFF
+ #endif
+#endif
+
+#if defined(SOL_USING_CXX_LUA)
+ #if (SOL_USING_CXX_LUA != 0)
+ #define SOL_USE_CXX_LUA_I_ SOL_ON
+ #else
+ #define SOL_USE_CXX_LUA_I_ SOL_OFF
+ #endif
+#elif defined(SOL_USE_CXX_LUA)
+ #if (SOL_USE_CXX_LUA != 0)
+ #define SOL_USE_CXX_LUA_I_ SOL_ON
+ #else
+ #define SOL_USE_CXX_LUA_I_ SOL_OFF
+ #endif
+#else
+ #define SOL_USE_CXX_LUA_I_ SOL_OFF
+#endif
+
+#if defined(SOL_USING_CXX_LUAJIT)
+ #if (SOL_USING_CXX_LUA != 0)
+ #define SOL_USE_CXX_LUAJIT_I_ SOL_ON
+ #else
+ #define SOL_USE_CXX_LUAJIT_I_ SOL_OFF
+ #endif
+#elif defined(SOL_USE_CXX_LUAJIT)
+ #if (SOL_USE_CXX_LUA != 0)
+ #define SOL_USE_CXX_LUAJIT_I_ SOL_ON
+ #else
+ #define SOL_USE_CXX_LUAJIT_I_ SOL_OFF
+ #endif
+#else
+ #define SOL_USE_CXX_LUAJIT_I_ SOL_OFF
+#endif
+
+#if defined(SOL_NO_LUA_HPP)
+ #if (SOL_NO_LUA_HPP != 0)
+ #define SOL_USE_LUA_HPP_I_ SOL_OFF
+ #else
+ #define SOL_USE_LUA_HPP_I_ SOL_ON
+ #endif
+#elif defined(SOL_USING_CXX_LUA)
+ #define SOL_USE_LUA_HPP_I_ SOL_OFF
+#elif defined(__has_include)
+ #if __has_include(<lua.hpp>)
+ #define SOL_USE_LUA_HPP_I_ SOL_ON
+ #else
+ #define SOL_USE_LUA_HPP_I_ SOL_OFF
+ #endif
+#else
+ #define SOL_USE_LUA_HPP_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_CONTAINERS_START)
+ #define SOL_CONTAINER_START_INDEX_I_ SOL_CONTAINERS_START
+#elif defined(SOL_CONTAINERS_START_INDEX)
+ #define SOL_CONTAINER_START_INDEX_I_ SOL_CONTAINERS_START_INDEX
+#elif defined(SOL_CONTAINER_START_INDEX)
+ #define SOL_CONTAINER_START_INDEX_I_ SOL_CONTAINER_START_INDEX
+#else
+ #define SOL_CONTAINER_START_INDEX_I_ 1
+#endif
+
+#if defined (SOL_NO_MEMORY_ALIGNMENT)
+ #if (SOL_NO_MEMORY_ALIGNMENT != 0)
+ #define SOL_ALIGN_MEMORY_I_ SOL_OFF
+ #else
+ #define SOL_ALIGN_MEMORY_I_ SOL_ON
+ #endif
+#else
+ #define SOL_ALIGN_MEMORY_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_USE_BOOST)
+ #if (SOL_USE_BOOST != 0)
+ #define SOL_USE_BOOST_I_ SOL_ON
+ #else
+ #define SOL_USE_BOOST_I_ SOL_OFF
+ #endif
+#else
+ #define SOL_USE_BOOST_I_ SOL_OFF
+#endif
+
+#if defined(SOL_USE_UNSAFE_BASE_LOOKUP)
+ #if (SOL_USE_UNSAFE_BASE_LOOKUP != 0)
+ #define SOL_USE_UNSAFE_BASE_LOOKUP_I_ SOL_ON
+ #else
+ #define SOL_USE_UNSAFE_BASE_LOOKUP_I_ SOL_OFF
+ #endif
+#else
+ #define SOL_USE_UNSAFE_BASE_LOOKUP_I_ SOL_OFF
+#endif
+
+#if defined(SOL_INSIDE_UNREAL)
+ #if (SOL_INSIDE_UNREAL != 0)
+ #define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_ON
+ #else
+ #define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_OFF
+ #endif
+#else
+ #if defined(UE_BUILD_DEBUG) || defined(UE_BUILD_DEVELOPMENT) || defined(UE_BUILD_TEST) || defined(UE_BUILD_SHIPPING) || defined(UE_SERVER)
+ #define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_ON
+ #else
+ #define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_DEFAULT_OFF
+ #endif
+#endif
+
+#if defined(SOL_NO_COMPAT)
+ #if (SOL_NO_COMPAT != 0)
+ #define SOL_USE_COMPATIBILITY_LAYER_I_ SOL_OFF
+ #else
+ #define SOL_USE_COMPATIBILITY_LAYER_I_ SOL_ON
+ #endif
+#else
+ #define SOL_USE_COMPATIBILITY_LAYER_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_GET_FUNCTION_POINTER_UNSAFE)
+ #if (SOL_GET_FUNCTION_POINTER_UNSAFE != 0)
+ #define SOL_GET_FUNCTION_POINTER_UNSAFE_I_ SOL_ON
+ #else
+ #define SOL_GET_FUNCTION_POINTER_UNSAFE_I_ SOL_OFF
+ #endif
+#else
+ #define SOL_GET_FUNCTION_POINTER_UNSAFE_I_ SOL_DEFAULT_OFF
+#endif
+
+#if SOL_IS_ON(SOL_COMPILER_FRONTEND_MINGW_I_) && defined(__GNUC__) && (__GNUC__ < 6)
+ // MinGW is off its rocker in some places...
+ #define SOL_MINGW_CCTYPE_IS_POISONED_I_ SOL_ON
+#else
+ #define SOL_MINGW_CCTYPE_IS_POISONED_I_ SOL_DEFAULT_OFF
+#endif
+
+// end of sol/version.hpp
+
+#include <utility>
+#include <type_traits>
+#include <string_view>
+
+#if SOL_IS_ON(SOL_USE_CXX_LUA_I_) || SOL_IS_ON(SOL_USE_CXX_LUAJIT_I_)
+struct lua_State;
+#else
+extern "C" {
+struct lua_State;
+}
+#endif // C++ Mangling for Lua vs. Not
+
+namespace sol {
+
+ enum class type;
+
+ class stateless_reference;
+ template <bool b>
+ class basic_reference;
+ using reference = basic_reference<false>;
+ using main_reference = basic_reference<true>;
+ class stateless_stack_reference;
+ class stack_reference;
+
+ template <typename A>
+ class basic_bytecode;
+
+ struct lua_value;
+
+ struct proxy_base_tag;
+ template <typename>
+ struct proxy_base;
+ template <typename, typename>
+ struct table_proxy;
+
+ template <bool, typename>
+ class basic_table_core;
+ template <bool b>
+ using table_core = basic_table_core<b, reference>;
+ template <bool b>
+ using main_table_core = basic_table_core<b, main_reference>;
+ template <bool b>
+ using stack_table_core = basic_table_core<b, stack_reference>;
+ template <typename base_type>
+ using basic_table = basic_table_core<false, base_type>;
+ using table = table_core<false>;
+ using global_table = table_core<true>;
+ using main_table = main_table_core<false>;
+ using main_global_table = main_table_core<true>;
+ using stack_table = stack_table_core<false>;
+ using stack_global_table = stack_table_core<true>;
+
+ template <typename>
+ struct basic_lua_table;
+ using lua_table = basic_lua_table<reference>;
+ using stack_lua_table = basic_lua_table<stack_reference>;
+
+ template <typename T, typename base_type>
+ class basic_usertype;
+ template <typename T>
+ using usertype = basic_usertype<T, reference>;
+ template <typename T>
+ using stack_usertype = basic_usertype<T, stack_reference>;
+
+ template <typename base_type>
+ class basic_metatable;
+ using metatable = basic_metatable<reference>;
+ using stack_metatable = basic_metatable<stack_reference>;
+
+ template <typename base_t>
+ struct basic_environment;
+ using environment = basic_environment<reference>;
+ using main_environment = basic_environment<main_reference>;
+ using stack_environment = basic_environment<stack_reference>;
+
+ template <typename T, bool>
+ class basic_function;
+ template <typename T, bool, typename H>
+ class basic_protected_function;
+ using unsafe_function = basic_function<reference, false>;
+ using safe_function = basic_protected_function<reference, false, reference>;
+ using main_unsafe_function = basic_function<main_reference, false>;
+ using main_safe_function = basic_protected_function<main_reference, false, reference>;
+ using stack_unsafe_function = basic_function<stack_reference, false>;
+ using stack_safe_function = basic_protected_function<stack_reference, false, reference>;
+ using stack_aligned_unsafe_function = basic_function<stack_reference, true>;
+ using stack_aligned_safe_function = basic_protected_function<stack_reference, true, reference>;
+ using protected_function = safe_function;
+ using main_protected_function = main_safe_function;
+ using stack_protected_function = stack_safe_function;
+ using stack_aligned_protected_function = stack_aligned_safe_function;
+#if SOL_IS_ON(SOL_SAFE_FUNCTION_OBJECTS_I_)
+ using function = protected_function;
+ using main_function = main_protected_function;
+ using stack_function = stack_protected_function;
+ using stack_aligned_function = stack_aligned_safe_function;
+#else
+ using function = unsafe_function;
+ using main_function = main_unsafe_function;
+ using stack_function = stack_unsafe_function;
+ using stack_aligned_function = stack_aligned_unsafe_function;
+#endif
+ using stack_aligned_stack_handler_function = basic_protected_function<stack_reference, true, stack_reference>;
+
+ struct unsafe_function_result;
+ struct protected_function_result;
+ using safe_function_result = protected_function_result;
+#if SOL_IS_ON(SOL_SAFE_FUNCTION_OBJECTS_I_)
+ using function_result = safe_function_result;
+#else
+ using function_result = unsafe_function_result;
+#endif
+
+ template <typename base_t>
+ class basic_object_base;
+ template <typename base_t>
+ class basic_object;
+ template <typename base_t>
+ class basic_userdata;
+ template <typename base_t>
+ class basic_lightuserdata;
+ template <typename base_t>
+ class basic_coroutine;
+ template <typename base_t>
+ class basic_thread;
+
+ using object = basic_object<reference>;
+ using userdata = basic_userdata<reference>;
+ using lightuserdata = basic_lightuserdata<reference>;
+ using thread = basic_thread<reference>;
+ using coroutine = basic_coroutine<reference>;
+ using main_object = basic_object<main_reference>;
+ using main_userdata = basic_userdata<main_reference>;
+ using main_lightuserdata = basic_lightuserdata<main_reference>;
+ using main_coroutine = basic_coroutine<main_reference>;
+ using stack_object = basic_object<stack_reference>;
+ using stack_userdata = basic_userdata<stack_reference>;
+ using stack_lightuserdata = basic_lightuserdata<stack_reference>;
+ using stack_thread = basic_thread<stack_reference>;
+ using stack_coroutine = basic_coroutine<stack_reference>;
+
+ struct stack_proxy_base;
+ struct stack_proxy;
+ struct variadic_args;
+ struct variadic_results;
+ struct stack_count;
+ struct this_state;
+ struct this_main_state;
+ struct this_environment;
+
+ class state_view;
+ class state;
+
+ template <typename T>
+ struct as_table_t;
+ template <typename T>
+ struct as_container_t;
+ template <typename T>
+ struct nested;
+ template <typename T>
+ struct light;
+ template <typename T>
+ struct user;
+ template <typename T>
+ struct as_args_t;
+ template <typename T>
+ struct protect_t;
+ template <typename F, typename... Policies>
+ struct policy_wrapper;
+
+ template <typename T>
+ struct usertype_traits;
+ template <typename T>
+ struct unique_usertype_traits;
+
+ template <typename... Args>
+ struct types {
+ typedef std::make_index_sequence<sizeof...(Args)> indices;
+ static constexpr std::size_t size() {
+ return sizeof...(Args);
+ }
+ };
+
+ template <typename T>
+ struct derive : std::false_type {
+ typedef types<> type;
+ };
+
+ template <typename T>
+ struct base : std::false_type {
+ typedef types<> type;
+ };
+
+ template <typename T>
+ struct weak_derive {
+ static bool value;
+ };
+
+ template <typename T>
+ bool weak_derive<T>::value = false;
+
+ namespace stack {
+ struct record;
+ }
+
+#if SOL_IS_OFF(SOL_USE_BOOST_I_)
+ template <class T>
+ class optional;
+
+ template <class T>
+ class optional<T&>;
+#endif
+
+ using check_handler_type = int(lua_State*, int, type, type, const char*);
+
+} // namespace sol
+
+#define SOL_BASE_CLASSES(T, ...) \
+ namespace sol { \
+ template <> \
+ struct base<T> : std::true_type { \
+ typedef ::sol::types<__VA_ARGS__> type; \
+ }; \
+ } \
+ void a_sol3_detail_function_decl_please_no_collide()
+#define SOL_DERIVED_CLASSES(T, ...) \
+ namespace sol { \
+ template <> \
+ struct derive<T> : std::true_type { \
+ typedef ::sol::types<__VA_ARGS__> type; \
+ }; \
+ } \
+ void a_sol3_detail_function_decl_please_no_collide()
+
+#endif // SOL_FORWARD_HPP
+// end of sol/forward.hpp
+
+#endif // SOL_SINGLE_INCLUDE_FORWARD_HPP
diff --git a/3rdparty/sol2/sol/function.hpp b/3rdparty/sol2/sol/function.hpp
deleted file mode 100644
index 57b2e0accd8..00000000000
--- a/3rdparty/sol2/sol/function.hpp
+++ /dev/null
@@ -1,159 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_FUNCTION_HPP
-#define SOL_FUNCTION_HPP
-
-#include "reference.hpp"
-#include "stack.hpp"
-#include "function_result.hpp"
-#include "function_types.hpp"
-#include <cstdint>
-#include <functional>
-#include <memory>
-
-namespace sol {
- template <typename base_t>
- class basic_function : public base_t {
- private:
- void luacall(std::ptrdiff_t argcount, std::ptrdiff_t resultcount) const {
- lua_callk(base_t::lua_state(), static_cast<int>(argcount), static_cast<int>(resultcount), 0, nullptr);
- }
-
- template<std::size_t... I, typename... Ret>
- auto invoke(types<Ret...>, std::index_sequence<I...>, std::ptrdiff_t n) const {
- luacall(n, lua_size<std::tuple<Ret...>>::value);
- return stack::pop<std::tuple<Ret...>>(base_t::lua_state());
- }
-
- template<std::size_t I, typename Ret>
- Ret invoke(types<Ret>, std::index_sequence<I>, std::ptrdiff_t n) const {
- luacall(n, lua_size<Ret>::value);
- return stack::pop<Ret>(base_t::lua_state());
- }
-
- template <std::size_t I>
- void invoke(types<void>, std::index_sequence<I>, std::ptrdiff_t n) const {
- luacall(n, 0);
- }
-
- function_result invoke(types<>, std::index_sequence<>, std::ptrdiff_t n) const {
- int stacksize = lua_gettop(base_t::lua_state());
- int firstreturn = (std::max)(1, stacksize - static_cast<int>(n));
- luacall(n, LUA_MULTRET);
- int poststacksize = lua_gettop(base_t::lua_state());
- int returncount = poststacksize - (firstreturn - 1);
- return function_result(base_t::lua_state(), firstreturn, returncount);
- }
-
- public:
- basic_function() = default;
- template <typename T, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_function>>, meta::neg<std::is_same<base_t, stack_reference>>, std::is_base_of<base_t, meta::unqualified_t<T>>> = meta::enabler>
- basic_function(T&& r) noexcept : base_t(std::forward<T>(r)) {
-#ifdef SOL_CHECK_ARGUMENTS
- if (!is_function<meta::unqualified_t<T>>::value) {
- auto pp = stack::push_pop(*this);
- stack::check<basic_function>(base_t::lua_state(), -1, type_panic);
- }
-#endif // Safety
- }
- basic_function(const basic_function&) = default;
- basic_function& operator=(const basic_function&) = default;
- basic_function(basic_function&&) = default;
- basic_function& operator=(basic_function&&) = default;
- basic_function(const stack_reference& r) : basic_function(r.lua_state(), r.stack_index()) {}
- basic_function(stack_reference&& r) : basic_function(r.lua_state(), r.stack_index()) {}
- template <typename T, meta::enable<meta::neg<std::is_integral<meta::unqualified_t<T>>>, meta::neg<std::is_same<T, ref_index>>> = meta::enabler>
- basic_function(lua_State* L, T&& r) : basic_function(L, sol::ref_index(r.registry_index())) {}
- basic_function(lua_State* L, int index = -1) : base_t(L, index) {
-#ifdef SOL_CHECK_ARGUMENTS
- stack::check<basic_function>(L, index, type_panic);
-#endif // Safety
- }
- basic_function(lua_State* L, ref_index index) : base_t(L, index) {
-#ifdef SOL_CHECK_ARGUMENTS
- auto pp = stack::push_pop(*this);
- stack::check<basic_function>(L, -1, type_panic);
-#endif // Safety
- }
-
- template<typename... Args>
- function_result operator()(Args&&... args) const {
- return call<>(std::forward<Args>(args)...);
- }
-
- template<typename... Ret, typename... Args>
- decltype(auto) operator()(types<Ret...>, Args&&... args) const {
- return call<Ret...>(std::forward<Args>(args)...);
- }
-
- template<typename... Ret, typename... Args>
- decltype(auto) call(Args&&... args) const {
- base_t::push();
- int pushcount = stack::multi_push_reference(base_t::lua_state(), std::forward<Args>(args)...);
- return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), pushcount);
- }
- };
-
- namespace stack {
- template<typename Signature>
- struct getter<std::function<Signature>> {
- typedef meta::bind_traits<Signature> fx_t;
- typedef typename fx_t::args_list args_lists;
- typedef meta::tuple_types<typename fx_t::return_type> return_types;
-
- template<typename... Args, typename... Ret>
- static std::function<Signature> get_std_func(types<Ret...>, types<Args...>, lua_State* L, int index) {
- sol::function f(L, index);
- auto fx = [f, L, index](Args&&... args) -> meta::return_type_t<Ret...> {
- return f.call<Ret...>(std::forward<Args>(args)...);
- };
- return std::move(fx);
- }
-
- template<typename... FxArgs>
- static std::function<Signature> get_std_func(types<void>, types<FxArgs...>, lua_State* L, int index) {
- sol::function f(L, index);
- auto fx = [f, L, index](FxArgs&&... args) -> void {
- f(std::forward<FxArgs>(args)...);
- };
- return std::move(fx);
- }
-
- template<typename... FxArgs>
- static std::function<Signature> get_std_func(types<>, types<FxArgs...> t, lua_State* L, int index) {
- return get_std_func(types<void>(), t, L, index);
- }
-
- static std::function<Signature> get(lua_State* L, int index, record& tracking) {
- tracking.last = 1;
- tracking.used += 1;
- type t = type_of(L, index);
- if (t == type::none || t == type::lua_nil) {
- return nullptr;
- }
- return get_std_func(return_types(), args_lists(), L, index);
- }
- };
- } // stack
-} // sol
-
-#endif // SOL_FUNCTION_HPP
diff --git a/3rdparty/sol2/sol/function_result.hpp b/3rdparty/sol2/sol/function_result.hpp
deleted file mode 100644
index 4e4da1289d1..00000000000
--- a/3rdparty/sol2/sol/function_result.hpp
+++ /dev/null
@@ -1,88 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_FUNCTION_RESULT_HPP
-#define SOL_FUNCTION_RESULT_HPP
-
-#include "reference.hpp"
-#include "tuple.hpp"
-#include "stack.hpp"
-#include "proxy_base.hpp"
-#include <cstdint>
-
-namespace sol {
- struct function_result : public proxy_base<function_result> {
- private:
- lua_State* L;
- int index;
- int returncount;
-
- public:
- function_result() = default;
- function_result(lua_State* Ls, int idx = -1, int retnum = 0) : L(Ls), index(idx), returncount(retnum) {
-
- }
- function_result(const function_result&) = default;
- function_result& operator=(const function_result&) = default;
- function_result(function_result&& o) : L(o.L), index(o.index), returncount(o.returncount) {
- // Must be manual, otherwise destructor will screw us
- // return count being 0 is enough to keep things clean
- // but will be thorough
- o.L = nullptr;
- o.index = 0;
- o.returncount = 0;
- }
- function_result& operator=(function_result&& o) {
- L = o.L;
- index = o.index;
- returncount = o.returncount;
- // Must be manual, otherwise destructor will screw us
- // return count being 0 is enough to keep things clean
- // but will be thorough
- o.L = nullptr;
- o.index = 0;
- o.returncount = 0;
- return *this;
- }
-
- template<typename T>
- decltype(auto) get() const {
- return stack::get<T>(L, index);
- }
-
- call_status status() const noexcept {
- return call_status::ok;
- }
-
- bool valid() const noexcept {
- return status() == call_status::ok || status() == call_status::yielded;
- }
-
- lua_State* lua_state() const { return L; };
- int stack_index() const { return index; };
-
- ~function_result() {
- lua_pop(L, returncount);
- }
- };
-} // sol
-
-#endif // SOL_FUNCTION_RESULT_HPP
diff --git a/3rdparty/sol2/sol/function_types.hpp b/3rdparty/sol2/sol/function_types.hpp
deleted file mode 100644
index 67b0c7163ba..00000000000
--- a/3rdparty/sol2/sol/function_types.hpp
+++ /dev/null
@@ -1,342 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_FUNCTION_TYPES_HPP
-#define SOL_FUNCTION_TYPES_HPP
-
-#include "function_types_core.hpp"
-#include "function_types_templated.hpp"
-#include "function_types_stateless.hpp"
-#include "function_types_stateful.hpp"
-#include "function_types_overloaded.hpp"
-#include "resolve.hpp"
-#include "call.hpp"
-
-namespace sol {
- namespace stack {
- template<typename... Sigs>
- struct pusher<function_sig<Sigs...>> {
- template <typename... Sig, typename Fx, typename... Args>
- static void select_convertible(std::false_type, types<Sig...>, lua_State* L, Fx&& fx, Args&&... args) {
- typedef std::remove_pointer_t<std::decay_t<Fx>> clean_fx;
- typedef function_detail::functor_function<clean_fx> F;
- set_fx<F>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
- }
-
- template <typename R, typename... A, typename Fx, typename... Args>
- static void select_convertible(std::true_type, types<R(A...)>, lua_State* L, Fx&& fx, Args&&... args) {
- using fx_ptr_t = R(*)(A...);
- fx_ptr_t fxptr = detail::unwrap(std::forward<Fx>(fx));
- select_function(std::true_type(), L, fxptr, std::forward<Args>(args)...);
- }
-
- template <typename R, typename... A, typename Fx, typename... Args>
- static void select_convertible(types<R(A...)> t, lua_State* L, Fx&& fx, Args&&... args) {
- typedef std::decay_t<meta::unwrap_unqualified_t<Fx>> raw_fx_t;
- typedef R(*fx_ptr_t)(A...);
- typedef std::is_convertible<raw_fx_t, fx_ptr_t> is_convertible;
- select_convertible(is_convertible(), t, L, std::forward<Fx>(fx), std::forward<Args>(args)...);
- }
-
- template <typename Fx, typename... Args>
- static void select_convertible(types<>, lua_State* L, Fx&& fx, Args&&... args) {
- typedef meta::function_signature_t<meta::unwrap_unqualified_t<Fx>> Sig;
- select_convertible(types<Sig>(), L, std::forward<Fx>(fx), std::forward<Args>(args)...);
- }
-
- template <typename Fx, typename T, typename... Args>
- static void select_reference_member_variable(std::false_type, lua_State* L, Fx&& fx, T&& obj, Args&&... args) {
- typedef std::remove_pointer_t<std::decay_t<Fx>> clean_fx;
- typedef function_detail::member_variable<meta::unwrap_unqualified_t<T>, clean_fx> F;
- set_fx<F>(L, std::forward<Fx>(fx), std::forward<T>(obj), std::forward<Args>(args)...);
- }
-
- template <typename Fx, typename T, typename... Args>
- static void select_reference_member_variable(std::true_type, lua_State* L, Fx&& fx, T&& obj, Args&&... args) {
- typedef std::decay_t<Fx> dFx;
- dFx memfxptr(std::forward<Fx>(fx));
- auto userptr = detail::ptr(std::forward<T>(obj), std::forward<Args>(args)...);
- lua_CFunction freefunc = &function_detail::upvalue_member_variable<std::decay_t<decltype(*userptr)>, meta::unqualified_t<Fx>>::call;
-
- int upvalues = stack::stack_detail::push_as_upvalues(L, memfxptr);
- upvalues += stack::push(L, lightuserdata_value(static_cast<void*>(userptr)));
- stack::push(L, c_closure(freefunc, upvalues));
- }
-
- template <typename Fx, typename... Args>
- static void select_member_variable(std::false_type, lua_State* L, Fx&& fx, Args&&... args) {
- select_convertible(types<Sigs...>(), L, std::forward<Fx>(fx), std::forward<Args>(args)...);
- }
-
- template <typename Fx, typename T, typename... Args>
- static void select_member_variable(std::true_type, lua_State* L, Fx&& fx, T&& obj, Args&&... args) {
- typedef meta::boolean<meta::is_specialization_of<std::reference_wrapper, meta::unqualified_t<T>>::value || std::is_pointer<T>::value> is_reference;
- select_reference_member_variable(is_reference(), L, std::forward<Fx>(fx), std::forward<T>(obj), std::forward<Args>(args)...);
- }
-
- template <typename Fx>
- static void select_member_variable(std::true_type, lua_State* L, Fx&& fx) {
- typedef typename meta::bind_traits<meta::unqualified_t<Fx>>::object_type C;
- lua_CFunction freefunc = &function_detail::upvalue_this_member_variable<C, Fx>::call;
- int upvalues = stack::stack_detail::push_as_upvalues(L, fx);
- stack::push(L, c_closure(freefunc, upvalues));
- }
-
- template <typename Fx, typename T, typename... Args>
- static void select_reference_member_function(std::false_type, lua_State* L, Fx&& fx, T&& obj, Args&&... args) {
- typedef std::decay_t<Fx> clean_fx;
- typedef function_detail::member_function<meta::unwrap_unqualified_t<T>, clean_fx> F;
- set_fx<F>(L, std::forward<Fx>(fx), std::forward<T>(obj), std::forward<Args>(args)...);
- }
-
- template <typename Fx, typename T, typename... Args>
- static void select_reference_member_function(std::true_type, lua_State* L, Fx&& fx, T&& obj, Args&&... args) {
- typedef std::decay_t<Fx> dFx;
- dFx memfxptr(std::forward<Fx>(fx));
- auto userptr = detail::ptr(std::forward<T>(obj), std::forward<Args>(args)...);
- lua_CFunction freefunc = &function_detail::upvalue_member_function<std::decay_t<decltype(*userptr)>, meta::unqualified_t<Fx>>::call;
-
- int upvalues = stack::stack_detail::push_as_upvalues(L, memfxptr);
- upvalues += stack::push(L, lightuserdata_value(static_cast<void*>(userptr)));
- stack::push(L, c_closure(freefunc, upvalues));
- }
-
- template <typename Fx, typename... Args>
- static void select_member_function(std::false_type, lua_State* L, Fx&& fx, Args&&... args) {
- select_member_variable(std::is_member_object_pointer<meta::unqualified_t<Fx>>(), L, std::forward<Fx>(fx), std::forward<Args>(args)...);
- }
-
- template <typename Fx, typename T, typename... Args>
- static void select_member_function(std::true_type, lua_State* L, Fx&& fx, T&& obj, Args&&... args) {
- typedef meta::boolean<meta::is_specialization_of<std::reference_wrapper, meta::unqualified_t<T>>::value || std::is_pointer<T>::value> is_reference;
- select_reference_member_function(is_reference(), L, std::forward<Fx>(fx), std::forward<T>(obj), std::forward<Args>(args)...);
- }
-
- template <typename Fx>
- static void select_member_function(std::true_type, lua_State* L, Fx&& fx) {
- typedef typename meta::bind_traits<meta::unqualified_t<Fx>>::object_type C;
- lua_CFunction freefunc = &function_detail::upvalue_this_member_function<C, Fx>::call;
- int upvalues = stack::stack_detail::push_as_upvalues(L, fx);
- stack::push(L, c_closure(freefunc, upvalues));
- }
-
- template <typename Fx, typename... Args>
- static void select_function(std::false_type, lua_State* L, Fx&& fx, Args&&... args) {
- select_member_function(std::is_member_function_pointer<meta::unqualified_t<Fx>>(), L, std::forward<Fx>(fx), std::forward<Args>(args)...);
- }
-
- template <typename Fx, typename... Args>
- static void select_function(std::true_type, lua_State* L, Fx&& fx, Args&&... args) {
- std::decay_t<Fx> target(std::forward<Fx>(fx), std::forward<Args>(args)...);
- lua_CFunction freefunc = &function_detail::upvalue_free_function<Fx>::call;
-
- int upvalues = stack::stack_detail::push_as_upvalues(L, target);
- stack::push(L, c_closure(freefunc, upvalues));
- }
-
- static void select_function(std::true_type, lua_State* L, lua_CFunction f) {
- stack::push(L, f);
- }
-
- template <typename Fx, typename... Args>
- static void select(lua_State* L, Fx&& fx, Args&&... args) {
- select_function(std::is_function<meta::unqualified_t<Fx>>(), L, std::forward<Fx>(fx), std::forward<Args>(args)...);
- }
-
- template <typename Fx, typename... Args>
- static void set_fx(lua_State* L, Args&&... args) {
- lua_CFunction freefunc = function_detail::call<meta::unqualified_t<Fx>>;
-
- stack::push_specific<user<Fx>>(L, std::forward<Args>(args)...);
- stack::push(L, c_closure(freefunc, 1));
- }
-
- template<typename... Args>
- static int push(lua_State* L, Args&&... args) {
- // Set will always place one thing (function) on the stack
- select(L, std::forward<Args>(args)...);
- return 1;
- }
- };
-
- template<typename T, typename... Args>
- struct pusher<function_arguments<T, Args...>> {
- template <std::size_t... I, typename FP>
- static int push_func(std::index_sequence<I...>, lua_State* L, FP&& fp) {
- return stack::push_specific<T>(L, detail::forward_get<I>(fp.arguments)...);
- }
-
- static int push(lua_State* L, const function_arguments<T, Args...>& fp) {
- return push_func(std::make_index_sequence<sizeof...(Args)>(), L, fp);
- }
-
- static int push(lua_State* L, function_arguments<T, Args...>&& fp) {
- return push_func(std::make_index_sequence<sizeof...(Args)>(), L, std::move(fp));
- }
- };
-
- template<typename Signature>
- struct pusher<std::function<Signature>> {
- static int push(lua_State* L, std::function<Signature> fx) {
- return pusher<function_sig<Signature>>{}.push(L, std::move(fx));
- }
- };
-
- template<typename Signature>
- struct pusher<Signature, std::enable_if_t<std::is_member_pointer<Signature>::value>> {
- template <typename F>
- static int push(lua_State* L, F&& f) {
- return pusher<function_sig<>>{}.push(L, std::forward<F>(f));
- }
- };
-
- template<typename Signature>
- struct pusher<Signature, std::enable_if_t<meta::all<std::is_function<Signature>, meta::neg<std::is_same<Signature, lua_CFunction>>, meta::neg<std::is_same<Signature, std::remove_pointer_t<lua_CFunction>>>>::value>> {
- template <typename F>
- static int push(lua_State* L, F&& f) {
- return pusher<function_sig<>>{}.push(L, std::forward<F>(f));
- }
- };
-
- template<typename... Functions>
- struct pusher<overload_set<Functions...>> {
- static int push(lua_State* L, overload_set<Functions...>&& set) {
- typedef function_detail::overloaded_function<Functions...> F;
- pusher<function_sig<>>{}.set_fx<F>(L, std::move(set.functions));
- return 1;
- }
-
- static int push(lua_State* L, const overload_set<Functions...>& set) {
- typedef function_detail::overloaded_function<Functions...> F;
- pusher<function_sig<>>{}.set_fx<F>(L, set.functions);
- return 1;
- }
- };
-
- template <typename T>
- struct pusher<protect_t<T>> {
- static int push(lua_State* L, protect_t<T>&& pw) {
- lua_CFunction cf = call_detail::call_user<void, false, false, protect_t<T>>;
- int closures = stack::push_specific<user<protect_t<T>>>(L, std::move(pw.value));
- return stack::push(L, c_closure(cf, closures));
- }
-
- static int push(lua_State* L, const protect_t<T>& pw) {
- lua_CFunction cf = call_detail::call_user<void, false, false, protect_t<T>>;
- int closures = stack::push_specific<user<protect_t<T>>>(L, pw.value);
- return stack::push(L, c_closure(cf, closures));
- }
- };
-
- template <typename F, typename G>
- struct pusher<property_wrapper<F, G>, std::enable_if_t<!std::is_void<F>::value && !std::is_void<G>::value>> {
- static int push(lua_State* L, property_wrapper<F, G>&& pw) {
- return stack::push(L, sol::overload(std::move(pw.read), std::move(pw.write)));
- }
- static int push(lua_State* L, const property_wrapper<F, G>& pw) {
- return stack::push(L, sol::overload(pw.read, pw.write));
- }
- };
-
- template <typename F>
- struct pusher<property_wrapper<F, void>> {
- static int push(lua_State* L, property_wrapper<F, void>&& pw) {
- return stack::push(L, std::move(pw.read));
- }
- static int push(lua_State* L, const property_wrapper<F, void>& pw) {
- return stack::push(L, pw.read);
- }
- };
-
- template <typename F>
- struct pusher<property_wrapper<void, F>> {
- static int push(lua_State* L, property_wrapper<void, F>&& pw) {
- return stack::push(L, std::move(pw.write));
- }
- static int push(lua_State* L, const property_wrapper<void, F>& pw) {
- return stack::push(L, pw.write);
- }
- };
-
- template <typename T>
- struct pusher<var_wrapper<T>> {
- static int push(lua_State* L, var_wrapper<T>&& vw) {
- return stack::push(L, std::move(vw.value));
- }
- static int push(lua_State* L, const var_wrapper<T>& vw) {
- return stack::push(L, vw.value);
- }
- };
-
- template <typename... Functions>
- struct pusher<factory_wrapper<Functions...>> {
- static int push(lua_State* L, const factory_wrapper<Functions...>& fw) {
- typedef function_detail::overloaded_function<Functions...> F;
- pusher<function_sig<>>{}.set_fx<F>(L, fw.functions);
- return 1;
- }
-
- static int push(lua_State* L, factory_wrapper<Functions...>&& fw) {
- typedef function_detail::overloaded_function<Functions...> F;
- pusher<function_sig<>>{}.set_fx<F>(L, std::move(fw.functions));
- return 1;
- }
- };
-
- template <typename T, typename... Lists>
- struct pusher<detail::tagged<T, constructor_list<Lists...>>> {
- static int push(lua_State* L, detail::tagged<T, constructor_list<Lists...>>) {
- lua_CFunction cf = call_detail::construct<T, Lists...>;
- return stack::push(L, cf);
- }
- };
-
- template <typename T, typename... Fxs>
- struct pusher<detail::tagged<T, constructor_wrapper<Fxs...>>> {
- template <typename C>
- static int push(lua_State* L, C&& c) {
- lua_CFunction cf = call_detail::call_user<T, false, false, constructor_wrapper<Fxs...>>;
- int closures = stack::push_specific<user<constructor_wrapper<Fxs...>>>(L, std::forward<C>(c));
- return stack::push(L, c_closure(cf, closures));
- }
- };
-
- template <typename T>
- struct pusher<detail::tagged<T, destructor_wrapper<void>>> {
- static int push(lua_State* L, destructor_wrapper<void>) {
- lua_CFunction cf = detail::usertype_alloc_destroy<T>;
- return stack::push(L, cf);
- }
- };
-
- template <typename T, typename Fx>
- struct pusher<detail::tagged<T, destructor_wrapper<Fx>>> {
- static int push(lua_State* L, destructor_wrapper<Fx> c) {
- lua_CFunction cf = call_detail::call_user<T, false, false, destructor_wrapper<Fx>>;
- int closures = stack::push_specific<user<T>>(L, std::move(c));
- return stack::push(L, c_closure(cf, closures));
- }
- };
-
- } // stack
-} // sol
-
-#endif // SOL_FUNCTION_TYPES_HPP
diff --git a/3rdparty/sol2/sol/function_types_core.hpp b/3rdparty/sol2/sol/function_types_core.hpp
deleted file mode 100644
index 24169ea7faf..00000000000
--- a/3rdparty/sol2/sol/function_types_core.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_FUNCTION_TYPES_CORE_HPP
-#define SOL_FUNCTION_TYPES_CORE_HPP
-
-#include "stack.hpp"
-#include "wrapper.hpp"
-#include <memory>
-
-namespace sol {
- namespace function_detail {
- template <typename Fx>
- inline int call(lua_State* L) {
- Fx& fx = stack::get<user<Fx>>(L, upvalue_index(1));
- return fx(L);
- }
- } // function_detail
-} // sol
-
-#endif // SOL_FUNCTION_TYPES_CORE_HPP
diff --git a/3rdparty/sol2/sol/function_types_overloaded.hpp b/3rdparty/sol2/sol/function_types_overloaded.hpp
deleted file mode 100644
index cfcfdebec68..00000000000
--- a/3rdparty/sol2/sol/function_types_overloaded.hpp
+++ /dev/null
@@ -1,59 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_FUNCTION_TYPES_OVERLOAD_HPP
-#define SOL_FUNCTION_TYPES_OVERLOAD_HPP
-
-#include "overload.hpp"
-#include "call.hpp"
-#include "function_types_core.hpp"
-
-namespace sol {
- namespace function_detail {
- template <typename... Functions>
- struct overloaded_function {
- typedef std::tuple<Functions...> overload_list;
- typedef std::make_index_sequence<sizeof...(Functions)> indices;
- overload_list overloads;
-
- overloaded_function(overload_list set)
- : overloads(std::move(set)) {}
-
- overloaded_function(Functions... fxs)
- : overloads(fxs...) {
-
- }
-
- template <typename Fx, std::size_t I, typename... R, typename... Args>
- int call(types<Fx>, index_value<I>, types<R...>, types<Args...>, lua_State* L, int, int) {
- auto& func = std::get<I>(overloads);
- return call_detail::call_wrapped<void, true, false>(L, func);
- }
-
- int operator()(lua_State* L) {
- auto mfx = [&](auto&&... args) { return this->call(std::forward<decltype(args)>(args)...); };
- return call_detail::overload_match<Functions...>(mfx, L, 1);
- }
- };
- } // function_detail
-} // sol
-
-#endif // SOL_FUNCTION_TYPES_OVERLOAD_HPP \ No newline at end of file
diff --git a/3rdparty/sol2/sol/function_types_stateful.hpp b/3rdparty/sol2/sol/function_types_stateful.hpp
deleted file mode 100644
index aa79dadb28f..00000000000
--- a/3rdparty/sol2/sol/function_types_stateful.hpp
+++ /dev/null
@@ -1,100 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_FUNCTION_TYPES_STATEFUL_HPP
-#define SOL_FUNCTION_TYPES_STATEFUL_HPP
-
-#include "function_types_core.hpp"
-
-namespace sol {
- namespace function_detail {
- template<typename Func>
- struct functor_function {
- typedef meta::unwrapped_t<meta::unqualified_t<Func>> Function;
- Function fx;
-
- template<typename... Args>
- functor_function(Function f, Args&&... args) : fx(std::move(f), std::forward<Args>(args)...) {}
-
- int call(lua_State* L) {
- return call_detail::call_wrapped<void, true, false>(L, fx);
- }
-
- int operator()(lua_State* L) {
- auto f = [&](lua_State*) -> int { return this->call(L); };
- return detail::trampoline(L, f);
- }
- };
-
- template<typename T, typename Function>
- struct member_function {
- typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
- typedef meta::function_return_t<function_type> return_type;
- typedef meta::function_args_t<function_type> args_lists;
- function_type invocation;
- T member;
-
- template<typename... Args>
- member_function(function_type f, Args&&... args) : invocation(std::move(f)), member(std::forward<Args>(args)...) {}
-
- int call(lua_State* L) {
- return call_detail::call_wrapped<T, true, false, -1>(L, invocation, detail::unwrap(detail::deref(member)));
- }
-
- int operator()(lua_State* L) {
- auto f = [&](lua_State*) -> int { return this->call(L); };
- return detail::trampoline(L, f);
- }
- };
-
- template<typename T, typename Function>
- struct member_variable {
- typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
- typedef typename meta::bind_traits<function_type>::return_type return_type;
- typedef typename meta::bind_traits<function_type>::args_list args_lists;
- function_type var;
- T member;
- typedef std::add_lvalue_reference_t<meta::unwrapped_t<std::remove_reference_t<decltype(detail::deref(member))>>> M;
-
- template<typename... Args>
- member_variable(function_type v, Args&&... args) : var(std::move(v)), member(std::forward<Args>(args)...) {}
-
- int call(lua_State* L) {
- M mem = detail::unwrap(detail::deref(member));
- switch (lua_gettop(L)) {
- case 0:
- return call_detail::call_wrapped<T, true, false, -1>(L, var, mem);
- case 1:
- return call_detail::call_wrapped<T, false, false, -1>(L, var, mem);
- default:
- return luaL_error(L, "sol: incorrect number of arguments to member variable function");
- }
- }
-
- int operator()(lua_State* L) {
- auto f = [&](lua_State*) -> int { return this->call(L); };
- return detail::trampoline(L, f);
- }
- };
- } // function_detail
-} // sol
-
-#endif // SOL_FUNCTION_TYPES_STATEFUL_HPP
diff --git a/3rdparty/sol2/sol/function_types_stateless.hpp b/3rdparty/sol2/sol/function_types_stateless.hpp
deleted file mode 100644
index 0b6e9072ddd..00000000000
--- a/3rdparty/sol2/sol/function_types_stateless.hpp
+++ /dev/null
@@ -1,163 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_FUNCTION_TYPES_STATELESS_HPP
-#define SOL_FUNCTION_TYPES_STATELESS_HPP
-
-#include "stack.hpp"
-
-namespace sol {
- namespace function_detail {
- template<typename Function>
- struct upvalue_free_function {
- typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
- typedef lua_bind_traits<function_type> traits_type;
-
- static int real_call(lua_State* L) {
- auto udata = stack::stack_detail::get_as_upvalues<function_type*>(L);
- function_type* fx = udata.first;
- return call_detail::call_wrapped<void, true, false>(L, fx);
- }
-
- static int call(lua_State* L) {
- return detail::static_trampoline<(&real_call)>(L);
- }
-
- int operator()(lua_State* L) {
- return call(L);
- }
- };
-
- template<typename T, typename Function>
- struct upvalue_member_function {
- typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
- typedef lua_bind_traits<function_type> traits_type;
-
- static int real_call(lua_State* L) {
- // Layout:
- // idx 1...n: verbatim data of member function pointer
- // idx n + 1: is the object's void pointer
- // We don't need to store the size, because the other side is templated
- // with the same member function pointer type
- auto memberdata = stack::stack_detail::get_as_upvalues<function_type>(L, 1);
- auto objdata = stack::stack_detail::get_as_upvalues<T*>(L, memberdata.second);
- function_type& memfx = memberdata.first;
- auto& item = *objdata.first;
- return call_detail::call_wrapped<T, true, false, -1>(L, memfx, item);
- }
-
- static int call(lua_State* L) {
- return detail::static_trampoline<(&real_call)>(L);
- }
-
- int operator()(lua_State* L) {
- return call(L);
- }
- };
-
- template<typename T, typename Function>
- struct upvalue_member_variable {
- typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
- typedef lua_bind_traits<function_type> traits_type;
-
- static int real_call(lua_State* L) {
- // Layout:
- // idx 1...n: verbatim data of member variable pointer
- // idx n + 1: is the object's void pointer
- // We don't need to store the size, because the other side is templated
- // with the same member function pointer type
- auto memberdata = stack::stack_detail::get_as_upvalues<function_type>(L, 1);
- auto objdata = stack::stack_detail::get_as_upvalues<T*>(L, memberdata.second);
- auto& mem = *objdata.first;
- function_type& var = memberdata.first;
- switch (lua_gettop(L)) {
- case 0:
- return call_detail::call_wrapped<T, true, false, -1>(L, var, mem);
- case 1:
- return call_detail::call_wrapped<T, false, false, -1>(L, var, mem);
- default:
- return luaL_error(L, "sol: incorrect number of arguments to member variable function");
- }
- }
-
- static int call(lua_State* L) {
- return detail::static_trampoline<(&real_call)>(L);
- }
-
- int operator()(lua_State* L) {
- return call(L);
- }
- };
-
- template<typename T, typename Function>
- struct upvalue_this_member_function {
- typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
- typedef lua_bind_traits<function_type> traits_type;
-
- static int real_call(lua_State* L) {
- // Layout:
- // idx 1...n: verbatim data of member variable pointer
- auto memberdata = stack::stack_detail::get_as_upvalues<function_type>(L, 1);
- function_type& memfx = memberdata.first;
- return call_detail::call_wrapped<T, false, false>(L, memfx);
- }
-
- static int call(lua_State* L) {
- return detail::static_trampoline<(&real_call)>(L);
- }
-
- int operator()(lua_State* L) {
- return call(L);
- }
- };
-
- template<typename T, typename Function>
- struct upvalue_this_member_variable {
- typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
- typedef lua_bind_traits<function_type> traits_type;
-
- static int real_call(lua_State* L) {
- // Layout:
- // idx 1...n: verbatim data of member variable pointer
- auto memberdata = stack::stack_detail::get_as_upvalues<function_type>(L, 1);
- function_type& var = memberdata.first;
- switch (lua_gettop(L)) {
- case 1:
- return call_detail::call_wrapped<T, true, false>(L, var);
- case 2:
- return call_detail::call_wrapped<T, false, false>(L, var);
- default:
- return luaL_error(L, "sol: incorrect number of arguments to member variable function");
- }
- }
-
- static int call(lua_State* L) {
- return detail::static_trampoline<(&real_call)>(L);
- }
-
- int operator()(lua_State* L) {
- return call(L);
- }
- };
- } // function_detail
-} // sol
-
-#endif // SOL_FUNCTION_TYPES_STATELESS_HPP
diff --git a/3rdparty/sol2/sol/function_types_templated.hpp b/3rdparty/sol2/sol/function_types_templated.hpp
deleted file mode 100644
index 80989408ad8..00000000000
--- a/3rdparty/sol2/sol/function_types_templated.hpp
+++ /dev/null
@@ -1,132 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_FUNCTION_TYPES_TEMPLATED_HPP
-#define SOL_FUNCTION_TYPES_TEMPLATED_HPP
-
-#include "call.hpp"
-
-namespace sol {
- namespace function_detail {
- template <typename F, F fx>
- inline int call_wrapper_variable(std::false_type, lua_State* L) {
- typedef meta::bind_traits<meta::unqualified_t<F>> traits_type;
- typedef typename traits_type::args_list args_list;
- typedef meta::tuple_types<typename traits_type::return_type> return_type;
- return stack::call_into_lua(return_type(), args_list(), L, 1, fx);
- }
-
- template <typename R, typename V, V, typename T>
- inline int call_set_assignable(std::false_type, T&&, lua_State* L) {
- return luaL_error(L, "cannot write to this type: copy assignment/constructor not available");
- }
-
- template <typename R, typename V, V variable, typename T>
- inline int call_set_assignable(std::true_type, lua_State* L, T&& mem) {
- (mem.*variable) = stack::get<R>(L, 2);
- return 0;
- }
-
- template <typename R, typename V, V, typename T>
- inline int call_set_variable(std::false_type, lua_State* L, T&&) {
- return luaL_error(L, "cannot write to a const variable");
- }
-
- template <typename R, typename V, V variable, typename T>
- inline int call_set_variable(std::true_type, lua_State* L, T&& mem) {
- return call_set_assignable<R, V, variable>(std::is_assignable<std::add_lvalue_reference_t<R>, R>(), L, std::forward<T>(mem));
- }
-
- template <typename V, V variable>
- inline int call_wrapper_variable(std::true_type, lua_State* L) {
- typedef meta::bind_traits<meta::unqualified_t<V>> traits_type;
- typedef typename traits_type::object_type T;
- typedef typename traits_type::return_type R;
- auto& mem = stack::get<T>(L, 1);
- switch (lua_gettop(L)) {
- case 1: {
- decltype(auto) r = (mem.*variable);
- stack::push_reference(L, std::forward<decltype(r)>(r));
- return 1; }
- case 2:
- return call_set_variable<R, V, variable>(meta::neg<std::is_const<R>>(), L, mem);
- default:
- return luaL_error(L, "incorrect number of arguments to member variable function call");
- }
- }
-
- template <typename F, F fx>
- inline int call_wrapper_function(std::false_type, lua_State* L) {
- return call_wrapper_variable<F, fx>(std::is_member_object_pointer<F>(), L);
- }
-
- template <typename F, F fx>
- inline int call_wrapper_function(std::true_type, lua_State* L) {
- return call_detail::call_wrapped<void, false, false>(L, fx);
- }
-
- template <typename F, F fx>
- int call_wrapper_entry(lua_State* L) {
- return call_wrapper_function<F, fx>(std::is_member_function_pointer<meta::unqualified_t<F>>(), L);
- }
-
- template <typename... Fxs>
- struct c_call_matcher {
- template <typename Fx, std::size_t I, typename R, typename... Args>
- int operator()(types<Fx>, index_value<I>, types<R>, types<Args...>, lua_State* L, int, int) const {
- typedef meta::at_in_pack_t<I, Fxs...> target;
- return target::call(L);
- }
- };
-
- } // function_detail
-
- template <typename F, F fx>
- inline int c_call(lua_State* L) {
-#ifdef __clang__
- return detail::trampoline(L, function_detail::call_wrapper_entry<F, fx>);
-#else
- return detail::static_trampoline<(&function_detail::call_wrapper_entry<F, fx>)>(L);
-#endif // fuck you clang :c
- }
-
- template <typename F, F f>
- struct wrap {
- typedef F type;
-
- static int call(lua_State* L) {
- return c_call<type, f>(L);
- }
- };
-
- template <typename... Fxs>
- inline int c_call(lua_State* L) {
- if (sizeof...(Fxs) < 2) {
- return meta::at_in_pack_t<0, Fxs...>::call(L);
- }
- else {
- return call_detail::overload_match_arity<typename Fxs::type...>(function_detail::c_call_matcher<Fxs...>(), L, lua_gettop(L), 1);
- }
- }
-
-} // sol
-
-#endif // SOL_FUNCTION_TYPES_TEMPLATED_HPP
diff --git a/3rdparty/sol2/sol/in_place.hpp b/3rdparty/sol2/sol/in_place.hpp
deleted file mode 100644
index 2410fb96791..00000000000
--- a/3rdparty/sol2/sol/in_place.hpp
+++ /dev/null
@@ -1,50 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_IN_PLACE_HPP
-#define SOL_IN_PLACE_HPP
-
-namespace sol {
-
- namespace detail {
- struct in_place_of {};
- template <std::size_t I>
- struct in_place_of_i {};
- template <typename T>
- struct in_place_of_t {};
- } // detail
-
- struct in_place_tag { struct init {}; constexpr in_place_tag(init) {} in_place_tag() = delete; };
- constexpr inline in_place_tag in_place(detail::in_place_of) { return in_place_tag(in_place_tag::init()); }
- template <typename T>
- constexpr inline in_place_tag in_place(detail::in_place_of_t<T>) { return in_place_tag(in_place_tag::init()); }
- template <std::size_t I>
- constexpr inline in_place_tag in_place(detail::in_place_of_i<I>) { return in_place_tag(in_place_tag::init()); }
-
- using in_place_t = in_place_tag(&)(detail::in_place_of);
- template <typename T>
- using in_place_type_t = in_place_tag(&)(detail::in_place_of_t<T>);
- template <std::size_t I>
- using in_place_index_t = in_place_tag(&)(detail::in_place_of_i<I>);
-
-} // sol
-
-#endif // SOL_IN_PLACE_HPP
diff --git a/3rdparty/sol2/sol/inheritance.hpp b/3rdparty/sol2/sol/inheritance.hpp
deleted file mode 100644
index f2583495bc4..00000000000
--- a/3rdparty/sol2/sol/inheritance.hpp
+++ /dev/null
@@ -1,117 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_INHERITANCE_HPP
-#define SOL_INHERITANCE_HPP
-
-#include "types.hpp"
-#include <atomic>
-
-namespace sol {
- template <typename... Args>
- struct base_list { };
- template <typename... Args>
- using bases = base_list<Args...>;
-
- typedef bases<> base_classes_tag;
- const auto base_classes = base_classes_tag();
-
- namespace detail {
-
- template <typename T>
- struct has_derived {
- static bool value;
- };
-
- template <typename T>
- bool has_derived<T>::value = false;
-
- inline std::size_t unique_id() {
- static std::atomic<std::size_t> x(0);
- return ++x;
- }
-
- template <typename T>
- struct id_for {
- static const std::size_t value;
- };
-
- template <typename T>
- const std::size_t id_for<T>::value = unique_id();
-
- inline decltype(auto) base_class_check_key() {
- static const auto& key = "class_check";
- return key;
- }
-
- inline decltype(auto) base_class_cast_key() {
- static const auto& key = "class_cast";
- return key;
- }
-
- inline decltype(auto) base_class_index_propogation_key() {
- static const auto& key = u8"\xF0\x9F\x8C\xB2.index";
- return key;
- }
-
- inline decltype(auto) base_class_new_index_propogation_key() {
- static const auto& key = u8"\xF0\x9F\x8C\xB2.new_index";
- return key;
- }
-
- template <typename T, typename... Bases>
- struct inheritance {
- static bool type_check_bases(types<>, std::size_t) {
- return false;
- }
-
- template <typename Base, typename... Args>
- static bool type_check_bases(types<Base, Args...>, std::size_t ti) {
- return ti == id_for<Base>::value || type_check_bases(types<Args...>(), ti);
- }
-
- static bool type_check(std::size_t ti) {
- return ti == id_for<T>::value || type_check_bases(types<Bases...>(), ti);
- }
-
- static void* type_cast_bases(types<>, T*, std::size_t) {
- return nullptr;
- }
-
- template <typename Base, typename... Args>
- static void* type_cast_bases(types<Base, Args...>, T* data, std::size_t ti) {
- // Make sure to convert to T first, and then dynamic cast to the proper type
- return ti != id_for<Base>::value ? type_cast_bases(types<Args...>(), data, ti) : static_cast<void*>(static_cast<Base*>(data));
- }
-
- static void* type_cast(void* voiddata, std::size_t ti) {
- T* data = static_cast<T*>(voiddata);
- return static_cast<void*>(ti != id_for<T>::value ? type_cast_bases(types<Bases...>(), data, ti) : data);
- }
- };
-
- using inheritance_check_function = decltype(&inheritance<void>::type_check);
- using inheritance_cast_function = decltype(&inheritance<void>::type_cast);
-
- } // detail
-} // sol
-
-#endif // SOL_INHERITANCE_HPP
diff --git a/3rdparty/sol2/sol/load_result.hpp b/3rdparty/sol2/sol/load_result.hpp
deleted file mode 100644
index 443b3d765a0..00000000000
--- a/3rdparty/sol2/sol/load_result.hpp
+++ /dev/null
@@ -1,139 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_LOAD_RESULT_HPP
-#define SOL_LOAD_RESULT_HPP
-
-#include "stack.hpp"
-#include "function.hpp"
-#include "proxy_base.hpp"
-#include <cstdint>
-
-namespace sol {
- struct load_result : public proxy_base<load_result> {
- private:
- lua_State* L;
- int index;
- int returncount;
- int popcount;
- load_status err;
-
- template <typename T>
- decltype(auto) tagged_get(types<sol::optional<T>>) const {
- if (!valid()) {
- return sol::optional<T>(nullopt);
- }
- return stack::get<sol::optional<T>>(L, index);
- }
-
- template <typename T>
- decltype(auto) tagged_get(types<T>) const {
-#ifdef SOL_CHECK_ARGUMENTS
- if (!valid()) {
- type_panic(L, index, type_of(L, index), type::none);
- }
-#endif // Check Argument Safety
- return stack::get<T>(L, index);
- }
-
- sol::optional<sol::error> tagged_get(types<sol::optional<sol::error>>) const {
- if (valid()) {
- return nullopt;
- }
- return sol::error(detail::direct_error, stack::get<std::string>(L, index));
- }
-
- sol::error tagged_get(types<sol::error>) const {
-#ifdef SOL_CHECK_ARGUMENTS
- if (valid()) {
- type_panic(L, index, type_of(L, index), type::none);
- }
-#endif // Check Argument Safety
- return sol::error(detail::direct_error, stack::get<std::string>(L, index));
- }
-
- public:
- load_result() = default;
- 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) {
-
- }
- load_result(const load_result&) = default;
- load_result& operator=(const load_result&) = default;
- load_result(load_result&& o) noexcept : L(o.L), index(o.index), returncount(o.returncount), popcount(o.popcount), err(o.err) {
- // Must be manual, otherwise destructor will screw us
- // return count being 0 is enough to keep things clean
- // but we will be thorough
- o.L = nullptr;
- o.index = 0;
- o.returncount = 0;
- o.popcount = 0;
- o.err = load_status::syntax;
- }
- load_result& operator=(load_result&& o) noexcept {
- L = o.L;
- index = o.index;
- returncount = o.returncount;
- popcount = o.popcount;
- err = o.err;
- // Must be manual, otherwise destructor will screw us
- // return count being 0 is enough to keep things clean
- // but we will be thorough
- o.L = nullptr;
- o.index = 0;
- o.returncount = 0;
- o.popcount = 0;
- o.err = load_status::syntax;
- return *this;
- }
-
- load_status status() const noexcept {
- return err;
- }
-
- bool valid() const noexcept {
- return status() == load_status::ok;
- }
-
- template<typename T>
- T get() const {
- return tagged_get(types<meta::unqualified_t<T>>());
- }
-
- template<typename... Ret, typename... Args>
- decltype(auto) call(Args&&... args) {
- return get<protected_function>().template call<Ret...>(std::forward<Args>(args)...);
- }
-
- template<typename... Args>
- decltype(auto) operator()(Args&&... args) {
- return call<>(std::forward<Args>(args)...);
- }
-
- lua_State* lua_state() const noexcept { return L; };
- int stack_index() const noexcept { return index; };
-
- ~load_result() {
- stack::remove(L, index, popcount);
- }
- };
-} // sol
-
-#endif // SOL_LOAD_RESULT_HPP
diff --git a/3rdparty/sol2/sol/object.hpp b/3rdparty/sol2/sol/object.hpp
deleted file mode 100644
index ab6e41854a1..00000000000
--- a/3rdparty/sol2/sol/object.hpp
+++ /dev/null
@@ -1,154 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_OBJECT_HPP
-#define SOL_OBJECT_HPP
-
-#include "reference.hpp"
-#include "stack.hpp"
-#include "userdata.hpp"
-#include "as_args.hpp"
-#include "variadic_args.hpp"
-#include "optional.hpp"
-
-namespace sol {
-
- template <typename R = reference, bool should_pop = !std::is_base_of<stack_reference, R>::value, typename T>
- R make_reference(lua_State* L, T&& value) {
- int backpedal = stack::push(L, std::forward<T>(value));
- R r = stack::get<R>(L, -backpedal);
- if (should_pop) {
- lua_pop(L, backpedal);
- }
- return r;
- }
-
- template <typename T, typename R = reference, bool should_pop = !std::is_base_of<stack_reference, R>::value, typename... Args>
- R make_reference(lua_State* L, Args&&... args) {
- int backpedal = stack::push_specific<T>(L, std::forward<Args>(args)...);
- R r = stack::get<R>(L, -backpedal);
- if (should_pop) {
- lua_pop(L, backpedal);
- }
- return r;
- }
-
- template <typename base_t>
- class basic_object : public base_t {
- private:
- template<typename T>
- decltype(auto) as_stack(std::true_type) const {
- return stack::get<T>(base_t::lua_state(), base_t::stack_index());
- }
-
- template<typename T>
- decltype(auto) as_stack(std::false_type) const {
- base_t::push();
- return stack::pop<T>(base_t::lua_state());
- }
-
- template<typename T>
- bool is_stack(std::true_type) const {
- return stack::check<T>(base_t::lua_state(), base_t::stack_index(), no_panic);
- }
-
- template<typename T>
- bool is_stack(std::false_type) const {
- auto pp = stack::push_pop(*this);
- return stack::check<T>(base_t::lua_state(), -1, no_panic);
- }
-
- template <bool invert_and_pop = false>
- basic_object(std::integral_constant<bool, invert_and_pop>, lua_State* L, int index = -1) noexcept : base_t(L, index) {
- if (invert_and_pop) {
- lua_pop(L, -index);
- }
- }
-
- public:
- basic_object() noexcept = default;
- template <typename T, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_object>>, meta::neg<std::is_same<base_t, stack_reference>>, std::is_base_of<base_t, meta::unqualified_t<T>>> = meta::enabler>
- basic_object(T&& r) : base_t(std::forward<T>(r)) {}
- basic_object(lua_nil_t r) : base_t(r) {}
- basic_object(const basic_object&) = default;
- basic_object(basic_object&&) = default;
- basic_object(const stack_reference& r) noexcept : basic_object(r.lua_state(), r.stack_index()) {}
- basic_object(stack_reference&& r) noexcept : basic_object(r.lua_state(), r.stack_index()) {}
- template <typename Super>
- basic_object(const proxy_base<Super>& r) noexcept : basic_object(r.operator basic_object()) {}
- template <typename Super>
- basic_object(proxy_base<Super>&& r) noexcept : basic_object(r.operator basic_object()) {}
- basic_object(lua_State* L, int index = -1) noexcept : base_t(L, index) {}
- basic_object(lua_State* L, ref_index index) noexcept : base_t(L, index) {}
- template <typename T, typename... Args>
- basic_object(lua_State* L, in_place_type_t<T>, Args&&... args) noexcept : basic_object(std::integral_constant<bool, !std::is_base_of<stack_reference, base_t>::value>(), L, -stack::push_specific<T>(L, std::forward<Args>(args)...)) {}
- template <typename T, typename... Args>
- basic_object(lua_State* L, in_place_t, T&& arg, Args&&... args) noexcept : basic_object(L, in_place<T>, std::forward<T>(arg), std::forward<Args>(args)...) {}
- basic_object& operator=(const basic_object&) = default;
- basic_object& operator=(basic_object&&) = default;
- basic_object& operator=(const base_t& b) { base_t::operator=(b); return *this; }
- basic_object& operator=(base_t&& b) { base_t::operator=(std::move(b)); return *this; }
- template <typename Super>
- basic_object& operator=(const proxy_base<Super>& r) { this->operator=(r.operator basic_object()); return *this; }
- template <typename Super>
- basic_object& operator=(proxy_base<Super>&& r) { this->operator=(r.operator basic_object()); return *this; }
-
- template<typename T>
- decltype(auto) as() const {
- return as_stack<T>(std::is_same<base_t, stack_reference>());
- }
-
- template<typename T>
- bool is() const {
- if (!base_t::valid())
- return false;
- return is_stack<T>(std::is_same<base_t, stack_reference>());
- }
- };
-
- template <typename T>
- object make_object(lua_State* L, T&& value) {
- return make_reference<object, true>(L, std::forward<T>(value));
- }
-
- template <typename T, typename... Args>
- object make_object(lua_State* L, Args&&... args) {
- return make_reference<T, object, true>(L, std::forward<Args>(args)...);
- }
-
- inline bool operator==(const object& lhs, const lua_nil_t&) {
- return !lhs.valid();
- }
-
- inline bool operator==(const lua_nil_t&, const object& rhs) {
- return !rhs.valid();
- }
-
- inline bool operator!=(const object& lhs, const lua_nil_t&) {
- return lhs.valid();
- }
-
- inline bool operator!=(const lua_nil_t&, const object& rhs) {
- return rhs.valid();
- }
-} // sol
-
-#endif // SOL_OBJECT_HPP
diff --git a/3rdparty/sol2/sol/optional.hpp b/3rdparty/sol2/sol/optional.hpp
deleted file mode 100644
index 16f805e4ebf..00000000000
--- a/3rdparty/sol2/sol/optional.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_OPTIONAL_HPP
-#define SOL_OPTIONAL_HPP
-
-#include "compatibility.hpp"
-#include "in_place.hpp"
-#if defined(SOL_USE_BOOST)
-#include <boost/optional.hpp>
-#else
-#include "optional_implementation.hpp"
-#endif // Boost vs. Better optional
-
-namespace sol {
-
-#if defined(SOL_USE_BOOST)
- template <typename T>
- using optional = boost::optional<T>;
- using nullopt_t = boost::none_t;
- const nullopt_t nullopt = boost::none;
-#endif // Boost vs. Better optional
-
-} // sol
-
-#endif // SOL_OPTIONAL_HPP
diff --git a/3rdparty/sol2/sol/optional_implementation.hpp b/3rdparty/sol2/sol/optional_implementation.hpp
deleted file mode 100644
index 4ffd0f27cd8..00000000000
--- a/3rdparty/sol2/sol/optional_implementation.hpp
+++ /dev/null
@@ -1,1135 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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.
-
-// Copyright (C) 2011 - 2012 Andrzej Krzemienski.
-// Use, modification, and distribution is subject to the Boost Software
-// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-// The idea and interface is based on Boost.Optional library
-// authored by Fernando Luis Cacciola Carballal
-
-# ifndef SOL_OPTIONAL_IMPLEMENTATION_HPP
-# define SOL_OPTIONAL_IMPLEMENTATION_HPP
-
-# include <utility>
-# include <type_traits>
-# include <initializer_list>
-# include <cassert>
-# include <functional>
-# include <string>
-# include <stdexcept>
-#ifdef SOL_NO_EXCEPTIONS
-#include <cstdlib>
-#endif // Exceptions
-
-# define TR2_OPTIONAL_REQUIRES(...) typename ::std::enable_if<__VA_ARGS__::value, bool>::type = false
-
-# if defined __GNUC__ // NOTE: GNUC is also defined for Clang
-# if (__GNUC__ >= 5)
-# define TR2_OPTIONAL_GCC_5_0_AND_HIGHER___
-# define TR2_OPTIONAL_GCC_4_8_AND_HIGHER___
-# elif (__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)
-# define TR2_OPTIONAL_GCC_4_8_AND_HIGHER___
-# elif (__GNUC__ > 4)
-# define TR2_OPTIONAL_GCC_4_8_AND_HIGHER___
-# endif
-#
-# if (__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)
-# define TR2_OPTIONAL_GCC_4_7_AND_HIGHER___
-# elif (__GNUC__ > 4)
-# define TR2_OPTIONAL_GCC_4_7_AND_HIGHER___
-# endif
-#
-# if (__GNUC__ == 4) && (__GNUC_MINOR__ == 8) && (__GNUC_PATCHLEVEL__ >= 1)
-# define TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___
-# elif (__GNUC__ == 4) && (__GNUC_MINOR__ >= 9)
-# define TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___
-# elif (__GNUC__ > 4)
-# define TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___
-# endif
-# endif
-#
-# if defined __clang_major__
-# if (__clang_major__ == 3 && __clang_minor__ >= 5)
-# define TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_
-# elif (__clang_major__ > 3)
-# define TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_
-# endif
-# if defined TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_
-# define TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_
-# elif (__clang_major__ == 3 && __clang_minor__ == 4 && __clang_patchlevel__ >= 2)
-# define TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_
-# endif
-# endif
-#
-# if defined _MSC_VER
-# if (_MSC_VER >= 1900)
-# define TR2_OPTIONAL_MSVC_2015_AND_HIGHER___
-# endif
-# endif
-
-# if defined __clang__
-# if (__clang_major__ > 2) || (__clang_major__ == 2) && (__clang_minor__ >= 9)
-# define OPTIONAL_HAS_THIS_RVALUE_REFS 1
-# else
-# define OPTIONAL_HAS_THIS_RVALUE_REFS 0
-# endif
-# elif defined TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___
-# define OPTIONAL_HAS_THIS_RVALUE_REFS 1
-# elif defined TR2_OPTIONAL_MSVC_2015_AND_HIGHER___
-# define OPTIONAL_HAS_THIS_RVALUE_REFS 1
-# else
-# define OPTIONAL_HAS_THIS_RVALUE_REFS 0
-# endif
-
-
-# if defined TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___
-# define OPTIONAL_HAS_CONSTEXPR_INIT_LIST 1
-# define OPTIONAL_CONSTEXPR_INIT_LIST constexpr
-# else
-# define OPTIONAL_HAS_CONSTEXPR_INIT_LIST 0
-# define OPTIONAL_CONSTEXPR_INIT_LIST
-# endif
-
-# if defined(TR2_OPTIONAL_MSVC_2015_AND_HIGHER___) || (defined TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_ && (defined __cplusplus) && (__cplusplus != 201103L))
-# define OPTIONAL_HAS_MOVE_ACCESSORS 1
-# else
-# define OPTIONAL_HAS_MOVE_ACCESSORS 0
-# endif
-
-# // In C++11 constexpr implies const, so we need to make non-const members also non-constexpr
-# if defined(TR2_OPTIONAL_MSVC_2015_AND_HIGHER___) || ((defined __cplusplus) && (__cplusplus == 201103L))
-# define OPTIONAL_MUTABLE_CONSTEXPR
-# else
-# define OPTIONAL_MUTABLE_CONSTEXPR constexpr
-# endif
-
-# if defined TR2_OPTIONAL_MSVC_2015_AND_HIGHER___
-#pragma warning( push )
-#pragma warning( disable : 4814 )
-#endif
-
-namespace sol {
-
- // BEGIN workaround for missing is_trivially_destructible
-# if defined TR2_OPTIONAL_GCC_4_8_AND_HIGHER___
- // leave it: it is already there
-# elif defined TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_
- // leave it: it is already there
-# elif defined TR2_OPTIONAL_MSVC_2015_AND_HIGHER___
- // leave it: it is already there
-# elif defined TR2_OPTIONAL_DISABLE_EMULATION_OF_TYPE_TRAITS
- // leave it: the user doesn't want it
-# else
- template <typename T>
- using is_trivially_destructible = ::std::has_trivial_destructor<T>;
-# endif
- // END workaround for missing is_trivially_destructible
-
-# if (defined TR2_OPTIONAL_GCC_4_7_AND_HIGHER___)
- // leave it; our metafunctions are already defined.
-# elif defined TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_
- // leave it; our metafunctions are already defined.
-# elif defined TR2_OPTIONAL_MSVC_2015_AND_HIGHER___
- // leave it: it is already there
-# elif defined TR2_OPTIONAL_DISABLE_EMULATION_OF_TYPE_TRAITS
- // leave it: the user doesn't want it
-# else
-
-
-// workaround for missing traits in GCC and CLANG
- template <class T>
- struct is_nothrow_move_constructible
- {
- constexpr static bool value = ::std::is_nothrow_constructible<T, T&&>::value;
- };
-
-
- template <class T, class U>
- struct is_assignable
- {
- template <class X, class Y>
- constexpr static bool has_assign(...) { return false; }
-
- template <class X, class Y, size_t S = sizeof((::std::declval<X>() = ::std::declval<Y>(), true)) >
- // the comma operator is necessary for the cases where operator= returns void
- constexpr static bool has_assign(bool) { return true; }
-
- constexpr static bool value = has_assign<T, U>(true);
- };
-
-
- template <class T>
- struct is_nothrow_move_assignable
- {
- template <class X, bool has_any_move_assign>
- struct has_nothrow_move_assign {
- constexpr static bool value = false;
- };
-
- template <class X>
- struct has_nothrow_move_assign<X, true> {
- constexpr static bool value = noexcept(::std::declval<X&>() = ::std::declval<X&&>());
- };
-
- constexpr static bool value = has_nothrow_move_assign<T, is_assignable<T&, T&&>::value>::value;
- };
- // end workaround
-
-
-# endif
-
-
-
-// 20.5.4, optional for object types
- template <class T> class optional;
-
- // 20.5.5, optional for lvalue reference types
- template <class T> class optional<T&>;
-
-
- // workaround: std utility functions aren't constexpr yet
- template <class T> inline constexpr T&& constexpr_forward(typename ::std::remove_reference<T>::type& t) noexcept
- {
- return static_cast<T&&>(t);
- }
-
- template <class T> inline constexpr T&& constexpr_forward(typename ::std::remove_reference<T>::type&& t) noexcept
- {
- static_assert(!::std::is_lvalue_reference<T>::value, "!!");
- return static_cast<T&&>(t);
- }
-
- template <class T> inline constexpr typename ::std::remove_reference<T>::type&& constexpr_move(T&& t) noexcept
- {
- return static_cast<typename ::std::remove_reference<T>::type&&>(t);
- }
-
-
-#if defined NDEBUG
-# define TR2_OPTIONAL_ASSERTED_EXPRESSION(CHECK, EXPR) (EXPR)
-#else
-# define TR2_OPTIONAL_ASSERTED_EXPRESSION(CHECK, EXPR) ((CHECK) ? (EXPR) : ([]{assert(!#CHECK);}(), (EXPR)))
-#endif
-
-
- namespace detail_
- {
-
- // static_addressof: a constexpr version of addressof
- template <typename T>
- struct has_overloaded_addressof
- {
- template <class X>
- constexpr static bool has_overload(...) { return false; }
-
- template <class X, size_t S = sizeof(::std::declval<X&>().operator&()) >
- constexpr static bool has_overload(bool) { return true; }
-
- constexpr static bool value = has_overload<T>(true);
- };
-
- template <typename T, TR2_OPTIONAL_REQUIRES(!has_overloaded_addressof<T>)>
- constexpr T* static_addressof(T& ref)
- {
- return &ref;
- }
-
- template <typename T, TR2_OPTIONAL_REQUIRES(has_overloaded_addressof<T>)>
- T* static_addressof(T& ref)
- {
- return ::std::addressof(ref);
- }
-
-
- // the call to convert<A>(b) has return type A and converts b to type A iff b decltype(b) is implicitly convertible to A
- template <class U>
- constexpr U convert(U v) { return v; }
-
- } // namespace detail_
-
- constexpr struct trivial_init_t {} trivial_init{};
-
- // 20.5.7, Disengaged state indicator
- struct nullopt_t
- {
- struct init {};
- constexpr explicit nullopt_t(init) {}
- };
- constexpr nullopt_t nullopt{ nullopt_t::init() };
-
-
- // 20.5.8, class bad_optional_access
- class bad_optional_access : public ::std::logic_error {
- public:
- explicit bad_optional_access(const ::std::string& what_arg) : ::std::logic_error{ what_arg } {}
- explicit bad_optional_access(const char* what_arg) : ::std::logic_error{ what_arg } {}
- };
-
-
- template <class T>
- struct alignas(T) optional_base {
- char storage_[sizeof(T)];
- bool init_;
-
- constexpr optional_base() noexcept : storage_(), init_(false) {};
-
- explicit optional_base(const T& v) : storage_(), init_(true) {
- new (&storage())T(v);
- }
-
- explicit optional_base(T&& v) : storage_(), init_(true) {
- new (&storage())T(constexpr_move(v));
- }
-
- template <class... Args> explicit optional_base(in_place_t, Args&&... args)
- : init_(true), storage_() {
- new (&storage())T(constexpr_forward<Args>(args)...);
- }
-
- template <class U, class... Args, TR2_OPTIONAL_REQUIRES(::std::is_constructible<T, ::std::initializer_list<U>>)>
- explicit optional_base(in_place_t, ::std::initializer_list<U> il, Args&&... args)
- : init_(true), storage_() {
- new (&storage())T(il, constexpr_forward<Args>(args)...);
- }
-#if defined __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wstrict-aliasing"
-#endif
- T& storage() {
- return *reinterpret_cast<T*>(&storage_[0]);
- }
-
- constexpr const T& storage() const {
- return *reinterpret_cast<T const*>(&storage_[0]);
- }
-#if defined __GNUC__
-#pragma GCC diagnostic pop
-#endif
-
- ~optional_base() { if (init_) { storage().T::~T(); } }
- };
-
-#if defined __GNUC__ && !defined TR2_OPTIONAL_GCC_5_0_AND_HIGHER___
- // Sorry, GCC 4.x; you're just a piece of shit
- template <typename T>
- using constexpr_optional_base = optional_base<T>;
-#else
- template <class T>
- struct alignas(T) constexpr_optional_base {
- char storage_[sizeof(T)];
- bool init_;
- constexpr constexpr_optional_base() noexcept : storage_(), init_(false) {}
-
- explicit constexpr constexpr_optional_base(const T& v) : storage_(), init_(true) {
- new (&storage())T(v);
- }
-
- explicit constexpr constexpr_optional_base(T&& v) : storage_(), init_(true) {
- new (&storage())T(constexpr_move(v));
- }
-
- template <class... Args> explicit constexpr constexpr_optional_base(in_place_t, Args&&... args)
- : init_(true), storage_() {
- new (&storage())T(constexpr_forward<Args>(args)...);
- }
-
- template <class U, class... Args, TR2_OPTIONAL_REQUIRES(::std::is_constructible<T, ::std::initializer_list<U>>)>
- OPTIONAL_CONSTEXPR_INIT_LIST explicit constexpr_optional_base(in_place_t, ::std::initializer_list<U> il, Args&&... args)
- : init_(true), storage_() {
- new (&storage())T(il, constexpr_forward<Args>(args)...);
- }
-
-#if defined __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wstrict-aliasing"
-#endif
- T& storage() {
- return (*reinterpret_cast<T*>(&storage_[0]));
- }
-
- constexpr const T& storage() const {
- return (*reinterpret_cast<T const*>(&storage_[0]));
- }
-#if defined __GNUC__
-#pragma GCC diagnostic pop
-#endif
-
- ~constexpr_optional_base() = default;
- };
-#endif
-
- template <class T>
- using OptionalBase = typename ::std::conditional<
- ::std::is_trivially_destructible<T>::value,
- constexpr_optional_base<typename ::std::remove_const<T>::type>,
- optional_base<typename ::std::remove_const<T>::type>
- >::type;
-
-
-
- template <class T>
- class optional : private OptionalBase<T>
- {
- static_assert(!::std::is_same<typename ::std::decay<T>::type, nullopt_t>::value, "bad T");
- static_assert(!::std::is_same<typename ::std::decay<T>::type, in_place_t>::value, "bad T");
-
-
- constexpr bool initialized() const noexcept { return OptionalBase<T>::init_; }
- typename ::std::remove_const<T>::type* dataptr() { return ::std::addressof(OptionalBase<T>::storage()); }
- constexpr const T* dataptr() const { return detail_::static_addressof(OptionalBase<T>::storage()); }
-
-# if OPTIONAL_HAS_THIS_RVALUE_REFS == 1
- constexpr const T& contained_val() const& { return OptionalBase<T>::storage(); }
-# if OPTIONAL_HAS_MOVE_ACCESSORS == 1
- OPTIONAL_MUTABLE_CONSTEXPR T&& contained_val() && { return ::std::move(OptionalBase<T>::storage()); }
- OPTIONAL_MUTABLE_CONSTEXPR T& contained_val() & { return OptionalBase<T>::storage(); }
-# else
- T& contained_val() & { return OptionalBase<T>::storage(); }
- T&& contained_val() && { return ::std::move(OptionalBase<T>::storage()); }
-# endif
-# else
- constexpr const T& contained_val() const { return OptionalBase<T>::storage(); }
- T& contained_val() { return OptionalBase<T>::storage(); }
-# endif
-
- void clear() noexcept {
- if (initialized()) dataptr()->T::~T();
- OptionalBase<T>::init_ = false;
- }
-
- template <class... Args>
- void initialize(Args&&... args) noexcept(noexcept(T(::std::forward<Args>(args)...)))
- {
- assert(!OptionalBase<T>::init_);
- ::new (static_cast<void*>(dataptr())) T(::std::forward<Args>(args)...);
- OptionalBase<T>::init_ = true;
- }
-
- template <class U, class... Args>
- void initialize(::std::initializer_list<U> il, Args&&... args) noexcept(noexcept(T(il, ::std::forward<Args>(args)...)))
- {
- assert(!OptionalBase<T>::init_);
- ::new (static_cast<void*>(dataptr())) T(il, ::std::forward<Args>(args)...);
- OptionalBase<T>::init_ = true;
- }
-
- public:
- typedef T value_type;
-
- // 20.5.5.1, constructors
- constexpr optional() noexcept : OptionalBase<T>() {};
- constexpr optional(nullopt_t) noexcept : OptionalBase<T>() {};
-
- optional(const optional& rhs)
- : OptionalBase<T>()
- {
- if (rhs.initialized()) {
- ::new (static_cast<void*>(dataptr())) T(*rhs);
- OptionalBase<T>::init_ = true;
- }
- }
-
- optional(const optional<T&>& rhs) : optional()
- {
- if (rhs) {
- ::new (static_cast<void*>(dataptr())) T(*rhs);
- OptionalBase<T>::init_ = true;
- }
- }
-
-
- optional(optional&& rhs) noexcept(::std::is_nothrow_move_constructible<T>::value)
- : OptionalBase<T>()
- {
- if (rhs.initialized()) {
- ::new (static_cast<void*>(dataptr())) T(::std::move(*rhs));
- OptionalBase<T>::init_ = true;
- }
- }
-
- constexpr optional(const T& v) : OptionalBase<T>(v) {}
-
- constexpr optional(T&& v) : OptionalBase<T>(constexpr_move(v)) {}
-
- template <class... Args>
- explicit constexpr optional(in_place_t, Args&&... args)
- : OptionalBase<T>(in_place, constexpr_forward<Args>(args)...) {}
-
- template <class U, class... Args, TR2_OPTIONAL_REQUIRES(::std::is_constructible<T, ::std::initializer_list<U>>)>
- OPTIONAL_CONSTEXPR_INIT_LIST explicit optional(in_place_t, ::std::initializer_list<U> il, Args&&... args)
- : OptionalBase<T>(in_place, il, constexpr_forward<Args>(args)...) {}
-
- // 20.5.4.2, Destructor
- ~optional() = default;
-
- // 20.5.4.3, assignment
- optional& operator=(nullopt_t) noexcept
- {
- clear();
- return *this;
- }
-
- optional& operator=(const optional& rhs)
- {
- if (initialized() == true && rhs.initialized() == false) clear();
- else if (initialized() == false && rhs.initialized() == true) initialize(*rhs);
- else if (initialized() == true && rhs.initialized() == true) contained_val() = *rhs;
- return *this;
- }
-
- optional& operator=(optional&& rhs)
- noexcept(::std::is_nothrow_move_assignable<T>::value && ::std::is_nothrow_move_constructible<T>::value)
- {
- if (initialized() == true && rhs.initialized() == false) clear();
- else if (initialized() == false && rhs.initialized() == true) initialize(::std::move(*rhs));
- else if (initialized() == true && rhs.initialized() == true) contained_val() = ::std::move(*rhs);
- return *this;
- }
-
- template <class U>
- auto operator=(U&& v)
- -> typename ::std::enable_if
- <
- ::std::is_same<typename ::std::decay<U>::type, T>::value,
- optional&
- >::type
- {
- if (initialized()) { contained_val() = ::std::forward<U>(v); }
- else { initialize(::std::forward<U>(v)); }
- return *this;
- }
-
-
- template <class... Args>
- void emplace(Args&&... args)
- {
- clear();
- initialize(::std::forward<Args>(args)...);
- }
-
- template <class U, class... Args>
- void emplace(::std::initializer_list<U> il, Args&&... args)
- {
- clear();
- initialize<U, Args...>(il, ::std::forward<Args>(args)...);
- }
-
- // 20.5.4.4, Swap
- void swap(optional<T>& rhs) noexcept(::std::is_nothrow_move_constructible<T>::value && noexcept(swap(::std::declval<T&>(), ::std::declval<T&>())))
- {
- if (initialized() == true && rhs.initialized() == false) { rhs.initialize(::std::move(**this)); clear(); }
- else if (initialized() == false && rhs.initialized() == true) { initialize(::std::move(*rhs)); rhs.clear(); }
- else if (initialized() == true && rhs.initialized() == true) { using ::std::swap; swap(**this, *rhs); }
- }
-
- // 20.5.4.5, Observers
-
- explicit constexpr operator bool() const noexcept { return initialized(); }
-
- constexpr T const* operator ->() const {
- return TR2_OPTIONAL_ASSERTED_EXPRESSION(initialized(), dataptr());
- }
-
-# if OPTIONAL_HAS_MOVE_ACCESSORS == 1
-
- OPTIONAL_MUTABLE_CONSTEXPR T* operator ->() {
- assert(initialized());
- return dataptr();
- }
-
- constexpr T const& operator *() const& {
- return TR2_OPTIONAL_ASSERTED_EXPRESSION(initialized(), contained_val());
- }
-
- OPTIONAL_MUTABLE_CONSTEXPR T& operator *() & {
- assert(initialized());
- return contained_val();
- }
-
- OPTIONAL_MUTABLE_CONSTEXPR T&& operator *() && {
- assert(initialized());
- return constexpr_move(contained_val());
- }
-
- constexpr T const& value() const& {
- return initialized() ?
- contained_val()
-#ifdef SOL_NO_EXCEPTIONS
- // we can't abort here
- // because there's no constexpr abort
- : *(T*)nullptr;
-#else
- : (throw bad_optional_access("bad optional access"), contained_val());
-#endif
- }
-
- OPTIONAL_MUTABLE_CONSTEXPR T& value() & {
- return initialized() ?
- contained_val()
-#ifdef SOL_NO_EXCEPTIONS
- : *(T*)nullptr;
-#else
- : (throw bad_optional_access("bad optional access"), contained_val());
-#endif
- }
-
- OPTIONAL_MUTABLE_CONSTEXPR T&& value() && {
- return initialized() ?
- contained_val()
-#ifdef SOL_NO_EXCEPTIONS
- // we can't abort here
- // because there's no constexpr abort
- : std::move(*(T*)nullptr);
-#else
- : (throw bad_optional_access("bad optional access"), contained_val());
-#endif
- }
-
-# else
-
- T* operator ->() {
- assert(initialized());
- return dataptr();
- }
-
- constexpr T const& operator *() const {
- return TR2_OPTIONAL_ASSERTED_EXPRESSION(initialized(), contained_val());
- }
-
- T& operator *() {
- assert(initialized());
- return contained_val();
- }
-
- constexpr T const& value() const {
- return initialized() ?
- contained_val()
-#ifdef SOL_NO_EXCEPTIONS
- // we can't abort here
- // because there's no constexpr abort
- : *(T*)nullptr;
-#else
- : (throw bad_optional_access("bad optional access"), contained_val());
-#endif
- }
-
- T& value() {
- return initialized() ?
- contained_val()
-#ifdef SOL_NO_EXCEPTIONS
- // we can abort here
- // but the others are constexpr, so we can't...
- : (std::abort(), *(T*)nullptr);
-#else
- : (throw bad_optional_access("bad optional access"), contained_val());
-#endif
- }
-
-# endif
-
-# if OPTIONAL_HAS_THIS_RVALUE_REFS == 1
-
- template <class V>
- constexpr T value_or(V&& v) const&
- {
- return *this ? **this : detail_::convert<T>(constexpr_forward<V>(v));
- }
-
-# if OPTIONAL_HAS_MOVE_ACCESSORS == 1
-
- template <class V>
- OPTIONAL_MUTABLE_CONSTEXPR T value_or(V&& v) &&
- {
- return *this ? constexpr_move(const_cast<optional<T>&>(*this).contained_val()) : detail_::convert<T>(constexpr_forward<V>(v));
- }
-
-# else
-
- template <class V>
- T value_or(V&& v) &&
- {
- return *this ? constexpr_move(const_cast<optional<T>&>(*this).contained_val()) : detail_::convert<T>(constexpr_forward<V>(v));
- }
-
-# endif
-
-# else
-
- template <class V>
- constexpr T value_or(V&& v) const
- {
- return *this ? **this : detail_::convert<T>(constexpr_forward<V>(v));
- }
-
-# endif
-
- };
-
-
- template <class T>
- class optional<T&>
- {
- static_assert(!::std::is_same<T, nullopt_t>::value, "bad T");
- static_assert(!::std::is_same<T, in_place_t>::value, "bad T");
- T* ref;
-
- public:
-
- // 20.5.5.1, construction/destruction
- constexpr optional() noexcept : ref(nullptr) {}
-
- constexpr optional(nullopt_t) noexcept : ref(nullptr) {}
-
- constexpr optional(T& v) noexcept : ref(detail_::static_addressof(v)) {}
-
- optional(T&&) = delete;
-
- constexpr optional(const optional& rhs) noexcept : ref(rhs.ref) {}
-
- explicit constexpr optional(in_place_t, T& v) noexcept : ref(detail_::static_addressof(v)) {}
-
- explicit optional(in_place_t, T&&) = delete;
-
- ~optional() = default;
-
- // 20.5.5.2, mutation
- optional& operator=(nullopt_t) noexcept {
- ref = nullptr;
- return *this;
- }
-
- // optional& operator=(const optional& rhs) noexcept {
- // ref = rhs.ref;
- // return *this;
- // }
-
- // optional& operator=(optional&& rhs) noexcept {
- // ref = rhs.ref;
- // return *this;
- // }
-
- template <typename U>
- auto operator=(U&& rhs) noexcept
- -> typename ::std::enable_if
- <
- ::std::is_same<typename ::std::decay<U>::type, optional<T&>>::value,
- optional&
- >::type
- {
- ref = rhs.ref;
- return *this;
- }
-
- template <typename U>
- auto operator=(U&& rhs) noexcept
- -> typename ::std::enable_if
- <
- !::std::is_same<typename ::std::decay<U>::type, optional<T&>>::value,
- optional&
- >::type
- = delete;
-
- void emplace(T& v) noexcept {
- ref = detail_::static_addressof(v);
- }
-
- void emplace(T&&) = delete;
-
-
- void swap(optional<T&>& rhs) noexcept
- {
- ::std::swap(ref, rhs.ref);
- }
-
- // 20.5.5.3, observers
- constexpr T* operator->() const {
- return TR2_OPTIONAL_ASSERTED_EXPRESSION(ref, ref);
- }
-
- constexpr T& operator*() const {
- return TR2_OPTIONAL_ASSERTED_EXPRESSION(ref, *ref);
- }
-
- constexpr T& value() const {
- return ref ?
- *ref
-#ifdef SOL_NO_EXCEPTIONS
- // we can't abort here
- // because there's no constexpr abort
- : *(T*)nullptr;
-#else
- : throw bad_optional_access("bad optional access");
-#endif
- }
-
- explicit constexpr operator bool() const noexcept {
- return ref != nullptr;
- }
-
- template <typename V>
- constexpr T& value_or(V&& v) const
- {
- return *this ? **this : detail_::convert<T&>(constexpr_forward<V>(v));
- }
- };
-
-
- template <class T>
- class optional<T&&>
- {
- static_assert(sizeof(T) == 0, "optional rvalue references disallowed");
- };
-
-
- // 20.5.8, Relational operators
- template <class T> constexpr bool operator==(const optional<T>& x, const optional<T>& y)
- {
- return bool(x) != bool(y) ? false : bool(x) == false ? true : *x == *y;
- }
-
- template <class T> constexpr bool operator!=(const optional<T>& x, const optional<T>& y)
- {
- return !(x == y);
- }
-
- template <class T> constexpr bool operator<(const optional<T>& x, const optional<T>& y)
- {
- return (!y) ? false : (!x) ? true : *x < *y;
- }
-
- template <class T> constexpr bool operator>(const optional<T>& x, const optional<T>& y)
- {
- return (y < x);
- }
-
- template <class T> constexpr bool operator<=(const optional<T>& x, const optional<T>& y)
- {
- return !(y < x);
- }
-
- template <class T> constexpr bool operator>=(const optional<T>& x, const optional<T>& y)
- {
- return !(x < y);
- }
-
-
- // 20.5.9, Comparison with nullopt
- template <class T> constexpr bool operator==(const optional<T>& x, nullopt_t) noexcept
- {
- return (!x);
- }
-
- template <class T> constexpr bool operator==(nullopt_t, const optional<T>& x) noexcept
- {
- return (!x);
- }
-
- template <class T> constexpr bool operator!=(const optional<T>& x, nullopt_t) noexcept
- {
- return bool(x);
- }
-
- template <class T> constexpr bool operator!=(nullopt_t, const optional<T>& x) noexcept
- {
- return bool(x);
- }
-
- template <class T> constexpr bool operator<(const optional<T>&, nullopt_t) noexcept
- {
- return false;
- }
-
- template <class T> constexpr bool operator<(nullopt_t, const optional<T>& x) noexcept
- {
- return bool(x);
- }
-
- template <class T> constexpr bool operator<=(const optional<T>& x, nullopt_t) noexcept
- {
- return (!x);
- }
-
- template <class T> constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept
- {
- return true;
- }
-
- template <class T> constexpr bool operator>(const optional<T>& x, nullopt_t) noexcept
- {
- return bool(x);
- }
-
- template <class T> constexpr bool operator>(nullopt_t, const optional<T>&) noexcept
- {
- return false;
- }
-
- template <class T> constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept
- {
- return true;
- }
-
- template <class T> constexpr bool operator>=(nullopt_t, const optional<T>& x) noexcept
- {
- return (!x);
- }
-
-
-
- // 20.5.10, Comparison with T
- template <class T> constexpr bool operator==(const optional<T>& x, const T& v)
- {
- return bool(x) ? *x == v : false;
- }
-
- template <class T> constexpr bool operator==(const T& v, const optional<T>& x)
- {
- return bool(x) ? v == *x : false;
- }
-
- template <class T> constexpr bool operator!=(const optional<T>& x, const T& v)
- {
- return bool(x) ? *x != v : true;
- }
-
- template <class T> constexpr bool operator!=(const T& v, const optional<T>& x)
- {
- return bool(x) ? v != *x : true;
- }
-
- template <class T> constexpr bool operator<(const optional<T>& x, const T& v)
- {
- return bool(x) ? *x < v : true;
- }
-
- template <class T> constexpr bool operator>(const T& v, const optional<T>& x)
- {
- return bool(x) ? v > *x : true;
- }
-
- template <class T> constexpr bool operator>(const optional<T>& x, const T& v)
- {
- return bool(x) ? *x > v : false;
- }
-
- template <class T> constexpr bool operator<(const T& v, const optional<T>& x)
- {
- return bool(x) ? v < *x : false;
- }
-
- template <class T> constexpr bool operator>=(const optional<T>& x, const T& v)
- {
- return bool(x) ? *x >= v : false;
- }
-
- template <class T> constexpr bool operator<=(const T& v, const optional<T>& x)
- {
- return bool(x) ? v <= *x : false;
- }
-
- template <class T> constexpr bool operator<=(const optional<T>& x, const T& v)
- {
- return bool(x) ? *x <= v : true;
- }
-
- template <class T> constexpr bool operator>=(const T& v, const optional<T>& x)
- {
- return bool(x) ? v >= *x : true;
- }
-
-
- // Comparison of optional<T&> with T
- template <class T> constexpr bool operator==(const optional<T&>& x, const T& v)
- {
- return bool(x) ? *x == v : false;
- }
-
- template <class T> constexpr bool operator==(const T& v, const optional<T&>& x)
- {
- return bool(x) ? v == *x : false;
- }
-
- template <class T> constexpr bool operator!=(const optional<T&>& x, const T& v)
- {
- return bool(x) ? *x != v : true;
- }
-
- template <class T> constexpr bool operator!=(const T& v, const optional<T&>& x)
- {
- return bool(x) ? v != *x : true;
- }
-
- template <class T> constexpr bool operator<(const optional<T&>& x, const T& v)
- {
- return bool(x) ? *x < v : true;
- }
-
- template <class T> constexpr bool operator>(const T& v, const optional<T&>& x)
- {
- return bool(x) ? v > *x : true;
- }
-
- template <class T> constexpr bool operator>(const optional<T&>& x, const T& v)
- {
- return bool(x) ? *x > v : false;
- }
-
- template <class T> constexpr bool operator<(const T& v, const optional<T&>& x)
- {
- return bool(x) ? v < *x : false;
- }
-
- template <class T> constexpr bool operator>=(const optional<T&>& x, const T& v)
- {
- return bool(x) ? *x >= v : false;
- }
-
- template <class T> constexpr bool operator<=(const T& v, const optional<T&>& x)
- {
- return bool(x) ? v <= *x : false;
- }
-
- template <class T> constexpr bool operator<=(const optional<T&>& x, const T& v)
- {
- return bool(x) ? *x <= v : true;
- }
-
- template <class T> constexpr bool operator>=(const T& v, const optional<T&>& x)
- {
- return bool(x) ? v >= *x : true;
- }
-
- // Comparison of optional<T const&> with T
- template <class T> constexpr bool operator==(const optional<const T&>& x, const T& v)
- {
- return bool(x) ? *x == v : false;
- }
-
- template <class T> constexpr bool operator==(const T& v, const optional<const T&>& x)
- {
- return bool(x) ? v == *x : false;
- }
-
- template <class T> constexpr bool operator!=(const optional<const T&>& x, const T& v)
- {
- return bool(x) ? *x != v : true;
- }
-
- template <class T> constexpr bool operator!=(const T& v, const optional<const T&>& x)
- {
- return bool(x) ? v != *x : true;
- }
-
- template <class T> constexpr bool operator<(const optional<const T&>& x, const T& v)
- {
- return bool(x) ? *x < v : true;
- }
-
- template <class T> constexpr bool operator>(const T& v, const optional<const T&>& x)
- {
- return bool(x) ? v > *x : true;
- }
-
- template <class T> constexpr bool operator>(const optional<const T&>& x, const T& v)
- {
- return bool(x) ? *x > v : false;
- }
-
- template <class T> constexpr bool operator<(const T& v, const optional<const T&>& x)
- {
- return bool(x) ? v < *x : false;
- }
-
- template <class T> constexpr bool operator>=(const optional<const T&>& x, const T& v)
- {
- return bool(x) ? *x >= v : false;
- }
-
- template <class T> constexpr bool operator<=(const T& v, const optional<const T&>& x)
- {
- return bool(x) ? v <= *x : false;
- }
-
- template <class T> constexpr bool operator<=(const optional<const T&>& x, const T& v)
- {
- return bool(x) ? *x <= v : true;
- }
-
- template <class T> constexpr bool operator>=(const T& v, const optional<const T&>& x)
- {
- return bool(x) ? v >= *x : true;
- }
-
-
- // 20.5.12, Specialized algorithms
- template <class T>
- void swap(optional<T>& x, optional<T>& y) noexcept(noexcept(x.swap(y))) {
- x.swap(y);
- }
-
-
- template <class T>
- constexpr optional<typename ::std::decay<T>::type> make_optional(T&& v) {
- return optional<typename ::std::decay<T>::type>(constexpr_forward<T>(v));
- }
-
- template <class X>
- constexpr optional<X&> make_optional(::std::reference_wrapper<X> v) {
- return optional<X&>(v.get());
- }
-
-
-} // namespace
-
-namespace std
-{
- template <typename T>
- struct hash<sol::optional<T>> {
- typedef typename hash<T>::result_type result_type;
- typedef sol::optional<T> argument_type;
-
- constexpr result_type operator()(argument_type const& arg) const {
- return arg ? ::std::hash<T>{}(*arg) : result_type{};
- }
- };
-
- template <typename T>
- struct hash<sol::optional<T&>> {
- typedef typename hash<T>::result_type result_type;
- typedef sol::optional<T&> argument_type;
-
- constexpr result_type operator()(argument_type const& arg) const {
- return arg ? ::std::hash<T>{}(*arg) : result_type{};
- }
- };
-}
-
-# if defined TR2_OPTIONAL_MSVC_2015_AND_HIGHER___
-#pragma warning( pop )
-#endif
-
-
-# undef TR2_OPTIONAL_REQUIRES
-# undef TR2_OPTIONAL_ASSERTED_EXPRESSION
-
-# endif // SOL_OPTIONAL_IMPLEMENTATION_HPP
diff --git a/3rdparty/sol2/sol/overload.hpp b/3rdparty/sol2/sol/overload.hpp
deleted file mode 100644
index 316a3322ba3..00000000000
--- a/3rdparty/sol2/sol/overload.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_OVERLOAD_HPP
-#define SOL_OVERLOAD_HPP
-
-#include <utility>
-
-namespace sol {
- template <typename... Functions>
- struct overload_set {
- std::tuple<Functions...> functions;
- template <typename Arg, typename... Args, meta::disable<std::is_same<overload_set, meta::unqualified_t<Arg>>> = meta::enabler>
- overload_set (Arg&& arg, Args&&... args) : functions(std::forward<Arg>(arg), std::forward<Args>(args)...) {}
- overload_set(const overload_set&) = default;
- overload_set(overload_set&&) = default;
- overload_set& operator=(const overload_set&) = default;
- overload_set& operator=(overload_set&&) = default;
- };
-
- template <typename... Args>
- decltype(auto) overload(Args&&... args) {
- return overload_set<std::decay_t<Args>...>(std::forward<Args>(args)...);
- }
-}
-
-#endif // SOL_OVERLOAD_HPP \ No newline at end of file
diff --git a/3rdparty/sol2/sol/property.hpp b/3rdparty/sol2/sol/property.hpp
deleted file mode 100644
index 703cac925d2..00000000000
--- a/3rdparty/sol2/sol/property.hpp
+++ /dev/null
@@ -1,105 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_PROPERTY_HPP
-#define SOL_PROPERTY_HPP
-
-namespace sol {
-
- struct no_prop { };
-
- template <typename R, typename W>
- struct property_wrapper {
- typedef std::integral_constant<bool, !std::is_void<R>::value> can_read;
- typedef std::integral_constant<bool, !std::is_void<W>::value> can_write;
- typedef std::conditional_t<can_read::value, R, no_prop> Read;
- typedef std::conditional_t<can_write::value, W, no_prop> Write;
- Read read;
- Write write;
-
- template <typename Rx, typename Wx>
- property_wrapper(Rx&& r, Wx&& w) : read(std::forward<Rx>(r)), write(std::forward<Wx>(w)) {}
- };
-
- namespace property_detail {
- template <typename R, typename W>
- inline decltype(auto) property(std::true_type, R&& read, W&& write) {
- return property_wrapper<std::decay_t<R>, std::decay_t<W>>(std::forward<R>(read), std::forward<W>(write));
- }
- template <typename W, typename R>
- inline decltype(auto) property(std::false_type, W&& write, R&& read) {
- return property_wrapper<std::decay_t<R>, std::decay_t<W>>(std::forward<R>(read), std::forward<W>(write));
- }
- template <typename R>
- inline decltype(auto) property(std::true_type, R&& read) {
- return property_wrapper<std::decay_t<R>, void>(std::forward<R>(read), no_prop());
- }
- template <typename W>
- inline decltype(auto) property(std::false_type, W&& write) {
- return property_wrapper<void, std::decay_t<W>>(no_prop(), std::forward<W>(write));
- }
- } // property_detail
-
- template <typename F, typename G>
- inline decltype(auto) property(F&& f, G&& g) {
- typedef lua_bind_traits<meta::unqualified_t<F>> left_traits;
- typedef lua_bind_traits<meta::unqualified_t<G>> right_traits;
- return property_detail::property(meta::boolean<(left_traits::free_arity < right_traits::free_arity)>(), std::forward<F>(f), std::forward<G>(g));
- }
-
- template <typename F>
- inline decltype(auto) property(F&& f) {
- typedef lua_bind_traits<meta::unqualified_t<F>> left_traits;
- return property_detail::property(meta::boolean<(left_traits::free_arity < 2)>(), std::forward<F>(f));
- }
-
- template <typename F>
- inline decltype(auto) readonly_property(F&& f) {
- return property_detail::property(std::true_type(), std::forward<F>(f));
- }
-
- // Allow someone to make a member variable readonly (const)
- template <typename R, typename T>
- inline auto readonly(R T::* v) {
- typedef const R C;
- return static_cast<C T::*>(v);
- }
-
- template <typename T>
- struct var_wrapper {
- T value;
- template <typename... Args>
- var_wrapper(Args&&... args) : value(std::forward<Args>(args)...) {}
- var_wrapper(const var_wrapper&) = default;
- var_wrapper(var_wrapper&&) = default;
- var_wrapper& operator=(const var_wrapper&) = default;
- var_wrapper& operator=(var_wrapper&&) = default;
- };
-
- template <typename V>
- inline auto var(V&& v) {
- typedef meta::unqualified_t<V> T;
- return var_wrapper<T>(std::forward<V>(v));
- }
-
-} // sol
-
-#endif // SOL_PROPERTY_HPP
diff --git a/3rdparty/sol2/sol/protected_function.hpp b/3rdparty/sol2/sol/protected_function.hpp
deleted file mode 100644
index 0f188a1a677..00000000000
--- a/3rdparty/sol2/sol/protected_function.hpp
+++ /dev/null
@@ -1,198 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_PROTECTED_FUNCTION_HPP
-#define SOL_PROTECTED_FUNCTION_HPP
-
-#include "reference.hpp"
-#include "stack.hpp"
-#include "protected_function_result.hpp"
-#include <cstdint>
-#include <algorithm>
-
-namespace sol {
- namespace detail {
- inline reference& handler_storage() {
- static sol::reference h;
- return h;
- }
-
- struct handler {
- const reference& target;
- int stackindex;
- handler(const reference& target) : target(target), stackindex(0) {
- if (target.valid()) {
- stackindex = lua_gettop(target.lua_state()) + 1;
- target.push();
- }
- }
- bool valid() const { return stackindex != 0; }
- ~handler() {
- if (valid()) {
- lua_remove(target.lua_state(), stackindex);
- }
- }
- };
- }
-
- template <typename base_t>
- class basic_protected_function : public base_t {
- public:
- static reference& get_default_handler() {
- return detail::handler_storage();
- }
-
- static void set_default_handler(const reference& ref) {
- detail::handler_storage() = ref;
- }
-
- static void set_default_handler(reference&& ref) {
- detail::handler_storage() = std::move(ref);
- }
-
- private:
- call_status luacall(std::ptrdiff_t argcount, std::ptrdiff_t resultcount, detail::handler& h) const {
- return static_cast<call_status>(lua_pcallk(base_t::lua_state(), static_cast<int>(argcount), static_cast<int>(resultcount), h.stackindex, 0, nullptr));
- }
-
- template<std::size_t... I, typename... Ret>
- auto invoke(types<Ret...>, std::index_sequence<I...>, std::ptrdiff_t n, detail::handler& h) const {
- luacall(n, sizeof...(Ret), h);
- return stack::pop<std::tuple<Ret...>>(base_t::lua_state());
- }
-
- template<std::size_t I, typename Ret>
- Ret invoke(types<Ret>, std::index_sequence<I>, std::ptrdiff_t n, detail::handler& h) const {
- luacall(n, 1, h);
- return stack::pop<Ret>(base_t::lua_state());
- }
-
- template <std::size_t I>
- void invoke(types<void>, std::index_sequence<I>, std::ptrdiff_t n, detail::handler& h) const {
- luacall(n, 0, h);
- }
-
- protected_function_result invoke(types<>, std::index_sequence<>, std::ptrdiff_t n, detail::handler& h) const {
- int stacksize = lua_gettop(base_t::lua_state());
- int poststacksize = stacksize;
- int firstreturn = 1;
- int returncount = 0;
- call_status code = call_status::ok;
-#ifndef SOL_NO_EXCEPTIONS
- auto onexcept = [&](const char* error) {
- h.stackindex = 0;
- if (h.target.valid()) {
- h.target.push();
- stack::push(base_t::lua_state(), error);
- lua_call(base_t::lua_state(), 1, 1);
- }
- else {
- stack::push(base_t::lua_state(), error);
- }
- };
- try {
-#endif // No Exceptions
- firstreturn = (std::max)(1, static_cast<int>(stacksize - n - static_cast<int>(h.valid())));
- code = luacall(n, LUA_MULTRET, h);
- poststacksize = lua_gettop(base_t::lua_state()) - static_cast<int>(h.valid());
- returncount = poststacksize - (firstreturn - 1);
-#ifndef SOL_NO_EXCEPTIONS
- }
- // Handle C++ errors thrown from C++ functions bound inside of lua
- catch (const char* error) {
- onexcept(error);
- firstreturn = lua_gettop(base_t::lua_state());
- return protected_function_result(base_t::lua_state(), firstreturn, 0, 1, call_status::runtime);
- }
- catch (const std::exception& error) {
- onexcept(error.what());
- firstreturn = lua_gettop(base_t::lua_state());
- return protected_function_result(base_t::lua_state(), firstreturn, 0, 1, call_status::runtime);
- }
- catch (...) {
- onexcept("caught (...) unknown error during protected_function call");
- firstreturn = lua_gettop(base_t::lua_state());
- return protected_function_result(base_t::lua_state(), firstreturn, 0, 1, call_status::runtime);
- }
-#endif // No Exceptions
- return protected_function_result(base_t::lua_state(), firstreturn, returncount, returncount, code);
- }
-
- public:
- reference error_handler;
-
- basic_protected_function() = default;
- template <typename T, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_protected_function>>, meta::neg<std::is_same<base_t, stack_reference>>, std::is_base_of<base_t, meta::unqualified_t<T>>> = meta::enabler>
- basic_protected_function(T&& r) noexcept : base_t(std::forward<T>(r)) {
-#ifdef SOL_CHECK_ARGUMENTS
- if (!is_function<meta::unqualified_t<T>>::value) {
- auto pp = stack::push_pop(*this);
- stack::check<basic_protected_function>(base_t::lua_state(), -1, type_panic);
- }
-#endif // Safety
- }
- basic_protected_function(const basic_protected_function&) = default;
- basic_protected_function& operator=(const basic_protected_function&) = default;
- basic_protected_function(basic_protected_function&&) = default;
- basic_protected_function& operator=(basic_protected_function&&) = default;
- basic_protected_function(const basic_function<base_t>& b, reference eh = get_default_handler()) : base_t(b), error_handler(std::move(eh)) {}
- basic_protected_function(basic_function<base_t>&& b, reference eh = get_default_handler()) : base_t(std::move(b)), error_handler(std::move(eh)) {}
- basic_protected_function(const stack_reference& r, reference eh = get_default_handler()) : basic_protected_function(r.lua_state(), r.stack_index(), std::move(eh)) {}
- basic_protected_function(stack_reference&& r, reference eh = get_default_handler()) : basic_protected_function(r.lua_state(), r.stack_index(), std::move(eh)) {}
- template <typename Super>
- basic_protected_function(proxy_base<Super>&& p, reference eh = get_default_handler()) : basic_protected_function(p.operator basic_function<base_t>(), std::move(eh)) {}
- template <typename Super>
- basic_protected_function(const proxy_base<Super>& p, reference eh = get_default_handler()) : basic_protected_function(static_cast<basic_function<base_t>>(p), std::move(eh)) {}
- template <typename T, meta::enable<meta::neg<std::is_integral<meta::unqualified_t<T>>>, meta::neg<std::is_same<T, ref_index>>> = meta::enabler>
- basic_protected_function(lua_State* L, T&& r, reference eh) : basic_protected_function(L, sol::ref_index(r.registry_index()), std::move(eh)) {}
- basic_protected_function(lua_State* L, int index = -1, reference eh = get_default_handler()) : base_t(L, index), error_handler(std::move(eh)) {
-#ifdef SOL_CHECK_ARGUMENTS
- stack::check<basic_protected_function>(L, index, type_panic);
-#endif // Safety
- }
- basic_protected_function(lua_State* L, ref_index index, reference eh = get_default_handler()) : base_t(L, index), error_handler(std::move(eh)) {
-#ifdef SOL_CHECK_ARGUMENTS
- auto pp = stack::push_pop(*this);
- stack::check<basic_protected_function>(L, -1, type_panic);
-#endif // Safety
- }
-
- template<typename... Args>
- protected_function_result operator()(Args&&... args) const {
- return call<>(std::forward<Args>(args)...);
- }
-
- template<typename... Ret, typename... Args>
- decltype(auto) operator()(types<Ret...>, Args&&... args) const {
- return call<Ret...>(std::forward<Args>(args)...);
- }
-
- template<typename... Ret, typename... Args>
- decltype(auto) call(Args&&... args) const {
- detail::handler h(error_handler);
- base_t::push();
- int pushcount = stack::multi_push_reference(base_t::lua_state(), std::forward<Args>(args)...);
- return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), pushcount, h);
- }
- };
-} // sol
-
-#endif // SOL_FUNCTION_HPP
diff --git a/3rdparty/sol2/sol/protected_function_result.hpp b/3rdparty/sol2/sol/protected_function_result.hpp
deleted file mode 100644
index 9fce575389a..00000000000
--- a/3rdparty/sol2/sol/protected_function_result.hpp
+++ /dev/null
@@ -1,130 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_PROTECTED_FUNCTION_RESULT_HPP
-#define SOL_PROTECTED_FUNCTION_RESULT_HPP
-
-#include "reference.hpp"
-#include "tuple.hpp"
-#include "stack.hpp"
-#include "proxy_base.hpp"
-#include <cstdint>
-
-namespace sol {
- struct protected_function_result : public proxy_base<protected_function_result> {
- private:
- lua_State* L;
- int index;
- int returncount;
- int popcount;
- call_status err;
-
- template <typename T>
- decltype(auto) tagged_get(types<sol::optional<T>>) const {
- if (!valid()) {
- return sol::optional<T>(nullopt);
- }
- return stack::get<sol::optional<T>>(L, index);
- }
-
- template <typename T>
- decltype(auto) tagged_get(types<T>) const {
-#ifdef SOL_CHECK_ARGUMENTS
- if (!valid()) {
- type_panic(L, index, type_of(L, index), type::none);
- }
-#endif // Check Argument Safety
- return stack::get<T>(L, index);
- }
-
- optional<error> tagged_get(types<optional<error>>) const {
- if (valid()) {
- return nullopt;
- }
- return error(detail::direct_error, stack::get<std::string>(L, index));
- }
-
- error tagged_get(types<error>) const {
-#ifdef SOL_CHECK_ARGUMENTS
- if (valid()) {
- type_panic(L, index, type_of(L, index), type::none);
- }
-#endif // Check Argument Safety
- return error(detail::direct_error, stack::get<std::string>(L, index));
- }
-
- public:
- protected_function_result() = default;
- 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) {
-
- }
- protected_function_result(const protected_function_result&) = default;
- protected_function_result& operator=(const protected_function_result&) = default;
- protected_function_result(protected_function_result&& o) noexcept : L(o.L), index(o.index), returncount(o.returncount), popcount(o.popcount), err(o.err) {
- // Must be manual, otherwise destructor will screw us
- // return count being 0 is enough to keep things clean
- // but we will be thorough
- o.L = nullptr;
- o.index = 0;
- o.returncount = 0;
- o.popcount = 0;
- o.err = call_status::runtime;
- }
- protected_function_result& operator=(protected_function_result&& o) noexcept {
- L = o.L;
- index = o.index;
- returncount = o.returncount;
- popcount = o.popcount;
- err = o.err;
- // Must be manual, otherwise destructor will screw us
- // return count being 0 is enough to keep things clean
- // but we will be thorough
- o.L = nullptr;
- o.index = 0;
- o.returncount = 0;
- o.popcount = 0;
- o.err = call_status::runtime;
- return *this;
- }
-
- call_status status() const noexcept {
- return err;
- }
-
- bool valid() const noexcept {
- return status() == call_status::ok || status() == call_status::yielded;
- }
-
- template<typename T>
- decltype(auto) get() const {
- return tagged_get(types<meta::unqualified_t<T>>());
- }
-
- lua_State* lua_state() const noexcept { return L; };
- int stack_index() const noexcept { return index; };
-
- ~protected_function_result() {
- stack::remove(L, index, popcount);
- }
- };
-} // sol
-
-#endif // SOL_PROTECTED_FUNCTION_RESULT_HPP
diff --git a/3rdparty/sol2/sol/proxy.hpp b/3rdparty/sol2/sol/proxy.hpp
deleted file mode 100644
index 5cd8b5e1fc9..00000000000
--- a/3rdparty/sol2/sol/proxy.hpp
+++ /dev/null
@@ -1,179 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_PROXY_HPP
-#define SOL_PROXY_HPP
-
-#include "traits.hpp"
-#include "object.hpp"
-#include "function.hpp"
-#include "protected_function.hpp"
-#include "proxy_base.hpp"
-
-namespace sol {
- template<typename Table, typename Key>
- struct proxy : public proxy_base<proxy<Table, Key>> {
- private:
- typedef meta::condition<meta::is_specialization_of<std::tuple, Key>, Key, std::tuple<meta::condition<std::is_array<meta::unqualified_t<Key>>, Key&, meta::unqualified_t<Key>>>> key_type;
-
- template<typename T, std::size_t... I>
- decltype(auto) tuple_get(std::index_sequence<I...>) const {
- return tbl.template traverse_get<T>(std::get<I>(key)...);
- }
-
- template<std::size_t... I, typename T>
- void tuple_set(std::index_sequence<I...>, T&& value) {
- tbl.traverse_set(std::get<I>(key)..., std::forward<T>(value));
- }
-
- public:
- Table tbl;
- key_type key;
-
- template<typename T>
- proxy(Table table, T&& k) : tbl(table), key(std::forward<T>(k)) {}
-
- template<typename T>
- proxy& set(T&& item) {
- tuple_set(std::make_index_sequence<std::tuple_size<meta::unqualified_t<key_type>>::value>(), std::forward<T>(item));
- return *this;
- }
-
- template<typename... Args>
- proxy& set_function(Args&&... args) {
- tbl.set_function(key, std::forward<Args>(args)...);
- return *this;
- }
-
- template<typename U, meta::enable<meta::neg<is_lua_reference<meta::unwrap_unqualified_t<U>>>, meta::is_callable<meta::unwrap_unqualified_t<U>>> = meta::enabler>
- proxy& operator=(U&& other) {
- return set_function(std::forward<U>(other));
- }
-
- template<typename U, meta::disable<meta::neg<is_lua_reference<meta::unwrap_unqualified_t<U>>>, meta::is_callable<meta::unwrap_unqualified_t<U>>> = meta::enabler>
- proxy& operator=(U&& other) {
- return set(std::forward<U>(other));
- }
-
- template<typename T>
- decltype(auto) get() const {
- return tuple_get<T>(std::make_index_sequence<std::tuple_size<meta::unqualified_t<key_type>>::value>());
- }
-
- template<typename T>
- decltype(auto) get_or(T&& otherwise) const {
- typedef decltype(get<T>()) U;
- sol::optional<U> option = get<sol::optional<U>>();
- if (option) {
- return static_cast<U>(option.value());
- }
- return static_cast<U>(std::forward<T>(otherwise));
- }
-
- template<typename T, typename D>
- decltype(auto) get_or(D&& otherwise) const {
- sol::optional<T> option = get<sol::optional<T>>();
- if (option) {
- return static_cast<T>(option.value());
- }
- return static_cast<T>(std::forward<D>(otherwise));
- }
-
- template <typename K>
- decltype(auto) operator[](K&& k) const {
- auto keys = meta::tuplefy(key, std::forward<K>(k));
- return proxy<Table, decltype(keys)>(tbl, std::move(keys));
- }
-
- template<typename... Ret, typename... Args>
- decltype(auto) call(Args&&... args) {
- return get<function>().template call<Ret...>(std::forward<Args>(args)...);
- }
-
- template<typename... Args>
- decltype(auto) operator()(Args&&... args) {
- return call<>(std::forward<Args>(args)...);
- }
-
- bool valid() const {
- auto pp = stack::push_pop(tbl);
- auto p = stack::probe_get_field<std::is_same<meta::unqualified_t<Table>, global_table>::value>(tbl.lua_state(), key, lua_gettop(tbl.lua_state()));
- lua_pop(tbl.lua_state(), p.levels);
- return p;
- }
- };
-
- template<typename Table, typename Key, typename T>
- inline bool operator==(T&& left, const proxy<Table, Key>& right) {
- typedef decltype(stack::get<T>(nullptr, 0)) U;
- return right.template get<optional<U>>() == left;
- }
-
- template<typename Table, typename Key, typename T>
- inline bool operator==(const proxy<Table, Key>& right, T&& left) {
- typedef decltype(stack::get<T>(nullptr, 0)) U;
- return right.template get<optional<U>>() == left;
- }
-
- template<typename Table, typename Key, typename T>
- inline bool operator!=(T&& left, const proxy<Table, Key>& right) {
- typedef decltype(stack::get<T>(nullptr, 0)) U;
- return right.template get<optional<U>>() == left;
- }
-
- template<typename Table, typename Key, typename T>
- inline bool operator!=(const proxy<Table, Key>& right, T&& left) {
- typedef decltype(stack::get<T>(nullptr, 0)) U;
- return right.template get<optional<U>>() == left;
- }
-
- template<typename Table, typename Key>
- inline bool operator==(lua_nil_t, const proxy<Table, Key>& right) {
- return !right.valid();
- }
-
- template<typename Table, typename Key>
- inline bool operator==(const proxy<Table, Key>& right, lua_nil_t) {
- return !right.valid();
- }
-
- template<typename Table, typename Key>
- inline bool operator!=(lua_nil_t, const proxy<Table, Key>& right) {
- return right.valid();
- }
-
- template<typename Table, typename Key>
- inline bool operator!=(const proxy<Table, Key>& right, lua_nil_t) {
- return right.valid();
- }
-
- namespace stack {
- template <typename Table, typename Key>
- struct pusher<proxy<Table, Key>> {
- static int push(lua_State* L, const proxy<Table, Key>& p) {
- sol::reference r = p;
- return r.push(L);
- }
- };
- } // stack
-} // sol
-
-#endif // SOL_PROXY_HPP
diff --git a/3rdparty/sol2/sol/proxy_base.hpp b/3rdparty/sol2/sol/proxy_base.hpp
deleted file mode 100644
index 959f6e6b281..00000000000
--- a/3rdparty/sol2/sol/proxy_base.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_PROXY_BASE_HPP
-#define SOL_PROXY_BASE_HPP
-
-#include "reference.hpp"
-#include "tuple.hpp"
-#include "stack.hpp"
-
-namespace sol {
- template <typename Super>
- struct proxy_base {
- operator std::string() const {
- const Super& super = *static_cast<const Super*>(static_cast<const void*>(this));
- return super.template get<std::string>();
- }
-
- template<typename T, meta::enable<meta::neg<meta::is_string_constructible<T>>, is_proxy_primitive<meta::unqualified_t<T>>> = meta::enabler>
- operator T () const {
- const Super& super = *static_cast<const Super*>(static_cast<const void*>(this));
- return super.template get<T>();
- }
-
- template<typename T, meta::enable<meta::neg<meta::is_string_constructible<T>>, meta::neg<is_proxy_primitive<meta::unqualified_t<T>>>> = meta::enabler>
- operator T& () const {
- const Super& super = *static_cast<const Super*>(static_cast<const void*>(this));
- return super.template get<T&>();
- }
- };
-} // sol
-
-#endif // SOL_PROXY_BASE_HPP
diff --git a/3rdparty/sol2/sol/raii.hpp b/3rdparty/sol2/sol/raii.hpp
deleted file mode 100644
index c7b20a69613..00000000000
--- a/3rdparty/sol2/sol/raii.hpp
+++ /dev/null
@@ -1,132 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_RAII_HPP
-#define SOL_RAII_HPP
-
-#include <memory>
-#include "traits.hpp"
-
-namespace sol {
- namespace detail {
- struct default_construct {
- template<typename T, typename... Args>
- static void construct(T&& obj, Args&&... args) {
- std::allocator<meta::unqualified_t<T>> alloc{};
- alloc.construct(obj, std::forward<Args>(args)...);
- }
-
- template<typename T, typename... Args>
- void operator()(T&& obj, Args&&... args) const {
- construct(std::forward<T>(obj), std::forward<Args>(args)...);
- }
- };
-
- struct default_destruct {
- template<typename T>
- static void destroy(T&& obj) {
- std::allocator<meta::unqualified_t<T>> alloc{};
- alloc.destroy(obj);
- }
-
- template<typename T>
- void operator()(T&& obj) const {
- destroy(std::forward<T>(obj));
- }
- };
-
- struct deleter {
- template <typename T>
- void operator()(T* p) const {
- delete p;
- }
- };
-
- template <typename T, typename Dx, typename... Args>
- inline std::unique_ptr<T, Dx> make_unique_deleter(Args&&... args) {
- return std::unique_ptr<T, Dx>(new T(std::forward<Args>(args)...));
- }
-
- template <typename Tag, typename T>
- struct tagged {
- T value;
- template <typename Arg, typename... Args, meta::disable<std::is_same<meta::unqualified_t<Arg>, tagged>> = meta::enabler>
- tagged(Arg&& arg, Args&&... args) : value(std::forward<Arg>(arg), std::forward<Args>(args)...) {}
- };
- } // detail
-
- template <typename... Args>
- struct constructor_list {};
-
- template<typename... Args>
- using constructors = constructor_list<Args...>;
-
- const auto default_constructor = constructors<types<>>{};
-
- struct no_construction {};
- const auto no_constructor = no_construction{};
-
- struct call_construction {};
- const auto call_constructor = call_construction{};
-
- template <typename... Functions>
- struct constructor_wrapper {
- std::tuple<Functions...> functions;
- template <typename Arg, typename... Args, meta::disable<std::is_same<meta::unqualified_t<Arg>, constructor_wrapper>> = meta::enabler>
- constructor_wrapper(Arg&& arg, Args&&... args) : functions(std::forward<Arg>(arg), std::forward<Args>(args)...) {}
- };
-
- template <typename... Functions>
- inline auto initializers(Functions&&... functions) {
- return constructor_wrapper<std::decay_t<Functions>...>(std::forward<Functions>(functions)...);
- }
-
- template <typename... Functions>
- struct factory_wrapper {
- std::tuple<Functions...> functions;
- template <typename Arg, typename... Args, meta::disable<std::is_same<meta::unqualified_t<Arg>, factory_wrapper>> = meta::enabler>
- factory_wrapper(Arg&& arg, Args&&... args) : functions(std::forward<Arg>(arg), std::forward<Args>(args)...) {}
- };
-
- template <typename... Functions>
- inline auto factories(Functions&&... functions) {
- return factory_wrapper<std::decay_t<Functions>...>(std::forward<Functions>(functions)...);
- }
-
- template <typename Function>
- struct destructor_wrapper {
- Function fx;
- destructor_wrapper(Function f) : fx(std::move(f)) {}
- };
-
- template <>
- struct destructor_wrapper<void> {};
-
- const destructor_wrapper<void> default_destructor{};
-
- template <typename Fx>
- inline auto destructor(Fx&& fx) {
- return destructor_wrapper<std::decay_t<Fx>>(std::forward<Fx>(fx));
- }
-
-} // sol
-
-#endif // SOL_RAII_HPP
diff --git a/3rdparty/sol2/sol/reference.hpp b/3rdparty/sol2/sol/reference.hpp
deleted file mode 100644
index a5f3ebe45b1..00000000000
--- a/3rdparty/sol2/sol/reference.hpp
+++ /dev/null
@@ -1,191 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_REFERENCE_HPP
-#define SOL_REFERENCE_HPP
-
-#include "types.hpp"
-#include "stack_reference.hpp"
-
-namespace sol {
- namespace stack {
- template <bool top_level>
- struct push_popper_n {
- lua_State* L;
- int t;
- push_popper_n(lua_State* luastate, int x) : L(luastate), t(x) { }
- ~push_popper_n() { lua_pop(L, t); }
- };
- template <>
- struct push_popper_n<true> {
- push_popper_n(lua_State*, int) { }
- };
- template <bool top_level, typename T>
- struct push_popper {
- T t;
- push_popper(T x) : t(x) { t.push(); }
- ~push_popper() { t.pop(); }
- };
- template <typename T>
- struct push_popper<true, T> {
- push_popper(T) {}
- ~push_popper() {}
- };
- template <bool top_level = false, typename T>
- push_popper<top_level, T> push_pop(T&& x) {
- return push_popper<top_level, T>(std::forward<T>(x));
- }
- template <bool top_level = false>
- push_popper_n<top_level> pop_n(lua_State* L, int x) {
- return push_popper_n<top_level>(L, x);
- }
- } // stack
-
- namespace detail {
- struct global_tag { } const global_{};
- } // detail
-
- class reference {
- private:
- lua_State* luastate = nullptr; // non-owning
- int ref = LUA_NOREF;
-
- int copy() const noexcept {
- if (ref == LUA_NOREF)
- return LUA_NOREF;
- push();
- return luaL_ref(lua_state(), LUA_REGISTRYINDEX);
- }
-
- protected:
- reference(lua_State* L, detail::global_tag) noexcept : luastate(L) {
- lua_pushglobaltable(lua_state());
- ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
- }
-
- int stack_index() const noexcept {
- return -1;
- }
-
- void deref() const noexcept {
- luaL_unref(lua_state(), LUA_REGISTRYINDEX, ref);
- }
-
- public:
- reference() noexcept = default;
- reference(lua_nil_t) noexcept : reference() {}
- reference(const stack_reference& r) noexcept : reference(r.lua_state(), r.stack_index()) {}
- reference(stack_reference&& r) noexcept : reference(r.lua_state(), r.stack_index()) {}
- reference(lua_State* L, int index = -1) noexcept : luastate(L) {
- lua_pushvalue(lua_state(), index);
- ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
- }
- reference(lua_State* L, ref_index index) noexcept : luastate(L) {
- lua_rawgeti(L, LUA_REGISTRYINDEX, index.index);
- ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
- }
-
- ~reference() noexcept {
- deref();
- }
-
- reference(reference&& o) noexcept {
- luastate = o.luastate;
- ref = o.ref;
-
- o.luastate = nullptr;
- o.ref = LUA_NOREF;
- }
-
- reference& operator=(reference&& o) noexcept {
- luastate = o.luastate;
- ref = o.ref;
-
- o.luastate = nullptr;
- o.ref = LUA_NOREF;
-
- return *this;
- }
-
- reference(const reference& o) noexcept {
- luastate = o.luastate;
- ref = o.copy();
- }
-
- reference& operator=(const reference& o) noexcept {
- luastate = o.luastate;
- deref();
- ref = o.copy();
- return *this;
- }
-
- int push() const noexcept {
- return push(lua_state());
- }
-
- int push(lua_State* Ls) const noexcept {
- lua_rawgeti(Ls, LUA_REGISTRYINDEX, ref);
- return 1;
- }
-
- void pop() const noexcept {
- pop(lua_state());
- }
-
- void pop(lua_State* Ls, int n = 1) const noexcept {
- lua_pop(Ls, n);
- }
-
- int registry_index() const noexcept {
- return ref;
- }
-
- bool valid() const noexcept {
- return !(ref == LUA_NOREF || ref == LUA_REFNIL);
- }
-
- explicit operator bool() const noexcept {
- return valid();
- }
-
- type get_type() const noexcept {
- auto pp = stack::push_pop(*this);
- int result = lua_type(lua_state(), -1);
- return static_cast<type>(result);
- }
-
- lua_State* lua_state() const noexcept {
- return luastate;
- }
- };
-
- inline bool operator== (const reference& l, const reference& r) {
- auto ppl = stack::push_pop(l);
- auto ppr = stack::push_pop(r);
- return lua_compare(l.lua_state(), -1, -2, LUA_OPEQ) == 1;
- }
-
- inline bool operator!= (const reference& l, const reference& r) {
- return !operator==(l, r);
- }
-} // sol
-
-#endif // SOL_REFERENCE_HPP
diff --git a/3rdparty/sol2/sol/resolve.hpp b/3rdparty/sol2/sol/resolve.hpp
deleted file mode 100644
index acd372dd772..00000000000
--- a/3rdparty/sol2/sol/resolve.hpp
+++ /dev/null
@@ -1,173 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_RESOLVE_HPP
-#define SOL_RESOLVE_HPP
-
-#include "traits.hpp"
-#include "tuple.hpp"
-
-namespace sol {
-
-#ifndef __clang__
- // constexpr is fine for not-clang
-
- namespace detail {
- template<typename R, typename... Args, typename F, typename = std::result_of_t<meta::unqualified_t<F>(Args...)>>
- inline constexpr auto resolve_i(types<R(Args...)>, F&&)->R(meta::unqualified_t<F>::*)(Args...) {
- using Sig = R(Args...);
- typedef meta::unqualified_t<F> Fu;
- return static_cast<Sig Fu::*>(&Fu::operator());
- }
-
- template<typename F, typename U = meta::unqualified_t<F>>
- inline constexpr auto resolve_f(std::true_type, F&& f)
- -> decltype(resolve_i(types<meta::function_signature_t<decltype(&U::operator())>>(), std::forward<F>(f))) {
- return resolve_i(types<meta::function_signature_t<decltype(&U::operator())>>(), std::forward<F>(f));
- }
-
- template<typename F>
- inline constexpr void resolve_f(std::false_type, F&&) {
- static_assert(meta::has_deducible_signature<F>::value,
- "Cannot use no-template-parameter call with an overloaded functor: specify the signature");
- }
-
- template<typename F, typename U = meta::unqualified_t<F>>
- inline constexpr auto resolve_i(types<>, F&& f) -> decltype(resolve_f(meta::has_deducible_signature<U>(), std::forward<F>(f))) {
- return resolve_f(meta::has_deducible_signature<U> {}, std::forward<F>(f));
- }
-
- template<typename... Args, typename F, typename R = std::result_of_t<F&(Args...)>>
- inline constexpr auto resolve_i(types<Args...>, F&& f) -> decltype(resolve_i(types<R(Args...)>(), std::forward<F>(f))) {
- return resolve_i(types<R(Args...)>(), std::forward<F>(f));
- }
-
- template<typename Sig, typename C>
- inline constexpr Sig C::* resolve_v(std::false_type, Sig C::* mem_func_ptr) {
- return mem_func_ptr;
- }
-
- template<typename Sig, typename C>
- inline constexpr Sig C::* resolve_v(std::true_type, Sig C::* mem_variable_ptr) {
- return mem_variable_ptr;
- }
- } // detail
-
- template<typename... Args, typename R>
- inline constexpr auto resolve(R fun_ptr(Args...))->R(*)(Args...) {
- return fun_ptr;
- }
-
- template<typename Sig>
- inline constexpr Sig* resolve(Sig* fun_ptr) {
- return fun_ptr;
- }
-
- template<typename... Args, typename R, typename C>
- inline constexpr auto resolve(R(C::*mem_ptr)(Args...))->R(C::*)(Args...) {
- return mem_ptr;
- }
-
- template<typename Sig, typename C>
- inline constexpr Sig C::* resolve(Sig C::* mem_ptr) {
- return detail::resolve_v(std::is_member_object_pointer<Sig C::*>(), mem_ptr);
- }
-
- template<typename... Sig, typename F, meta::disable<std::is_function<meta::unqualified_t<F>>> = meta::enabler>
- inline constexpr auto resolve(F&& f) -> decltype(detail::resolve_i(types<Sig...>(), std::forward<F>(f))) {
- return detail::resolve_i(types<Sig...>(), std::forward<F>(f));
- }
-#else
-
- // Clang has distinct problems with constexpr arguments,
- // so don't use the constexpr versions inside of clang.
-
- namespace detail {
- template<typename R, typename... Args, typename F, typename = std::result_of_t<meta::unqualified_t<F>(Args...)>>
- inline auto resolve_i(types<R(Args...)>, F&&)->R(meta::unqualified_t<F>::*)(Args...) {
- using Sig = R(Args...);
- typedef meta::unqualified_t<F> Fu;
- return static_cast<Sig Fu::*>(&Fu::operator());
- }
-
- template<typename F, typename U = meta::unqualified_t<F>>
- inline auto resolve_f(std::true_type, F&& f)
- -> decltype(resolve_i(types<meta::function_signature_t<decltype(&U::operator())>>(), std::forward<F>(f))) {
- return resolve_i(types<meta::function_signature_t<decltype(&U::operator())>>(), std::forward<F>(f));
- }
-
- template<typename F>
- inline void resolve_f(std::false_type, F&&) {
- static_assert(meta::has_deducible_signature<F>::value,
- "Cannot use no-template-parameter call with an overloaded functor: specify the signature");
- }
-
- template<typename F, typename U = meta::unqualified_t<F>>
- inline auto resolve_i(types<>, F&& f) -> decltype(resolve_f(meta::has_deducible_signature<U>(), std::forward<F>(f))) {
- return resolve_f(meta::has_deducible_signature<U> {}, std::forward<F>(f));
- }
-
- template<typename... Args, typename F, typename R = std::result_of_t<F&(Args...)>>
- inline auto resolve_i(types<Args...>, F&& f) -> decltype(resolve_i(types<R(Args...)>(), std::forward<F>(f))) {
- return resolve_i(types<R(Args...)>(), std::forward<F>(f));
- }
-
- template<typename Sig, typename C>
- inline Sig C::* resolve_v(std::false_type, Sig C::* mem_func_ptr) {
- return mem_func_ptr;
- }
-
- template<typename Sig, typename C>
- inline Sig C::* resolve_v(std::true_type, Sig C::* mem_variable_ptr) {
- return mem_variable_ptr;
- }
- } // detail
-
- template<typename... Args, typename R>
- inline auto resolve(R fun_ptr(Args...))->R(*)(Args...) {
- return fun_ptr;
- }
-
- template<typename Sig>
- inline Sig* resolve(Sig* fun_ptr) {
- return fun_ptr;
- }
-
- template<typename... Args, typename R, typename C>
- inline auto resolve(R(C::*mem_ptr)(Args...))->R(C::*)(Args...) {
- return mem_ptr;
- }
-
- template<typename Sig, typename C>
- inline Sig C::* resolve(Sig C::* mem_ptr) {
- return detail::resolve_v(std::is_member_object_pointer<Sig C::*>(), mem_ptr);
- }
-
- template<typename... Sig, typename F>
- inline auto resolve(F&& f) -> decltype(detail::resolve_i(types<Sig...>(), std::forward<F>(f))) {
- return detail::resolve_i(types<Sig...>(), std::forward<F>(f));
- }
-
-#endif
-
-} // sol
-
-#endif // SOL_RESOLVE_HPP
diff --git a/3rdparty/sol2/sol/simple_usertype_metatable.hpp b/3rdparty/sol2/sol/simple_usertype_metatable.hpp
deleted file mode 100644
index c2db29a09df..00000000000
--- a/3rdparty/sol2/sol/simple_usertype_metatable.hpp
+++ /dev/null
@@ -1,559 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_SIMPLE_USERTYPE_METATABLE_HPP
-#define SOL_SIMPLE_USERTYPE_METATABLE_HPP
-
-#include "usertype_metatable.hpp"
-#include "object.hpp"
-#include <vector>
-#include <unordered_map>
-#include <utility>
-
-namespace sol {
-
- namespace usertype_detail {
- const lua_Integer toplevel_magic = static_cast<lua_Integer>(0x00000001);
-
- struct variable_wrapper {
- virtual int index(lua_State* L) = 0;
- virtual int new_index(lua_State* L) = 0;
- virtual ~variable_wrapper() {};
- };
-
- template <typename T, typename F>
- struct callable_binding : variable_wrapper {
- F fx;
-
- template <typename Arg>
- callable_binding(Arg&& arg) : fx(std::forward<Arg>(arg)) {}
-
- virtual int index(lua_State* L) override {
- return call_detail::call_wrapped<T, true, true>(L, fx);
- }
-
- virtual int new_index(lua_State* L) override {
- return call_detail::call_wrapped<T, false, true>(L, fx);
- }
- };
-
- typedef std::unordered_map<std::string, std::unique_ptr<variable_wrapper>> variable_map;
- typedef std::unordered_map<std::string, object> function_map;
-
- struct simple_map {
- const char* metakey;
- variable_map variables;
- function_map functions;
- base_walk indexbaseclasspropogation;
- base_walk newindexbaseclasspropogation;
-
- simple_map(const char* mkey, base_walk index, base_walk newindex, variable_map&& vars, function_map&& funcs) : metakey(mkey), variables(std::move(vars)), functions(std::move(funcs)), indexbaseclasspropogation(index), newindexbaseclasspropogation(newindex) {}
- };
-
- template <typename T>
- inline int simple_metatable_newindex(lua_State* L) {
- int isnum = 0;
- lua_Integer magic = lua_tointegerx(L, lua_upvalueindex(4), &isnum);
- if (isnum != 0 && magic == toplevel_magic) {
- for (std::size_t i = 0; i < 3; lua_pop(L, 1), ++i) {
- // Pointer types, AKA "references" from C++
- const char* metakey = nullptr;
- switch (i) {
- case 0:
- metakey = &usertype_traits<T*>::metatable()[0];
- break;
- case 1:
- metakey = &usertype_traits<detail::unique_usertype<T>>::metatable()[0];
- break;
- case 2:
- default:
- metakey = &usertype_traits<T>::metatable()[0];
- break;
- }
- luaL_getmetatable(L, metakey);
- int tableindex = lua_gettop(L);
- if (type_of(L, tableindex) == type::lua_nil) {
- continue;
- }
- stack::set_field<false, true>(L, stack_reference(L, 2), stack_reference(L, 3), tableindex);
- }
- lua_settop(L, 0);
- return 0;
- }
- lua_pop(L, 1);
- return indexing_fail<false>(L);
- }
-
- template <bool is_index, bool toplevel = false>
- inline int simple_core_indexing_call(lua_State* L) {
- simple_map& sm = toplevel ? stack::get<user<simple_map>>(L, upvalue_index(1)) : stack::pop<user<simple_map>>(L);
- variable_map& variables = sm.variables;
- function_map& functions = sm.functions;
- static const int keyidx = -2 + static_cast<int>(is_index);
- if (toplevel) {
- if (stack::get<type>(L, keyidx) != type::string) {
- lua_CFunction indexingfunc = is_index ? stack::get<lua_CFunction>(L, upvalue_index(2)) : stack::get<lua_CFunction>(L, upvalue_index(3));
- return indexingfunc(L);
- }
- }
- string_detail::string_shim accessor = stack::get<string_detail::string_shim>(L, keyidx);
- std::string accessorkey = accessor.c_str();
- auto vit = variables.find(accessorkey);
- if (vit != variables.cend()) {
- auto& varwrap = *(vit->second);
- if (is_index) {
- return varwrap.index(L);
- }
- return varwrap.new_index(L);
- }
- auto fit = functions.find(accessorkey);
- if (fit != functions.cend()) {
- auto& func = (fit->second);
- return stack::push(L, func);
- }
- // Check table storage first for a method that works
- luaL_getmetatable(L, sm.metakey);
- if (type_of(L, -1) != type::lua_nil) {
- stack::get_field<false, true>(L, accessor.c_str(), lua_gettop(L));
- if (type_of(L, -1) != type::lua_nil) {
- // Woo, we found it?
- lua_remove(L, -2);
- return 1;
- }
- lua_pop(L, 1);
- }
- lua_pop(L, 1);
-
- int ret = 0;
- bool found = false;
- // Otherwise, we need to do propagating calls through the bases
- if (is_index) {
- sm.indexbaseclasspropogation(L, found, ret, accessor);
- }
- else {
- sm.newindexbaseclasspropogation(L, found, ret, accessor);
- }
- if (found) {
- return ret;
- }
- if (toplevel) {
- lua_CFunction indexingfunc = is_index ? stack::get<lua_CFunction>(L, upvalue_index(2)) : stack::get<lua_CFunction>(L, upvalue_index(3));
- return indexingfunc(L);
- }
- return -1;
- }
-
- inline int simple_real_index_call(lua_State* L) {
- return simple_core_indexing_call<true, true>(L);
- }
-
- inline int simple_real_new_index_call(lua_State* L) {
- return simple_core_indexing_call<false, true>(L);
- }
-
- inline int simple_index_call(lua_State* L) {
- return detail::static_trampoline<(&simple_real_index_call)>(L);
- }
-
- inline int simple_new_index_call(lua_State* L) {
- return detail::static_trampoline<(&simple_real_new_index_call)>(L);
- }
- }
-
- struct simple_tag {} const simple{};
-
- template <typename T>
- struct simple_usertype_metatable : usertype_detail::registrar {
- public:
- usertype_detail::function_map registrations;
- usertype_detail::variable_map varmap;
- object callconstructfunc;
- lua_CFunction indexfunc;
- lua_CFunction newindexfunc;
- lua_CFunction indexbase;
- lua_CFunction newindexbase;
- usertype_detail::base_walk indexbaseclasspropogation;
- usertype_detail::base_walk newindexbaseclasspropogation;
- void* baseclasscheck;
- void* baseclasscast;
- bool mustindex;
- bool secondarymeta;
-
- template <typename N>
- void insert(N&& n, object&& o) {
- std::string key = usertype_detail::make_string(std::forward<N>(n));
- auto hint = registrations.find(key);
- if (hint == registrations.cend()) {
- registrations.emplace_hint(hint, std::move(key), std::move(o));
- return;
- }
- hint->second = std::move(o);
- }
-
- template <typename N, typename F, meta::enable<meta::is_callable<meta::unwrap_unqualified_t<F>>> = meta::enabler>
- void add_function(lua_State* L, N&& n, F&& f) {
- insert(std::forward<N>(n), make_object(L, as_function_reference(std::forward<F>(f))));
- }
-
- template <typename N, typename F, meta::disable<meta::is_callable<meta::unwrap_unqualified_t<F>>> = meta::enabler>
- void add_function(lua_State* L, N&& n, F&& f) {
- object o = make_object(L, std::forward<F>(f));
- if (std::is_same<meta::unqualified_t<N>, call_construction>::value) {
- callconstructfunc = std::move(o);
- return;
- }
- insert(std::forward<N>(n), std::move(o));
- }
-
- template <typename N, typename F, meta::disable<is_variable_binding<meta::unqualified_t<F>>> = meta::enabler>
- void add(lua_State* L, N&& n, F&& f) {
- add_function(L, std::forward<N>(n), std::forward<F>(f));
- }
-
- template <typename N, typename F, meta::enable<is_variable_binding<meta::unqualified_t<F>>> = meta::enabler>
- void add(lua_State*, N&& n, F&& f) {
- mustindex = true;
- secondarymeta = true;
- std::string key = usertype_detail::make_string(std::forward<N>(n));
- auto o = std::make_unique<usertype_detail::callable_binding<T, std::decay_t<F>>>(std::forward<F>(f));
- auto hint = varmap.find(key);
- if (hint == varmap.cend()) {
- varmap.emplace_hint(hint, std::move(key), std::move(o));
- return;
- }
- hint->second = std::move(o);
- }
-
- template <typename N, typename... Fxs>
- void add(lua_State* L, N&& n, constructor_wrapper<Fxs...> c) {
- object o(L, in_place<detail::tagged<T, constructor_wrapper<Fxs...>>>, std::move(c));
- if (std::is_same<meta::unqualified_t<N>, call_construction>::value) {
- callconstructfunc = std::move(o);
- return;
- }
- insert(std::forward<N>(n), std::move(o));
- }
-
- template <typename N, typename... Lists>
- void add(lua_State* L, N&& n, constructor_list<Lists...> c) {
- object o(L, in_place<detail::tagged<T, constructor_list<Lists...>>>, std::move(c));
- if (std::is_same<meta::unqualified_t<N>, call_construction>::value) {
- callconstructfunc = std::move(o);
- return;
- }
- insert(std::forward<N>(n), std::move(o));
- }
-
- template <typename N>
- void add(lua_State* L, N&& n, destructor_wrapper<void> c) {
- object o(L, in_place<detail::tagged<T, destructor_wrapper<void>>>, std::move(c));
- if (std::is_same<meta::unqualified_t<N>, call_construction>::value) {
- callconstructfunc = std::move(o);
- return;
- }
- insert(std::forward<N>(n), std::move(o));
- }
-
- template <typename N, typename Fx>
- void add(lua_State* L, N&& n, destructor_wrapper<Fx> c) {
- object o(L, in_place<detail::tagged<T, destructor_wrapper<Fx>>>, std::move(c));
- if (std::is_same<meta::unqualified_t<N>, call_construction>::value) {
- callconstructfunc = std::move(o);
- return;
- }
- insert(std::forward<N>(n), std::move(o));
- }
-
- template <typename... Bases>
- void add(lua_State*, base_classes_tag, bases<Bases...>) {
- static_assert(sizeof(usertype_detail::base_walk) <= sizeof(void*), "size of function pointer is greater than sizeof(void*); cannot work on this platform. Please file a bug report.");
- if (sizeof...(Bases) < 1) {
- return;
- }
- mustindex = true;
- (void)detail::swallow{ 0, ((detail::has_derived<Bases>::value = true), 0)... };
-
- static_assert(sizeof(void*) <= sizeof(detail::inheritance_check_function), "The size of this data pointer is too small to fit the inheritance checking function: Please file a bug report.");
- static_assert(sizeof(void*) <= sizeof(detail::inheritance_cast_function), "The size of this data pointer is too small to fit the inheritance checking function: Please file a bug report.");
- baseclasscheck = (void*)&detail::inheritance<T, Bases...>::type_check;
- baseclasscast = (void*)&detail::inheritance<T, Bases...>::type_cast;
- indexbaseclasspropogation = usertype_detail::walk_all_bases<true, Bases...>;
- newindexbaseclasspropogation = usertype_detail::walk_all_bases<false, Bases...>;
- }
-
- private:
- template<std::size_t... I, typename Tuple>
- simple_usertype_metatable(usertype_detail::verified_tag, std::index_sequence<I...>, lua_State* L, Tuple&& args)
- : callconstructfunc(lua_nil),
- indexfunc(&usertype_detail::indexing_fail<true>), newindexfunc(&usertype_detail::indexing_fail<false>),
- indexbase(&usertype_detail::simple_core_indexing_call<true>), newindexbase(&usertype_detail::simple_core_indexing_call<false>),
- indexbaseclasspropogation(usertype_detail::walk_all_bases<true>), newindexbaseclasspropogation(&usertype_detail::walk_all_bases<false>),
- baseclasscheck(nullptr), baseclasscast(nullptr),
- mustindex(false), secondarymeta(false) {
- (void)detail::swallow{ 0,
- (add(L, detail::forward_get<I * 2>(args), detail::forward_get<I * 2 + 1>(args)),0)...
- };
- }
-
- template<typename... Args>
- simple_usertype_metatable(lua_State* L, usertype_detail::verified_tag v, Args&&... args) : simple_usertype_metatable(v, std::make_index_sequence<sizeof...(Args) / 2>(), L, std::forward_as_tuple(std::forward<Args>(args)...)) {}
-
- template<typename... Args>
- simple_usertype_metatable(lua_State* L, usertype_detail::add_destructor_tag, Args&&... args) : simple_usertype_metatable(L, usertype_detail::verified, std::forward<Args>(args)..., "__gc", default_destructor) {}
-
- template<typename... Args>
- simple_usertype_metatable(lua_State* L, usertype_detail::check_destructor_tag, Args&&... args) : simple_usertype_metatable(L, meta::condition<meta::all<std::is_destructible<T>, meta::neg<usertype_detail::has_destructor<Args...>>>, usertype_detail::add_destructor_tag, usertype_detail::verified_tag>(), std::forward<Args>(args)...) {}
-
- public:
- simple_usertype_metatable(lua_State* L) : simple_usertype_metatable(L, meta::condition<meta::all<std::is_default_constructible<T>>, decltype(default_constructor), usertype_detail::check_destructor_tag>()) {}
-
- template<typename Arg, typename... Args, meta::disable_any<
- meta::any_same<meta::unqualified_t<Arg>,
- usertype_detail::verified_tag,
- usertype_detail::add_destructor_tag,
- usertype_detail::check_destructor_tag
- >,
- meta::is_specialization_of<constructors, meta::unqualified_t<Arg>>,
- meta::is_specialization_of<constructor_wrapper, meta::unqualified_t<Arg>>
- > = meta::enabler>
- simple_usertype_metatable(lua_State* L, Arg&& arg, Args&&... args) : simple_usertype_metatable(L, meta::condition<meta::all<std::is_default_constructible<T>, meta::neg<usertype_detail::has_constructor<Args...>>>, decltype(default_constructor), usertype_detail::check_destructor_tag>(), std::forward<Arg>(arg), std::forward<Args>(args)...) {}
-
- template<typename... Args, typename... CArgs>
- simple_usertype_metatable(lua_State* L, constructors<CArgs...> constructorlist, Args&&... args) : simple_usertype_metatable(L, usertype_detail::check_destructor_tag(), std::forward<Args>(args)..., "new", constructorlist) {}
-
- template<typename... Args, typename... Fxs>
- simple_usertype_metatable(lua_State* L, constructor_wrapper<Fxs...> constructorlist, Args&&... args) : simple_usertype_metatable(L, usertype_detail::check_destructor_tag(), std::forward<Args>(args)..., "new", constructorlist) {}
-
- virtual int push_um(lua_State* L) override {
- return stack::push(L, std::move(*this));
- }
- };
-
- namespace stack {
- template <typename T>
- struct pusher<simple_usertype_metatable<T>> {
- typedef simple_usertype_metatable<T> umt_t;
-
- static usertype_detail::simple_map& make_cleanup(lua_State* L, umt_t& umx) {
- static int uniqueness = 0;
- std::string uniquegcmetakey = usertype_traits<T>::user_gc_metatable();
- // std::to_string doesn't exist in android still, with NDK, so this bullshit
- // is necessary
- // thanks, Android :v
- int appended = snprintf(nullptr, 0, "%d", uniqueness);
- std::size_t insertionpoint = uniquegcmetakey.length() - 1;
- uniquegcmetakey.append(appended, '\0');
- char* uniquetarget = &uniquegcmetakey[insertionpoint];
- snprintf(uniquetarget, uniquegcmetakey.length(), "%d", uniqueness);
- ++uniqueness;
-
- const char* gcmetakey = &usertype_traits<T>::gc_table()[0];
- stack::push_specific<user<usertype_detail::simple_map>>(L, metatable_key, uniquegcmetakey, &usertype_traits<T>::metatable()[0],
- umx.indexbaseclasspropogation, umx.newindexbaseclasspropogation,
- std::move(umx.varmap), std::move(umx.registrations)
- );
- stack_reference stackvarmap(L, -1);
- stack::set_field<true>(L, gcmetakey, stackvarmap);
- stackvarmap.pop();
-
- stack::get_field<true>(L, gcmetakey);
- usertype_detail::simple_map& varmap = stack::pop<light<usertype_detail::simple_map>>(L);
- return varmap;
- }
-
- static int push(lua_State* L, umt_t&& umx) {
- auto& varmap = make_cleanup(L, umx);
- bool hasequals = false;
- bool hasless = false;
- bool haslessequals = false;
- auto register_kvp = [&](std::size_t i, stack_reference& t, const std::string& first, object& second) {
- if (first == name_of(meta_function::equal_to)) {
- hasequals = true;
- }
- else if (first == name_of(meta_function::less_than)) {
- hasless = true;
- }
- else if (first == name_of(meta_function::less_than_or_equal_to)) {
- haslessequals = true;
- }
- else if (first == name_of(meta_function::index)) {
- umx.indexfunc = second.template as<lua_CFunction>();
- }
- else if (first == name_of(meta_function::new_index)) {
- umx.newindexfunc = second.template as<lua_CFunction>();
- }
- switch (i) {
- case 0:
- if (first == name_of(meta_function::garbage_collect)) {
- return;
- }
- break;
- case 1:
- if (first == name_of(meta_function::garbage_collect)) {
- stack::set_field(L, first, detail::unique_destruct<T>, t.stack_index());
- return;
- }
- break;
- case 2:
- default:
- break;
- }
- stack::set_field(L, first, second, t.stack_index());
- };
- for (std::size_t i = 0; i < 3; ++i) {
- // Pointer types, AKA "references" from C++
- const char* metakey = nullptr;
- switch (i) {
- case 0:
- metakey = &usertype_traits<T*>::metatable()[0];
- break;
- case 1:
- metakey = &usertype_traits<detail::unique_usertype<T>>::metatable()[0];
- break;
- case 2:
- default:
- metakey = &usertype_traits<T>::metatable()[0];
- break;
- }
- luaL_newmetatable(L, metakey);
- stack_reference t(L, -1);
- for (auto& kvp : varmap.functions) {
- auto& first = std::get<0>(kvp);
- auto& second = std::get<1>(kvp);
- register_kvp(i, t, first, second);
- }
- luaL_Reg opregs[4]{};
- int opregsindex = 0;
- if (!hasless) {
- const char* name = name_of(meta_function::less_than).c_str();
- usertype_detail::make_reg_op<T, std::less<>, meta::supports_op_less<T>>(opregs, opregsindex, name);
- }
- if (!haslessequals) {
- const char* name = name_of(meta_function::less_than_or_equal_to).c_str();
- usertype_detail::make_reg_op<T, std::less_equal<>, meta::supports_op_less_equal<T>>(opregs, opregsindex, name);
- }
- if (!hasequals) {
- const char* name = name_of(meta_function::equal_to).c_str();
- usertype_detail::make_reg_op<T, std::conditional_t<meta::supports_op_equal<T>::value, std::equal_to<>, usertype_detail::no_comp>, std::true_type>(opregs, opregsindex, name);
- }
- t.push();
- luaL_setfuncs(L, opregs, 0);
- t.pop();
-
- if (umx.baseclasscheck != nullptr) {
- stack::set_field(L, detail::base_class_check_key(), umx.baseclasscheck, t.stack_index());
- }
- if (umx.baseclasscast != nullptr) {
- stack::set_field(L, detail::base_class_cast_key(), umx.baseclasscast, t.stack_index());
- }
-
- // Base class propagation features
- stack::set_field(L, detail::base_class_index_propogation_key(), umx.indexbase, t.stack_index());
- stack::set_field(L, detail::base_class_new_index_propogation_key(), umx.newindexbase, t.stack_index());
-
- if (umx.mustindex) {
- // use indexing function
- stack::set_field(L, meta_function::index,
- make_closure(&usertype_detail::simple_index_call,
- make_light(varmap),
- umx.indexfunc,
- umx.newindexfunc
- ), t.stack_index());
- stack::set_field(L, meta_function::new_index,
- make_closure(&usertype_detail::simple_new_index_call,
- make_light(varmap),
- umx.indexfunc,
- umx.newindexfunc
- ), t.stack_index());
- }
- else {
- // Metatable indexes itself
- stack::set_field(L, meta_function::index, t, t.stack_index());
- }
- // metatable on the metatable
- // for call constructor purposes and such
- lua_createtable(L, 0, 2 * static_cast<int>(umx.secondarymeta) + static_cast<int>(umx.callconstructfunc.valid()));
- stack_reference metabehind(L, -1);
- if (umx.callconstructfunc.valid()) {
- stack::set_field(L, sol::meta_function::call_function, umx.callconstructfunc, metabehind.stack_index());
- }
- if (umx.secondarymeta) {
- stack::set_field(L, meta_function::index,
- make_closure(&usertype_detail::simple_index_call,
- make_light(varmap),
- umx.indexfunc,
- umx.newindexfunc
- ), metabehind.stack_index());
- stack::set_field(L, meta_function::new_index,
- make_closure(&usertype_detail::simple_new_index_call,
- make_light(varmap),
- umx.indexfunc,
- umx.newindexfunc
- ), metabehind.stack_index());
- }
- stack::set_field(L, metatable_key, metabehind, t.stack_index());
- metabehind.pop();
-
- t.pop();
- }
-
- // Now for the shim-table that actually gets pushed
- luaL_newmetatable(L, &usertype_traits<T>::user_metatable()[0]);
- stack_reference t(L, -1);
- for (auto& kvp : varmap.functions) {
- auto& first = std::get<0>(kvp);
- auto& second = std::get<1>(kvp);
- register_kvp(2, t, first, second);
- }
- {
- lua_createtable(L, 0, 2 + static_cast<int>(umx.callconstructfunc.valid()));
- stack_reference metabehind(L, -1);
- if (umx.callconstructfunc.valid()) {
- stack::set_field(L, sol::meta_function::call_function, umx.callconstructfunc, metabehind.stack_index());
- }
- // use indexing function
- stack::set_field(L, meta_function::index,
- make_closure(&usertype_detail::simple_index_call,
- make_light(varmap),
- &usertype_detail::simple_index_call,
- &usertype_detail::simple_metatable_newindex<T>,
- usertype_detail::toplevel_magic
- ), metabehind.stack_index());
- stack::set_field(L, meta_function::new_index,
- make_closure(&usertype_detail::simple_new_index_call,
- make_light(varmap),
- &usertype_detail::simple_index_call,
- &usertype_detail::simple_metatable_newindex<T>,
- usertype_detail::toplevel_magic
- ), metabehind.stack_index());
- stack::set_field(L, metatable_key, metabehind, t.stack_index());
- metabehind.pop();
- }
-
- // Don't pop the table when we're done;
- // return it
- return 1;
- }
- };
- } // stack
-} // sol
-
-#endif // SOL_SIMPLE_USERTYPE_METATABLE_HPP
diff --git a/3rdparty/sol2/sol/sol.hpp b/3rdparty/sol2/sol/sol.hpp
new file mode 100644
index 00000000000..4ef5807fdcb
--- /dev/null
+++ b/3rdparty/sol2/sol/sol.hpp
@@ -0,0 +1,26674 @@
+// The MIT License (MIT)
+
+// Copyright (c) 2013-2020 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.
+
+// This file was generated with a script.
+// Generated 2020-10-03 21:34:24.496436 UTC
+// This header was generated with sol v3.2.1 (revision 48eea7b5)
+// https://github.com/ThePhD/sol2
+
+#ifndef SOL_SINGLE_INCLUDE_HPP
+#define SOL_SINGLE_INCLUDE_HPP
+
+// beginning of sol/sol.hpp
+
+#ifndef SOL_HPP
+#define SOL_HPP
+
+// beginning of sol/version.hpp
+
+#include <sol/config.hpp>
+
+#include <cstdint>
+
+#define SOL_VERSION_MAJOR 3
+#define SOL_VERSION_MINOR 5
+#define SOL_VERSION_PATCH 0
+#define SOL_VERSION_STRING "3.5.0"
+#define SOL_VERSION ((SOL_VERSION_MAJOR * 100000) + (SOL_VERSION_MINOR * 100) + (SOL_VERSION_PATCH))
+
+#define SOL_IS_ON(OP_SYMBOL) ((3 OP_SYMBOL 3) != 0)
+#define SOL_IS_OFF(OP_SYMBOL) ((3 OP_SYMBOL 3) == 0)
+#define SOL_IS_DEFAULT_ON(OP_SYMBOL) ((3 OP_SYMBOL 3) > 3)
+#define SOL_IS_DEFAULT_OFF(OP_SYMBOL) ((3 OP_SYMBOL 3 OP_SYMBOL 3) < 0)
+
+#define SOL_ON |
+#define SOL_OFF ^
+#define SOL_DEFAULT_ON +
+#define SOL_DEFAULT_OFF -
+
+#if defined(_MSC_VER)
+ #define SOL_COMPILER_CLANG_I_ SOL_OFF
+ #define SOL_COMPILER_GCC_I_ SOL_OFF
+ #define SOL_COMPILER_EDG_I_ SOL_OFF
+ #define SOL_COMPILER_VCXX_I_ SOL_ON
+#elif defined(__clang__)
+ #define SOL_COMPILER_CLANG_I_ SOL_ON
+ #define SOL_COMPILER_GCC_I_ SOL_OFF
+ #define SOL_COMPILER_EDG_I_ SOL_OFF
+ #define SOL_COMPILER_VCXX_I_ SOL_OFF
+#elif defined(__GNUC__)
+ #define SOL_COMPILER_CLANG_I_ SOL_OFF
+ #define SOL_COMPILER_GCC_I_ SOL_ON
+ #define SOL_COMPILER_EDG_I_ SOL_OFF
+ #define SOL_COMPILER_VCXX_I_ SOL_OFF
+#else
+ #define SOL_COMPILER_CLANG_I_ SOL_OFF
+ #define SOL_COMPILER_GCC_I_ SOL_OFF
+ #define SOL_COMPILER_EDG_I_ SOL_OFF
+ #define SOL_COMPILER_VCXX_I_ SOL_OFF
+#endif
+
+#if defined(__MINGW32__)
+ #define SOL_COMPILER_FRONTEND_MINGW_I_ SOL_ON
+#else
+ #define SOL_COMPILER_FRONTEND_MINGW_I_ SOL_OFF
+#endif
+
+#if SIZE_MAX <= 0xFFFFULL
+ #define SOL_PLATFORM_X16_I_ SOL_ON
+ #define SOL_PLATFORM_X86_I_ SOL_OFF
+ #define SOL_PLATFORM_X64_I_ SOL_OFF
+#elif SIZE_MAX <= 0xFFFFFFFFULL
+ #define SOL_PLATFORM_X16_I_ SOL_OFF
+ #define SOL_PLATFORM_X86_I_ SOL_ON
+ #define SOL_PLATFORM_X64_I_ SOL_OFF
+#else
+ #define SOL_PLATFORM_X16_I_ SOL_OFF
+ #define SOL_PLATFORM_X86_I_ SOL_OFF
+ #define SOL_PLATFORM_X64_I_ SOL_ON
+#endif
+
+#define SOL_PLATFORM_ARM32_I_ SOL_OFF
+#define SOL_PLATFORM_ARM64_I_ SOL_OFF
+
+#if defined(_WIN32)
+ #define SOL_PLATFORM_WINDOWS_I_ SOL_ON
+#else
+ #define SOL_PLATFORM_WINDOWS_I_ SOL_OFF
+#endif
+#if defined(__APPLE__)
+ #define SOL_PLATFORM_APPLE_I_ SOL_ON
+#else
+ #define SOL_PLATFORM_APPLE_I_ SOL_OFF
+#endif
+#if defined(__unix__)
+ #define SOL_PLATFORM_UNIXLIKE_I_ SOL_ON
+#else
+ #define SOL_PLATFORM_UNIXLIKE_I_ SOL_OFF
+#endif
+#if defined(__linux__)
+ #define SOL_PLATFORM_LINUXLIKE_I_ SOL_ON
+#else
+ #define SOL_PLATFORM_LINUXLIKE_I_ SOL_OFF
+#endif
+
+#define SOL_PLATFORM_APPLE_IPHONE_I_ SOL_OFF
+#define SOL_PLATFORM_BSDLIKE_I_ SOL_OFF
+
+#if defined(SOL_IN_DEBUG_DETECTED)
+ #if SOL_IN_DEBUG_DETECTED != 0
+ #define SOL_DEBUG_BUILD_I_ SOL_ON
+ #else
+ #define SOL_DEBUG_BUILD_I_ SOL_OFF
+ #endif
+#elif !defined(NDEBUG)
+ #if SOL_IS_ON(SOL_COMPILER_VCXX_I_) && defined(_DEBUG)
+ #define SOL_DEBUG_BUILD_I_ SOL_ON
+ #elif (SOL_IS_ON(SOL_COMPILER_CLANG_I_) || SOL_IS_ON(SOL_COMPILER_GCC_I_)) && !defined(__OPTIMIZE__)
+ #define SOL_DEBUG_BUILD_I_ SOL_ON
+ #else
+ #define SOL_DEBUG_BUILD_I_ SOL_OFF
+ #endif
+#else
+ #define SOL_DEBUG_BUILD_I_ SOL_DEFAULT_OFF
+#endif // We are in a debug mode of some sort
+
+#if defined(SOL_NO_EXCEPTIONS)
+ #if (SOL_NO_EXCEPTIONS != 0)
+ #define SOL_EXCEPTIONS_I_ SOL_OFF
+ #else
+ #define SOL_EXCEPTIONS_I_ SOL_ON
+ #endif
+#elif SOL_IS_ON(SOL_COMPILER_VCXX_I_)
+ #if !defined(_CPPUNWIND)
+ #define SOL_EXCEPTIONS_I_ SOL_OFF
+ #else
+ #define SOL_EXCEPTIONS_I_ SOL_ON
+ #endif
+#elif SOL_IS_ON(SOL_COMPILER_CLANG_I_) || SOL_IS_ON(SOL_COMPILER_GCC_I_)
+ #if !defined(__EXCEPTIONS)
+ #define SOL_EXCEPTIONS_I_ SOL_OFF
+ #else
+ #define SOL_EXCEPTIONS_I_ SOL_ON
+ #endif
+#else
+ #define SOL_EXCEPTIONS_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_NO_RTTI)
+ #if (SOL_NO_RTTI != 0)
+ #define SOL_RTTI_I_ SOL_OFF
+ #else
+ #define SOL_RTTI_I_ SOL_ON
+ #endif
+#elif SOL_IS_ON(SOL_COMPILER_VCXX_I_)
+ #if !defined(_CPPRTTI)
+ #define SOL_RTTI_I_ SOL_OFF
+ #else
+ #define SOL_RTTI_I_ SOL_ON
+ #endif
+#elif SOL_IS_ON(SOL_COMPILER_CLANG_I_) || SOL_IS_ON(SOL_COMPILER_GCC_I_)
+ #if !defined(__GXX_RTTI)
+ #define SOL_RTTI_I_ SOL_OFF
+ #else
+ #define SOL_RTTI_I_ SOL_ON
+ #endif
+#else
+ #define SOL_RTTI_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_NO_THREAD_LOCAL) && (SOL_NO_THREAD_LOCAL != 0)
+ #define SOL_USE_THREAD_LOCAL_I_ SOL_OFF
+#else
+ #define SOL_USE_THREAD_LOCAL_I_ SOL_DEFAULT_ON
+#endif // thread_local keyword is bjorked on some platforms
+
+#if defined(SOL_ALL_SAFETIES_ON) && (SOL_ALL_SAFETIES_ON != 0)
+ #define SOL_ALL_SAFETIES_ON_I_ SOL_ON
+#else
+ #define SOL_ALL_SAFETIES_ON_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_SAFE_GETTER) && (SOL_SAFE_GETTER != 0)
+ #define SOL_SAFE_GETTER_I_ SOL_ON
+#else
+ #if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+ #define SOL_SAFE_GETTER_I_ SOL_ON
+ #elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+ #define SOL_SAFE_GETTER_I_ SOL_DEFAULT_ON
+ #else
+ #define SOL_SAFE_GETTER_I_ SOL_DEFAULT_OFF
+ #endif
+#endif
+
+#if defined(SOL_SAFE_USERTYPE) && (SOL_SAFE_USERTYPE != 0)
+ #define SOL_SAFE_USERTYPE_I_ SOL_ON
+#else
+ #if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+ #define SOL_SAFE_USERTYPE_I_ SOL_ON
+ #elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+ #define SOL_SAFE_USERTYPE_I_ SOL_DEFAULT_ON
+ #else
+ #define SOL_SAFE_USERTYPE_I_ SOL_DEFAULT_OFF
+ #endif
+#endif
+
+#if defined(SOL_SAFE_REFERENCES) && (SOL_SAFE_REFERENCES != 0)
+ #define SOL_SAFE_REFERENCES_I_ SOL_ON
+#else
+ #if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+ #define SOL_SAFE_REFERENCES_I_ SOL_ON
+ #elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+ #define SOL_SAFE_REFERENCES_I_ SOL_DEFAULT_ON
+ #else
+ #define SOL_SAFE_REFERENCES_I_ SOL_DEFAULT_OFF
+ #endif
+#endif
+
+#if (defined(SOL_SAFE_FUNCTIONS) && (SOL_SAFE_FUNCTIONS != 0)) \
+ || (defined(SOL_SAFE_FUNCTION_OBJECTS) && (SOL_SAFE_FUNCTION_OBJECTS != 0))
+ #define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_ON
+#else
+ #if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+ #define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_ON
+ #elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+ #define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_DEFAULT_ON
+ #else
+ #define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_DEFAULT_OFF
+ #endif
+#endif
+
+#if defined(SOL_SAFE_FUNCTION_CALLS) && (SOL_SAFE_FUNCTION_CALLS != 0)
+ #define SOL_SAFE_FUNCTION_CALLS_I_ SOL_ON
+#else
+ #if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+ #define SOL_SAFE_FUNCTION_CALLS_I_ SOL_ON
+ #elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+ #define SOL_SAFE_FUNCTION_CALLS_I_ SOL_DEFAULT_ON
+ #else
+ #define SOL_SAFE_FUNCTION_CALLS_I_ SOL_DEFAULT_OFF
+ #endif
+#endif
+
+#if defined(SOL_SAFE_PROXIES) && (SOL_SAFE_PROXIES != 0)
+ #define SOL_SAFE_PROXIES_I_ SOL_ON
+#else
+ #if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+ #define SOL_SAFE_PROXIES_I_ SOL_ON
+ #elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+ #define SOL_SAFE_PROXIES_I_ SOL_DEFAULT_ON
+ #else
+ #define SOL_SAFE_PROXIES_I_ SOL_DEFAULT_OFF
+ #endif
+#endif
+
+#if defined(SOL_SAFE_NUMERICS) && (SOL_SAFE_NUMERICS != 0)
+ #define SOL_SAFE_NUMERICS_I_ SOL_ON
+#else
+ #if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+ #define SOL_SAFE_NUMERICS_I_ SOL_ON
+ #elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+ #define SOL_SAFE_NUMERICS_I_ SOL_DEFAULT_ON
+ #else
+ #define SOL_SAFE_NUMERICS_I_ SOL_DEFAULT_OFF
+ #endif
+#endif
+
+#if defined(SOL_SAFE_STACK_CHECK) && (SOL_SAFE_STACK_CHECK != 0)
+ #define SOL_SAFE_STACK_CHECK_I_ SOL_ON
+#else
+ #if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+ #define SOL_SAFE_STACK_CHECK_I_ SOL_ON
+ #elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+ #define SOL_SAFE_STACK_CHECK_I_ SOL_DEFAULT_ON
+ #else
+ #define SOL_SAFE_STACK_CHECK_I_ SOL_DEFAULT_OFF
+ #endif
+#endif
+
+#if (defined(SOL_NO_CHECK_NUMBER_PRECISION) && (SOL_NO_CHECK_NUMBER_PRECISION != 0)) \
+ || (defined(SOL_NO_CHECKING_NUMBER_PRECISION) && (SOL_NO_CHECKING_NUMBER_PRECISION != 0))
+ #define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_OFF
+#else
+ #if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+ #define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_ON
+ #elif SOL_IS_ON(SOL_SAFE_NUMERICS_I_)
+ #define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_ON
+ #elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+ #define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_DEFAULT_ON
+ #else
+ #define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_DEFAULT_OFF
+ #endif
+#endif
+
+#if defined(SOL_STRINGS_ARE_NUMBERS)
+ #if (SOL_STRINGS_ARE_NUMBERS != 0)
+ #define SOL_STRINGS_ARE_NUMBERS_I_ SOL_ON
+ #else
+ #define SOL_STRINGS_ARE_NUMBERS_I_ SOL_OFF
+ #endif
+#else
+ #define SOL_STRINGS_ARE_NUMBERS_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_ENABLE_INTEROP) && (SOL_ENABLE_INTEROP != 0) \
+ || defined(SOL_USE_INTEROP) && (SOL_USE_INTEROP != 0)
+ #define SOL_USE_INTEROP_I_ SOL_ON
+#else
+ #define SOL_USE_INTEROP_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_NO_NIL)
+ #if (SOL_NO_NIL != 0)
+ #define SOL_NIL_I_ SOL_OFF
+ #else
+ #define SOL_NIL_I_ SOL_ON
+ #endif
+#elif defined(__MAC_OS_X_VERSION_MAX_ALLOWED) || defined(__OBJC__) || defined(nil)
+ #define SOL_NIL_I_ SOL_DEFAULT_OFF
+#else
+ #define SOL_NIL_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_USERTYPE_TYPE_BINDING_INFO)
+ #if (SOL_USERTYPE_TYPE_BINDING_INFO != 0)
+ #define SOL_USERTYPE_TYPE_BINDING_INFO_I_ SOL_ON
+ #else
+ #define SOL_USERTYPE_TYPE_BINDING_INFO_I_ SOL_OFF
+ #endif
+#else
+ #define SOL_USERTYPE_TYPE_BINDING_INFO_I_ SOL_DEFAULT_ON
+#endif // We should generate a my_type.__type table with lots of class information for usertypes
+
+#if defined(SOL_AUTOMAGICAL_TYPES_BY_DEFAULT)
+ #if (SOL_AUTOMAGICAL_TYPES_BY_DEFAULT != 0)
+ #define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_ON
+ #else
+ #define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_OFF
+ #endif
+#elif defined(SOL_DEFAULT_AUTOMAGICAL_USERTYPES)
+ #if (SOL_DEFAULT_AUTOMAGICAL_USERTYPES != 0)
+ #define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_ON
+ #else
+ #define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_OFF
+ #endif
+#else
+ #define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_DEFAULT_ON
+#endif // make is_automagical on/off by default
+
+#if defined(SOL_STD_VARIANT)
+ #if (SOL_STD_VARIANT != 0)
+ #define SOL_STD_VARIANT_I_ SOL_ON
+ #else
+ #define SOL_STD_VARIANT_I_ SOL_OFF
+ #endif
+#else
+ #if SOL_IS_ON(SOL_COMPILER_CLANG_I_) && SOL_IS_ON(SOL_PLATFORM_APPLE_I_)
+ #if defined(__has_include)
+ #if __has_include(<variant>)
+ #define SOL_STD_VARIANT_I_ SOL_ON
+ #else
+ #define SOL_STD_VARIANT_I_ SOL_OFF
+ #endif
+ #else
+ #define SOL_STD_VARIANT_I_ SOL_OFF
+ #endif
+ #else
+ #define SOL_STD_VARIANT_I_ SOL_DEFAULT_ON
+ #endif
+#endif // make is_automagical on/off by default
+
+#if defined(SOL_NOEXCEPT_FUNCTION_TYPE)
+ #if (SOL_NOEXCEPT_FUNCTION_TYPE != 0)
+ #define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_ON
+ #else
+ #define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_OFF
+ #endif
+#else
+ #if defined(__cpp_noexcept_function_type)
+ #define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_ON
+ #elif SOL_IS_ON(SOL_COMPILER_VCXX_I_) && (defined(_MSVC_LANG) && (_MSVC_LANG < 201403L))
+ // There is a bug in the VC++ compiler??
+ // on /std:c++latest under x86 conditions (VS 15.5.2),
+ // compiler errors are tossed for noexcept markings being on function types
+ // that are identical in every other way to their non-noexcept marked types function types...
+ // VS 2019: There is absolutely a bug.
+ #define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_OFF
+ #else
+ #define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_DEFAULT_ON
+ #endif
+#endif // noexcept is part of a function's type
+
+#if defined(SOL_STACK_STRING_OPTIMIZATION_SIZE) && SOL_STACK_STRING_OPTIMIZATION_SIZE > 0
+ #define SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_ SOL_STACK_STRING_OPTIMIZATION_SIZE
+#else
+ #define SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_ 1024
+#endif
+
+#if defined(SOL_ID_SIZE) && SOL_ID_SIZE > 0
+ #define SOL_ID_SIZE_I_ SOL_ID_SIZE
+#else
+ #define SOL_ID_SIZE_I_ 512
+#endif
+
+#if defined(LUA_IDSIZE) && LUA_IDSIZE > 0
+ #define SOL_FILE_ID_SIZE_I_ LUA_IDSIZE
+#elif defined(SOL_ID_SIZE) && SOL_ID_SIZE > 0
+ #define SOL_FILE_ID_SIZE_I_ SOL_FILE_ID_SIZE
+#else
+ #define SOL_FILE_ID_SIZE_I_ 2048
+#endif
+
+#if defined(SOL_PRINT_ERRORS)
+ #if (SOL_PRINT_ERRORS != 0)
+ #define SOL_PRINT_ERRORS_I_ SOL_ON
+ #else
+ #define SOL_PRINT_ERRORS_I_ SOL_OFF
+ #endif
+#else
+ #if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+ #define SOL_PRINT_ERRORS_I_ SOL_ON
+ #elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+ #define SOL_PRINT_ERRORS_I_ SOL_DEFAULT_ON
+ #else
+ #define SOL_PRINT_ERRORS_I_ SOL_OFF
+ #endif
+#endif
+
+#if defined(SOL_DEFAULT_PASS_ON_ERROR) && (SOL_DEFAULT_PASS_ON_ERROR != 0)
+ #define SOL_DEFAULT_PASS_ON_ERROR_I_ SOL_ON
+#else
+ #if SOL_IS_ON(SOL_ALL_SAFETIES_ON_I_)
+ #define SOL_DEFAULT_PASS_ON_ERROR_I_ SOL_ON
+ #elif SOL_IS_ON(SOL_DEBUG_BUILD_I_)
+ #define SOL_DEFAULT_PASS_ON_ERROR_I_ SOL_DEFAULT_ON
+ #else
+ #define SOL_DEFAULT_PASS_ON_ERROR_I_ SOL_OFF
+ #endif
+#endif
+
+#if defined(SOL_USING_CXX_LUA)
+ #if (SOL_USING_CXX_LUA != 0)
+ #define SOL_USE_CXX_LUA_I_ SOL_ON
+ #else
+ #define SOL_USE_CXX_LUA_I_ SOL_OFF
+ #endif
+#elif defined(SOL_USE_CXX_LUA)
+ #if (SOL_USE_CXX_LUA != 0)
+ #define SOL_USE_CXX_LUA_I_ SOL_ON
+ #else
+ #define SOL_USE_CXX_LUA_I_ SOL_OFF
+ #endif
+#else
+ #define SOL_USE_CXX_LUA_I_ SOL_OFF
+#endif
+
+#if defined(SOL_USING_CXX_LUAJIT)
+ #if (SOL_USING_CXX_LUA != 0)
+ #define SOL_USE_CXX_LUAJIT_I_ SOL_ON
+ #else
+ #define SOL_USE_CXX_LUAJIT_I_ SOL_OFF
+ #endif
+#elif defined(SOL_USE_CXX_LUAJIT)
+ #if (SOL_USE_CXX_LUA != 0)
+ #define SOL_USE_CXX_LUAJIT_I_ SOL_ON
+ #else
+ #define SOL_USE_CXX_LUAJIT_I_ SOL_OFF
+ #endif
+#else
+ #define SOL_USE_CXX_LUAJIT_I_ SOL_OFF
+#endif
+
+#if defined(SOL_NO_LUA_HPP)
+ #if (SOL_NO_LUA_HPP != 0)
+ #define SOL_USE_LUA_HPP_I_ SOL_OFF
+ #else
+ #define SOL_USE_LUA_HPP_I_ SOL_ON
+ #endif
+#elif defined(SOL_USING_CXX_LUA)
+ #define SOL_USE_LUA_HPP_I_ SOL_OFF
+#elif defined(__has_include)
+ #if __has_include(<lua.hpp>)
+ #define SOL_USE_LUA_HPP_I_ SOL_ON
+ #else
+ #define SOL_USE_LUA_HPP_I_ SOL_OFF
+ #endif
+#else
+ #define SOL_USE_LUA_HPP_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_CONTAINERS_START)
+ #define SOL_CONTAINER_START_INDEX_I_ SOL_CONTAINERS_START
+#elif defined(SOL_CONTAINERS_START_INDEX)
+ #define SOL_CONTAINER_START_INDEX_I_ SOL_CONTAINERS_START_INDEX
+#elif defined(SOL_CONTAINER_START_INDEX)
+ #define SOL_CONTAINER_START_INDEX_I_ SOL_CONTAINER_START_INDEX
+#else
+ #define SOL_CONTAINER_START_INDEX_I_ 1
+#endif
+
+#if defined (SOL_NO_MEMORY_ALIGNMENT)
+ #if (SOL_NO_MEMORY_ALIGNMENT != 0)
+ #define SOL_ALIGN_MEMORY_I_ SOL_OFF
+ #else
+ #define SOL_ALIGN_MEMORY_I_ SOL_ON
+ #endif
+#else
+ #define SOL_ALIGN_MEMORY_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_USE_BOOST)
+ #if (SOL_USE_BOOST != 0)
+ #define SOL_USE_BOOST_I_ SOL_ON
+ #else
+ #define SOL_USE_BOOST_I_ SOL_OFF
+ #endif
+#else
+ #define SOL_USE_BOOST_I_ SOL_OFF
+#endif
+
+#if defined(SOL_USE_UNSAFE_BASE_LOOKUP)
+ #if (SOL_USE_UNSAFE_BASE_LOOKUP != 0)
+ #define SOL_USE_UNSAFE_BASE_LOOKUP_I_ SOL_ON
+ #else
+ #define SOL_USE_UNSAFE_BASE_LOOKUP_I_ SOL_OFF
+ #endif
+#else
+ #define SOL_USE_UNSAFE_BASE_LOOKUP_I_ SOL_OFF
+#endif
+
+#if defined(SOL_INSIDE_UNREAL)
+ #if (SOL_INSIDE_UNREAL != 0)
+ #define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_ON
+ #else
+ #define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_OFF
+ #endif
+#else
+ #if defined(UE_BUILD_DEBUG) || defined(UE_BUILD_DEVELOPMENT) || defined(UE_BUILD_TEST) || defined(UE_BUILD_SHIPPING) || defined(UE_SERVER)
+ #define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_ON
+ #else
+ #define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_DEFAULT_OFF
+ #endif
+#endif
+
+#if defined(SOL_NO_COMPAT)
+ #if (SOL_NO_COMPAT != 0)
+ #define SOL_USE_COMPATIBILITY_LAYER_I_ SOL_OFF
+ #else
+ #define SOL_USE_COMPATIBILITY_LAYER_I_ SOL_ON
+ #endif
+#else
+ #define SOL_USE_COMPATIBILITY_LAYER_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_GET_FUNCTION_POINTER_UNSAFE)
+ #if (SOL_GET_FUNCTION_POINTER_UNSAFE != 0)
+ #define SOL_GET_FUNCTION_POINTER_UNSAFE_I_ SOL_ON
+ #else
+ #define SOL_GET_FUNCTION_POINTER_UNSAFE_I_ SOL_OFF
+ #endif
+#else
+ #define SOL_GET_FUNCTION_POINTER_UNSAFE_I_ SOL_DEFAULT_OFF
+#endif
+
+#if SOL_IS_ON(SOL_COMPILER_FRONTEND_MINGW_I_) && defined(__GNUC__) && (__GNUC__ < 6)
+ // MinGW is off its rocker in some places...
+ #define SOL_MINGW_CCTYPE_IS_POISONED_I_ SOL_ON
+#else
+ #define SOL_MINGW_CCTYPE_IS_POISONED_I_ SOL_DEFAULT_OFF
+#endif
+
+// end of sol/version.hpp
+
+#if SOL_IS_ON(SOL_INSIDE_UNREAL_ENGINE_I_)
+#ifdef check
+#pragma push_macro("check")
+#undef check
+#endif
+#endif // Unreal Engine 4 Bullshit
+
+#if SOL_IS_ON(SOL_COMPILER_GCC_I_)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshadow"
+#pragma GCC diagnostic ignored "-Wconversion"
+#if __GNUC__ > 6
+#pragma GCC diagnostic ignored "-Wnoexcept-type"
+#endif
+#elif SOL_IS_ON(SOL_COMPILER_CLANG_I_)
+#elif SOL_IS_ON(SOL_COMPILER_VCXX_I_)
+#pragma warning(push)
+#pragma warning(disable : 4505) // unreferenced local function has been removed GEE THANKS
+#endif // clang++ vs. g++ vs. VC++
+
+// beginning of sol/forward.hpp
+
+#ifndef SOL_FORWARD_HPP
+#define SOL_FORWARD_HPP
+
+#include <utility>
+#include <type_traits>
+#include <string_view>
+
+#if SOL_IS_ON(SOL_USE_CXX_LUA_I_) || SOL_IS_ON(SOL_USE_CXX_LUAJIT_I_)
+struct lua_State;
+#else
+extern "C" {
+struct lua_State;
+}
+#endif // C++ Mangling for Lua vs. Not
+
+namespace sol {
+
+ enum class type;
+
+ class stateless_reference;
+ template <bool b>
+ class basic_reference;
+ using reference = basic_reference<false>;
+ using main_reference = basic_reference<true>;
+ class stateless_stack_reference;
+ class stack_reference;
+
+ template <typename A>
+ class basic_bytecode;
+
+ struct lua_value;
+
+ struct proxy_base_tag;
+ template <typename>
+ struct proxy_base;
+ template <typename, typename>
+ struct table_proxy;
+
+ template <bool, typename>
+ class basic_table_core;
+ template <bool b>
+ using table_core = basic_table_core<b, reference>;
+ template <bool b>
+ using main_table_core = basic_table_core<b, main_reference>;
+ template <bool b>
+ using stack_table_core = basic_table_core<b, stack_reference>;
+ template <typename base_type>
+ using basic_table = basic_table_core<false, base_type>;
+ using table = table_core<false>;
+ using global_table = table_core<true>;
+ using main_table = main_table_core<false>;
+ using main_global_table = main_table_core<true>;
+ using stack_table = stack_table_core<false>;
+ using stack_global_table = stack_table_core<true>;
+
+ template <typename>
+ struct basic_lua_table;
+ using lua_table = basic_lua_table<reference>;
+ using stack_lua_table = basic_lua_table<stack_reference>;
+
+ template <typename T, typename base_type>
+ class basic_usertype;
+ template <typename T>
+ using usertype = basic_usertype<T, reference>;
+ template <typename T>
+ using stack_usertype = basic_usertype<T, stack_reference>;
+
+ template <typename base_type>
+ class basic_metatable;
+ using metatable = basic_metatable<reference>;
+ using stack_metatable = basic_metatable<stack_reference>;
+
+ template <typename base_t>
+ struct basic_environment;
+ using environment = basic_environment<reference>;
+ using main_environment = basic_environment<main_reference>;
+ using stack_environment = basic_environment<stack_reference>;
+
+ template <typename T, bool>
+ class basic_function;
+ template <typename T, bool, typename H>
+ class basic_protected_function;
+ using unsafe_function = basic_function<reference, false>;
+ using safe_function = basic_protected_function<reference, false, reference>;
+ using main_unsafe_function = basic_function<main_reference, false>;
+ using main_safe_function = basic_protected_function<main_reference, false, reference>;
+ using stack_unsafe_function = basic_function<stack_reference, false>;
+ using stack_safe_function = basic_protected_function<stack_reference, false, reference>;
+ using stack_aligned_unsafe_function = basic_function<stack_reference, true>;
+ using stack_aligned_safe_function = basic_protected_function<stack_reference, true, reference>;
+ using protected_function = safe_function;
+ using main_protected_function = main_safe_function;
+ using stack_protected_function = stack_safe_function;
+ using stack_aligned_protected_function = stack_aligned_safe_function;
+#if SOL_IS_ON(SOL_SAFE_FUNCTION_OBJECTS_I_)
+ using function = protected_function;
+ using main_function = main_protected_function;
+ using stack_function = stack_protected_function;
+ using stack_aligned_function = stack_aligned_safe_function;
+#else
+ using function = unsafe_function;
+ using main_function = main_unsafe_function;
+ using stack_function = stack_unsafe_function;
+ using stack_aligned_function = stack_aligned_unsafe_function;
+#endif
+ using stack_aligned_stack_handler_function = basic_protected_function<stack_reference, true, stack_reference>;
+
+ struct unsafe_function_result;
+ struct protected_function_result;
+ using safe_function_result = protected_function_result;
+#if SOL_IS_ON(SOL_SAFE_FUNCTION_OBJECTS_I_)
+ using function_result = safe_function_result;
+#else
+ using function_result = unsafe_function_result;
+#endif
+
+ template <typename base_t>
+ class basic_object_base;
+ template <typename base_t>
+ class basic_object;
+ template <typename base_t>
+ class basic_userdata;
+ template <typename base_t>
+ class basic_lightuserdata;
+ template <typename base_t>
+ class basic_coroutine;
+ template <typename base_t>
+ class basic_thread;
+
+ using object = basic_object<reference>;
+ using userdata = basic_userdata<reference>;
+ using lightuserdata = basic_lightuserdata<reference>;
+ using thread = basic_thread<reference>;
+ using coroutine = basic_coroutine<reference>;
+ using main_object = basic_object<main_reference>;
+ using main_userdata = basic_userdata<main_reference>;
+ using main_lightuserdata = basic_lightuserdata<main_reference>;
+ using main_coroutine = basic_coroutine<main_reference>;
+ using stack_object = basic_object<stack_reference>;
+ using stack_userdata = basic_userdata<stack_reference>;
+ using stack_lightuserdata = basic_lightuserdata<stack_reference>;
+ using stack_thread = basic_thread<stack_reference>;
+ using stack_coroutine = basic_coroutine<stack_reference>;
+
+ struct stack_proxy_base;
+ struct stack_proxy;
+ struct variadic_args;
+ struct variadic_results;
+ struct stack_count;
+ struct this_state;
+ struct this_main_state;
+ struct this_environment;
+
+ class state_view;
+ class state;
+
+ template <typename T>
+ struct as_table_t;
+ template <typename T>
+ struct as_container_t;
+ template <typename T>
+ struct nested;
+ template <typename T>
+ struct light;
+ template <typename T>
+ struct user;
+ template <typename T>
+ struct as_args_t;
+ template <typename T>
+ struct protect_t;
+ template <typename F, typename... Policies>
+ struct policy_wrapper;
+
+ template <typename T>
+ struct usertype_traits;
+ template <typename T>
+ struct unique_usertype_traits;
+
+ template <typename... Args>
+ struct types {
+ typedef std::make_index_sequence<sizeof...(Args)> indices;
+ static constexpr std::size_t size() {
+ return sizeof...(Args);
+ }
+ };
+
+ template <typename T>
+ struct derive : std::false_type {
+ typedef types<> type;
+ };
+
+ template <typename T>
+ struct base : std::false_type {
+ typedef types<> type;
+ };
+
+ template <typename T>
+ struct weak_derive {
+ static bool value;
+ };
+
+ template <typename T>
+ bool weak_derive<T>::value = false;
+
+ namespace stack {
+ struct record;
+ }
+
+#if SOL_IS_OFF(SOL_USE_BOOST_I_)
+ template <class T>
+ class optional;
+
+ template <class T>
+ class optional<T&>;
+#endif
+
+ using check_handler_type = int(lua_State*, int, type, type, const char*);
+
+} // namespace sol
+
+#define SOL_BASE_CLASSES(T, ...) \
+ namespace sol { \
+ template <> \
+ struct base<T> : std::true_type { \
+ typedef ::sol::types<__VA_ARGS__> type; \
+ }; \
+ } \
+ void a_sol3_detail_function_decl_please_no_collide()
+#define SOL_DERIVED_CLASSES(T, ...) \
+ namespace sol { \
+ template <> \
+ struct derive<T> : std::true_type { \
+ typedef ::sol::types<__VA_ARGS__> type; \
+ }; \
+ } \
+ void a_sol3_detail_function_decl_please_no_collide()
+
+#endif // SOL_FORWARD_HPP
+// end of sol/forward.hpp
+
+// beginning of sol/forward_detail.hpp
+
+#ifndef SOL_FORWARD_DETAIL_HPP
+#define SOL_FORWARD_DETAIL_HPP
+
+// beginning of sol/traits.hpp
+
+// beginning of sol/tuple.hpp
+
+// beginning of sol/base_traits.hpp
+
+#include <type_traits>
+
+namespace sol {
+ namespace detail {
+ struct unchecked_t {};
+ const unchecked_t unchecked = unchecked_t{};
+ } // namespace detail
+
+ namespace meta {
+ using sfinae_yes_t = std::true_type;
+ using sfinae_no_t = std::false_type;
+
+ template <typename T>
+ using void_t = void;
+
+ template <typename T>
+ using unqualified = std::remove_cv<std::remove_reference_t<T>>;
+
+ template <typename T>
+ using unqualified_t = typename unqualified<T>::type;
+
+ namespace meta_detail {
+ template <typename T>
+ struct unqualified_non_alias : unqualified<T> {};
+
+ template <template <class...> class Test, class, class... Args>
+ struct is_detected : std::false_type {};
+
+ template <template <class...> class Test, class... Args>
+ struct is_detected<Test, void_t<Test<Args...>>, Args...> : std::true_type {};
+ } // namespace meta_detail
+
+ template <template <class...> class Trait, class... Args>
+ using is_detected = typename meta_detail::is_detected<Trait, void, Args...>::type;
+
+ template <template <class...> class Trait, class... Args>
+ constexpr inline bool is_detected_v = is_detected<Trait, Args...>::value;
+
+ template <std::size_t I>
+ using index_value = std::integral_constant<std::size_t, I>;
+
+ template <bool>
+ struct conditional {
+ template <typename T, typename U>
+ using type = T;
+ };
+
+ template <>
+ struct conditional<false> {
+ template <typename T, typename U>
+ using type = U;
+ };
+
+ template <bool B, typename T, typename U>
+ using conditional_t = typename conditional<B>::template type<T, U>;
+
+ namespace meta_detail {
+ template <typename T, template <typename...> class Templ>
+ struct is_specialization_of : std::false_type {};
+ template <typename... T, template <typename...> class Templ>
+ struct is_specialization_of<Templ<T...>, Templ> : std::true_type {};
+ } // namespace meta_detail
+
+ template <typename T, template <typename...> class Templ>
+ using is_specialization_of = meta_detail::is_specialization_of<std::remove_cv_t<T>, Templ>;
+
+ template <typename T, template <typename...> class Templ>
+ inline constexpr bool is_specialization_of_v = is_specialization_of<std::remove_cv_t<T>, Templ>::value;
+
+ template <typename T>
+ struct identity {
+ typedef T type;
+ };
+
+ template <typename T>
+ using identity_t = typename identity<T>::type;
+
+ template <typename T>
+ using is_builtin_type = std::integral_constant<bool, std::is_arithmetic<T>::value || std::is_pointer<T>::value || std::is_array<T>::value>;
+
+ } // namespace meta
+} // namespace sol
+
+// end of sol/base_traits.hpp
+
+#include <tuple>
+#include <cstddef>
+
+namespace sol {
+ namespace detail {
+ using swallow = std::initializer_list<int>;
+ } // namespace detail
+
+ namespace meta {
+ template <typename T>
+ using is_tuple = is_specialization_of<T, std::tuple>;
+
+ template <typename T>
+ constexpr inline bool is_tuple_v = is_tuple<T>::value;
+
+ namespace detail {
+ template <typename... Args>
+ struct tuple_types_ { typedef types<Args...> type; };
+
+ template <typename... Args>
+ struct tuple_types_<std::tuple<Args...>> { typedef types<Args...> type; };
+ } // namespace detail
+
+ template <typename... Args>
+ using tuple_types = typename detail::tuple_types_<Args...>::type;
+
+ template <typename Arg>
+ struct pop_front_type;
+
+ template <typename Arg>
+ using pop_front_type_t = typename pop_front_type<Arg>::type;
+
+ template <typename... Args>
+ struct pop_front_type<types<Args...>> {
+ typedef void front_type;
+ typedef types<Args...> type;
+ };
+
+ template <typename Arg, typename... Args>
+ struct pop_front_type<types<Arg, Args...>> {
+ typedef Arg front_type;
+ typedef types<Args...> type;
+ };
+
+ template <std::size_t N, typename Tuple>
+ using tuple_element = std::tuple_element<N, std::remove_reference_t<Tuple>>;
+
+ template <std::size_t N, typename Tuple>
+ using tuple_element_t = std::tuple_element_t<N, std::remove_reference_t<Tuple>>;
+
+ template <std::size_t N, typename Tuple>
+ using unqualified_tuple_element = unqualified<tuple_element_t<N, Tuple>>;
+
+ template <std::size_t N, typename Tuple>
+ using unqualified_tuple_element_t = unqualified_t<tuple_element_t<N, Tuple>>;
+
+ } // namespace meta
+} // namespace sol
+
+// end of sol/tuple.hpp
+
+// beginning of sol/bind_traits.hpp
+
+namespace sol { namespace meta {
+ namespace meta_detail {
+
+ template <class F>
+ struct check_deducible_signature {
+ struct nat {};
+ template <class G>
+ static auto test(int) -> decltype(&G::operator(), void());
+ template <class>
+ static auto test(...) -> nat;
+
+ using type = std::is_void<decltype(test<F>(0))>;
+ };
+ } // namespace meta_detail
+
+ template <class F>
+ struct has_deducible_signature : meta_detail::check_deducible_signature<F>::type {};
+
+ namespace meta_detail {
+
+ template <std::size_t I, typename T>
+ struct void_tuple_element : meta::tuple_element<I, T> {};
+
+ template <std::size_t I>
+ struct void_tuple_element<I, std::tuple<>> {
+ typedef void type;
+ };
+
+ template <std::size_t I, typename T>
+ using void_tuple_element_t = typename void_tuple_element<I, T>::type;
+
+ template <bool it_is_noexcept, bool has_c_variadic, typename T, typename R, typename... Args>
+ struct basic_traits {
+ private:
+ using first_type = meta::conditional_t<std::is_void<T>::value, int, T>&;
+
+ public:
+ inline static constexpr const bool is_noexcept = it_is_noexcept;
+ inline static constexpr bool is_member_function = std::is_void<T>::value;
+ inline static constexpr bool has_c_var_arg = has_c_variadic;
+ inline static constexpr std::size_t arity = sizeof...(Args);
+ inline static constexpr std::size_t free_arity = sizeof...(Args) + static_cast<std::size_t>(!std::is_void<T>::value);
+ typedef types<Args...> args_list;
+ typedef std::tuple<Args...> args_tuple;
+ typedef T object_type;
+ typedef R return_type;
+ typedef tuple_types<R> returns_list;
+ typedef R(function_type)(Args...);
+ typedef meta::conditional_t<std::is_void<T>::value, args_list, types<first_type, Args...>> free_args_list;
+ typedef meta::conditional_t<std::is_void<T>::value, R(Args...), R(first_type, Args...)> free_function_type;
+ typedef meta::conditional_t<std::is_void<T>::value, R (*)(Args...), R (*)(first_type, Args...)> free_function_pointer_type;
+ typedef std::remove_pointer_t<free_function_pointer_type> signature_type;
+ template <std::size_t i>
+ using arg_at = void_tuple_element_t<i, args_tuple>;
+ };
+
+ template <typename Signature, bool b = has_deducible_signature<Signature>::value>
+ struct fx_traits : basic_traits<false, false, void, void> {};
+
+ // Free Functions
+ template <typename R, typename... Args>
+ struct fx_traits<R(Args...), false> : basic_traits<false, false, void, R, Args...> {
+ typedef R (*function_pointer_type)(Args...);
+ };
+
+ template <typename R, typename... Args>
+ struct fx_traits<R (*)(Args...), false> : basic_traits<false, false, void, R, Args...> {
+ typedef R (*function_pointer_type)(Args...);
+ };
+
+ template <typename R, typename... Args>
+ struct fx_traits<R(Args..., ...), false> : basic_traits<false, true, void, R, Args...> {
+ typedef R (*function_pointer_type)(Args..., ...);
+ };
+
+ template <typename R, typename... Args>
+ struct fx_traits<R (*)(Args..., ...), false> : basic_traits<false, true, void, R, Args...> {
+ typedef R (*function_pointer_type)(Args..., ...);
+ };
+
+ // Member Functions
+ /* C-Style Variadics */
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (T::*)(Args...), false> : basic_traits<false, false, T, R, Args...> {
+ typedef R (T::*function_pointer_type)(Args...);
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (T::*)(Args..., ...), false> : basic_traits<false, true, T, R, Args...> {
+ typedef R (T::*function_pointer_type)(Args..., ...);
+ };
+
+ /* Const Volatile */
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (T::*)(Args...) const, false> : basic_traits<false, false, T, R, Args...> {
+ typedef R (T::*function_pointer_type)(Args...) const;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (T::*)(Args..., ...) const, false> : basic_traits<false, true, T, R, Args...> {
+ typedef R (T::*function_pointer_type)(Args..., ...) const;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (T::*)(Args...) const volatile, false> : basic_traits<false, false, T, R, Args...> {
+ typedef R (T::*function_pointer_type)(Args...) const volatile;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (T::*)(Args..., ...) const volatile, false> : basic_traits<false, true, T, R, Args...> {
+ typedef R (T::*function_pointer_type)(Args..., ...) const volatile;
+ };
+
+ /* Member Function Qualifiers */
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (T::*)(Args...)&, false> : basic_traits<false, false, T, R, Args...> {
+ typedef R (T::*function_pointer_type)(Args...) &;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (T::*)(Args..., ...)&, false> : basic_traits<false, true, T, R, Args...> {
+ typedef R (T::*function_pointer_type)(Args..., ...) &;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (T::*)(Args...) const&, false> : basic_traits<false, false, T, R, Args...> {
+ typedef R (T::*function_pointer_type)(Args...) const&;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (T::*)(Args..., ...) const&, false> : basic_traits<false, true, T, R, Args...> {
+ typedef R (T::*function_pointer_type)(Args..., ...) const&;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (T::*)(Args...) const volatile&, false> : basic_traits<false, false, T, R, Args...> {
+ typedef R (T::*function_pointer_type)(Args...) const volatile&;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (T::*)(Args..., ...) const volatile&, false> : basic_traits<false, true, T, R, Args...> {
+ typedef R (T::*function_pointer_type)(Args..., ...) const volatile&;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (T::*)(Args...)&&, false> : basic_traits<false, false, T, R, Args...> {
+ typedef R (T::*function_pointer_type)(Args...) &&;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (T::*)(Args..., ...)&&, false> : basic_traits<false, true, T, R, Args...> {
+ typedef R (T::*function_pointer_type)(Args..., ...) &&;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (T::*)(Args...) const&&, false> : basic_traits<false, false, T, R, Args...> {
+ typedef R (T::*function_pointer_type)(Args...) const&&;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (T::*)(Args..., ...) const&&, false> : basic_traits<false, true, T, R, Args...> {
+ typedef R (T::*function_pointer_type)(Args..., ...) const&&;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (T::*)(Args...) const volatile&&, false> : basic_traits<false, false, T, R, Args...> {
+ typedef R (T::*function_pointer_type)(Args...) const volatile&&;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (T::*)(Args..., ...) const volatile&&, false> : basic_traits<false, true, T, R, Args...> {
+ typedef R (T::*function_pointer_type)(Args..., ...) const volatile&&;
+ };
+
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_)
+
+ template <typename R, typename... Args>
+ struct fx_traits<R(Args...) noexcept, false> : basic_traits<true, false, void, R, Args...> {
+ typedef R (*function_pointer_type)(Args...) noexcept;
+ };
+
+ template <typename R, typename... Args>
+ struct fx_traits<R (*)(Args...) noexcept, false> : basic_traits<true, false, void, R, Args...> {
+ typedef R (*function_pointer_type)(Args...) noexcept;
+ };
+
+ template <typename R, typename... Args>
+ struct fx_traits<R(Args..., ...) noexcept, false> : basic_traits<true, true, void, R, Args...> {
+ typedef R (*function_pointer_type)(Args..., ...) noexcept;
+ };
+
+ template <typename R, typename... Args>
+ struct fx_traits<R (*)(Args..., ...) noexcept, false> : basic_traits<true, true, void, R, Args...> {
+ typedef R (*function_pointer_type)(Args..., ...) noexcept;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (T::*)(Args...) noexcept, false> : basic_traits<true, false, T, R, Args...> {
+ typedef R (T::*function_pointer_type)(Args...) noexcept;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (T::*)(Args..., ...) noexcept, false> : basic_traits<true, true, T, R, Args...> {
+ typedef R (T::*function_pointer_type)(Args..., ...) noexcept;
+ };
+
+ /* Const Volatile */
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (T::*)(Args...) const noexcept, false> : basic_traits<true, false, T, R, Args...> {
+ typedef R (T::*function_pointer_type)(Args...) const noexcept;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (T::*)(Args..., ...) const noexcept, false> : basic_traits<true, true, T, R, Args...> {
+ typedef R (T::*function_pointer_type)(Args..., ...) const noexcept;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (T::*)(Args...) const volatile noexcept, false> : basic_traits<true, false, T, R, Args...> {
+ typedef R (T::*function_pointer_type)(Args...) const volatile noexcept;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (T::*)(Args..., ...) const volatile noexcept, false> : basic_traits<true, true, T, R, Args...> {
+ typedef R (T::*function_pointer_type)(Args..., ...) const volatile noexcept;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (T::*)(Args...) & noexcept, false> : basic_traits<true, false, T, R, Args...> {
+ typedef R (T::*function_pointer_type)(Args...) & noexcept;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (T::*)(Args..., ...) & noexcept, false> : basic_traits<true, true, T, R, Args...> {
+ typedef R (T::*function_pointer_type)(Args..., ...) & noexcept;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (T::*)(Args...) const& noexcept, false> : basic_traits<true, false, T, R, Args...> {
+ typedef R (T::*function_pointer_type)(Args...) const& noexcept;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (T::*)(Args..., ...) const& noexcept, false> : basic_traits<true, true, T, R, Args...> {
+ typedef R (T::*function_pointer_type)(Args..., ...) const& noexcept;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (T::*)(Args...) const volatile& noexcept, false> : basic_traits<true, false, T, R, Args...> {
+ typedef R (T::*function_pointer_type)(Args...) const volatile& noexcept;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (T::*)(Args..., ...) const volatile& noexcept, false> : basic_traits<true, true, T, R, Args...> {
+ typedef R (T::*function_pointer_type)(Args..., ...) const volatile& noexcept;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (T::*)(Args...) && noexcept, false> : basic_traits<true, false, T, R, Args...> {
+ typedef R (T::*function_pointer_type)(Args...) && noexcept;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (T::*)(Args..., ...) && noexcept, false> : basic_traits<true, true, T, R, Args...> {
+ typedef R (T::*function_pointer_type)(Args..., ...) && noexcept;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (T::*)(Args...) const&& noexcept, false> : basic_traits<true, false, T, R, Args...> {
+ typedef R (T::*function_pointer_type)(Args...) const&& noexcept;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (T::*)(Args..., ...) const&& noexcept, false> : basic_traits<true, true, T, R, Args...> {
+ typedef R (T::*function_pointer_type)(Args..., ...) const&& noexcept;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (T::*)(Args...) const volatile&& noexcept, false> : basic_traits<true, false, T, R, Args...> {
+ typedef R (T::*function_pointer_type)(Args...) const volatile&& noexcept;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (T::*)(Args..., ...) const volatile&& noexcept, false> : basic_traits<true, true, T, R, Args...> {
+ typedef R (T::*function_pointer_type)(Args..., ...) const volatile&& noexcept;
+ };
+
+#endif // noexcept is part of a function's type
+
+#if SOL_IS_ON(SOL_COMPILER_VCXX_I_) && SOL_IS_ON(SOL_PLATFORM_X86_I_)
+ template <typename R, typename... Args>
+ struct fx_traits<R __stdcall(Args...), false> : basic_traits<false, false, void, R, Args...> {
+ typedef R(__stdcall* function_pointer_type)(Args...);
+ };
+
+ template <typename R, typename... Args>
+ struct fx_traits<R(__stdcall*)(Args...), false> : basic_traits<false, false, void, R, Args...> {
+ typedef R(__stdcall* function_pointer_type)(Args...);
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (__stdcall T::*)(Args...), false> : basic_traits<false, false, T, R, Args...> {
+ typedef R (__stdcall T::*function_pointer_type)(Args...);
+ };
+
+ /* Const Volatile */
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (__stdcall T::*)(Args...) const, false> : basic_traits<false, false, T, R, Args...> {
+ typedef R (__stdcall T::*function_pointer_type)(Args...) const;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (__stdcall T::*)(Args...) const volatile, false> : basic_traits<false, false, T, R, Args...> {
+ typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile;
+ };
+
+ /* Member Function Qualifiers */
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (__stdcall T::*)(Args...)&, false> : basic_traits<false, false, T, R, Args...> {
+ typedef R (__stdcall T::*function_pointer_type)(Args...) &;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (__stdcall T::*)(Args...) const&, false> : basic_traits<false, false, T, R, Args...> {
+ typedef R (__stdcall T::*function_pointer_type)(Args...) const&;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (__stdcall T::*)(Args...) const volatile&, false> : basic_traits<false, false, T, R, Args...> {
+ typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile&;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (__stdcall T::*)(Args...)&&, false> : basic_traits<false, false, T, R, Args...> {
+ typedef R (__stdcall T::*function_pointer_type)(Args...) &&;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (__stdcall T::*)(Args...) const&&, false> : basic_traits<false, false, T, R, Args...> {
+ typedef R (__stdcall T::*function_pointer_type)(Args...) const&&;
+ };
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (__stdcall T::*)(Args...) const volatile&&, false> : basic_traits<false, false, T, R, Args...> {
+ typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile&&;
+ };
+
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_)
+
+ template <typename R, typename... Args>
+ struct fx_traits<R __stdcall(Args...) noexcept, false> : basic_traits<true, false, void, R, Args...> {
+ typedef R(__stdcall* function_pointer_type)(Args...) noexcept;
+ };
+
+ template <typename R, typename... Args>
+ struct fx_traits<R(__stdcall*)(Args...) noexcept, false> : basic_traits<true, false, void, R, Args...> {
+ typedef R(__stdcall* function_pointer_type)(Args...) noexcept;
+ };
+
+ /* __stdcall cannot be applied to functions with varargs*/
+ /*template <typename R, typename... Args>
+ struct fx_traits<__stdcall R(Args..., ...) noexcept, false> : basic_traits<true, true, void, R, Args...> {
+ typedef R(__stdcall* function_pointer_type)(Args..., ...) noexcept;
+ };
+
+ template <typename R, typename... Args>
+ struct fx_traits<R (__stdcall *)(Args..., ...) noexcept, false> : basic_traits<true, true, void, R, Args...> {
+ typedef R(__stdcall* function_pointer_type)(Args..., ...) noexcept;
+ };*/
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (__stdcall T::*)(Args...) noexcept, false> : basic_traits<true, false, T, R, Args...> {
+ typedef R (__stdcall T::*function_pointer_type)(Args...) noexcept;
+ };
+
+ /* __stdcall does not work with varargs */
+ /*template <typename T, typename R, typename... Args>
+ struct fx_traits<R (__stdcall T::*)(Args..., ...) noexcept, false> : basic_traits<true, true, T, R, Args...> {
+ typedef R (__stdcall T::*function_pointer_type)(Args..., ...) noexcept;
+ };*/
+
+ /* Const Volatile */
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (__stdcall T::*)(Args...) const noexcept, false> : basic_traits<true, false, T, R, Args...> {
+ typedef R (__stdcall T::*function_pointer_type)(Args...) const noexcept;
+ };
+
+ /* __stdcall does not work with varargs */
+ /*template <typename T, typename R, typename... Args>
+ struct fx_traits<R (__stdcall T::*)(Args..., ...) const noexcept, false> : basic_traits<true, true, T, R, Args...> {
+ typedef R (__stdcall T::*function_pointer_type)(Args..., ...) const noexcept;
+ };*/
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (__stdcall T::*)(Args...) const volatile noexcept, false> : basic_traits<true, false, T, R, Args...> {
+ typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile noexcept;
+ };
+
+ /* __stdcall does not work with varargs */
+ /*template <typename T, typename R, typename... Args>
+ struct fx_traits<R (__stdcall T::*)(Args..., ...) const volatile noexcept, false> : basic_traits<true, true, T, R, Args...> {
+ typedef R (__stdcall T::*function_pointer_type)(Args..., ...) const volatile noexcept;
+ };*/
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (__stdcall T::*)(Args...) & noexcept, false> : basic_traits<true, false, T, R, Args...> {
+ typedef R (__stdcall T::*function_pointer_type)(Args...) & noexcept;
+ };
+
+ /* __stdcall does not work with varargs */
+ /*template <typename T, typename R, typename... Args>
+ struct fx_traits<R (__stdcall T::*)(Args..., ...) & noexcept, false> : basic_traits<true, true, T, R, Args...> {
+ typedef R (__stdcall T::*function_pointer_type)(Args..., ...) & noexcept;
+ };*/
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (__stdcall T::*)(Args...) const& noexcept, false> : basic_traits<true, false, T, R, Args...> {
+ typedef R (__stdcall T::*function_pointer_type)(Args...) const& noexcept;
+ };
+
+ /* __stdcall does not work with varargs */
+ /*template <typename T, typename R, typename... Args>
+ struct fx_traits<R (__stdcall T::*)(Args..., ...) const& noexcept, false> : basic_traits<true, true, T, R, Args...> {
+ typedef R (__stdcall T::*function_pointer_type)(Args..., ...) const& noexcept;
+ };*/
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (__stdcall T::*)(Args...) const volatile& noexcept, false> : basic_traits<true, false, T, R, Args...> {
+ typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile& noexcept;
+ };
+
+ /* __stdcall does not work with varargs */
+ /*template <typename T, typename R, typename... Args>
+ struct fx_traits<R (__stdcall T::*)(Args..., ...) const volatile& noexcept, false> : basic_traits<true, true, T, R, Args...> {
+ typedef R (__stdcall T::*function_pointer_type)(Args..., ...) const volatile& noexcept;
+ };*/
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (__stdcall T::*)(Args...) && noexcept, false> : basic_traits<true, false, T, R, Args...> {
+ typedef R (__stdcall T::*function_pointer_type)(Args...) && noexcept;
+ };
+
+ /* __stdcall does not work with varargs */
+ /*template <typename T, typename R, typename... Args>
+ struct fx_traits<R (__stdcall T::*)(Args..., ...) && noexcept, false> : basic_traits<true, true, T, R, Args...> {
+ typedef R (__stdcall T::*function_pointer_type)(Args..., ...) && noexcept;
+ };*/
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (__stdcall T::*)(Args...) const&& noexcept, false> : basic_traits<true, false, T, R, Args...> {
+ typedef R (__stdcall T::*function_pointer_type)(Args...) const&& noexcept;
+ };
+
+ /* __stdcall does not work with varargs */
+ /*template <typename T, typename R, typename... Args>
+ struct fx_traits<R (__stdcall T::*)(Args..., ...) const&& noexcept, false> : basic_traits<true, true, T, R, Args...> {
+ typedef R (__stdcall T::*function_pointer_type)(Args..., ...) const&& noexcept;
+ };*/
+
+ template <typename T, typename R, typename... Args>
+ struct fx_traits<R (__stdcall T::*)(Args...) const volatile&& noexcept, false> : basic_traits<true, false, T, R, Args...> {
+ typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile&& noexcept;
+ };
+
+ /* __stdcall does not work with varargs */
+ /*template <typename T, typename R, typename... Args>
+ struct fx_traits<R (__stdcall T::*)(Args..., ...) const volatile&& noexcept, false> : basic_traits<true, true, T, R, Args...> {
+ typedef R (__stdcall T::*function_pointer_type)(Args..., ...) const volatile&& noexcept;
+ };*/
+#endif // noexcept is part of a function's type
+#endif // __stdcall x86 VC++ bug
+
+ template <typename Signature>
+ struct fx_traits<Signature, true>
+ : public fx_traits<typename fx_traits<decltype(&Signature::operator())>::function_type, false> {};
+
+ template <typename Signature, bool b = std::is_member_object_pointer<Signature>::value>
+ struct callable_traits
+ : public fx_traits<std::decay_t<Signature>> {};
+
+ template <typename R, typename T>
+ struct callable_traits<R(T::*), true> {
+ typedef meta::conditional_t<std::is_array_v<R>, std::add_lvalue_reference_t<R>, R> return_type;
+ typedef return_type Arg;
+ typedef T object_type;
+ using signature_type = R(T::*);
+ inline static constexpr bool is_noexcept = false;
+ inline static constexpr bool is_member_function = false;
+ inline static constexpr std::size_t arity = 1;
+ inline static constexpr std::size_t free_arity = 2;
+ typedef std::tuple<Arg> args_tuple;
+ typedef types<Arg> args_list;
+ typedef types<T, Arg> free_args_list;
+ typedef meta::tuple_types<return_type> returns_list;
+ typedef return_type(function_type)(T&, return_type);
+ typedef return_type (*function_pointer_type)(T&, Arg);
+ typedef return_type (*free_function_pointer_type)(T&, Arg);
+ template <std::size_t i>
+ using arg_at = void_tuple_element_t<i, args_tuple>;
+ };
+
+ } // namespace meta_detail
+
+ template <typename Signature>
+ struct bind_traits : meta_detail::callable_traits<Signature> {};
+
+ template <typename Signature>
+ using function_args_t = typename bind_traits<Signature>::args_list;
+
+ template <typename Signature>
+ using function_signature_t = typename bind_traits<Signature>::signature_type;
+
+ template <typename Signature>
+ using function_return_t = typename bind_traits<Signature>::return_type;
+}} // namespace sol::meta
+
+// end of sol/bind_traits.hpp
+
+// beginning of sol/pointer_like.hpp
+
+#include <utility>
+#include <type_traits>
+
+namespace sol {
+
+ namespace meta {
+ namespace meta_detail {
+ template <typename T>
+ using is_dereferenceable_test = decltype(*std::declval<T>());
+
+ template <typename T>
+ using is_explicitly_dereferenceable_test = decltype(std::declval<T>().operator*());
+ }
+
+ template <typename T>
+ using is_pointer_like = std::integral_constant<bool, !std::is_array_v<T> && (std::is_pointer_v<T> || is_detected_v<meta_detail::is_explicitly_dereferenceable_test, T>)>;
+
+ template <typename T>
+ constexpr inline bool is_pointer_like_v = is_pointer_like<T>::value;
+ } // namespace meta
+
+ namespace detail {
+
+ template <typename T>
+ auto unwrap(T&& item) -> decltype(std::forward<T>(item)) {
+ return std::forward<T>(item);
+ }
+
+ template <typename T>
+ T& unwrap(std::reference_wrapper<T> arg) {
+ return arg.get();
+ }
+
+ template <typename T>
+ inline decltype(auto) deref(T&& item) {
+ using Tu = meta::unqualified_t<T>;
+ if constexpr (meta::is_pointer_like_v<Tu>) {
+ return *std::forward<T>(item);
+ }
+ else {
+ return std::forward<T>(item);
+ }
+ }
+
+ template <typename T>
+ inline decltype(auto) deref_move_only(T&& item) {
+ using Tu = meta::unqualified_t<T>;
+ if constexpr (meta::is_pointer_like_v<Tu> && !std::is_pointer_v<Tu> && !std::is_copy_constructible_v<Tu>) {
+ return *std::forward<T>(item);
+ }
+ else {
+ return std::forward<T>(item);
+ }
+ }
+
+ template <typename T>
+ inline T* ptr(T& val) {
+ return std::addressof(val);
+ }
+
+ template <typename T>
+ inline T* ptr(std::reference_wrapper<T> val) {
+ return std::addressof(val.get());
+ }
+
+ template <typename T>
+ inline T* ptr(T* val) {
+ return val;
+ }
+ } // namespace detail
+} // namespace sol
+
+// end of sol/pointer_like.hpp
+
+// beginning of sol/string_view.hpp
+
+#include <cstddef>
+#include <string>
+#include <string_view>
+#include <functional>
+
+namespace sol {
+ template <typename C, typename T = std::char_traits<C>>
+ using basic_string_view = std::basic_string_view<C, T>;
+
+ typedef std::string_view string_view;
+ typedef std::wstring_view wstring_view;
+ typedef std::u16string_view u16string_view;
+ typedef std::u32string_view u32string_view;
+ typedef std::hash<std::string_view> string_view_hash;
+} // namespace sol
+
+// end of sol/string_view.hpp
+
+#include <type_traits>
+#include <cstdint>
+#include <memory>
+#include <functional>
+#include <array>
+#include <iterator>
+#include <iosfwd>
+#if SOL_IS_ON(SOL_STD_VARIANT_I_)
+#include <variant>
+#endif // variant is weird on XCode, thanks XCode
+
+namespace sol { namespace meta {
+ template <typename T>
+ struct unwrapped {
+ typedef T type;
+ };
+
+ template <typename T>
+ struct unwrapped<std::reference_wrapper<T>> {
+ typedef T type;
+ };
+
+ template <typename T>
+ using unwrapped_t = typename unwrapped<T>::type;
+
+ template <typename T>
+ struct unwrap_unqualified : unwrapped<unqualified_t<T>> {};
+
+ template <typename T>
+ using unwrap_unqualified_t = typename unwrap_unqualified<T>::type;
+
+ template <typename T>
+ struct remove_member_pointer;
+
+ template <typename R, typename T>
+ struct remove_member_pointer<R T::*> {
+ typedef R type;
+ };
+
+ template <typename R, typename T>
+ struct remove_member_pointer<R T::*const> {
+ typedef R type;
+ };
+
+ template <typename T>
+ using remove_member_pointer_t = remove_member_pointer<T>;
+
+ template <typename T, typename...>
+ struct all_same : std::true_type {};
+
+ template <typename T, typename U, typename... Args>
+ struct all_same<T, U, Args...> : std::integral_constant<bool, std::is_same<T, U>::value && all_same<T, Args...>::value> {};
+
+ template <typename T, typename...>
+ struct any_same : std::false_type {};
+
+ template <typename T, typename U, typename... Args>
+ struct any_same<T, U, Args...> : std::integral_constant<bool, std::is_same<T, U>::value || any_same<T, Args...>::value> {};
+
+ template <typename T, typename... Args>
+ constexpr inline bool any_same_v = any_same<T, Args...>::value;
+
+ template <bool B>
+ using boolean = std::integral_constant<bool, B>;
+
+ template <bool B>
+ constexpr inline bool boolean_v = boolean<B>::value;
+
+ template <typename T>
+ using neg = boolean<!T::value>;
+
+ template <typename T>
+ constexpr inline bool neg_v = neg<T>::value;
+
+ template <typename... Args>
+ struct all : boolean<true> {};
+
+ template <typename T, typename... Args>
+ struct all<T, Args...> : std::conditional_t<T::value, all<Args...>, boolean<false>> {};
+
+ template <typename... Args>
+ struct any : boolean<false> {};
+
+ template <typename T, typename... Args>
+ struct any<T, Args...> : std::conditional_t<T::value, boolean<true>, any<Args...>> {};
+
+ template <typename T, typename... Args>
+ constexpr inline bool all_v = all<T, Args...>::value;
+
+ template <typename T, typename... Args>
+ constexpr inline bool any_v = any<T, Args...>::value;
+
+ enum class enable_t { _ };
+
+ constexpr const auto enabler = enable_t::_;
+
+ template <bool value, typename T = void>
+ using disable_if_t = std::enable_if_t<!value, T>;
+
+ template <typename... Args>
+ using enable = std::enable_if_t<all<Args...>::value, enable_t>;
+
+ template <typename... Args>
+ using disable = std::enable_if_t<neg<all<Args...>>::value, enable_t>;
+
+ template <typename... Args>
+ using enable_any = std::enable_if_t<any<Args...>::value, enable_t>;
+
+ template <typename... Args>
+ using disable_any = std::enable_if_t<neg<any<Args...>>::value, enable_t>;
+
+ template <typename V, typename... Vs>
+ struct find_in_pack_v : boolean<false> {};
+
+ template <typename V, typename Vs1, typename... Vs>
+ struct find_in_pack_v<V, Vs1, Vs...> : any<boolean<(V::value == Vs1::value)>, find_in_pack_v<V, Vs...>> {};
+
+ namespace meta_detail {
+ template <std::size_t I, typename T, typename... Args>
+ struct index_in_pack : std::integral_constant<std::size_t, SIZE_MAX> {};
+
+ template <std::size_t I, typename T, typename T1, typename... Args>
+ struct index_in_pack<I, T, T1, Args...>
+ : conditional_t<std::is_same<T, T1>::value, std::integral_constant<std::ptrdiff_t, I>, index_in_pack<I + 1, T, Args...>> {};
+ } // namespace meta_detail
+
+ template <typename T, typename... Args>
+ struct index_in_pack : meta_detail::index_in_pack<0, T, Args...> {};
+
+ template <typename T, typename List>
+ struct index_in : meta_detail::index_in_pack<0, T, List> {};
+
+ template <typename T, typename... Args>
+ struct index_in<T, types<Args...>> : meta_detail::index_in_pack<0, T, Args...> {};
+
+ template <std::size_t I, typename... Args>
+ struct at_in_pack {};
+
+ template <std::size_t I, typename... Args>
+ using at_in_pack_t = typename at_in_pack<I, Args...>::type;
+
+ template <std::size_t I, typename Arg, typename... Args>
+ struct at_in_pack<I, Arg, Args...> : std::conditional<I == 0, Arg, at_in_pack_t<I - 1, Args...>> {};
+
+ template <typename Arg, typename... Args>
+ struct at_in_pack<0, Arg, Args...> {
+ typedef Arg type;
+ };
+
+ namespace meta_detail {
+ template <typename, typename TI>
+ using on_even = meta::boolean<(TI::value % 2) == 0>;
+
+ template <typename, typename TI>
+ using on_odd = meta::boolean<(TI::value % 2) == 1>;
+
+ template <typename, typename>
+ using on_always = std::true_type;
+
+ template <template <typename...> class When, std::size_t Limit, std::size_t I, template <typename...> class Pred, typename... Ts>
+ struct count_when_for_pack : std::integral_constant<std::size_t, 0> {};
+ template <template <typename...> class When, std::size_t Limit, std::size_t I, template <typename...> class Pred, typename T, typename... Ts>
+ struct count_when_for_pack<When, Limit, I, Pred, T, Ts...> : conditional_t < sizeof...(Ts)
+ == 0
+ || Limit<2, std::integral_constant<std::size_t, I + static_cast<std::size_t>(Limit != 0 && Pred<T>::value)>,
+ count_when_for_pack<When, Limit - static_cast<std::size_t>(When<T, std::integral_constant<std::size_t, I>>::value),
+ I + static_cast<std::size_t>(When<T, std::integral_constant<std::size_t, I>>::value&& Pred<T>::value), Pred, Ts...>> {};
+ } // namespace meta_detail
+
+ template <template <typename...> class Pred, typename... Ts>
+ struct count_for_pack : meta_detail::count_when_for_pack<meta_detail::on_always, sizeof...(Ts), 0, Pred, Ts...> {};
+
+ template <template <typename...> class Pred, typename... Ts>
+ inline constexpr std::size_t count_for_pack_v = count_for_pack<Pred, Ts...>::value;
+
+ template <template <typename...> class Pred, typename List>
+ struct count_for;
+
+ template <template <typename...> class Pred, typename... Args>
+ struct count_for<Pred, types<Args...>> : count_for_pack<Pred, Args...> {};
+
+ template <std::size_t Limit, template <typename...> class Pred, typename... Ts>
+ struct count_for_to_pack : meta_detail::count_when_for_pack<meta_detail::on_always, Limit, 0, Pred, Ts...> {};
+
+ template <std::size_t Limit, template <typename...> class Pred, typename... Ts>
+ inline constexpr std::size_t count_for_to_pack_v = count_for_to_pack<Limit, Pred, Ts...>::value;
+
+ template <template <typename...> class When, std::size_t Limit, template <typename...> class Pred, typename... Ts>
+ struct count_when_for_to_pack : meta_detail::count_when_for_pack<When, Limit, 0, Pred, Ts...> {};
+
+ template <template <typename...> class When, std::size_t Limit, template <typename...> class Pred, typename... Ts>
+ inline constexpr std::size_t count_when_for_to_pack_v = count_when_for_to_pack<When, Limit, Pred, Ts...>::value;
+
+ template <template <typename...> class Pred, typename... Ts>
+ using count_even_for_pack = count_when_for_to_pack<meta_detail::on_even, sizeof...(Ts), Pred, Ts...>;
+
+ template <template <typename...> class Pred, typename... Ts>
+ inline constexpr std::size_t count_even_for_pack_v = count_even_for_pack<Pred, Ts...>::value;
+
+ template <template <typename...> class Pred, typename... Ts>
+ using count_odd_for_pack = count_when_for_to_pack<meta_detail::on_odd, sizeof...(Ts), Pred, Ts...>;
+
+ template <template <typename...> class Pred, typename... Ts>
+ inline constexpr std::size_t count_odd_for_pack_v = count_odd_for_pack<Pred, Ts...>::value;
+
+ template <typename... Args>
+ struct return_type {
+ typedef std::tuple<Args...> type;
+ };
+
+ template <typename T>
+ struct return_type<T> {
+ typedef T type;
+ };
+
+ template <>
+ struct return_type<> {
+ typedef void type;
+ };
+
+ template <typename... Args>
+ using return_type_t = typename return_type<Args...>::type;
+
+ namespace meta_detail {
+ template <typename>
+ struct always_true : std::true_type {};
+ struct is_invokable_tester {
+ template <typename Fun, typename... Args>
+ static always_true<decltype(std::declval<Fun>()(std::declval<Args>()...))> test(int);
+ template <typename...>
+ static std::false_type test(...);
+ };
+ } // namespace meta_detail
+
+ template <typename T>
+ struct is_invokable;
+ template <typename Fun, typename... Args>
+ struct is_invokable<Fun(Args...)> : decltype(meta_detail::is_invokable_tester::test<Fun, Args...>(0)) {};
+
+ namespace meta_detail {
+
+ template <typename T, typename = void>
+ struct is_callable : std::is_function<std::remove_pointer_t<T>> {};
+
+ template <typename T>
+ struct is_callable<T,
+ std::enable_if_t<std::is_final<unqualified_t<T>>::value && std::is_class<unqualified_t<T>>::value
+ && std::is_same<decltype(void(&T::operator())), void>::value>> {};
+
+ template <typename T>
+ struct is_callable<T,
+ std::enable_if_t<!std::is_final<unqualified_t<T>>::value && std::is_class<unqualified_t<T>>::value
+ && std::is_destructible<unqualified_t<T>>::value>> {
+ struct F {
+ void operator()() {};
+ };
+ struct Derived : T, F {};
+ template <typename U, U>
+ struct Check;
+
+ template <typename V>
+ static sfinae_no_t test(Check<void (F::*)(), &V::operator()>*);
+
+ template <typename>
+ static sfinae_yes_t test(...);
+
+ static constexpr bool value = std::is_same_v<decltype(test<Derived>(0)), sfinae_yes_t>;
+ };
+
+ template <typename T>
+ struct is_callable<T,
+ std::enable_if_t<!std::is_final<unqualified_t<T>>::value && std::is_class<unqualified_t<T>>::value
+ && !std::is_destructible<unqualified_t<T>>::value>> {
+ struct F {
+ void operator()() {};
+ };
+ struct Derived : T, F {
+ ~Derived() = delete;
+ };
+ template <typename U, U>
+ struct Check;
+
+ template <typename V>
+ static sfinae_no_t test(Check<void (F::*)(), &V::operator()>*);
+
+ template <typename>
+ static sfinae_yes_t test(...);
+
+ static constexpr bool value = std::is_same_v<decltype(test<Derived>(0)), sfinae_yes_t>;
+ };
+
+ struct has_begin_end_impl {
+ template <typename T, typename U = unqualified_t<T>, typename B = decltype(std::declval<U&>().begin()),
+ typename E = decltype(std::declval<U&>().end())>
+ static std::true_type test(int);
+
+ template <typename...>
+ static std::false_type test(...);
+ };
+
+ struct has_key_type_impl {
+ template <typename T, typename U = unqualified_t<T>, typename V = typename U::key_type>
+ static std::true_type test(int);
+
+ template <typename...>
+ static std::false_type test(...);
+ };
+
+ struct has_key_comp_impl {
+ template <typename T, typename V = decltype(std::declval<unqualified_t<T>>().key_comp())>
+ static std::true_type test(int);
+
+ template <typename...>
+ static std::false_type test(...);
+ };
+
+ struct has_load_factor_impl {
+ template <typename T, typename V = decltype(std::declval<unqualified_t<T>>().load_factor())>
+ static std::true_type test(int);
+
+ template <typename...>
+ static std::false_type test(...);
+ };
+
+ struct has_mapped_type_impl {
+ template <typename T, typename V = typename unqualified_t<T>::mapped_type>
+ static std::true_type test(int);
+
+ template <typename...>
+ static std::false_type test(...);
+ };
+
+ struct has_value_type_impl {
+ template <typename T, typename V = typename unqualified_t<T>::value_type>
+ static std::true_type test(int);
+
+ template <typename...>
+ static std::false_type test(...);
+ };
+
+ struct has_iterator_impl {
+ template <typename T, typename V = typename unqualified_t<T>::iterator>
+ static std::true_type test(int);
+
+ template <typename...>
+ static std::false_type test(...);
+ };
+
+ struct has_key_value_pair_impl {
+ template <typename T, typename U = unqualified_t<T>, typename V = typename U::value_type, typename F = decltype(std::declval<V&>().first),
+ typename S = decltype(std::declval<V&>().second)>
+ static std::true_type test(int);
+
+ template <typename...>
+ static std::false_type test(...);
+ };
+
+ template <typename T>
+ struct has_push_back_test {
+ private:
+ template <typename C>
+ static sfinae_yes_t test(decltype(std::declval<C>().push_back(std::declval<std::add_rvalue_reference_t<typename C::value_type>>()))*);
+ template <typename C>
+ static sfinae_no_t test(...);
+
+ public:
+ static constexpr bool value = std::is_same_v<decltype(test<T>(0)), sfinae_yes_t>;
+ };
+
+ template <typename T>
+ struct has_insert_test {
+ private:
+ template <typename C>
+ static sfinae_yes_t test(decltype(std::declval<C>().insert(std::declval<std::add_rvalue_reference_t<typename C::const_iterator>>(),
+ std::declval<std::add_rvalue_reference_t<typename C::value_type>>()))*);
+ template <typename C>
+ static sfinae_no_t test(...);
+
+ public:
+ static constexpr bool value = std::is_same_v<decltype(test<T>(0)), sfinae_yes_t>;
+ };
+
+ template <typename T>
+ struct has_insert_after_test {
+ private:
+ template <typename C>
+ static sfinae_yes_t test(decltype(std::declval<C>().insert_after(std::declval<std::add_rvalue_reference_t<typename C::const_iterator>>(),
+ std::declval<std::add_rvalue_reference_t<typename C::value_type>>()))*);
+ template <typename C>
+ static sfinae_no_t test(...);
+
+ public:
+ static constexpr bool value = std::is_same_v<decltype(test<T>(0)), sfinae_yes_t>;
+ };
+
+ template <typename T>
+ struct has_size_test {
+ private:
+ template <typename C>
+ static sfinae_yes_t test(decltype(std::declval<C>().size())*);
+ template <typename C>
+ static sfinae_no_t test(...);
+
+ public:
+ static constexpr bool value = std::is_same_v<decltype(test<T>(0)), sfinae_yes_t>;
+ };
+
+ template <typename T>
+ struct has_max_size_test {
+ private:
+ template <typename C>
+ static sfinae_yes_t test(decltype(std::declval<C>().max_size())*);
+ template <typename C>
+ static sfinae_no_t test(...);
+
+ public:
+ static constexpr bool value = std::is_same_v<decltype(test<T>(0)), sfinae_yes_t>;
+ };
+
+ template <typename T>
+ struct has_to_string_test {
+ private:
+ template <typename C>
+ static sfinae_yes_t test(decltype(std::declval<C>().to_string())*);
+ template <typename C>
+ static sfinae_no_t test(...);
+
+ public:
+ static constexpr bool value = std::is_same_v<decltype(test<T>(0)), sfinae_yes_t>;
+ };
+
+ template <typename T, typename U, typename = void>
+ class supports_op_less_test : public std::false_type {};
+ template <typename T, typename U>
+ class supports_op_less_test<T, U, void_t<decltype(std::declval<T&>() < std::declval<U&>())>>
+ : public std::integral_constant<bool,
+ !is_specialization_of_v<unqualified_t<T>, std::variant> && !is_specialization_of_v<unqualified_t<U>, std::variant>> {};
+
+ template <typename T, typename U, typename = void>
+ class supports_op_equal_test : public std::false_type {};
+ template <typename T, typename U>
+ class supports_op_equal_test<T, U, void_t<decltype(std::declval<T&>() == std::declval<U&>())>>
+ : public std::integral_constant<bool,
+ !is_specialization_of_v<unqualified_t<T>, std::variant> && !is_specialization_of_v<unqualified_t<U>, std::variant>> {};
+
+ template <typename T, typename U, typename = void>
+ class supports_op_less_equal_test : public std::false_type {};
+ template <typename T, typename U>
+ class supports_op_less_equal_test<T, U, void_t<decltype(std::declval<T&>() <= std::declval<U&>())>>
+ : public std::integral_constant<bool,
+ !is_specialization_of_v<unqualified_t<T>, std::variant> && !is_specialization_of_v<unqualified_t<U>, std::variant>> {};
+
+ template <typename T, typename U, typename = void>
+ class supports_op_left_shift_test : public std::false_type {};
+ template <typename T, typename U>
+ class supports_op_left_shift_test<T, U, void_t<decltype(std::declval<T&>() << std::declval<U&>())>> : public std::true_type {};
+
+ template <typename T, typename = void>
+ class supports_adl_to_string_test : public std::false_type {};
+ template <typename T>
+ class supports_adl_to_string_test<T, void_t<decltype(to_string(std::declval<const T&>()))>> : public std::true_type {};
+
+ template <typename T, bool b>
+ struct is_matched_lookup_impl : std::false_type {};
+ template <typename T>
+ struct is_matched_lookup_impl<T, true> : std::is_same<typename T::key_type, typename T::value_type> {};
+
+ template <typename T>
+ using non_void_t = meta::conditional_t<std::is_void_v<T>, ::sol::detail::unchecked_t, T>;
+ } // namespace meta_detail
+
+ template <typename T, typename U = T>
+ class supports_op_less : public meta_detail::supports_op_less_test<T, U> {};
+
+ template <typename T, typename U = T>
+ class supports_op_equal : public meta_detail::supports_op_equal_test<T, U> {};
+
+ template <typename T, typename U = T>
+ class supports_op_less_equal : public meta_detail::supports_op_less_equal_test<T, U> {};
+
+ template <typename T, typename U = T>
+ class supports_op_left_shift : public meta_detail::supports_op_left_shift_test<T, U> {};
+
+ template <typename T>
+ class supports_adl_to_string : public meta_detail::supports_adl_to_string_test<T> {};
+
+ template <typename T>
+ class supports_to_string_member : public meta::boolean<meta_detail::has_to_string_test<meta_detail::non_void_t<T>>::value> {};
+
+ template <typename T>
+ using is_callable = boolean<meta_detail::is_callable<T>::value>;
+
+ template <typename T>
+ constexpr inline bool is_callable_v = is_callable<T>::value;
+
+ template <typename T>
+ struct has_begin_end : decltype(meta_detail::has_begin_end_impl::test<T>(0)) {};
+
+ template <typename T>
+ constexpr inline bool has_begin_end_v = has_begin_end<T>::value;
+
+ template <typename T>
+ struct has_key_value_pair : decltype(meta_detail::has_key_value_pair_impl::test<T>(0)) {};
+
+ template <typename T>
+ struct has_key_type : decltype(meta_detail::has_key_type_impl::test<T>(0)) {};
+
+ template <typename T>
+ struct has_key_comp : decltype(meta_detail::has_key_comp_impl::test<T>(0)) {};
+
+ template <typename T>
+ struct has_load_factor : decltype(meta_detail::has_load_factor_impl::test<T>(0)) {};
+
+ template <typename T>
+ struct has_mapped_type : decltype(meta_detail::has_mapped_type_impl::test<T>(0)) {};
+
+ template <typename T>
+ struct has_iterator : decltype(meta_detail::has_iterator_impl::test<T>(0)) {};
+
+ template <typename T>
+ struct has_value_type : decltype(meta_detail::has_value_type_impl::test<T>(0)) {};
+
+ template <typename T>
+ using has_push_back = meta::boolean<meta_detail::has_push_back_test<T>::value>;
+
+ template <typename T>
+ using has_max_size = meta::boolean<meta_detail::has_max_size_test<T>::value>;
+
+ template <typename T>
+ using has_insert = meta::boolean<meta_detail::has_insert_test<T>::value>;
+
+ template <typename T>
+ using has_insert_after = meta::boolean<meta_detail::has_insert_after_test<T>::value>;
+
+ template <typename T>
+ using has_size = meta::boolean<meta_detail::has_size_test<T>::value>;
+
+ template <typename T>
+ using is_associative = meta::all<has_key_type<T>, has_key_value_pair<T>, has_mapped_type<T>>;
+
+ template <typename T>
+ using is_lookup = meta::all<has_key_type<T>, has_value_type<T>>;
+
+ template <typename T>
+ using is_ordered = meta::all<has_key_comp<T>, meta::neg<has_load_factor<T>>>;
+
+ template <typename T>
+ using is_matched_lookup = meta_detail::is_matched_lookup_impl<T, is_lookup<T>::value>;
+
+ template <typename T>
+ using is_initializer_list = meta::is_specialization_of<T, std::initializer_list>;
+
+ template <typename T>
+ constexpr inline bool is_initializer_list_v = is_initializer_list<T>::value;
+
+ template <typename T, typename CharT = char>
+ using is_string_literal_array_of = boolean<std::is_array_v<T> && std::is_same_v<std::remove_all_extents_t<T>, CharT>>;
+
+ template <typename T, typename CharT = char>
+ constexpr inline bool is_string_literal_array_of_v = is_string_literal_array_of<T, CharT>::value;
+
+ template <typename T>
+ using is_string_literal_array = boolean<std::is_array_v<T> && any_same_v<std::remove_all_extents_t<T>, char, char16_t, char32_t, wchar_t>>;
+
+ template <typename T>
+ constexpr inline bool is_string_literal_array_v = is_string_literal_array<T>::value;
+
+ template <typename T, typename CharT>
+ struct is_string_of : std::false_type {};
+
+ template <typename CharT, typename CharTargetT, typename TraitsT, typename AllocT>
+ struct is_string_of<std::basic_string<CharT, TraitsT, AllocT>, CharTargetT> : std::is_same<CharT, CharTargetT> {};
+
+ template <typename T, typename CharT>
+ constexpr inline bool is_string_of_v = is_string_of<T, CharT>::value;
+
+ template <typename T, typename CharT>
+ struct is_string_view_of : std::false_type {};
+
+ template <typename CharT, typename CharTargetT, typename TraitsT>
+ struct is_string_view_of<std::basic_string_view<CharT, TraitsT>, CharTargetT> : std::is_same<CharT, CharTargetT> {};
+
+ template <typename T, typename CharT>
+ constexpr inline bool is_string_view_of_v = is_string_view_of<T, CharT>::value;
+
+ template <typename T>
+ using is_string_like
+ = meta::boolean<is_specialization_of_v<T, std::basic_string> || is_specialization_of_v<T, std::basic_string_view> || is_string_literal_array_v<T>>;
+
+ template <typename T>
+ constexpr inline bool is_string_like_v = is_string_like<T>::value;
+
+ template <typename T, typename CharT = char>
+ 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_of_v<T, CharT> || std::is_same_v<T, std::initializer_list<CharT>> || is_string_view_of_v<T, CharT>>;
+
+ template <typename T, typename CharT = char>
+ constexpr inline bool is_string_constructible_v = is_string_constructible<T, CharT>::value;
+
+ template <typename T>
+ using is_string_like_or_constructible = meta::boolean<is_string_like_v<T> || is_string_constructible_v<T>>;
+
+ template <typename T>
+ struct is_pair : std::false_type {};
+
+ template <typename T1, typename T2>
+ struct is_pair<std::pair<T1, T2>> : std::true_type {};
+
+ template <typename T, typename Char>
+ using is_c_str_of = any<std::is_same<T, const Char*>, std::is_same<T, Char const* const>, std::is_same<T, Char*>, is_string_of<T, Char>,
+ is_string_literal_array_of<T, Char>>;
+
+ template <typename T, typename Char>
+ constexpr inline bool is_c_str_of_v = is_c_str_of<T, Char>::value;
+
+ template <typename T>
+ using is_c_str = is_c_str_of<T, char>;
+
+ template <typename T>
+ constexpr inline bool is_c_str_v = is_c_str<T>::value;
+
+ template <typename T>
+ struct is_move_only : all<neg<std::is_reference<T>>, neg<std::is_copy_constructible<unqualified_t<T>>>, std::is_move_constructible<unqualified_t<T>>> {};
+
+ template <typename T>
+ using is_not_move_only = neg<is_move_only<T>>;
+
+ namespace meta_detail {
+ template <typename T>
+ decltype(auto) force_tuple(T&& x) {
+ if constexpr (meta::is_specialization_of_v<meta::unqualified_t<T>, std::tuple>) {
+ return std::forward<T>(x);
+ }
+ else {
+ return std::tuple<T>(std::forward<T>(x));
+ }
+ }
+ } // namespace meta_detail
+
+ template <typename... X>
+ decltype(auto) tuplefy(X&&... x) {
+ return std::tuple_cat(meta_detail::force_tuple(std::forward<X>(x))...);
+ }
+
+ template <typename T, typename = void>
+ struct iterator_tag {
+ using type = std::input_iterator_tag;
+ };
+
+ template <typename T>
+ struct iterator_tag<T, conditional_t<false, typename std::iterator_traits<T>::iterator_category, void>> {
+ using type = typename std::iterator_traits<T>::iterator_category;
+ };
+
+}} // namespace sol::meta
+
+// end of sol/traits.hpp
+
+namespace sol {
+ namespace detail {
+ const bool default_safe_function_calls =
+#if SOL_IS_ON(SOL_SAFE_FUNCTION_CALLS_I_)
+ true;
+#else
+ false;
+#endif
+ } // namespace detail
+
+ namespace meta { namespace meta_detail {
+ }} // namespace meta::meta_detail
+
+ namespace stack { namespace stack_detail {
+ using undefined_method_func = void (*)(stack_reference);
+
+ template <typename T>
+ void set_undefined_methods_on(stack_reference);
+
+ struct undefined_metatable;
+ }} // namespace stack::stack_detail
+} // namespace sol
+
+#endif // SOL_FORWARD_DETAIL_HPP
+// end of sol/forward_detail.hpp
+
+// beginning of sol/bytecode.hpp
+
+// beginning of sol/compatibility.hpp
+
+// beginning of sol/compatibility/lua_version.hpp
+
+#if SOL_IS_ON(SOL_USE_CXX_LUA_I_)
+ #include <lua.h>
+ #include <lualib.h>
+ #include <lauxlib.h>
+#elif SOL_IS_ON(SOL_USE_LUA_HPP_I_)
+ #include <lua.hpp>
+#else
+ extern "C" {
+ #include <lua.h>
+ #include <lauxlib.h>
+ #include <lualib.h>
+ }
+#endif // C++ Mangling for Lua vs. Not
+
+#if defined(SOL_LUAJIT)
+ #if (SOL_LUAJIT != 0)
+ #define SOL_USE_LUAJIT_I_ SOL_ON
+ #else
+ #define SOL_USE_LUAJIT_I_ SOL_OFF
+ #endif
+#elif defined(LUAJIT_VERSION)
+ #define SOL_USE_LUAJIT_I_ SOL_OFF
+#else
+ #define SOL_USE_LUAJIT_I_ SOL_DEFAULT_OFF
+#endif // luajit
+
+#if SOL_IS_ON(SOL_USE_CXX_LUAJIT_I_)
+ #include <luajit.h>
+#elif SOL_IS_ON(SOL_USE_LUAJIT_I_)
+ extern "C" {
+ #include <luajit.h>
+ }
+#endif // C++ LuaJIT ... whatever that means
+
+#if defined(SOL_LUAJIT_VERSION)
+ #define SOL_LUAJIT_VERSION_I_ SOL_LUAJIT_VERSION
+#elif SOL_IS_ON(SOL_USE_LUAJIT_I_)
+ #define SOL_LUAJIT_VERSION_I_ LUAJIT_VERSION_NUM
+#else
+ #define SOL_LUAJIT_VERSION_I_ 0
+#endif
+
+#if defined(MOONJIT_VERSION)
+ #define SOL_USE_MOONJIT_I_ SOL_ON
+#else
+ #define SOL_USE_MOONJIT_I_ SOL_OFF
+#endif
+
+#if !defined(SOL_LUA_VERSION)
+ #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 502
+ #define SOL_LUA_VERSION LUA_VERSION_NUM
+ #elif defined(LUA_VERSION_NUM) && LUA_VERSION_NUM == 501
+ #define SOL_LUA_VERSION LUA_VERSION_NUM
+ #elif !defined(LUA_VERSION_NUM) || !(LUA_VERSION_NUM)
+ // Definitely 5.0
+ #define SOL_LUA_VERSION 500
+ #else
+ // ??? Not sure, assume latest?
+ #define SOL_LUA_VERSION 504
+ #endif // Lua Version 503, 502, 501 || luajit, 500
+#endif // SOL_LUA_VERSION
+
+#if defined(SOL_LUA_VERSION)
+ #define SOL_LUA_VESION_I_ SOL_LUA_VERSION
+#else
+ #define SOL_LUA_VESION_I_ 504
+#endif
+
+#if defined(SOL_EXCEPTIONS_ALWAYS_UNSAFE)
+ #if (SOL_EXCEPTIONS_ALWAYS_UNSAFE != 0)
+ #define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_OFF
+ #else
+ #define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_ON
+ #endif
+#elif defined(SOL_EXCEPTIONS_SAFE_PROPAGATION)
+ #if (SOL_EXCEPTIONS_SAFE_PROPAGATION != 0)
+ #define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_ON
+ #else
+ #define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_OFF
+ #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
+ // 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 // LuaJIT beta 02.01.00 have better exception handling on all platforms since beta3
+
+#if defined(SOL_LUAJIT_USE_EXCEPTION_TRAMPOLINE)
+ #if (SOL_LUAJIT_USE_EXCEPTION_TRAMPOLINE != 0)
+ #define SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE_I_ SOL_ON
+ #else
+ #define SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE_I_ SOL_OFF
+ #endif
+#else
+ #if SOL_IS_OFF(SOL_PROPAGATE_EXCEPTIONS_I_) && SOL_IS_ON(SOL_USE_LUAJIT_I_)
+ #define SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE_I_ SOL_ON
+ #else
+ #define SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE_I_ SOL_DEFAULT_OFF
+ #endif
+#endif
+
+#if defined(SOL_LUAL_STREAM_HAS_CLOSE_FUNCTION)
+ #if (SOL_LUAL_STREAM_HAS_CLOSE_FUNCTION != 0)
+ #define SOL_LUAL_STREAM_USE_CLOSE_FUNCTION_I_ SOL_ON
+ #else
+ #define SOL_LUAL_STREAM_USE_CLOSE_FUNCTION_I_ SOL_OFF
+ #endif
+#else
+ #if SOL_IS_OFF(SOL_USE_LUAJIT_I_) && (SOL_LUA_VERSION > 501)
+ #define SOL_LUAL_STREAM_USE_CLOSE_FUNCTION_I_ SOL_ON
+ #else
+ #define SOL_LUAL_STREAM_USE_CLOSE_FUNCTION_I_ SOL_DEFAULT_OFF
+ #endif
+#endif
+
+// end of sol/compatibility/lua_version.hpp
+
+#if SOL_IS_ON(SOL_USE_COMPATIBILITY_LAYER_I_)
+
+#if SOL_IS_ON(SOL_USE_CXX_LUA_I_) || SOL_IS_ON(SOL_USE_CXX_LUAJIT_I_)
+#ifndef COMPAT53_LUA_CPP
+#define COMPAT53_LUA_CPP 1
+#endif // Build Lua Compat layer as C++
+#endif
+#ifndef COMPAT53_INCLUDE_SOURCE
+#define COMPAT53_INCLUDE_SOURCE 1
+#endif // Build Compat Layer Inline
+
+// beginning of sol/compatibility/compat-5.3.h
+
+#ifndef KEPLER_PROJECT_COMPAT53_H_
+#define KEPLER_PROJECT_COMPAT53_H_
+
+#include <stddef.h>
+#include <limits.h>
+#include <string.h>
+#if defined(__cplusplus) && !defined(COMPAT53_LUA_CPP)
+extern "C" {
+#endif
+#include <lua.h>
+#include <lauxlib.h>
+#include <lualib.h>
+#if defined(__cplusplus) && !defined(COMPAT53_LUA_CPP)
+}
+#endif
+
+#ifndef COMPAT53_PREFIX
+/* we chose this name because many other lua bindings / libs have
+* their own compatibility layer, and that use the compat53 declaration
+* frequently, causing all kinds of linker / compiler issues
+*/
+# define COMPAT53_PREFIX kp_compat53
+#endif // COMPAT53_PREFIX
+
+#ifndef COMPAT53_API
+# if defined(COMPAT53_INCLUDE_SOURCE) && COMPAT53_INCLUDE_SOURCE
+# if defined(__GNUC__) || defined(__clang__)
+# define COMPAT53_API __attribute__((__unused__)) static inline
+# else
+# define COMPAT53_API static inline
+# endif /* Clang/GCC */
+# else /* COMPAT53_INCLUDE_SOURCE */
+/* we are not including source, so everything is extern */
+# define COMPAT53_API extern
+# endif /* COMPAT53_INCLUDE_SOURCE */
+#endif /* COMPAT53_PREFIX */
+
+#define COMPAT53_CONCAT_HELPER(a, b) a##b
+#define COMPAT53_CONCAT(a, b) COMPAT53_CONCAT_HELPER(a, b)
+
+/* declarations for Lua 5.1 */
+#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM == 501
+
+/* XXX not implemented:
+* lua_arith (new operators)
+* lua_upvalueid
+* lua_upvaluejoin
+* lua_version
+* lua_yieldk
+*/
+
+#ifndef LUA_OK
+# define LUA_OK 0
+#endif
+#ifndef LUA_OPADD
+# define LUA_OPADD 0
+#endif
+#ifndef LUA_OPSUB
+# define LUA_OPSUB 1
+#endif
+#ifndef LUA_OPMUL
+# define LUA_OPMUL 2
+#endif
+#ifndef LUA_OPDIV
+# define LUA_OPDIV 3
+#endif
+#ifndef LUA_OPMOD
+# define LUA_OPMOD 4
+#endif
+#ifndef LUA_OPPOW
+# define LUA_OPPOW 5
+#endif
+#ifndef LUA_OPUNM
+# define LUA_OPUNM 6
+#endif
+#ifndef LUA_OPEQ
+# define LUA_OPEQ 0
+#endif
+#ifndef LUA_OPLT
+# define LUA_OPLT 1
+#endif
+#ifndef LUA_OPLE
+# define LUA_OPLE 2
+#endif
+
+/* LuaJIT/Lua 5.1 does not have the updated
+* error codes for thread status/function returns (but some patched versions do)
+* define it only if it's not found
+*/
+#if !defined(LUA_ERRGCMM)
+/* Use + 2 because in some versions of Lua (Lua 5.1)
+* LUA_ERRFILE is defined as (LUA_ERRERR+1)
+* so we need to avoid it (LuaJIT might have something at this
+* integer value too)
+*/
+# define LUA_ERRGCMM (LUA_ERRERR + 2)
+#endif /* LUA_ERRGCMM define */
+
+#if !defined(MOONJIT_VERSION)
+typedef size_t lua_Unsigned;
+#endif
+
+typedef struct luaL_Buffer_53 {
+ luaL_Buffer b; /* make incorrect code crash! */
+ char *ptr;
+ size_t nelems;
+ size_t capacity;
+ lua_State *L2;
+} luaL_Buffer_53;
+#define luaL_Buffer luaL_Buffer_53
+
+/* In PUC-Rio 5.1, userdata is a simple FILE*
+* In LuaJIT, it's a struct where the first member is a FILE*
+* We can't support the `closef` member
+*/
+typedef struct luaL_Stream {
+ FILE *f;
+} luaL_Stream;
+
+#define lua_absindex COMPAT53_CONCAT(COMPAT53_PREFIX, _absindex)
+COMPAT53_API int lua_absindex(lua_State *L, int i);
+
+#define lua_arith COMPAT53_CONCAT(COMPAT53_PREFIX, _arith)
+COMPAT53_API void lua_arith(lua_State *L, int op);
+
+#define lua_compare COMPAT53_CONCAT(COMPAT53_PREFIX, _compare)
+COMPAT53_API int lua_compare(lua_State *L, int idx1, int idx2, int op);
+
+#define lua_copy COMPAT53_CONCAT(COMPAT53_PREFIX, _copy)
+COMPAT53_API void lua_copy(lua_State *L, int from, int to);
+
+#define lua_getuservalue(L, i) \
+ (lua_getfenv((L), (i)), lua_type((L), -1))
+#define lua_setuservalue(L, i) \
+ (luaL_checktype((L), -1, LUA_TTABLE), lua_setfenv((L), (i)))
+
+#define lua_len COMPAT53_CONCAT(COMPAT53_PREFIX, _len)
+COMPAT53_API void lua_len(lua_State *L, int i);
+
+#define lua_pushstring(L, s) \
+ (lua_pushstring((L), (s)), lua_tostring((L), -1))
+
+#define lua_pushlstring(L, s, len) \
+ ((((len) == 0) ? lua_pushlstring((L), "", 0) : lua_pushlstring((L), (s), (len))), lua_tostring((L), -1))
+
+#ifndef luaL_newlibtable
+# define luaL_newlibtable(L, l) \
+ (lua_createtable((L), 0, sizeof((l))/sizeof(*(l))-1))
+#endif
+#ifndef luaL_newlib
+# define luaL_newlib(L, l) \
+ (luaL_newlibtable((L), (l)), luaL_register((L), NULL, (l)))
+#endif
+
+#ifndef lua_pushglobaltable
+# define lua_pushglobaltable(L) \
+ lua_pushvalue((L), LUA_GLOBALSINDEX)
+#endif
+#define lua_rawgetp COMPAT53_CONCAT(COMPAT53_PREFIX, _rawgetp)
+COMPAT53_API int lua_rawgetp(lua_State *L, int i, const void *p);
+
+#define lua_rawsetp COMPAT53_CONCAT(COMPAT53_PREFIX, _rawsetp)
+COMPAT53_API void lua_rawsetp(lua_State *L, int i, const void *p);
+
+#define lua_rawlen(L, i) lua_objlen((L), (i))
+
+#define lua_tointeger(L, i) lua_tointegerx((L), (i), NULL)
+
+#define lua_tonumberx COMPAT53_CONCAT(COMPAT53_PREFIX, _tonumberx)
+COMPAT53_API lua_Number lua_tonumberx(lua_State *L, int i, int *isnum);
+
+#define luaL_checkversion COMPAT53_CONCAT(COMPAT53_PREFIX, L_checkversion)
+COMPAT53_API void luaL_checkversion(lua_State *L);
+
+#define lua_load COMPAT53_CONCAT(COMPAT53_PREFIX, _load_53)
+COMPAT53_API int lua_load(lua_State *L, lua_Reader reader, void *data, const char* source, const char* mode);
+
+#define luaL_loadfilex COMPAT53_CONCAT(COMPAT53_PREFIX, L_loadfilex)
+COMPAT53_API int luaL_loadfilex(lua_State *L, const char *filename, const char *mode);
+
+#define luaL_loadbufferx COMPAT53_CONCAT(COMPAT53_PREFIX, L_loadbufferx)
+COMPAT53_API int luaL_loadbufferx(lua_State *L, const char *buff, size_t sz, const char *name, const char *mode);
+
+#define luaL_checkstack COMPAT53_CONCAT(COMPAT53_PREFIX, L_checkstack_53)
+COMPAT53_API void luaL_checkstack(lua_State *L, int sp, const char *msg);
+
+#define luaL_getsubtable COMPAT53_CONCAT(COMPAT53_PREFIX, L_getsubtable)
+COMPAT53_API int luaL_getsubtable(lua_State* L, int i, const char *name);
+
+#define luaL_len COMPAT53_CONCAT(COMPAT53_PREFIX, L_len)
+COMPAT53_API lua_Integer luaL_len(lua_State *L, int i);
+
+#define luaL_setfuncs COMPAT53_CONCAT(COMPAT53_PREFIX, L_setfuncs)
+COMPAT53_API void luaL_setfuncs(lua_State *L, const luaL_Reg *l, int nup);
+
+#define luaL_setmetatable COMPAT53_CONCAT(COMPAT53_PREFIX, L_setmetatable)
+COMPAT53_API void luaL_setmetatable(lua_State *L, const char *tname);
+
+#define luaL_testudata COMPAT53_CONCAT(COMPAT53_PREFIX, L_testudata)
+COMPAT53_API void *luaL_testudata(lua_State *L, int i, const char *tname);
+
+#define luaL_traceback COMPAT53_CONCAT(COMPAT53_PREFIX, L_traceback)
+COMPAT53_API void luaL_traceback(lua_State *L, lua_State *L1, const char *msg, int level);
+
+#define luaL_fileresult COMPAT53_CONCAT(COMPAT53_PREFIX, L_fileresult)
+COMPAT53_API int luaL_fileresult(lua_State *L, int stat, const char *fname);
+
+#define luaL_execresult COMPAT53_CONCAT(COMPAT53_PREFIX, L_execresult)
+COMPAT53_API int luaL_execresult(lua_State *L, int stat);
+
+#define lua_callk(L, na, nr, ctx, cont) \
+ ((void)(ctx), (void)(cont), lua_call((L), (na), (nr)))
+#define lua_pcallk(L, na, nr, err, ctx, cont) \
+ ((void)(ctx), (void)(cont), lua_pcall((L), (na), (nr), (err)))
+
+#define lua_resume(L, from, nargs) \
+ ((void)(from), lua_resume((L), (nargs)))
+
+#define luaL_buffinit COMPAT53_CONCAT(COMPAT53_PREFIX, _buffinit_53)
+COMPAT53_API void luaL_buffinit(lua_State *L, luaL_Buffer_53 *B);
+
+#define luaL_prepbuffsize COMPAT53_CONCAT(COMPAT53_PREFIX, _prepbufsize_53)
+COMPAT53_API char *luaL_prepbuffsize(luaL_Buffer_53 *B, size_t s);
+
+#define luaL_addlstring COMPAT53_CONCAT(COMPAT53_PREFIX, _addlstring_53)
+COMPAT53_API void luaL_addlstring(luaL_Buffer_53 *B, const char *s, size_t l);
+
+#define luaL_addvalue COMPAT53_CONCAT(COMPAT53_PREFIX, _addvalue_53)
+COMPAT53_API void luaL_addvalue(luaL_Buffer_53 *B);
+
+#define luaL_pushresult COMPAT53_CONCAT(COMPAT53_PREFIX, _pushresult_53)
+COMPAT53_API void luaL_pushresult(luaL_Buffer_53 *B);
+
+#undef luaL_buffinitsize
+#define luaL_buffinitsize(L, B, s) \
+ (luaL_buffinit((L), (B)), luaL_prepbuffsize((B), (s)))
+
+#undef luaL_prepbuffer
+#define luaL_prepbuffer(B) \
+ luaL_prepbuffsize((B), LUAL_BUFFERSIZE)
+
+#undef luaL_addchar
+#define luaL_addchar(B, c) \
+ ((void)((B)->nelems < (B)->capacity || luaL_prepbuffsize((B), 1)), \
+ ((B)->ptr[(B)->nelems++] = (c)))
+
+#undef luaL_addsize
+#define luaL_addsize(B, s) \
+ ((B)->nelems += (s))
+
+#undef luaL_addstring
+#define luaL_addstring(B, s) \
+ luaL_addlstring((B), (s), strlen((s)))
+
+#undef luaL_pushresultsize
+#define luaL_pushresultsize(B, s) \
+ (luaL_addsize((B), (s)), luaL_pushresult((B)))
+
+#if defined(LUA_COMPAT_APIINTCASTS)
+#define lua_pushunsigned(L, n) \
+ lua_pushinteger((L), (lua_Integer)(n))
+#define lua_tounsignedx(L, i, is) \
+ ((lua_Unsigned)lua_tointegerx((L), (i), (is)))
+#define lua_tounsigned(L, i) \
+ lua_tounsignedx((L), (i), NULL)
+#define luaL_checkunsigned(L, a) \
+ ((lua_Unsigned)luaL_checkinteger((L), (a)))
+#define luaL_optunsigned(L, a, d) \
+ ((lua_Unsigned)luaL_optinteger((L), (a), (lua_Integer)(d)))
+#endif
+
+#endif /* Lua 5.1 only */
+
+/* declarations for Lua 5.1 and 5.2 */
+#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM <= 502
+
+typedef int lua_KContext;
+
+typedef int(*lua_KFunction)(lua_State *L, int status, lua_KContext ctx);
+
+#define lua_dump(L, w, d, s) \
+ ((void)(s), lua_dump((L), (w), (d)))
+
+#define lua_getfield(L, i, k) \
+ (lua_getfield((L), (i), (k)), lua_type((L), -1))
+
+#define lua_gettable(L, i) \
+ (lua_gettable((L), (i)), lua_type((L), -1))
+
+#define lua_geti COMPAT53_CONCAT(COMPAT53_PREFIX, _geti)
+COMPAT53_API int lua_geti(lua_State *L, int index, lua_Integer i);
+
+#define lua_isinteger COMPAT53_CONCAT(COMPAT53_PREFIX, _isinteger)
+COMPAT53_API int lua_isinteger(lua_State *L, int index);
+
+#define lua_tointegerx COMPAT53_CONCAT(COMPAT53_PREFIX, _tointegerx_53)
+COMPAT53_API lua_Integer lua_tointegerx(lua_State *L, int i, int *isnum);
+
+#define lua_numbertointeger(n, p) \
+ ((*(p) = (lua_Integer)(n)), 1)
+
+#define lua_rawget(L, i) \
+ (lua_rawget((L), (i)), lua_type((L), -1))
+
+#define lua_rawgeti(L, i, n) \
+ (lua_rawgeti((L), (i), (n)), lua_type((L), -1))
+
+#define lua_rotate COMPAT53_CONCAT(COMPAT53_PREFIX, _rotate)
+COMPAT53_API void lua_rotate(lua_State *L, int idx, int n);
+
+#define lua_seti COMPAT53_CONCAT(COMPAT53_PREFIX, _seti)
+COMPAT53_API void lua_seti(lua_State *L, int index, lua_Integer i);
+
+#define lua_stringtonumber COMPAT53_CONCAT(COMPAT53_PREFIX, _stringtonumber)
+COMPAT53_API size_t lua_stringtonumber(lua_State *L, const char *s);
+
+#define luaL_tolstring COMPAT53_CONCAT(COMPAT53_PREFIX, L_tolstring)
+COMPAT53_API const char *luaL_tolstring(lua_State *L, int idx, size_t *len);
+
+#define luaL_getmetafield(L, o, e) \
+ (luaL_getmetafield((L), (o), (e)) ? lua_type((L), -1) : LUA_TNIL)
+
+#define luaL_newmetatable(L, tn) \
+ (luaL_newmetatable((L), (tn)) ? (lua_pushstring((L), (tn)), lua_setfield((L), -2, "__name"), 1) : 0)
+
+#define luaL_requiref COMPAT53_CONCAT(COMPAT53_PREFIX, L_requiref_53)
+COMPAT53_API void luaL_requiref(lua_State *L, const char *modname,
+ lua_CFunction openf, int glb);
+
+#endif /* Lua 5.1 and Lua 5.2 */
+
+/* declarations for Lua 5.2 */
+#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM == 502
+
+/* XXX not implemented:
+* lua_isyieldable
+* lua_getextraspace
+* lua_arith (new operators)
+* lua_pushfstring (new formats)
+*/
+
+#define lua_getglobal(L, n) \
+ (lua_getglobal((L), (n)), lua_type((L), -1))
+
+#define lua_getuservalue(L, i) \
+ (lua_getuservalue((L), (i)), lua_type((L), -1))
+
+#define lua_pushlstring(L, s, len) \
+ (((len) == 0) ? lua_pushlstring((L), "", 0) : lua_pushlstring((L), (s), (len)))
+
+#define lua_rawgetp(L, i, p) \
+ (lua_rawgetp((L), (i), (p)), lua_type((L), -1))
+
+#define LUA_KFUNCTION(_name) \
+ static int (_name)(lua_State *L, int status, lua_KContext ctx); \
+ static int (_name ## _52)(lua_State *L) { \
+ lua_KContext ctx; \
+ int status = lua_getctx(L, &ctx); \
+ return (_name)(L, status, ctx); \
+ } \
+ static int (_name)(lua_State *L, int status, lua_KContext ctx)
+
+#define lua_pcallk(L, na, nr, err, ctx, cont) \
+ lua_pcallk((L), (na), (nr), (err), (ctx), cont ## _52)
+
+#define lua_callk(L, na, nr, ctx, cont) \
+ lua_callk((L), (na), (nr), (ctx), cont ## _52)
+
+#define lua_yieldk(L, nr, ctx, cont) \
+ lua_yieldk((L), (nr), (ctx), cont ## _52)
+
+#ifdef lua_call
+# undef lua_call
+# define lua_call(L, na, nr) \
+ (lua_callk)((L), (na), (nr), 0, NULL)
+#endif
+
+#ifdef lua_pcall
+# undef lua_pcall
+# define lua_pcall(L, na, nr, err) \
+ (lua_pcallk)((L), (na), (nr), (err), 0, NULL)
+#endif
+
+#ifdef lua_yield
+# undef lua_yield
+# define lua_yield(L, nr) \
+ (lua_yieldk)((L), (nr), 0, NULL)
+#endif
+
+#endif /* Lua 5.2 only */
+
+/* other Lua versions */
+#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 501 || LUA_VERSION_NUM > 504
+
+# error "unsupported Lua version (i.e. not Lua 5.1, 5.2, 5.3, or 5.4)"
+
+#endif /* other Lua versions except 5.1, 5.2, 5.3, and 5.4 */
+
+/* helper macro for defining continuation functions (for every version
+* *except* Lua 5.2) */
+#ifndef LUA_KFUNCTION
+#define LUA_KFUNCTION(_name) \
+ static int (_name)(lua_State *L, int status, lua_KContext ctx)
+#endif
+
+#if defined(COMPAT53_INCLUDE_SOURCE) && COMPAT53_INCLUDE_SOURCE == 1
+// beginning of sol/compatibility/compat-5.3.c.h
+
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+#include <stdio.h>
+
+/* don't compile it again if it already is included via compat53.h */
+#ifndef KEPLER_PROJECT_COMPAT53_C_
+#define KEPLER_PROJECT_COMPAT53_C_
+
+/* definitions for Lua 5.1 only */
+#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM == 501
+
+#ifndef COMPAT53_FOPEN_NO_LOCK
+#if defined(_MSC_VER)
+#define COMPAT53_FOPEN_NO_LOCK 1
+#else /* otherwise */
+#define COMPAT53_FOPEN_NO_LOCK 0
+#endif /* VC++ only so far */
+#endif /* No-lock fopen_s usage if possible */
+
+#if defined(_MSC_VER) && COMPAT53_FOPEN_NO_LOCK
+#include <share.h>
+#endif /* VC++ _fsopen for share-allowed file read */
+
+#ifndef COMPAT53_HAVE_STRERROR_R
+#if defined(__GLIBC__) || defined(_POSIX_VERSION) || defined(__APPLE__) || (!defined(__MINGW32__) && defined(__GNUC__) && (__GNUC__ < 6))
+#define COMPAT53_HAVE_STRERROR_R 1
+#else /* none of the defines matched: define to 0 */
+#define COMPAT53_HAVE_STRERROR_R 0
+#endif /* have strerror_r of some form */
+#endif /* strerror_r */
+
+#ifndef COMPAT53_HAVE_STRERROR_S
+#if defined(_MSC_VER) || (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || (defined(__STDC_LIB_EXT1__) && __STDC_LIB_EXT1__)
+#define COMPAT53_HAVE_STRERROR_S 1
+#else /* not VC++ or C11 */
+#define COMPAT53_HAVE_STRERROR_S 0
+#endif /* strerror_s from VC++ or C11 */
+#endif /* strerror_s */
+
+#ifndef COMPAT53_LUA_FILE_BUFFER_SIZE
+#define COMPAT53_LUA_FILE_BUFFER_SIZE 4096
+#endif /* Lua File Buffer Size */
+
+static char* compat53_strerror(int en, char* buff, size_t sz) {
+#if COMPAT53_HAVE_STRERROR_R
+ /* use strerror_r here, because it's available on these specific platforms */
+ if (sz > 0) {
+ buff[0] = '\0';
+ /* we don't care whether the GNU version or the XSI version is used: */
+ if (strerror_r(en, buff, sz)) {
+ /* Yes, we really DO want to ignore the return value!
+ * GCC makes that extra hard, not even a (void) cast will do. */
+ }
+ if (buff[0] == '\0') {
+ /* Buffer is unchanged, so we probably have called GNU strerror_r which
+ * returned a static constant string. Chances are that strerror will
+ * return the same static constant string and therefore be thread-safe. */
+ return strerror(en);
+ }
+ }
+ return buff; /* sz is 0 *or* strerror_r wrote into the buffer */
+#elif COMPAT53_HAVE_STRERROR_S
+ /* for MSVC and other C11 implementations, use strerror_s since it's
+ * provided by default by the libraries */
+ strerror_s(buff, sz, en);
+ return buff;
+#else
+ /* fallback, but strerror is not guaranteed to be threadsafe due to modifying
+ * errno itself and some impls not locking a static buffer for it ... but most
+ * known systems have threadsafe errno: this might only change if the locale
+ * is changed out from under someone while this function is being called */
+ (void)buff;
+ (void)sz;
+ return strerror(en);
+#endif
+}
+
+COMPAT53_API int lua_absindex(lua_State* L, int i) {
+ if (i < 0 && i > LUA_REGISTRYINDEX)
+ i += lua_gettop(L) + 1;
+ return i;
+}
+
+static void compat53_call_lua(lua_State* L, char const code[], size_t len, int nargs, int nret) {
+ lua_rawgetp(L, LUA_REGISTRYINDEX, (void*)code);
+ if (lua_type(L, -1) != LUA_TFUNCTION) {
+ lua_pop(L, 1);
+ if (luaL_loadbuffer(L, code, len, "=none"))
+ lua_error(L);
+ lua_pushvalue(L, -1);
+ lua_rawsetp(L, LUA_REGISTRYINDEX, (void*)code);
+ }
+ lua_insert(L, -nargs - 1);
+ lua_call(L, nargs, nret);
+}
+
+static const char compat53_arith_code[]
+ = "local op,a,b=...\n"
+ "if op==0 then return a+b\n"
+ "elseif op==1 then return a-b\n"
+ "elseif op==2 then return a*b\n"
+ "elseif op==3 then return a/b\n"
+ "elseif op==4 then return a%b\n"
+ "elseif op==5 then return a^b\n"
+ "elseif op==6 then return -a\n"
+ "end\n";
+
+COMPAT53_API void lua_arith(lua_State* L, int op) {
+ if (op < LUA_OPADD || op > LUA_OPUNM)
+ luaL_error(L, "invalid 'op' argument for lua_arith");
+ luaL_checkstack(L, 5, "not enough stack slots");
+ if (op == LUA_OPUNM)
+ lua_pushvalue(L, -1);
+ lua_pushnumber(L, op);
+ lua_insert(L, -3);
+ compat53_call_lua(L, compat53_arith_code, sizeof(compat53_arith_code) - 1, 3, 1);
+}
+
+static const char compat53_compare_code[]
+ = "local a,b=...\n"
+ "return a<=b\n";
+
+COMPAT53_API int lua_compare(lua_State* L, int idx1, int idx2, int op) {
+ int result = 0;
+ switch (op) {
+ case LUA_OPEQ:
+ return lua_equal(L, idx1, idx2);
+ case LUA_OPLT:
+ return lua_lessthan(L, idx1, idx2);
+ case LUA_OPLE:
+ luaL_checkstack(L, 5, "not enough stack slots");
+ idx1 = lua_absindex(L, idx1);
+ idx2 = lua_absindex(L, idx2);
+ lua_pushvalue(L, idx1);
+ lua_pushvalue(L, idx2);
+ compat53_call_lua(L, compat53_compare_code, sizeof(compat53_compare_code) - 1, 2, 1);
+ result = lua_toboolean(L, -1);
+ lua_pop(L, 1);
+ return result;
+ default:
+ luaL_error(L, "invalid 'op' argument for lua_compare");
+ }
+ return 0;
+}
+
+COMPAT53_API void lua_copy(lua_State* L, int from, int to) {
+ int abs_to = lua_absindex(L, to);
+ luaL_checkstack(L, 1, "not enough stack slots");
+ lua_pushvalue(L, from);
+ lua_replace(L, abs_to);
+}
+
+COMPAT53_API void lua_len(lua_State* L, int i) {
+ switch (lua_type(L, i)) {
+ case LUA_TSTRING:
+ lua_pushnumber(L, (lua_Number)lua_objlen(L, i));
+ break;
+ case LUA_TTABLE:
+ if (!luaL_callmeta(L, i, "__len"))
+ lua_pushnumber(L, (lua_Number)lua_objlen(L, i));
+ break;
+ case LUA_TUSERDATA:
+ if (luaL_callmeta(L, i, "__len"))
+ break;
+ /* FALLTHROUGH */
+ default:
+ luaL_error(L, "attempt to get length of a %s value", lua_typename(L, lua_type(L, i)));
+ }
+}
+
+COMPAT53_API int lua_rawgetp(lua_State* L, int i, const void* p) {
+ int abs_i = lua_absindex(L, i);
+ lua_pushlightuserdata(L, (void*)p);
+ lua_rawget(L, abs_i);
+ return lua_type(L, -1);
+}
+
+COMPAT53_API void lua_rawsetp(lua_State* L, int i, const void* p) {
+ int abs_i = lua_absindex(L, i);
+ luaL_checkstack(L, 1, "not enough stack slots");
+ lua_pushlightuserdata(L, (void*)p);
+ lua_insert(L, -2);
+ lua_rawset(L, abs_i);
+}
+
+COMPAT53_API lua_Number lua_tonumberx(lua_State* L, int i, int* isnum) {
+ lua_Number n = lua_tonumber(L, i);
+ if (isnum != NULL) {
+ *isnum = (n != 0 || lua_isnumber(L, i));
+ }
+ return n;
+}
+
+COMPAT53_API void luaL_checkversion(lua_State* L) {
+ (void)L;
+}
+
+COMPAT53_API void luaL_checkstack(lua_State* L, int sp, const char* msg) {
+ if (!lua_checkstack(L, sp + LUA_MINSTACK)) {
+ if (msg != NULL)
+ luaL_error(L, "stack overflow (%s)", msg);
+ else {
+ lua_pushliteral(L, "stack overflow");
+ lua_error(L);
+ }
+ }
+}
+
+COMPAT53_API int luaL_getsubtable(lua_State* L, int i, const char* name) {
+ int abs_i = lua_absindex(L, i);
+ luaL_checkstack(L, 3, "not enough stack slots");
+ lua_pushstring(L, name);
+ lua_gettable(L, abs_i);
+ if (lua_istable(L, -1))
+ return 1;
+ lua_pop(L, 1);
+ lua_newtable(L);
+ lua_pushstring(L, name);
+ lua_pushvalue(L, -2);
+ lua_settable(L, abs_i);
+ return 0;
+}
+
+COMPAT53_API lua_Integer luaL_len(lua_State* L, int i) {
+ lua_Integer res = 0;
+ int isnum = 0;
+ luaL_checkstack(L, 1, "not enough stack slots");
+ lua_len(L, i);
+ res = lua_tointegerx(L, -1, &isnum);
+ lua_pop(L, 1);
+ if (!isnum)
+ luaL_error(L, "object length is not an integer");
+ return res;
+}
+
+COMPAT53_API void luaL_setfuncs(lua_State* L, const luaL_Reg* l, int nup) {
+ luaL_checkstack(L, nup + 1, "too many upvalues");
+ for (; l->name != NULL; l++) { /* fill the table with given functions */
+ int i;
+ lua_pushstring(L, l->name);
+ for (i = 0; i < nup; i++) /* copy upvalues to the top */
+ lua_pushvalue(L, -(nup + 1));
+ lua_pushcclosure(L, l->func, nup); /* closure with those upvalues */
+ lua_settable(L, -(nup + 3)); /* table must be below the upvalues, the name and the closure */
+ }
+ lua_pop(L, nup); /* remove upvalues */
+}
+
+COMPAT53_API void luaL_setmetatable(lua_State* L, const char* tname) {
+ luaL_checkstack(L, 1, "not enough stack slots");
+ luaL_getmetatable(L, tname);
+ lua_setmetatable(L, -2);
+}
+
+COMPAT53_API void* luaL_testudata(lua_State* L, int i, const char* tname) {
+ void* p = lua_touserdata(L, i);
+ luaL_checkstack(L, 2, "not enough stack slots");
+ if (p == NULL || !lua_getmetatable(L, i))
+ return NULL;
+ else {
+ int res = 0;
+ luaL_getmetatable(L, tname);
+ res = lua_rawequal(L, -1, -2);
+ lua_pop(L, 2);
+ if (!res)
+ p = NULL;
+ }
+ return p;
+}
+
+static int compat53_countlevels(lua_State* L) {
+ lua_Debug ar;
+ int li = 1, le = 1;
+ /* find an upper bound */
+ while (lua_getstack(L, le, &ar)) {
+ li = le;
+ le *= 2;
+ }
+ /* do a binary search */
+ while (li < le) {
+ int m = (li + le) / 2;
+ if (lua_getstack(L, m, &ar))
+ li = m + 1;
+ else
+ le = m;
+ }
+ return le - 1;
+}
+
+static int compat53_findfield(lua_State* L, int objidx, int level) {
+ if (level == 0 || !lua_istable(L, -1))
+ return 0; /* not found */
+ lua_pushnil(L); /* start 'next' loop */
+ while (lua_next(L, -2)) { /* for each pair in table */
+ if (lua_type(L, -2) == LUA_TSTRING) { /* ignore non-string keys */
+ if (lua_rawequal(L, objidx, -1)) { /* found object? */
+ lua_pop(L, 1); /* remove value (but keep name) */
+ return 1;
+ }
+ else if (compat53_findfield(L, objidx, level - 1)) { /* try recursively */
+ lua_remove(L, -2); /* remove table (but keep name) */
+ lua_pushliteral(L, ".");
+ lua_insert(L, -2); /* place '.' between the two names */
+ lua_concat(L, 3);
+ return 1;
+ }
+ }
+ lua_pop(L, 1); /* remove value */
+ }
+ return 0; /* not found */
+}
+
+static int compat53_pushglobalfuncname(lua_State* L, lua_Debug* ar) {
+ int top = lua_gettop(L);
+ lua_getinfo(L, "f", ar); /* push function */
+ lua_pushvalue(L, LUA_GLOBALSINDEX);
+ if (compat53_findfield(L, top + 1, 2)) {
+ lua_copy(L, -1, top + 1); /* move name to proper place */
+ lua_pop(L, 2); /* remove pushed values */
+ return 1;
+ }
+ else {
+ lua_settop(L, top); /* remove function and global table */
+ return 0;
+ }
+}
+
+static void compat53_pushfuncname(lua_State* L, lua_Debug* ar) {
+ if (*ar->namewhat != '\0') /* is there a name? */
+ lua_pushfstring(L, "function " LUA_QS, ar->name);
+ else if (*ar->what == 'm') /* main? */
+ lua_pushliteral(L, "main chunk");
+ else if (*ar->what == 'C') {
+ if (compat53_pushglobalfuncname(L, ar)) {
+ lua_pushfstring(L, "function " LUA_QS, lua_tostring(L, -1));
+ lua_remove(L, -2); /* remove name */
+ }
+ else
+ lua_pushliteral(L, "?");
+ }
+ else
+ lua_pushfstring(L, "function <%s:%d>", ar->short_src, ar->linedefined);
+}
+
+#define COMPAT53_LEVELS1 12 /* size of the first part of the stack */
+#define COMPAT53_LEVELS2 10 /* size of the second part of the stack */
+
+COMPAT53_API void luaL_traceback(lua_State* L, lua_State* L1, const char* msg, int level) {
+ lua_Debug ar;
+ int top = lua_gettop(L);
+ int numlevels = compat53_countlevels(L1);
+ int mark = (numlevels > COMPAT53_LEVELS1 + COMPAT53_LEVELS2) ? COMPAT53_LEVELS1 : 0;
+ if (msg)
+ lua_pushfstring(L, "%s\n", msg);
+ lua_pushliteral(L, "stack traceback:");
+ while (lua_getstack(L1, level++, &ar)) {
+ if (level == mark) { /* too many levels? */
+ lua_pushliteral(L, "\n\t..."); /* add a '...' */
+ level = numlevels - COMPAT53_LEVELS2; /* and skip to last ones */
+ }
+ else {
+ lua_getinfo(L1, "Slnt", &ar);
+ lua_pushfstring(L, "\n\t%s:", ar.short_src);
+ if (ar.currentline > 0)
+ lua_pushfstring(L, "%d:", ar.currentline);
+ lua_pushliteral(L, " in ");
+ compat53_pushfuncname(L, &ar);
+ lua_concat(L, lua_gettop(L) - top);
+ }
+ }
+ lua_concat(L, lua_gettop(L) - top);
+}
+
+COMPAT53_API int luaL_fileresult(lua_State* L, int stat, const char* fname) {
+ const char* serr = NULL;
+ int en = errno; /* calls to Lua API may change this value */
+ char buf[512] = { 0 };
+ if (stat) {
+ lua_pushboolean(L, 1);
+ return 1;
+ }
+ else {
+ lua_pushnil(L);
+ serr = compat53_strerror(en, buf, sizeof(buf));
+ if (fname)
+ lua_pushfstring(L, "%s: %s", fname, serr);
+ else
+ lua_pushstring(L, serr);
+ lua_pushnumber(L, (lua_Number)en);
+ return 3;
+ }
+}
+
+static int compat53_checkmode(lua_State* L, const char* mode, const char* modename, int err) {
+ if (mode && strchr(mode, modename[0]) == NULL) {
+ lua_pushfstring(L, "attempt to load a %s chunk (mode is '%s')", modename, mode);
+ return err;
+ }
+ return LUA_OK;
+}
+
+typedef struct {
+ lua_Reader reader;
+ void* ud;
+ int has_peeked_data;
+ const char* peeked_data;
+ size_t peeked_data_size;
+} compat53_reader_data;
+
+static const char* compat53_reader(lua_State* L, void* ud, size_t* size) {
+ compat53_reader_data* data = (compat53_reader_data*)ud;
+ if (data->has_peeked_data) {
+ data->has_peeked_data = 0;
+ *size = data->peeked_data_size;
+ return data->peeked_data;
+ }
+ else
+ return data->reader(L, data->ud, size);
+}
+
+COMPAT53_API int lua_load(lua_State* L, lua_Reader reader, void* data, const char* source, const char* mode) {
+ int status = LUA_OK;
+ compat53_reader_data compat53_data = { reader, data, 1, 0, 0 };
+ compat53_data.peeked_data = reader(L, data, &(compat53_data.peeked_data_size));
+ if (compat53_data.peeked_data && compat53_data.peeked_data_size && compat53_data.peeked_data[0] == LUA_SIGNATURE[0]) /* binary file? */
+ status = compat53_checkmode(L, mode, "binary", LUA_ERRSYNTAX);
+ else
+ status = compat53_checkmode(L, mode, "text", LUA_ERRSYNTAX);
+ if (status != LUA_OK)
+ return status;
+ /* we need to call the original 5.1 version of lua_load! */
+#undef lua_load
+ return lua_load(L, compat53_reader, &compat53_data, source);
+#define lua_load COMPAT53_CONCAT(COMPAT53_PREFIX, _load_53)
+}
+
+typedef struct {
+ int n; /* number of pre-read characters */
+ FILE* f; /* file being read */
+ char buff[COMPAT53_LUA_FILE_BUFFER_SIZE]; /* area for reading file */
+} compat53_LoadF;
+
+static const char* compat53_getF(lua_State* L, void* ud, size_t* size) {
+ compat53_LoadF* lf = (compat53_LoadF*)ud;
+ (void)L; /* not used */
+ if (lf->n > 0) { /* are there pre-read characters to be read? */
+ *size = lf->n; /* return them (chars already in buffer) */
+ lf->n = 0; /* no more pre-read characters */
+ }
+ else { /* read a block from file */
+ /* 'fread' can return > 0 *and* set the EOF flag. If next call to
+ 'compat53_getF' called 'fread', it might still wait for user input.
+ The next check avoids this problem. */
+ if (feof(lf->f))
+ return NULL;
+ *size = fread(lf->buff, 1, sizeof(lf->buff), lf->f); /* read block */
+ }
+ return lf->buff;
+}
+
+static int compat53_errfile(lua_State* L, const char* what, int fnameindex) {
+ char buf[512] = { 0 };
+ const char* serr = compat53_strerror(errno, buf, sizeof(buf));
+ const char* filename = lua_tostring(L, fnameindex) + 1;
+ lua_pushfstring(L, "cannot %s %s: %s", what, filename, serr);
+ lua_remove(L, fnameindex);
+ return LUA_ERRFILE;
+}
+
+static int compat53_skipBOM(compat53_LoadF* lf) {
+ const char* p = "\xEF\xBB\xBF"; /* UTF-8 BOM mark */
+ int c;
+ lf->n = 0;
+ do {
+ c = getc(lf->f);
+ if (c == EOF || c != *(const unsigned char*)p++)
+ return c;
+ lf->buff[lf->n++] = (char)c; /* to be read by the parser */
+ } while (*p != '\0');
+ lf->n = 0; /* prefix matched; discard it */
+ return getc(lf->f); /* return next character */
+}
+
+/*
+** reads the first character of file 'f' and skips an optional BOM mark
+** in its beginning plus its first line if it starts with '#'. Returns
+** true if it skipped the first line. In any case, '*cp' has the
+** first "valid" character of the file (after the optional BOM and
+** a first-line comment).
+*/
+static int compat53_skipcomment(compat53_LoadF* lf, int* cp) {
+ int c = *cp = compat53_skipBOM(lf);
+ if (c == '#') { /* first line is a comment (Unix exec. file)? */
+ do { /* skip first line */
+ c = getc(lf->f);
+ } while (c != EOF && c != '\n');
+ *cp = getc(lf->f); /* skip end-of-line, if present */
+ return 1; /* there was a comment */
+ }
+ else
+ return 0; /* no comment */
+}
+
+COMPAT53_API int luaL_loadfilex(lua_State* L, const char* filename, const char* mode) {
+ compat53_LoadF lf;
+ int status, readstatus;
+ int c;
+ int fnameindex = lua_gettop(L) + 1; /* index of filename on the stack */
+ if (filename == NULL) {
+ lua_pushliteral(L, "=stdin");
+ lf.f = stdin;
+ }
+ else {
+ lua_pushfstring(L, "@%s", filename);
+#if defined(_MSC_VER)
+ /* This code is here to stop a deprecation error that stops builds
+ * if a certain macro is defined. While normally not caring would
+ * be best, some header-only libraries and builds can't afford to
+ * dictate this to the user. A quick check shows that fopen_s this
+ * goes back to VS 2005, and _fsopen goes back to VS 2003 .NET,
+ * possibly even before that so we don't need to do any version
+ * number checks, since this has been there since forever. */
+
+ /* TO USER: if you want the behavior of typical fopen_s/fopen,
+ * which does lock the file on VC++, define the macro used below to 0 */
+#if COMPAT53_FOPEN_NO_LOCK
+ lf.f = _fsopen(filename, "r", _SH_DENYNO); /* do not lock the file in any way */
+ if (lf.f == NULL)
+ return compat53_errfile(L, "open", fnameindex);
+#else /* use default locking version */
+ if (fopen_s(&lf.f, filename, "r") != 0)
+ return compat53_errfile(L, "open", fnameindex);
+#endif /* Locking vs. No-locking fopen variants */
+#else
+ lf.f = fopen(filename, "r"); /* default stdlib doesn't forcefully lock files here */
+ if (lf.f == NULL)
+ return compat53_errfile(L, "open", fnameindex);
+#endif
+ }
+ if (compat53_skipcomment(&lf, &c)) /* read initial portion */
+ lf.buff[lf.n++] = '\n'; /* add line to correct line numbers */
+ if (c == LUA_SIGNATURE[0] && filename) { /* binary file? */
+#if defined(_MSC_VER)
+ if (freopen_s(&lf.f, filename, "rb", lf.f) != 0)
+ return compat53_errfile(L, "reopen", fnameindex);
+#else
+ lf.f = freopen(filename, "rb", lf.f); /* reopen in binary mode */
+ if (lf.f == NULL)
+ return compat53_errfile(L, "reopen", fnameindex);
+#endif
+ compat53_skipcomment(&lf, &c); /* re-read initial portion */
+ }
+ if (c != EOF)
+ lf.buff[lf.n++] = (char)c; /* 'c' is the first character of the stream */
+ status = lua_load(L, &compat53_getF, &lf, lua_tostring(L, -1), mode);
+ readstatus = ferror(lf.f);
+ if (filename)
+ fclose(lf.f); /* close file (even in case of errors) */
+ if (readstatus) {
+ lua_settop(L, fnameindex); /* ignore results from 'lua_load' */
+ return compat53_errfile(L, "read", fnameindex);
+ }
+ lua_remove(L, fnameindex);
+ return status;
+}
+
+COMPAT53_API int luaL_loadbufferx(lua_State* L, const char* buff, size_t sz, const char* name, const char* mode) {
+ int status = LUA_OK;
+ if (sz > 0 && buff[0] == LUA_SIGNATURE[0]) {
+ status = compat53_checkmode(L, mode, "binary", LUA_ERRSYNTAX);
+ }
+ else {
+ status = compat53_checkmode(L, mode, "text", LUA_ERRSYNTAX);
+ }
+ if (status != LUA_OK)
+ return status;
+ return luaL_loadbuffer(L, buff, sz, name);
+}
+
+#if !defined(l_inspectstat) \
+ && (defined(unix) || defined(__unix) || defined(__unix__) || defined(__TOS_AIX__) || defined(_SYSTYPE_BSD) || (defined(__APPLE__) && defined(__MACH__)))
+/* some form of unix; check feature macros in unistd.h for details */
+#include <unistd.h>
+/* check posix version; the relevant include files and macros probably
+ * were available before 2001, but I'm not sure */
+#if defined(_POSIX_VERSION) && _POSIX_VERSION >= 200112L
+#include <sys/wait.h>
+#define l_inspectstat(stat, what) \
+ if (WIFEXITED(stat)) { \
+ stat = WEXITSTATUS(stat); \
+ } \
+ else if (WIFSIGNALED(stat)) { \
+ stat = WTERMSIG(stat); \
+ what = "signal"; \
+ }
+#endif
+#endif
+
+/* provide default (no-op) version */
+#if !defined(l_inspectstat)
+#define l_inspectstat(stat, what) ((void)0)
+#endif
+
+COMPAT53_API int luaL_execresult(lua_State* L, int stat) {
+ const char* what = "exit";
+ if (stat == -1)
+ return luaL_fileresult(L, 0, NULL);
+ else {
+ l_inspectstat(stat, what);
+ if (*what == 'e' && stat == 0)
+ lua_pushboolean(L, 1);
+ else
+ lua_pushnil(L);
+ lua_pushstring(L, what);
+ lua_pushinteger(L, stat);
+ return 3;
+ }
+}
+
+COMPAT53_API void luaL_buffinit(lua_State* L, luaL_Buffer_53* B) {
+ /* make it crash if used via pointer to a 5.1-style luaL_Buffer */
+ B->b.p = NULL;
+ B->b.L = NULL;
+ B->b.lvl = 0;
+ /* reuse the buffer from the 5.1-style luaL_Buffer though! */
+ B->ptr = B->b.buffer;
+ B->capacity = LUAL_BUFFERSIZE;
+ B->nelems = 0;
+ B->L2 = L;
+}
+
+COMPAT53_API char* luaL_prepbuffsize(luaL_Buffer_53* B, size_t s) {
+ if (B->capacity - B->nelems < s) { /* needs to grow */
+ char* newptr = NULL;
+ size_t newcap = B->capacity * 2;
+ if (newcap - B->nelems < s)
+ newcap = B->nelems + s;
+ if (newcap < B->capacity) /* overflow */
+ luaL_error(B->L2, "buffer too large");
+ newptr = (char*)lua_newuserdata(B->L2, newcap);
+ memcpy(newptr, B->ptr, B->nelems);
+ if (B->ptr != B->b.buffer)
+ lua_replace(B->L2, -2); /* remove old buffer */
+ B->ptr = newptr;
+ B->capacity = newcap;
+ }
+ return B->ptr + B->nelems;
+}
+
+COMPAT53_API void luaL_addlstring(luaL_Buffer_53* B, const char* s, size_t l) {
+ memcpy(luaL_prepbuffsize(B, l), s, l);
+ luaL_addsize(B, l);
+}
+
+COMPAT53_API void luaL_addvalue(luaL_Buffer_53* B) {
+ size_t len = 0;
+ const char* s = lua_tolstring(B->L2, -1, &len);
+ if (!s)
+ luaL_error(B->L2, "cannot convert value to string");
+ if (B->ptr != B->b.buffer)
+ lua_insert(B->L2, -2); /* userdata buffer must be at stack top */
+ luaL_addlstring(B, s, len);
+ lua_remove(B->L2, B->ptr != B->b.buffer ? -2 : -1);
+}
+
+void luaL_pushresult(luaL_Buffer_53* B) {
+ lua_pushlstring(B->L2, B->ptr, B->nelems);
+ if (B->ptr != B->b.buffer)
+ lua_replace(B->L2, -2); /* remove userdata buffer */
+}
+
+#endif /* Lua 5.1 */
+
+/* definitions for Lua 5.1 and Lua 5.2 */
+#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM <= 502
+
+COMPAT53_API int lua_geti(lua_State* L, int index, lua_Integer i) {
+ index = lua_absindex(L, index);
+ lua_pushinteger(L, i);
+ lua_gettable(L, index);
+ return lua_type(L, -1);
+}
+
+COMPAT53_API int lua_isinteger(lua_State* L, int index) {
+ if (lua_type(L, index) == LUA_TNUMBER) {
+ lua_Number n = lua_tonumber(L, index);
+ lua_Integer i = lua_tointeger(L, index);
+ if (i == n)
+ return 1;
+ }
+ return 0;
+}
+
+COMPAT53_API lua_Integer lua_tointegerx(lua_State* L, int i, int* isnum) {
+ int ok = 0;
+ lua_Number n = lua_tonumberx(L, i, &ok);
+ if (ok) {
+ if (n == (lua_Integer)n) {
+ if (isnum)
+ *isnum = 1;
+ return (lua_Integer)n;
+ }
+ }
+ if (isnum)
+ *isnum = 0;
+ return 0;
+}
+
+static void compat53_reverse(lua_State* L, int a, int b) {
+ for (; a < b; ++a, --b) {
+ lua_pushvalue(L, a);
+ lua_pushvalue(L, b);
+ lua_replace(L, a);
+ lua_replace(L, b);
+ }
+}
+
+COMPAT53_API void lua_rotate(lua_State* L, int idx, int n) {
+ int n_elems = 0;
+ idx = lua_absindex(L, idx);
+ n_elems = lua_gettop(L) - idx + 1;
+ if (n < 0)
+ n += n_elems;
+ if (n > 0 && n < n_elems) {
+ luaL_checkstack(L, 2, "not enough stack slots available");
+ n = n_elems - n;
+ compat53_reverse(L, idx, idx + n - 1);
+ compat53_reverse(L, idx + n, idx + n_elems - 1);
+ compat53_reverse(L, idx, idx + n_elems - 1);
+ }
+}
+
+COMPAT53_API void lua_seti(lua_State* L, int index, lua_Integer i) {
+ luaL_checkstack(L, 1, "not enough stack slots available");
+ index = lua_absindex(L, index);
+ lua_pushinteger(L, i);
+ lua_insert(L, -2);
+ lua_settable(L, index);
+}
+
+#if !defined(lua_str2number)
+#define lua_str2number(s, p) strtod((s), (p))
+#endif
+
+COMPAT53_API size_t lua_stringtonumber(lua_State* L, const char* s) {
+ char* endptr;
+ lua_Number n = lua_str2number(s, &endptr);
+ if (endptr != s) {
+ while (*endptr != '\0' && isspace((unsigned char)*endptr))
+ ++endptr;
+ if (*endptr == '\0') {
+ lua_pushnumber(L, n);
+ return endptr - s + 1;
+ }
+ }
+ return 0;
+}
+
+COMPAT53_API const char* luaL_tolstring(lua_State* L, int idx, size_t* len) {
+ if (!luaL_callmeta(L, idx, "__tostring")) {
+ int t = lua_type(L, idx), tt = 0;
+ char const* name = NULL;
+ switch (t) {
+ case LUA_TNIL:
+ lua_pushliteral(L, "nil");
+ break;
+ case LUA_TSTRING:
+ case LUA_TNUMBER:
+ lua_pushvalue(L, idx);
+ break;
+ case LUA_TBOOLEAN:
+ if (lua_toboolean(L, idx))
+ lua_pushliteral(L, "true");
+ else
+ lua_pushliteral(L, "false");
+ break;
+ default:
+ tt = luaL_getmetafield(L, idx, "__name");
+ name = (tt == LUA_TSTRING) ? lua_tostring(L, -1) : lua_typename(L, t);
+ lua_pushfstring(L, "%s: %p", name, lua_topointer(L, idx));
+ if (tt != LUA_TNIL)
+ lua_replace(L, -2);
+ break;
+ }
+ }
+ else {
+ if (!lua_isstring(L, -1))
+ luaL_error(L, "'__tostring' must return a string");
+ }
+ return lua_tolstring(L, -1, len);
+}
+
+COMPAT53_API void luaL_requiref(lua_State* L, const char* modname, lua_CFunction openf, int glb) {
+ luaL_checkstack(L, 3, "not enough stack slots available");
+ luaL_getsubtable(L, LUA_REGISTRYINDEX, "_LOADED");
+ if (lua_getfield(L, -1, modname) == LUA_TNIL) {
+ lua_pop(L, 1);
+ lua_pushcfunction(L, openf);
+ lua_pushstring(L, modname);
+ lua_call(L, 1, 1);
+ lua_pushvalue(L, -1);
+ lua_setfield(L, -3, modname);
+ }
+ if (glb) {
+ lua_pushvalue(L, -1);
+ lua_setglobal(L, modname);
+ }
+ lua_replace(L, -2);
+}
+
+#endif /* Lua 5.1 and 5.2 */
+
+#endif /* KEPLER_PROJECT_COMPAT53_C_ */
+
+/*********************************************************************
+ * This file contains parts of Lua 5.2's and Lua 5.3's source code:
+ *
+ * Copyright (C) 1994-2014 Lua.org, PUC-Rio.
+ *
+ * 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.
+ *********************************************************************/
+// end of sol/compatibility/compat-5.3.c.h
+
+#endif
+
+#endif /* KEPLER_PROJECT_COMPAT53_H_ */
+
+// end of sol/compatibility/compat-5.3.h
+
+// beginning of sol/compatibility/compat-5.4.h
+
+#ifndef NOT_KEPLER_PROJECT_COMPAT54_H_
+#define NOT_KEPLER_PROJECT_COMPAT54_H_
+
+#if defined(__cplusplus) && !defined(COMPAT53_LUA_CPP)
+extern "C" {
+#endif
+#include <lua.h>
+#include <lauxlib.h>
+#include <lualib.h>
+#if defined(__cplusplus) && !defined(COMPAT53_LUA_CPP)
+}
+#endif
+
+#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM == 504
+
+#if !defined(LUA_ERRGCMM)
+/* So Lua 5.4 actually removes this, which breaks sol2...
+ man, this API is quite unstable...!
+*/
+# define LUA_ERRGCMM (LUA_ERRERR + 2)
+#endif /* LUA_ERRGCMM define */
+
+#endif // Lua 5.4 only
+
+#endif // NOT_KEPLER_PROJECT_COMPAT54_H_// end of sol/compatibility/compat-5.4.h
+
+#endif
+
+// end of sol/compatibility.hpp
+
+#include <vector>
+#include <cstdint>
+#include <cstddef>
+
+namespace sol {
+
+ template <typename Allocator = std::allocator<std::byte>>
+ class basic_bytecode : private std::vector<std::byte, Allocator> {
+ private:
+ using base_t = std::vector<std::byte, Allocator>;
+
+ public:
+ using typename base_t::allocator_type;
+ using typename base_t::const_iterator;
+ using typename base_t::const_pointer;
+ using typename base_t::const_reference;
+ using typename base_t::const_reverse_iterator;
+ using typename base_t::difference_type;
+ using typename base_t::iterator;
+ using typename base_t::pointer;
+ using typename base_t::reference;
+ using typename base_t::reverse_iterator;
+ using typename base_t::size_type;
+ using typename base_t::value_type;
+
+ using base_t::base_t;
+ using base_t::operator=;
+
+ using base_t::data;
+ using base_t::empty;
+ using base_t::max_size;
+ using base_t::size;
+
+ using base_t::at;
+ using base_t::operator[];
+ using base_t::back;
+ using base_t::front;
+
+ using base_t::begin;
+ using base_t::cbegin;
+ using base_t::cend;
+ using base_t::end;
+
+ using base_t::crbegin;
+ using base_t::crend;
+ using base_t::rbegin;
+ using base_t::rend;
+
+ using base_t::get_allocator;
+ using base_t::swap;
+
+ using base_t::clear;
+ using base_t::emplace;
+ using base_t::emplace_back;
+ using base_t::erase;
+ using base_t::insert;
+ using base_t::pop_back;
+ using base_t::push_back;
+ using base_t::reserve;
+ using base_t::resize;
+ using base_t::shrink_to_fit;
+
+ string_view as_string_view() const {
+ return string_view(reinterpret_cast<const char*>(this->data()), this->size());
+ }
+ };
+
+ template <typename Container>
+ inline int basic_insert_dump_writer(lua_State*, const void* memory, size_t memory_size, void* userdata) {
+ using storage_t = Container;
+ const std::byte* p_code = static_cast<const std::byte*>(memory);
+ storage_t& bc = *static_cast<storage_t*>(userdata);
+#if SOL_IS_OFF(SOL_EXCEPTIONS_I_)
+ bc.insert(bc.cend(), p_code, p_code + memory_size);
+#else
+ try {
+ bc.insert(bc.cend(), p_code, p_code + memory_size);
+ }
+ catch (...) {
+ return -1;
+ }
+#endif
+ return 0;
+ }
+
+ using bytecode = basic_bytecode<>;
+
+ constexpr inline auto bytecode_dump_writer = &basic_insert_dump_writer<bytecode>;
+
+} // namespace sol
+
+// end of sol/bytecode.hpp
+
+// beginning of sol/stack.hpp
+
+// beginning of sol/trampoline.hpp
+
+// beginning of sol/types.hpp
+
+// beginning of sol/error.hpp
+
+#include <stdexcept>
+#include <string>
+#include <array>
+
+namespace sol {
+ namespace detail {
+ struct direct_error_tag {};
+ const auto direct_error = direct_error_tag{};
+
+ struct error_result {
+ int results;
+ const char* format_string;
+ std::array<const char*, 4> args_strings;
+
+ error_result() : results(0), format_string(nullptr) {
+ }
+
+ error_result(int results) : results(results), format_string(nullptr) {
+ }
+
+ error_result(const char* fmt, const char* msg) : results(0), format_string(fmt) {
+ args_strings[0] = msg;
+ }
+ };
+
+ inline int handle_errors(lua_State* L, const error_result& er) {
+ if (er.format_string == nullptr) {
+ return er.results;
+ }
+ return luaL_error(L, er.format_string, er.args_strings[0], er.args_strings[1], er.args_strings[2], er.args_strings[3]);
+ }
+ } // namespace detail
+
+ class error : public std::runtime_error {
+ private:
+ // Because VC++ is upsetting, most of the time!
+ std::string what_reason;
+
+ public:
+ error(const std::string& str) : error(detail::direct_error, "lua: error: " + 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, std::string&& str) : std::runtime_error(""), what_reason(std::move(str)) {
+ }
+
+ error(const error& e) = default;
+ error(error&& e) = default;
+ error& operator=(const error& e) = default;
+ error& operator=(error&& e) = default;
+
+ virtual const char* what() const noexcept override {
+ return what_reason.c_str();
+ }
+ };
+
+} // namespace sol
+
+// end of sol/error.hpp
+
+// beginning of sol/optional.hpp
+
+// beginning of sol/in_place.hpp
+
+#include <cstddef>
+#include <utility>
+
+namespace sol {
+
+ using in_place_t = std::in_place_t;
+ constexpr std::in_place_t in_place {};
+ constexpr std::in_place_t in_place_of {};
+
+ template <typename T>
+ using in_place_type_t = std::in_place_type_t<T>;
+ template <typename T>
+ constexpr std::in_place_type_t<T> in_place_type {};
+
+ template <size_t I>
+ using in_place_index_t = std::in_place_index_t<I>;
+ template <size_t I>
+ constexpr in_place_index_t<I> in_place_index {};
+
+} // namespace sol
+
+// end of sol/in_place.hpp
+
+#if SOL_IS_ON(SOL_USE_BOOST_I_)
+#include <boost/optional.hpp>
+#else
+// beginning of sol/optional_implementation.hpp
+
+#define SOL_TL_OPTIONAL_VERSION_MAJOR 0
+#define SOL_TL_OPTIONAL_VERSION_MINOR 5
+
+#include <exception>
+#include <functional>
+#include <new>
+#include <type_traits>
+#include <utility>
+#include <cstdlib>
+#include <optional>
+
+#if (defined(_MSC_VER) && _MSC_VER == 1900)
+#define SOL_TL_OPTIONAL_MSVC2015
+#endif
+
+#if (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 9 && !defined(__clang__))
+#define SOL_TL_OPTIONAL_GCC49
+#endif
+
+#if (defined(__GNUC__) && __GNUC__ == 5 && __GNUC_MINOR__ <= 4 && !defined(__clang__))
+#define SOL_TL_OPTIONAL_GCC54
+#endif
+
+#if (defined(__GNUC__) && __GNUC__ == 5 && __GNUC_MINOR__ <= 5 && !defined(__clang__))
+#define SOL_TL_OPTIONAL_GCC55
+#endif
+
+#if (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 9 && !defined(__clang__))
+#define SOL_TL_OPTIONAL_NO_CONSTRR
+
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) std::has_trivial_copy_constructor<T>::value
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) std::has_trivial_copy_assign<T>::value
+
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible<T>::value
+
+#elif (defined(__GNUC__) && __GNUC__ < 8 && !defined(__clang__))
+#ifndef SOL_TL_GCC_LESS_8_TRIVIALLY_COPY_CONSTRUCTIBLE_MUTEX
+#define SOL_TL_GCC_LESS_8_TRIVIALLY_COPY_CONSTRUCTIBLE_MUTEX
+namespace sol { namespace detail {
+ template <class T>
+ struct is_trivially_copy_constructible : std::is_trivially_copy_constructible<T> {};
+#ifdef _GLIBCXX_VECTOR
+ template <class T, class A>
+ struct is_trivially_copy_constructible<std::vector<T, A>> : std::is_trivially_copy_constructible<T> {};
+#endif
+}} // namespace sol::detail
+#endif
+
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) sol::detail::is_trivially_copy_constructible<T>::value
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) std::is_trivially_copy_assignable<T>::value
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible<T>::value
+#else
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) std::is_trivially_copy_constructible<T>::value
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) std::is_trivially_copy_assignable<T>::value
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible<T>::value
+#endif
+
+#if __cplusplus > 201103L
+#define SOL_TL_OPTIONAL_CXX14
+#endif
+
+#if (__cplusplus == 201103L || defined(SOL_TL_OPTIONAL_MSVC2015) || defined(SOL_TL_OPTIONAL_GCC49))
+#define SOL_TL_OPTIONAL_11_CONSTEXPR
+#else
+ /// \exclude
+#define SOL_TL_OPTIONAL_11_CONSTEXPR constexpr
+#endif
+
+namespace sol {
+#ifndef SOL_TL_MONOSTATE_INPLACE_MUTEX
+#define SOL_TL_MONOSTATE_INPLACE_MUTEX
+ /// \brief Used to represent an optional with no data; essentially a bool
+ class monostate {};
+#endif
+
+ template <class T>
+ class optional;
+
+ /// \exclude
+ namespace detail {
+#ifndef SOL_TL_TRAITS_MUTEX
+#define SOL_TL_TRAITS_MUTEX
+ // C++14-style aliases for brevity
+ template <class T>
+ using remove_const_t = typename std::remove_const<T>::type;
+ template <class T>
+ using remove_reference_t = typename std::remove_reference<T>::type;
+ template <class T>
+ using decay_t = typename std::decay<T>::type;
+ template <bool E, class T = void>
+ using enable_if_t = typename std::enable_if<E, T>::type;
+ template <bool B, class T, class F>
+ using conditional_t = typename std::conditional<B, T, F>::type;
+
+ // std::conjunction from C++17
+ template <class...>
+ struct conjunction : std::true_type {};
+ template <class B>
+ struct conjunction<B> : B {};
+ template <class B, class... Bs>
+ struct conjunction<B, Bs...> : std::conditional<bool(B::value), conjunction<Bs...>, B>::type {};
+
+#if defined(_LIBCPP_VERSION) && __cplusplus == 201103L
+#define SOL_TL_OPTIONAL_LIBCXX_MEM_FN_WORKAROUND
+#endif
+
+#ifdef SOL_TL_OPTIONAL_LIBCXX_MEM_FN_WORKAROUND
+ template <class T>
+ struct is_pointer_to_non_const_member_func : std::false_type {};
+ template <class T, class Ret, class... Args>
+ struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...)> : std::true_type {};
+ template <class T, class Ret, class... Args>
+ struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...)&> : std::true_type {};
+ template <class T, class Ret, class... Args>
+ struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) &&> : std::true_type {};
+ template <class T, class Ret, class... Args>
+ struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) volatile> : std::true_type {};
+ template <class T, class Ret, class... Args>
+ struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) volatile&> : std::true_type {};
+ template <class T, class Ret, class... Args>
+ struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) volatile&&> : std::true_type {};
+
+ template <class T>
+ struct is_const_or_const_ref : std::false_type {};
+ template <class T>
+ struct is_const_or_const_ref<T const&> : std::true_type {};
+ template <class T>
+ struct is_const_or_const_ref<T const> : std::true_type {};
+#endif
+
+ // std::invoke from C++17
+ // https://stackoverflow.com/questions/38288042/c11-14-invoke-workaround
+ template <typename Fn, typename... Args,
+#ifdef SOL_TL_OPTIONAL_LIBCXX_MEM_FN_WORKAROUND
+ typename = enable_if_t<!(is_pointer_to_non_const_member_func<Fn>::value && is_const_or_const_ref<Args...>::value)>,
+#endif
+ typename = enable_if_t<std::is_member_pointer<decay_t<Fn>>::value>, int = 0>
+ constexpr auto invoke(Fn&& f, Args&&... args) noexcept(noexcept(std::mem_fn(f)(std::forward<Args>(args)...)))
+ -> decltype(std::mem_fn(f)(std::forward<Args>(args)...)) {
+ return std::mem_fn(f)(std::forward<Args>(args)...);
+ }
+
+ template <typename Fn, typename... Args, typename = enable_if_t<!std::is_member_pointer<decay_t<Fn>>::value>>
+ constexpr auto invoke(Fn&& f, Args&&... args) noexcept(noexcept(std::forward<Fn>(f)(std::forward<Args>(args)...)))
+ -> decltype(std::forward<Fn>(f)(std::forward<Args>(args)...)) {
+ return std::forward<Fn>(f)(std::forward<Args>(args)...);
+ }
+
+ // std::invoke_result from C++17
+ template <class F, class, class... Us>
+ struct invoke_result_impl;
+
+ template <class F, class... Us>
+ struct invoke_result_impl<F, decltype(detail::invoke(std::declval<F>(), std::declval<Us>()...), void()), Us...> {
+ using type = decltype(detail::invoke(std::declval<F>(), std::declval<Us>()...));
+ };
+
+ template <class F, class... Us>
+ using invoke_result = invoke_result_impl<F, void, Us...>;
+
+ template <class F, class... Us>
+ using invoke_result_t = typename invoke_result<F, Us...>::type;
+#endif
+
+ // std::void_t from C++17
+ template <class...>
+ struct voider {
+ using type = void;
+ };
+ template <class... Ts>
+ using void_t = typename voider<Ts...>::type;
+
+ // Trait for checking if a type is a sol::optional
+ template <class T>
+ struct is_optional_impl : std::false_type {};
+ template <class T>
+ struct is_optional_impl<optional<T>> : std::true_type {};
+ template <class T>
+ using is_optional = is_optional_impl<decay_t<T>>;
+
+ // Change void to sol::monostate
+ template <class U>
+ using fixup_void = conditional_t<std::is_void<U>::value, monostate, U>;
+
+ template <class F, class U, class = invoke_result_t<F, U>>
+ using get_map_return = optional<fixup_void<invoke_result_t<F, U>>>;
+
+ // Check if invoking F for some Us returns void
+ template <class F, class = void, class... U>
+ struct returns_void_impl;
+ template <class F, class... U>
+ struct returns_void_impl<F, void_t<invoke_result_t<F, U...>>, U...> : std::is_void<invoke_result_t<F, U...>> {};
+ template <class F, class... U>
+ using returns_void = returns_void_impl<F, void, U...>;
+
+ template <class T, class... U>
+ using enable_if_ret_void = enable_if_t<returns_void<T&&, U...>::value>;
+
+ template <class T, class... U>
+ using disable_if_ret_void = enable_if_t<!returns_void<T&&, U...>::value>;
+
+ template <class T, class U>
+ using enable_forward_value = detail::enable_if_t<std::is_constructible<T, U&&>::value && !std::is_same<detail::decay_t<U>, in_place_t>::value
+ && !std::is_same<optional<T>, detail::decay_t<U>>::value>;
+
+ template <class T, class U, class Other>
+ using enable_from_other = detail::enable_if_t<std::is_constructible<T, Other>::value && !std::is_constructible<T, optional<U>&>::value
+ && !std::is_constructible<T, optional<U>&&>::value && !std::is_constructible<T, const optional<U>&>::value
+ && !std::is_constructible<T, const optional<U>&&>::value && !std::is_convertible<optional<U>&, T>::value
+ && !std::is_convertible<optional<U>&&, T>::value && !std::is_convertible<const optional<U>&, T>::value
+ && !std::is_convertible<const optional<U>&&, T>::value>;
+
+ template <class T, class U>
+ using enable_assign_forward = detail::enable_if_t<!std::is_same<optional<T>, detail::decay_t<U>>::value
+ && !detail::conjunction<std::is_scalar<T>, std::is_same<T, detail::decay_t<U>>>::value && std::is_constructible<T, U>::value
+ && std::is_assignable<T&, U>::value>;
+
+ template <class T, class U, class Other>
+ using enable_assign_from_other = detail::enable_if_t<std::is_constructible<T, Other>::value && std::is_assignable<T&, Other>::value
+ && !std::is_constructible<T, optional<U>&>::value && !std::is_constructible<T, optional<U>&&>::value
+ && !std::is_constructible<T, const optional<U>&>::value && !std::is_constructible<T, const optional<U>&&>::value
+ && !std::is_convertible<optional<U>&, T>::value && !std::is_convertible<optional<U>&&, T>::value
+ && !std::is_convertible<const optional<U>&, T>::value && !std::is_convertible<const optional<U>&&, T>::value
+ && !std::is_assignable<T&, optional<U>&>::value && !std::is_assignable<T&, optional<U>&&>::value
+ && !std::is_assignable<T&, const optional<U>&>::value && !std::is_assignable<T&, const optional<U>&&>::value>;
+
+#ifdef _MSC_VER
+ // TODO make a version which works with MSVC
+ template <class T, class U = T>
+ struct is_swappable : std::true_type {};
+
+ template <class T, class U = T>
+ struct is_nothrow_swappable : std::true_type {};
+#else
+ // https://stackoverflow.com/questions/26744589/what-is-a-proper-way-to-implement-is-swappable-to-test-for-the-swappable-concept
+ namespace swap_adl_tests {
+ // if swap ADL finds this then it would call std::swap otherwise (same
+ // signature)
+ struct tag {};
+
+ template <class T>
+ tag swap(T&, T&);
+ template <class T, std::size_t N>
+ tag swap(T (&a)[N], T (&b)[N]);
+
+ // helper functions to test if an unqualified swap is possible, and if it
+ // becomes std::swap
+ template <class, class>
+ std::false_type can_swap(...) noexcept(false);
+ template <class T, class U, class = decltype(swap(std::declval<T&>(), std::declval<U&>()))>
+ std::true_type can_swap(int) noexcept(noexcept(swap(std::declval<T&>(), std::declval<U&>())));
+
+ template <class, class>
+ std::false_type uses_std(...);
+ template <class T, class U>
+ std::is_same<decltype(swap(std::declval<T&>(), std::declval<U&>())), tag> uses_std(int);
+
+ template <class T>
+ struct is_std_swap_noexcept
+ : std::integral_constant<bool, std::is_nothrow_move_constructible<T>::value && std::is_nothrow_move_assignable<T>::value> {};
+
+ template <class T, std::size_t N>
+ struct is_std_swap_noexcept<T[N]> : is_std_swap_noexcept<T> {};
+
+ template <class T, class U>
+ struct is_adl_swap_noexcept : std::integral_constant<bool, noexcept(can_swap<T, U>(0))> {};
+ } // namespace swap_adl_tests
+
+ template <class T, class U = T>
+ struct is_swappable : std::integral_constant<bool,
+ decltype(detail::swap_adl_tests::can_swap<T, U>(0))::value
+ && (!decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value
+ || (std::is_move_assignable<T>::value && std::is_move_constructible<T>::value))> {};
+
+ template <class T, std::size_t N>
+ struct is_swappable<T[N], T[N]> : std::integral_constant<bool,
+ decltype(detail::swap_adl_tests::can_swap<T[N], T[N]>(0))::value
+ && (!decltype(detail::swap_adl_tests::uses_std<T[N], T[N]>(0))::value || is_swappable<T, T>::value)> {};
+
+ template <class T, class U = T>
+ struct is_nothrow_swappable
+ : std::integral_constant<bool,
+ is_swappable<T, U>::value
+ && ((decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value&& detail::swap_adl_tests::is_std_swap_noexcept<T>::value)
+ || (!decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value&& detail::swap_adl_tests::is_adl_swap_noexcept<T, U>::value))> {};
+#endif
+
+ // The storage base manages the actual storage, and correctly propagates
+ // trivial destruction from T. This case is for when T is not trivially
+ // destructible.
+ template <class T, bool = ::std::is_trivially_destructible<T>::value>
+ struct optional_storage_base {
+ SOL_TL_OPTIONAL_11_CONSTEXPR optional_storage_base() noexcept : m_dummy(), m_has_value(false) {
+ }
+
+ template <class... U>
+ SOL_TL_OPTIONAL_11_CONSTEXPR optional_storage_base(in_place_t, U&&... u) : m_value(std::forward<U>(u)...), m_has_value(true) {
+ }
+
+ ~optional_storage_base() {
+ if (m_has_value) {
+ m_value.~T();
+ m_has_value = false;
+ }
+ }
+
+ struct dummy {};
+ union {
+ dummy m_dummy;
+ T m_value;
+ };
+
+ bool m_has_value;
+ };
+
+ // This case is for when T is trivially destructible.
+ template <class T>
+ struct optional_storage_base<T, true> {
+ SOL_TL_OPTIONAL_11_CONSTEXPR optional_storage_base() noexcept : m_dummy(), m_has_value(false) {
+ }
+
+ template <class... U>
+ SOL_TL_OPTIONAL_11_CONSTEXPR optional_storage_base(in_place_t, U&&... u) : m_value(std::forward<U>(u)...), m_has_value(true) {
+ }
+
+ // No destructor, so this class is trivially destructible
+
+ struct dummy {};
+ union {
+ dummy m_dummy;
+ T m_value;
+ };
+
+ bool m_has_value = false;
+ };
+
+ // This base class provides some handy member functions which can be used in
+ // further derived classes
+ template <class T>
+ struct optional_operations_base : optional_storage_base<T> {
+ using optional_storage_base<T>::optional_storage_base;
+
+ void hard_reset() noexcept {
+ get().~T();
+ this->m_has_value = false;
+ }
+
+ template <class... Args>
+ void construct(Args&&... args) noexcept {
+ new (std::addressof(this->m_value)) T(std::forward<Args>(args)...);
+ this->m_has_value = true;
+ }
+
+ template <class Opt>
+ void assign(Opt&& rhs) {
+ if (this->has_value()) {
+ if (rhs.has_value()) {
+ this->m_value = std::forward<Opt>(rhs).get();
+ }
+ else {
+ this->m_value.~T();
+ this->m_has_value = false;
+ }
+ }
+
+ else if (rhs.has_value()) {
+ construct(std::forward<Opt>(rhs).get());
+ }
+ }
+
+ bool has_value() const {
+ return this->m_has_value;
+ }
+
+ SOL_TL_OPTIONAL_11_CONSTEXPR T& get() & {
+ return this->m_value;
+ }
+ SOL_TL_OPTIONAL_11_CONSTEXPR const T& get() const& {
+ return this->m_value;
+ }
+ SOL_TL_OPTIONAL_11_CONSTEXPR T&& get() && {
+ return std::move(this->m_value);
+ }
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+ constexpr const T&& get() const&& {
+ return std::move(this->m_value);
+ }
+#endif
+ };
+
+ // This class manages conditionally having a trivial copy constructor
+ // This specialization is for when T is trivially copy constructible
+ template <class T, bool = SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T)>
+ struct optional_copy_base : optional_operations_base<T> {
+ using optional_operations_base<T>::optional_operations_base;
+ };
+
+ // This specialization is for when T is not trivially copy constructible
+ template <class T>
+ struct optional_copy_base<T, false> : optional_operations_base<T> {
+ using base_t = optional_operations_base<T>;
+
+ using base_t::base_t;
+
+ optional_copy_base() = default;
+ optional_copy_base(const optional_copy_base& rhs) : base_t() {
+ if (rhs.has_value()) {
+ this->construct(rhs.get());
+ }
+ else {
+ this->m_has_value = false;
+ }
+ }
+
+ optional_copy_base(optional_copy_base&& rhs) = default;
+ optional_copy_base& operator=(const optional_copy_base& rhs) = default;
+ optional_copy_base& operator=(optional_copy_base&& rhs) = default;
+ };
+
+#ifndef SOL_TL_OPTIONAL_GCC49
+ template <class T, bool = std::is_trivially_move_constructible<T>::value>
+ struct optional_move_base : optional_copy_base<T> {
+ using optional_copy_base<T>::optional_copy_base;
+ };
+#else
+ template <class T, bool = false>
+ struct optional_move_base;
+#endif
+ template <class T>
+ struct optional_move_base<T, false> : optional_copy_base<T> {
+ using optional_copy_base<T>::optional_copy_base;
+
+ optional_move_base() = default;
+ optional_move_base(const optional_move_base& rhs) = default;
+
+ optional_move_base(optional_move_base&& rhs) noexcept(std::is_nothrow_move_constructible<T>::value) {
+ if (rhs.has_value()) {
+ this->construct(std::move(rhs.get()));
+ }
+ else {
+ this->m_has_value = false;
+ }
+ }
+ optional_move_base& operator=(const optional_move_base& rhs) = default;
+ optional_move_base& operator=(optional_move_base&& rhs) = default;
+ };
+
+ // This class manages conditionally having a trivial copy assignment operator
+ template <class T,
+ bool = SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) && SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T)
+ && SOL_TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T)>
+ struct optional_copy_assign_base : optional_move_base<T> {
+ using optional_move_base<T>::optional_move_base;
+ };
+
+ template <class T>
+ struct optional_copy_assign_base<T, false> : optional_move_base<T> {
+ using optional_move_base<T>::optional_move_base;
+
+ optional_copy_assign_base() = default;
+ optional_copy_assign_base(const optional_copy_assign_base& rhs) = default;
+
+ optional_copy_assign_base(optional_copy_assign_base&& rhs) = default;
+ optional_copy_assign_base& operator=(const optional_copy_assign_base& rhs) {
+ this->assign(rhs);
+ return *this;
+ }
+ optional_copy_assign_base& operator=(optional_copy_assign_base&& rhs) = default;
+ };
+
+#ifndef SOL_TL_OPTIONAL_GCC49
+ template <class T,
+ bool = std::is_trivially_destructible<T>::value&& std::is_trivially_move_constructible<T>::value&& std::is_trivially_move_assignable<T>::value>
+ struct optional_move_assign_base : optional_copy_assign_base<T> {
+ using optional_copy_assign_base<T>::optional_copy_assign_base;
+ };
+#else
+ template <class T, bool = false>
+ struct optional_move_assign_base;
+#endif
+
+ template <class T>
+ struct optional_move_assign_base<T, false> : optional_copy_assign_base<T> {
+ using optional_copy_assign_base<T>::optional_copy_assign_base;
+
+ optional_move_assign_base() = default;
+ optional_move_assign_base(const optional_move_assign_base& rhs) = default;
+
+ optional_move_assign_base(optional_move_assign_base&& rhs) = default;
+
+ optional_move_assign_base& operator=(const optional_move_assign_base& rhs) = default;
+
+ optional_move_assign_base& operator=(optional_move_assign_base&& rhs) noexcept(
+ std::is_nothrow_move_constructible<T>::value&& std::is_nothrow_move_assignable<T>::value) {
+ this->assign(std::move(rhs));
+ return *this;
+ }
+ };
+
+ // optional_delete_ctor_base will conditionally delete copy and move
+ // constructors depending on whether T is copy/move constructible
+ template <class T, bool EnableCopy = std::is_copy_constructible<T>::value, bool EnableMove = std::is_move_constructible<T>::value>
+ struct optional_delete_ctor_base {
+ optional_delete_ctor_base() = default;
+ optional_delete_ctor_base(const optional_delete_ctor_base&) = default;
+ optional_delete_ctor_base(optional_delete_ctor_base&&) noexcept = default;
+ optional_delete_ctor_base& operator=(const optional_delete_ctor_base&) = default;
+ optional_delete_ctor_base& operator=(optional_delete_ctor_base&&) noexcept = default;
+ };
+
+ template <class T>
+ struct optional_delete_ctor_base<T, true, false> {
+ optional_delete_ctor_base() = default;
+ optional_delete_ctor_base(const optional_delete_ctor_base&) = default;
+ optional_delete_ctor_base(optional_delete_ctor_base&&) noexcept = delete;
+ optional_delete_ctor_base& operator=(const optional_delete_ctor_base&) = default;
+ optional_delete_ctor_base& operator=(optional_delete_ctor_base&&) noexcept = default;
+ };
+
+ template <class T>
+ struct optional_delete_ctor_base<T, false, true> {
+ optional_delete_ctor_base() = default;
+ optional_delete_ctor_base(const optional_delete_ctor_base&) = delete;
+ optional_delete_ctor_base(optional_delete_ctor_base&&) noexcept = default;
+ optional_delete_ctor_base& operator=(const optional_delete_ctor_base&) = default;
+ optional_delete_ctor_base& operator=(optional_delete_ctor_base&&) noexcept = default;
+ };
+
+ template <class T>
+ struct optional_delete_ctor_base<T, false, false> {
+ optional_delete_ctor_base() = default;
+ optional_delete_ctor_base(const optional_delete_ctor_base&) = delete;
+ optional_delete_ctor_base(optional_delete_ctor_base&&) noexcept = delete;
+ optional_delete_ctor_base& operator=(const optional_delete_ctor_base&) = default;
+ optional_delete_ctor_base& operator=(optional_delete_ctor_base&&) noexcept = default;
+ };
+
+ // optional_delete_assign_base will conditionally delete copy and move
+ // constructors depending on whether T is copy/move constructible + assignable
+ template <class T, bool EnableCopy = (std::is_copy_constructible<T>::value && std::is_copy_assignable<T>::value),
+ bool EnableMove = (std::is_move_constructible<T>::value && std::is_move_assignable<T>::value)>
+ struct optional_delete_assign_base {
+ optional_delete_assign_base() = default;
+ optional_delete_assign_base(const optional_delete_assign_base&) = default;
+ optional_delete_assign_base(optional_delete_assign_base&&) noexcept = default;
+ optional_delete_assign_base& operator=(const optional_delete_assign_base&) = default;
+ optional_delete_assign_base& operator=(optional_delete_assign_base&&) noexcept = default;
+ };
+
+ template <class T>
+ struct optional_delete_assign_base<T, true, false> {
+ optional_delete_assign_base() = default;
+ optional_delete_assign_base(const optional_delete_assign_base&) = default;
+ optional_delete_assign_base(optional_delete_assign_base&&) noexcept = default;
+ optional_delete_assign_base& operator=(const optional_delete_assign_base&) = default;
+ optional_delete_assign_base& operator=(optional_delete_assign_base&&) noexcept = delete;
+ };
+
+ template <class T>
+ struct optional_delete_assign_base<T, false, true> {
+ optional_delete_assign_base() = default;
+ optional_delete_assign_base(const optional_delete_assign_base&) = default;
+ optional_delete_assign_base(optional_delete_assign_base&&) noexcept = default;
+ optional_delete_assign_base& operator=(const optional_delete_assign_base&) = delete;
+ optional_delete_assign_base& operator=(optional_delete_assign_base&&) noexcept = default;
+ };
+
+ template <class T>
+ struct optional_delete_assign_base<T, false, false> {
+ optional_delete_assign_base() = default;
+ optional_delete_assign_base(const optional_delete_assign_base&) = default;
+ optional_delete_assign_base(optional_delete_assign_base&&) noexcept = default;
+ optional_delete_assign_base& operator=(const optional_delete_assign_base&) = delete;
+ optional_delete_assign_base& operator=(optional_delete_assign_base&&) noexcept = delete;
+ };
+
+ } // namespace detail
+
+ /// \brief A tag type to represent an empty optional
+ using nullopt_t = std::nullopt_t;
+
+ /// \brief Represents an empty optional
+ /// \synopsis static constexpr nullopt_t nullopt;
+ ///
+ /// *Examples*:
+ /// ```
+ /// sol::optional<int> a = sol::nullopt;
+ /// void foo (sol::optional<int>);
+ /// foo(sol::nullopt); //pass an empty optional
+ /// ```
+ using std::nullopt;
+
+ class bad_optional_access : public std::exception {
+ public:
+ bad_optional_access() = default;
+ const char* what() const noexcept {
+ return "Optional has no value";
+ }
+ };
+
+ /// An optional object is an object that contains the storage for another
+ /// object and manages the lifetime of this contained object, if any. The
+ /// contained object may be initialized after the optional object has been
+ /// initialized, and may be destroyed before the optional object has been
+ /// destroyed. The initialization state of the contained object is tracked by
+ /// the optional object.
+ template <class T>
+ class optional : private detail::optional_move_assign_base<T>,
+ private detail::optional_delete_ctor_base<T>,
+ private detail::optional_delete_assign_base<T> {
+ using base = detail::optional_move_assign_base<T>;
+
+ static_assert(!std::is_same<T, in_place_t>::value, "instantiation of optional with in_place_t is ill-formed");
+ static_assert(!std::is_same<detail::decay_t<T>, nullopt_t>::value, "instantiation of optional with nullopt_t is ill-formed");
+
+ public:
+#if defined(SOL_TL_OPTIONAL_CXX14) && !defined(SOL_TL_OPTIONAL_GCC49) && !defined(SOL_TL_OPTIONAL_GCC54) && !defined(SOL_TL_OPTIONAL_GCC55)
+ /// \group and_then
+ /// Carries out some operation which returns an optional on the stored
+ /// object if there is one. \requires `std::invoke(std::forward<F>(f),
+ /// value())` returns a `std::optional<U>` for some `U`. \returns Let `U` be
+ /// the result of `std::invoke(std::forward<F>(f), value())`. Returns a
+ /// `std::optional<U>`. The return value is empty if `*this` is empty,
+ /// otherwise the return value of `std::invoke(std::forward<F>(f), value())`
+ /// is returned.
+ /// \group and_then
+ /// \synopsis template <class F>\nconstexpr auto and_then(F &&f) &;
+ template <class F>
+ SOL_TL_OPTIONAL_11_CONSTEXPR auto and_then(F&& f) & {
+ using result = detail::invoke_result_t<F, T&>;
+ static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+ return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+ }
+
+ /// \group and_then
+ /// \synopsis template <class F>\nconstexpr auto and_then(F &&f) &&;
+ template <class F>
+ SOL_TL_OPTIONAL_11_CONSTEXPR auto and_then(F&& f) && {
+ using result = detail::invoke_result_t<F, T&&>;
+ static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+ return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : result(nullopt);
+ }
+
+ /// \group and_then
+ /// \synopsis template <class F>\nconstexpr auto and_then(F &&f) const &;
+ template <class F>
+ constexpr auto and_then(F&& f) const& {
+ using result = detail::invoke_result_t<F, const T&>;
+ static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+ return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+ }
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+ /// \group and_then
+ /// \synopsis template <class F>\nconstexpr auto and_then(F &&f) const &&;
+ template <class F>
+ constexpr auto and_then(F&& f) const&& {
+ using result = detail::invoke_result_t<F, const T&&>;
+ static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+ return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : result(nullopt);
+ }
+#endif
+#else
+ /// \group and_then
+ /// Carries out some operation which returns an optional on the stored
+ /// object if there is one. \requires `std::invoke(std::forward<F>(f),
+ /// value())` returns a `std::optional<U>` for some `U`.
+ /// \returns Let `U` be the result of `std::invoke(std::forward<F>(f),
+ /// value())`. Returns a `std::optional<U>`. The return value is empty if
+ /// `*this` is empty, otherwise the return value of
+ /// `std::invoke(std::forward<F>(f), value())` is returned.
+ /// \group and_then
+ /// \synopsis template <class F>\nconstexpr auto and_then(F &&f) &;
+ template <class F>
+ SOL_TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T&> and_then(F&& f) & {
+ using result = detail::invoke_result_t<F, T&>;
+ static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+ return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+ }
+
+ /// \group and_then
+ /// \synopsis template <class F>\nconstexpr auto and_then(F &&f) &&;
+ template <class F>
+ SOL_TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T&&> and_then(F&& f) && {
+ using result = detail::invoke_result_t<F, T&&>;
+ static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+ return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : result(nullopt);
+ }
+
+ /// \group and_then
+ /// \synopsis template <class F>\nconstexpr auto and_then(F &&f) const &;
+ template <class F>
+ constexpr detail::invoke_result_t<F, const T&> and_then(F&& f) const& {
+ using result = detail::invoke_result_t<F, const T&>;
+ static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+ return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+ }
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+ /// \group and_then
+ /// \synopsis template <class F>\nconstexpr auto and_then(F &&f) const &&;
+ template <class F>
+ constexpr detail::invoke_result_t<F, const T&&> and_then(F&& f) const&& {
+ using result = detail::invoke_result_t<F, const T&&>;
+ static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+ return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : result(nullopt);
+ }
+#endif
+#endif
+
+#if defined(SOL_TL_OPTIONAL_CXX14) && !defined(SOL_TL_OPTIONAL_GCC49) && !defined(SOL_TL_OPTIONAL_GCC54) && !defined(SOL_TL_OPTIONAL_GCC55)
+ /// \brief Carries out some operation on the stored object if there is one.
+ /// \returns Let `U` be the result of `std::invoke(std::forward<F>(f),
+ /// value())`. Returns a `std::optional<U>`. The return value is empty if
+ /// `*this` is empty, otherwise an `optional<U>` is constructed from the
+ /// return value of `std::invoke(std::forward<F>(f), value())` and is
+ /// returned.
+ ///
+ /// \group map
+ /// \synopsis template <class F> constexpr auto map(F &&f) &;
+ template <class F>
+ SOL_TL_OPTIONAL_11_CONSTEXPR auto map(F&& f) & {
+ return optional_map_impl(*this, std::forward<F>(f));
+ }
+
+ /// \group map
+ /// \synopsis template <class F> constexpr auto map(F &&f) &&;
+ template <class F>
+ SOL_TL_OPTIONAL_11_CONSTEXPR auto map(F&& f) && {
+ return optional_map_impl(std::move(*this), std::forward<F>(f));
+ }
+
+ /// \group map
+ /// \synopsis template <class F> constexpr auto map(F &&f) const&;
+ template <class F>
+ constexpr auto map(F&& f) const& {
+ return optional_map_impl(*this, std::forward<F>(f));
+ }
+
+ /// \group map
+ /// \synopsis template <class F> constexpr auto map(F &&f) const&&;
+ template <class F>
+ constexpr auto map(F&& f) const&& {
+ return optional_map_impl(std::move(*this), std::forward<F>(f));
+ }
+#else
+ /// \brief Carries out some operation on the stored object if there is one.
+ /// \returns Let `U` be the result of `std::invoke(std::forward<F>(f),
+ /// value())`. Returns a `std::optional<U>`. The return value is empty if
+ /// `*this` is empty, otherwise an `optional<U>` is constructed from the
+ /// return value of `std::invoke(std::forward<F>(f), value())` and is
+ /// returned.
+ ///
+ /// \group map
+ /// \synopsis template <class F> auto map(F &&f) &;
+ template <class F>
+ SOL_TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<optional&>(), std::declval<F&&>())) map(F&& f) & {
+ return optional_map_impl(*this, std::forward<F>(f));
+ }
+
+ /// \group map
+ /// \synopsis template <class F> auto map(F &&f) &&;
+ template <class F>
+ SOL_TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<optional&&>(), std::declval<F&&>())) map(F&& f) && {
+ return optional_map_impl(std::move(*this), std::forward<F>(f));
+ }
+
+ /// \group map
+ /// \synopsis template <class F> auto map(F &&f) const&;
+ template <class F>
+ constexpr decltype(optional_map_impl(std::declval<const optional&>(), std::declval<F&&>())) map(F&& f) const& {
+ return optional_map_impl(*this, std::forward<F>(f));
+ }
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+ /// \group map
+ /// \synopsis template <class F> auto map(F &&f) const&&;
+ template <class F>
+ constexpr decltype(optional_map_impl(std::declval<const optional&&>(), std::declval<F&&>())) map(F&& f) const&& {
+ return optional_map_impl(std::move(*this), std::forward<F>(f));
+ }
+#endif
+#endif
+
+ /// \brief Calls `f` if the optional is empty
+ /// \requires `std::invoke_result_t<F>` must be void or convertible to
+ /// `optional<T>`.
+ /// \effects If `*this` has a value, returns `*this`.
+ /// Otherwise, if `f` returns `void`, calls `std::forward<F>(f)` and returns
+ /// `std::nullopt`. Otherwise, returns `std::forward<F>(f)()`.
+ ///
+ /// \group or_else
+ /// \synopsis template <class F> optional<T> or_else (F &&f) &;
+ template <class F, detail::enable_if_ret_void<F>* = nullptr>
+ optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) & {
+ if (has_value())
+ return *this;
+
+ std::forward<F>(f)();
+ return nullopt;
+ }
+
+ /// \exclude
+ template <class F, detail::disable_if_ret_void<F>* = nullptr>
+ optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) & {
+ return has_value() ? *this : std::forward<F>(f)();
+ }
+
+ /// \group or_else
+ /// \synopsis template <class F> optional<T> or_else (F &&f) &&;
+ template <class F, detail::enable_if_ret_void<F>* = nullptr>
+ optional<T> or_else(F&& f) && {
+ if (has_value())
+ return std::move(*this);
+
+ std::forward<F>(f)();
+ return nullopt;
+ }
+
+ /// \exclude
+ template <class F, detail::disable_if_ret_void<F>* = nullptr>
+ optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) && {
+ return has_value() ? std::move(*this) : std::forward<F>(f)();
+ }
+
+ /// \group or_else
+ /// \synopsis template <class F> optional<T> or_else (F &&f) const &;
+ template <class F, detail::enable_if_ret_void<F>* = nullptr>
+ optional<T> or_else(F&& f) const& {
+ if (has_value())
+ return *this;
+
+ std::forward<F>(f)();
+ return nullopt;
+ }
+
+ /// \exclude
+ template <class F, detail::disable_if_ret_void<F>* = nullptr>
+ optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) const& {
+ return has_value() ? *this : std::forward<F>(f)();
+ }
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+ /// \exclude
+ template <class F, detail::enable_if_ret_void<F>* = nullptr>
+ optional<T> or_else(F&& f) const&& {
+ if (has_value())
+ return std::move(*this);
+
+ std::forward<F>(f)();
+ return nullopt;
+ }
+
+ /// \exclude
+ template <class F, detail::disable_if_ret_void<F>* = nullptr>
+ optional<T> or_else(F&& f) const&& {
+ return has_value() ? std::move(*this) : std::forward<F>(f)();
+ }
+#endif
+
+ /// \brief Maps the stored value with `f` if there is one, otherwise returns
+ /// `u`.
+ ///
+ /// \details If there is a value stored, then `f` is called with `**this`
+ /// and the value is returned. Otherwise `u` is returned.
+ ///
+ /// \group map_or
+ template <class F, class U>
+ U map_or(F&& f, U&& u) & {
+ return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u);
+ }
+
+ /// \group map_or
+ template <class F, class U>
+ U map_or(F&& f, U&& u) && {
+ return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u);
+ }
+
+ /// \group map_or
+ template <class F, class U>
+ U map_or(F&& f, U&& u) const& {
+ return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u);
+ }
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+ /// \group map_or
+ template <class F, class U>
+ U map_or(F&& f, U&& u) const&& {
+ return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u);
+ }
+#endif
+
+ /// \brief Maps the stored value with `f` if there is one, otherwise calls
+ /// `u` and returns the result.
+ ///
+ /// \details If there is a value stored, then `f` is
+ /// called with `**this` and the value is returned. Otherwise
+ /// `std::forward<U>(u)()` is returned.
+ ///
+ /// \group map_or_else
+ /// \synopsis template <class F, class U>\nauto map_or_else(F &&f, U &&u) &;
+ template <class F, class U>
+ detail::invoke_result_t<U> map_or_else(F&& f, U&& u) & {
+ return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u)();
+ }
+
+ /// \group map_or_else
+ /// \synopsis template <class F, class U>\nauto map_or_else(F &&f, U &&u)
+ /// &&;
+ template <class F, class U>
+ detail::invoke_result_t<U> map_or_else(F&& f, U&& u) && {
+ return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u)();
+ }
+
+ /// \group map_or_else
+ /// \synopsis template <class F, class U>\nauto map_or_else(F &&f, U &&u)
+ /// const &;
+ template <class F, class U>
+ detail::invoke_result_t<U> map_or_else(F&& f, U&& u) const& {
+ return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u)();
+ }
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+ /// \group map_or_else
+ /// \synopsis template <class F, class U>\nauto map_or_else(F &&f, U &&u)
+ /// const &&;
+ template <class F, class U>
+ detail::invoke_result_t<U> map_or_else(F&& f, U&& u) const&& {
+ return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u)();
+ }
+#endif
+
+ /// \returns `u` if `*this` has a value, otherwise an empty optional.
+ template <class U>
+ constexpr optional<typename std::decay<U>::type> conjunction(U&& u) const {
+ using result = optional<detail::decay_t<U>>;
+ return has_value() ? result { u } : result { nullopt };
+ }
+
+ /// \returns `rhs` if `*this` is empty, otherwise the current value.
+ /// \group disjunction
+ SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional& rhs) & {
+ return has_value() ? *this : rhs;
+ }
+
+ /// \group disjunction
+ constexpr optional disjunction(const optional& rhs) const& {
+ return has_value() ? *this : rhs;
+ }
+
+ /// \group disjunction
+ SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional& rhs) && {
+ return has_value() ? std::move(*this) : rhs;
+ }
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+ /// \group disjunction
+ constexpr optional disjunction(const optional& rhs) const&& {
+ return has_value() ? std::move(*this) : rhs;
+ }
+#endif
+
+ /// \group disjunction
+ SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional&& rhs) & {
+ return has_value() ? *this : std::move(rhs);
+ }
+
+ /// \group disjunction
+ constexpr optional disjunction(optional&& rhs) const& {
+ return has_value() ? *this : std::move(rhs);
+ }
+
+ /// \group disjunction
+ SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional&& rhs) && {
+ return has_value() ? std::move(*this) : std::move(rhs);
+ }
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+ /// \group disjunction
+ constexpr optional disjunction(optional&& rhs) const&& {
+ return has_value() ? std::move(*this) : std::move(rhs);
+ }
+#endif
+
+ /// Takes the value out of the optional, leaving it empty
+ /// \group take
+ optional take() & {
+ optional ret = *this;
+ reset();
+ return ret;
+ }
+
+ /// \group take
+ optional take() const& {
+ optional ret = *this;
+ reset();
+ return ret;
+ }
+
+ /// \group take
+ optional take() && {
+ optional ret = std::move(*this);
+ reset();
+ return ret;
+ }
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+ /// \group take
+ optional take() const&& {
+ optional ret = std::move(*this);
+ reset();
+ return ret;
+ }
+#endif
+
+ using value_type = T;
+
+ /// Constructs an optional that does not contain a value.
+ /// \group ctor_empty
+ constexpr optional() noexcept = default;
+
+ /// \group ctor_empty
+ constexpr optional(nullopt_t) noexcept {
+ }
+
+ /// Copy constructor
+ ///
+ /// If `rhs` contains a value, the stored value is direct-initialized with
+ /// it. Otherwise, the constructed optional is empty.
+ SOL_TL_OPTIONAL_11_CONSTEXPR optional(const optional& rhs) = default;
+
+ /// Move constructor
+ ///
+ /// If `rhs` contains a value, the stored value is direct-initialized with
+ /// it. Otherwise, the constructed optional is empty.
+ SOL_TL_OPTIONAL_11_CONSTEXPR optional(optional&& rhs) = default;
+
+ /// Constructs the stored value in-place using the given arguments.
+ /// \group in_place
+ /// \synopsis template <class... Args> constexpr explicit optional(in_place_t, Args&&... args);
+ template <class... Args>
+ constexpr explicit optional(detail::enable_if_t<std::is_constructible<T, Args...>::value, in_place_t>, Args&&... args)
+ : base(in_place, std::forward<Args>(args)...) {
+ }
+
+ /// \group in_place
+ /// \synopsis template <class U, class... Args>\nconstexpr explicit optional(in_place_t, std::initializer_list<U>&, Args&&... args);
+ template <class U, class... Args>
+ SOL_TL_OPTIONAL_11_CONSTEXPR explicit optional(detail::enable_if_t<std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value, in_place_t>,
+ std::initializer_list<U> il, Args&&... args) {
+ this->construct(il, std::forward<Args>(args)...);
+ }
+
+#if 0 // SOL_MODIFICATION
+ /// Constructs the stored value with `u`.
+ /// \synopsis template <class U=T> constexpr optional(U &&u);
+ template <class U = T, detail::enable_if_t<std::is_convertible<U&&, T>::value>* = nullptr, detail::enable_forward_value<T, U>* = nullptr>
+ constexpr optional(U&& u) : base(in_place, std::forward<U>(u)) {
+ }
+
+ /// \exclude
+ template <class U = T, detail::enable_if_t<!std::is_convertible<U&&, T>::value>* = nullptr, detail::enable_forward_value<T, U>* = nullptr>
+ constexpr explicit optional(U&& u) : base(in_place, std::forward<U>(u)) {
+ }
+#else
+ /// Constructs the stored value with `u`.
+ /// \synopsis template <class U=T> constexpr optional(U &&u);
+ constexpr optional(T&& u) : base(in_place, std::move(u)) {
+ }
+
+ /// \exclude
+ constexpr optional(const T& u) : base(in_place, u) {
+ }
+#endif // sol3 modification
+
+ /// Converting copy constructor.
+ /// \synopsis template <class U> optional(const optional<U> &rhs);
+ template <class U, detail::enable_from_other<T, U, const U&>* = nullptr, detail::enable_if_t<std::is_convertible<const U&, T>::value>* = nullptr>
+ optional(const optional<U>& rhs) {
+ if (rhs.has_value()) {
+ this->construct(*rhs);
+ }
+ }
+
+ /// \exclude
+ template <class U, detail::enable_from_other<T, U, const U&>* = nullptr, detail::enable_if_t<!std::is_convertible<const U&, T>::value>* = nullptr>
+ explicit optional(const optional<U>& rhs) {
+ if (rhs.has_value()) {
+ this->construct(*rhs);
+ }
+ }
+
+ /// Converting move constructor.
+ /// \synopsis template <class U> optional(optional<U> &&rhs);
+ template <class U, detail::enable_from_other<T, U, U&&>* = nullptr, detail::enable_if_t<std::is_convertible<U&&, T>::value>* = nullptr>
+ optional(optional<U>&& rhs) {
+ if (rhs.has_value()) {
+ this->construct(std::move(*rhs));
+ }
+ }
+
+ /// \exclude
+ template <class U, detail::enable_from_other<T, U, U&&>* = nullptr, detail::enable_if_t<!std::is_convertible<U&&, T>::value>* = nullptr>
+ explicit optional(optional<U>&& rhs) {
+ this->construct(std::move(*rhs));
+ }
+
+ /// Destroys the stored value if there is one.
+ ~optional() = default;
+
+ /// Assignment to empty.
+ ///
+ /// Destroys the current value if there is one.
+ optional& operator=(nullopt_t) noexcept {
+ if (has_value()) {
+ this->m_value.~T();
+ this->m_has_value = false;
+ }
+
+ return *this;
+ }
+
+ /// Copy assignment.
+ ///
+ /// Copies the value from `rhs` if there is one. Otherwise resets the stored
+ /// value in `*this`.
+ optional& operator=(const optional& rhs) = default;
+
+ /// Move assignment.
+ ///
+ /// Moves the value from `rhs` if there is one. Otherwise resets the stored
+ /// value in `*this`.
+ optional& operator=(optional&& rhs) = default;
+
+ /// Assigns the stored value from `u`, destroying the old value if there was
+ /// one.
+ /// \synopsis optional &operator=(U &&u);
+ template <class U = T, detail::enable_assign_forward<T, U>* = nullptr>
+ optional& operator=(U&& u) {
+ if (has_value()) {
+ this->m_value = std::forward<U>(u);
+ }
+ else {
+ this->construct(std::forward<U>(u));
+ }
+
+ return *this;
+ }
+
+ /// Converting copy assignment operator.
+ ///
+ /// Copies the value from `rhs` if there is one. Otherwise resets the stored
+ /// value in `*this`.
+ /// \synopsis optional &operator=(const optional<U> & rhs);
+ template <class U, detail::enable_assign_from_other<T, U, const U&>* = nullptr>
+ optional& operator=(const optional<U>& rhs) {
+ if (has_value()) {
+ if (rhs.has_value()) {
+ this->m_value = *rhs;
+ }
+ else {
+ this->hard_reset();
+ }
+ }
+
+ if (rhs.has_value()) {
+ this->construct(*rhs);
+ }
+
+ return *this;
+ }
+
+ // TODO check exception guarantee
+ /// Converting move assignment operator.
+ ///
+ /// Moves the value from `rhs` if there is one. Otherwise resets the stored
+ /// value in `*this`.
+ /// \synopsis optional &operator=(optional<U> && rhs);
+ template <class U, detail::enable_assign_from_other<T, U, U>* = nullptr>
+ optional& operator=(optional<U>&& rhs) {
+ if (has_value()) {
+ if (rhs.has_value()) {
+ this->m_value = std::move(*rhs);
+ }
+ else {
+ this->hard_reset();
+ }
+ }
+
+ if (rhs.has_value()) {
+ this->construct(std::move(*rhs));
+ }
+
+ return *this;
+ }
+
+ /// Constructs the value in-place, destroying the current one if there is
+ /// one.
+ /// \group emplace
+ template <class... Args>
+ T& emplace(Args&&... args) {
+ static_assert(std::is_constructible<T, Args&&...>::value, "T must be constructible with Args");
+
+ *this = nullopt;
+ this->construct(std::forward<Args>(args)...);
+ return value();
+ }
+
+ /// \group emplace
+ /// \synopsis template <class U, class... Args>\nT& emplace(std::initializer_list<U> il, Args &&... args);
+ template <class U, class... Args>
+ detail::enable_if_t<std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value, T&> emplace(std::initializer_list<U> il, Args&&... args) {
+ *this = nullopt;
+ this->construct(il, std::forward<Args>(args)...);
+ return value();
+ }
+
+ /// Swaps this optional with the other.
+ ///
+ /// If neither optionals have a value, nothing happens.
+ /// If both have a value, the values are swapped.
+ /// If one has a value, it is moved to the other and the movee is left
+ /// valueless.
+ void swap(optional& rhs) noexcept(std::is_nothrow_move_constructible<T>::value&& detail::is_nothrow_swappable<T>::value) {
+ if (has_value()) {
+ if (rhs.has_value()) {
+ using std::swap;
+ swap(**this, *rhs);
+ }
+ else {
+ new (std::addressof(rhs.m_value)) T(std::move(this->m_value));
+ this->m_value.T::~T();
+ }
+ }
+ else if (rhs.has_value()) {
+ new (std::addressof(this->m_value)) T(std::move(rhs.m_value));
+ rhs.m_value.T::~T();
+ }
+ }
+
+ /// \returns a pointer to the stored value
+ /// \requires a value is stored
+ /// \group pointer
+ /// \synopsis constexpr const T *operator->() const;
+ constexpr const T* operator->() const {
+ return std::addressof(this->m_value);
+ }
+
+ /// \group pointer
+ /// \synopsis constexpr T *operator->();
+ SOL_TL_OPTIONAL_11_CONSTEXPR T* operator->() {
+ return std::addressof(this->m_value);
+ }
+
+ /// \returns the stored value
+ /// \requires a value is stored
+ /// \group deref
+ /// \synopsis constexpr T &operator*();
+ SOL_TL_OPTIONAL_11_CONSTEXPR T& operator*() & {
+ return this->m_value;
+ }
+
+ /// \group deref
+ /// \synopsis constexpr const T &operator*() const;
+ constexpr const T& operator*() const& {
+ return this->m_value;
+ }
+
+ /// \exclude
+ SOL_TL_OPTIONAL_11_CONSTEXPR T&& operator*() && {
+ return std::move(this->m_value);
+ }
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+ /// \exclude
+ constexpr const T&& operator*() const&& {
+ return std::move(this->m_value);
+ }
+#endif
+
+ /// \returns whether or not the optional has a value
+ /// \group has_value
+ constexpr bool has_value() const noexcept {
+ return this->m_has_value;
+ }
+
+ /// \group has_value
+ constexpr explicit operator bool() const noexcept {
+ return this->m_has_value;
+ }
+
+ /// \returns the contained value if there is one, otherwise throws
+ /// [bad_optional_access]
+ /// \group value
+ /// \synopsis constexpr T &value();
+ SOL_TL_OPTIONAL_11_CONSTEXPR T& value() & {
+ if (has_value())
+ return this->m_value;
+#if SOL_IS_OFF(SOL_EXCEPTIONS_I_)
+ std::abort();
+#else
+ throw bad_optional_access();
+#endif // No exceptions allowed
+ }
+ /// \group value
+ /// \synopsis constexpr const T &value() const;
+ SOL_TL_OPTIONAL_11_CONSTEXPR const T& value() const& {
+ if (has_value())
+ return this->m_value;
+#if SOL_IS_OFF(SOL_EXCEPTIONS_I_)
+ std::abort();
+#else
+ throw bad_optional_access();
+#endif // No exceptions allowed
+ }
+ /// \exclude
+ SOL_TL_OPTIONAL_11_CONSTEXPR T&& value() && {
+ if (has_value())
+ return std::move(this->m_value);
+#if SOL_IS_OFF(SOL_EXCEPTIONS_I_)
+ std::abort();
+#else
+ throw bad_optional_access();
+#endif // No exceptions allowed
+ }
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+ /// \exclude
+ SOL_TL_OPTIONAL_11_CONSTEXPR const T&& value() const&& {
+ if (has_value())
+ return std::move(this->m_value);
+#if SOL_IS_OFF(SOL_EXCEPTIONS_I_)
+ std::abort();
+#else
+ throw bad_optional_access();
+#endif // No exceptions allowed
+ }
+#endif
+
+ /// \returns the stored value if there is one, otherwise returns `u`
+ /// \group value_or
+ template <class U>
+ constexpr T value_or(U&& u) const& {
+ static_assert(std::is_copy_constructible<T>::value && std::is_convertible<U&&, T>::value, "T must be copy constructible and convertible from U");
+ return has_value() ? **this : static_cast<T>(std::forward<U>(u));
+ }
+
+ /// \group value_or
+ template <class U>
+ SOL_TL_OPTIONAL_11_CONSTEXPR T value_or(U&& u) && {
+ static_assert(std::is_move_constructible<T>::value && std::is_convertible<U&&, T>::value, "T must be move constructible and convertible from U");
+ return has_value() ? **this : static_cast<T>(std::forward<U>(u));
+ }
+
+ /// Destroys the stored value if one exists, making the optional empty
+ void reset() noexcept {
+ if (has_value()) {
+ this->m_value.~T();
+ this->m_has_value = false;
+ }
+ }
+ }; // namespace sol
+
+ /// \group relop
+ /// \brief Compares two optional objects
+ /// \details If both optionals contain a value, they are compared with `T`s
+ /// relational operators. Otherwise `lhs` and `rhs` are equal only if they are
+ /// both empty, and `lhs` is less than `rhs` only if `rhs` is empty and `lhs`
+ /// is not.
+ template <class T, class U>
+ inline constexpr bool operator==(const optional<T>& lhs, const optional<U>& rhs) {
+ return lhs.has_value() == rhs.has_value() && (!lhs.has_value() || *lhs == *rhs);
+ }
+ /// \group relop
+ template <class T, class U>
+ inline constexpr bool operator!=(const optional<T>& lhs, const optional<U>& rhs) {
+ return lhs.has_value() != rhs.has_value() || (lhs.has_value() && *lhs != *rhs);
+ }
+ /// \group relop
+ template <class T, class U>
+ inline constexpr bool operator<(const optional<T>& lhs, const optional<U>& rhs) {
+ return rhs.has_value() && (!lhs.has_value() || *lhs < *rhs);
+ }
+ /// \group relop
+ template <class T, class U>
+ inline constexpr bool operator>(const optional<T>& lhs, const optional<U>& rhs) {
+ return lhs.has_value() && (!rhs.has_value() || *lhs > *rhs);
+ }
+ /// \group relop
+ template <class T, class U>
+ inline constexpr bool operator<=(const optional<T>& lhs, const optional<U>& rhs) {
+ return !lhs.has_value() || (rhs.has_value() && *lhs <= *rhs);
+ }
+ /// \group relop
+ template <class T, class U>
+ inline constexpr bool operator>=(const optional<T>& lhs, const optional<U>& rhs) {
+ return !rhs.has_value() || (lhs.has_value() && *lhs >= *rhs);
+ }
+
+ /// \group relop_nullopt
+ /// \brief Compares an optional to a `nullopt`
+ /// \details Equivalent to comparing the optional to an empty optional
+ template <class T>
+ inline constexpr bool operator==(const optional<T>& lhs, nullopt_t) noexcept {
+ return !lhs.has_value();
+ }
+ /// \group relop_nullopt
+ template <class T>
+ inline constexpr bool operator==(nullopt_t, const optional<T>& rhs) noexcept {
+ return !rhs.has_value();
+ }
+ /// \group relop_nullopt
+ template <class T>
+ inline constexpr bool operator!=(const optional<T>& lhs, nullopt_t) noexcept {
+ return lhs.has_value();
+ }
+ /// \group relop_nullopt
+ template <class T>
+ inline constexpr bool operator!=(nullopt_t, const optional<T>& rhs) noexcept {
+ return rhs.has_value();
+ }
+ /// \group relop_nullopt
+ template <class T>
+ inline constexpr bool operator<(const optional<T>&, nullopt_t) noexcept {
+ return false;
+ }
+ /// \group relop_nullopt
+ template <class T>
+ inline constexpr bool operator<(nullopt_t, const optional<T>& rhs) noexcept {
+ return rhs.has_value();
+ }
+ /// \group relop_nullopt
+ template <class T>
+ inline constexpr bool operator<=(const optional<T>& lhs, nullopt_t) noexcept {
+ return !lhs.has_value();
+ }
+ /// \group relop_nullopt
+ template <class T>
+ inline constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept {
+ return true;
+ }
+ /// \group relop_nullopt
+ template <class T>
+ inline constexpr bool operator>(const optional<T>& lhs, nullopt_t) noexcept {
+ return lhs.has_value();
+ }
+ /// \group relop_nullopt
+ template <class T>
+ inline constexpr bool operator>(nullopt_t, const optional<T>&) noexcept {
+ return false;
+ }
+ /// \group relop_nullopt
+ template <class T>
+ inline constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept {
+ return true;
+ }
+ /// \group relop_nullopt
+ template <class T>
+ inline constexpr bool operator>=(nullopt_t, const optional<T>& rhs) noexcept {
+ return !rhs.has_value();
+ }
+
+ /// \group relop_t
+ /// \brief Compares the optional with a value.
+ /// \details If the optional has a value, it is compared with the other value
+ /// using `T`s relational operators. Otherwise, the optional is considered
+ /// less than the value.
+ template <class T, class U>
+ inline constexpr bool operator==(const optional<T>& lhs, const U& rhs) {
+ return lhs.has_value() ? *lhs == rhs : false;
+ }
+ /// \group relop_t
+ template <class T, class U>
+ inline constexpr bool operator==(const U& lhs, const optional<T>& rhs) {
+ return rhs.has_value() ? lhs == *rhs : false;
+ }
+ /// \group relop_t
+ template <class T, class U>
+ inline constexpr bool operator!=(const optional<T>& lhs, const U& rhs) {
+ return lhs.has_value() ? *lhs != rhs : true;
+ }
+ /// \group relop_t
+ template <class T, class U>
+ inline constexpr bool operator!=(const U& lhs, const optional<T>& rhs) {
+ return rhs.has_value() ? lhs != *rhs : true;
+ }
+ /// \group relop_t
+ template <class T, class U>
+ inline constexpr bool operator<(const optional<T>& lhs, const U& rhs) {
+ return lhs.has_value() ? *lhs < rhs : true;
+ }
+ /// \group relop_t
+ template <class T, class U>
+ inline constexpr bool operator<(const U& lhs, const optional<T>& rhs) {
+ return rhs.has_value() ? lhs < *rhs : false;
+ }
+ /// \group relop_t
+ template <class T, class U>
+ inline constexpr bool operator<=(const optional<T>& lhs, const U& rhs) {
+ return lhs.has_value() ? *lhs <= rhs : true;
+ }
+ /// \group relop_t
+ template <class T, class U>
+ inline constexpr bool operator<=(const U& lhs, const optional<T>& rhs) {
+ return rhs.has_value() ? lhs <= *rhs : false;
+ }
+ /// \group relop_t
+ template <class T, class U>
+ inline constexpr bool operator>(const optional<T>& lhs, const U& rhs) {
+ return lhs.has_value() ? *lhs > rhs : false;
+ }
+ /// \group relop_t
+ template <class T, class U>
+ inline constexpr bool operator>(const U& lhs, const optional<T>& rhs) {
+ return rhs.has_value() ? lhs > *rhs : true;
+ }
+ /// \group relop_t
+ template <class T, class U>
+ inline constexpr bool operator>=(const optional<T>& lhs, const U& rhs) {
+ return lhs.has_value() ? *lhs >= rhs : false;
+ }
+ /// \group relop_t
+ template <class T, class U>
+ inline constexpr bool operator>=(const U& lhs, const optional<T>& rhs) {
+ return rhs.has_value() ? lhs >= *rhs : true;
+ }
+
+ /// \synopsis template <class T>\nvoid swap(optional<T> &lhs, optional<T> &rhs);
+ template <class T, detail::enable_if_t<std::is_move_constructible<T>::value>* = nullptr, detail::enable_if_t<detail::is_swappable<T>::value>* = nullptr>
+ void swap(optional<T>& lhs, optional<T>& rhs) noexcept(noexcept(lhs.swap(rhs))) {
+ return lhs.swap(rhs);
+ }
+
+ namespace detail {
+ struct i_am_secret {};
+ } // namespace detail
+
+ template <class T = detail::i_am_secret, class U, class Ret = detail::conditional_t<std::is_same<T, detail::i_am_secret>::value, detail::decay_t<U>, T>>
+ inline constexpr optional<Ret> make_optional(U&& v) {
+ return optional<Ret>(std::forward<U>(v));
+ }
+
+ template <class T, class... Args>
+ inline constexpr optional<T> make_optional(Args&&... args) {
+ return optional<T>(in_place, std::forward<Args>(args)...);
+ }
+ template <class T, class U, class... Args>
+ inline constexpr optional<T> make_optional(std::initializer_list<U> il, Args&&... args) {
+ return optional<T>(in_place, il, std::forward<Args>(args)...);
+ }
+
+#if __cplusplus >= 201703L
+ template <class T>
+ optional(T)->optional<T>;
+#endif
+
+ /// \exclude
+ namespace detail {
+#ifdef SOL_TL_OPTIONAL_CXX14
+ template <class Opt, class F, class Ret = decltype(detail::invoke(std::declval<F>(), *std::declval<Opt>())),
+ detail::enable_if_t<!std::is_void<Ret>::value>* = nullptr>
+ constexpr auto optional_map_impl(Opt&& opt, F&& f) {
+ return opt.has_value() ? detail::invoke(std::forward<F>(f), *std::forward<Opt>(opt)) : optional<Ret>(nullopt);
+ }
+
+ template <class Opt, class F, class Ret = decltype(detail::invoke(std::declval<F>(), *std::declval<Opt>())),
+ detail::enable_if_t<std::is_void<Ret>::value>* = nullptr>
+ auto optional_map_impl(Opt&& opt, F&& f) {
+ if (opt.has_value()) {
+ detail::invoke(std::forward<F>(f), *std::forward<Opt>(opt));
+ return make_optional(monostate {});
+ }
+
+ return optional<monostate>(nullopt);
+ }
+#else
+ template <class Opt, class F, class Ret = decltype(detail::invoke(std::declval<F>(), *std::declval<Opt>())),
+ detail::enable_if_t<!std::is_void<Ret>::value>* = nullptr>
+
+ constexpr auto optional_map_impl(Opt&& opt, F&& f) -> optional<Ret> {
+ return opt.has_value() ? detail::invoke(std::forward<F>(f), *std::forward<Opt>(opt)) : optional<Ret>(nullopt);
+ }
+
+ template <class Opt, class F, class Ret = decltype(detail::invoke(std::declval<F>(), *std::declval<Opt>())),
+ detail::enable_if_t<std::is_void<Ret>::value>* = nullptr>
+
+ auto optional_map_impl(Opt&& opt, F&& f) -> optional<monostate> {
+ if (opt.has_value()) {
+ detail::invoke(std::forward<F>(f), *std::forward<Opt>(opt));
+ return monostate {};
+ }
+
+ return nullopt;
+ }
+#endif
+ } // namespace detail
+
+ /// Specialization for when `T` is a reference. `optional<T&>` acts similarly
+ /// to a `T*`, but provides more operations and shows intent more clearly.
+ ///
+ /// *Examples*:
+ ///
+ /// ```
+ /// int i = 42;
+ /// sol::optional<int&> o = i;
+ /// *o == 42; //true
+ /// i = 12;
+ /// *o = 12; //true
+ /// &*o == &i; //true
+ /// ```
+ ///
+ /// Assignment has rebind semantics rather than assign-through semantics:
+ ///
+ /// ```
+ /// int j = 8;
+ /// o = j;
+ ///
+ /// &*o == &j; //true
+ /// ```
+ template <class T>
+ class optional<T&> {
+ public:
+#if defined(SOL_TL_OPTIONAL_CXX14) && !defined(SOL_TL_OPTIONAL_GCC49) && !defined(SOL_TL_OPTIONAL_GCC54) && !defined(SOL_TL_OPTIONAL_GCC55)
+ /// \group and_then
+ /// Carries out some operation which returns an optional on the stored
+ /// object if there is one. \requires `std::invoke(std::forward<F>(f),
+ /// value())` returns a `std::optional<U>` for some `U`. \returns Let `U` be
+ /// the result of `std::invoke(std::forward<F>(f), value())`. Returns a
+ /// `std::optional<U>`. The return value is empty if `*this` is empty,
+ /// otherwise the return value of `std::invoke(std::forward<F>(f), value())`
+ /// is returned.
+ /// \group and_then
+ /// \synopsis template <class F>\nconstexpr auto and_then(F &&f) &;
+ template <class F>
+ SOL_TL_OPTIONAL_11_CONSTEXPR auto and_then(F&& f) & {
+ using result = detail::invoke_result_t<F, T&>;
+ static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+ return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+ }
+
+ /// \group and_then
+ /// \synopsis template <class F>\nconstexpr auto and_then(F &&f) &&;
+ template <class F>
+ SOL_TL_OPTIONAL_11_CONSTEXPR auto and_then(F&& f) && {
+ using result = detail::invoke_result_t<F, T&>;
+ static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+ return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+ }
+
+ /// \group and_then
+ /// \synopsis template <class F>\nconstexpr auto and_then(F &&f) const &;
+ template <class F>
+ constexpr auto and_then(F&& f) const& {
+ using result = detail::invoke_result_t<F, const T&>;
+ static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+ return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+ }
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+ /// \group and_then
+ /// \synopsis template <class F>\nconstexpr auto and_then(F &&f) const &&;
+ template <class F>
+ constexpr auto and_then(F&& f) const&& {
+ using result = detail::invoke_result_t<F, const T&>;
+ static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+ return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+ }
+#endif
+#else
+ /// \group and_then
+ /// Carries out some operation which returns an optional on the stored
+ /// object if there is one. \requires `std::invoke(std::forward<F>(f),
+ /// value())` returns a `std::optional<U>` for some `U`. \returns Let `U` be
+ /// the result of `std::invoke(std::forward<F>(f), value())`. Returns a
+ /// `std::optional<U>`. The return value is empty if `*this` is empty,
+ /// otherwise the return value of `std::invoke(std::forward<F>(f), value())`
+ /// is returned.
+ /// \group and_then
+ /// \synopsis template <class F>\nconstexpr auto and_then(F &&f) &;
+ template <class F>
+ SOL_TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T&> and_then(F&& f) & {
+ using result = detail::invoke_result_t<F, T&>;
+ static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+ return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+ }
+
+ /// \group and_then
+ /// \synopsis template <class F>\nconstexpr auto and_then(F &&f) &&;
+ template <class F>
+ SOL_TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T&> and_then(F&& f) && {
+ using result = detail::invoke_result_t<F, T&>;
+ static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+ return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+ }
+
+ /// \group and_then
+ /// \synopsis template <class F>\nconstexpr auto and_then(F &&f) const &;
+ template <class F>
+ constexpr detail::invoke_result_t<F, const T&> and_then(F&& f) const& {
+ using result = detail::invoke_result_t<F, const T&>;
+ static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+ return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+ }
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+ /// \group and_then
+ /// \synopsis template <class F>\nconstexpr auto and_then(F &&f) const &&;
+ template <class F>
+ constexpr detail::invoke_result_t<F, const T&> and_then(F&& f) const&& {
+ using result = detail::invoke_result_t<F, const T&>;
+ static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+ return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+ }
+#endif
+#endif
+
+#if defined(SOL_TL_OPTIONAL_CXX14) && !defined(SOL_TL_OPTIONAL_GCC49) && !defined(SOL_TL_OPTIONAL_GCC54) && !defined(SOL_TL_OPTIONAL_GCC55)
+ /// \brief Carries out some operation on the stored object if there is one.
+ /// \returns Let `U` be the result of `std::invoke(std::forward<F>(f),
+ /// value())`. Returns a `std::optional<U>`. The return value is empty if
+ /// `*this` is empty, otherwise an `optional<U>` is constructed from the
+ /// return value of `std::invoke(std::forward<F>(f), value())` and is
+ /// returned.
+ ///
+ /// \group map
+ /// \synopsis template <class F> constexpr auto map(F &&f) &;
+ template <class F>
+ SOL_TL_OPTIONAL_11_CONSTEXPR auto map(F&& f) & {
+ return detail::optional_map_impl(*this, std::forward<F>(f));
+ }
+
+ /// \group map
+ /// \synopsis template <class F> constexpr auto map(F &&f) &&;
+ template <class F>
+ SOL_TL_OPTIONAL_11_CONSTEXPR auto map(F&& f) && {
+ return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
+ }
+
+ /// \group map
+ /// \synopsis template <class F> constexpr auto map(F &&f) const&;
+ template <class F>
+ constexpr auto map(F&& f) const& {
+ return detail::optional_map_impl(*this, std::forward<F>(f));
+ }
+
+ /// \group map
+ /// \synopsis template <class F> constexpr auto map(F &&f) const&&;
+ template <class F>
+ constexpr auto map(F&& f) const&& {
+ return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
+ }
+#else
+ /// \brief Carries out some operation on the stored object if there is one.
+ /// \returns Let `U` be the result of `std::invoke(std::forward<F>(f),
+ /// value())`. Returns a `std::optional<U>`. The return value is empty if
+ /// `*this` is empty, otherwise an `optional<U>` is constructed from the
+ /// return value of `std::invoke(std::forward<F>(f), value())` and is
+ /// returned.
+ ///
+ /// \group map
+ /// \synopsis template <class F> auto map(F &&f) &;
+ template <class F>
+ SOL_TL_OPTIONAL_11_CONSTEXPR decltype(detail::optional_map_impl(std::declval<optional&>(), std::declval<F&&>())) map(F&& f) & {
+ return detail::optional_map_impl(*this, std::forward<F>(f));
+ }
+
+ /// \group map
+ /// \synopsis template <class F> auto map(F &&f) &&;
+ template <class F>
+ SOL_TL_OPTIONAL_11_CONSTEXPR decltype(detail::optional_map_impl(std::declval<optional&&>(), std::declval<F&&>())) map(F&& f) && {
+ return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
+ }
+
+ /// \group map
+ /// \synopsis template <class F> auto map(F &&f) const&;
+ template <class F>
+ constexpr decltype(detail::optional_map_impl(std::declval<const optional&>(), std::declval<F&&>())) map(F&& f) const& {
+ return detail::optional_map_impl(*this, std::forward<F>(f));
+ }
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+ /// \group map
+ /// \synopsis template <class F> auto map(F &&f) const&&;
+ template <class F>
+ constexpr decltype(detail::optional_map_impl(std::declval<const optional&&>(), std::declval<F&&>())) map(F&& f) const&& {
+ return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
+ }
+#endif
+#endif
+
+ /// \brief Calls `f` if the optional is empty
+ /// \requires `std::invoke_result_t<F>` must be void or convertible to
+ /// `optional<T>`. \effects If `*this` has a value, returns `*this`.
+ /// Otherwise, if `f` returns `void`, calls `std::forward<F>(f)` and returns
+ /// `std::nullopt`. Otherwise, returns `std::forward<F>(f)()`.
+ ///
+ /// \group or_else
+ /// \synopsis template <class F> optional<T> or_else (F &&f) &;
+ template <class F, detail::enable_if_ret_void<F>* = nullptr>
+ optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) & {
+ if (has_value())
+ return *this;
+
+ std::forward<F>(f)();
+ return nullopt;
+ }
+
+ /// \exclude
+ template <class F, detail::disable_if_ret_void<F>* = nullptr>
+ optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) & {
+ return has_value() ? *this : std::forward<F>(f)();
+ }
+
+ /// \group or_else
+ /// \synopsis template <class F> optional<T> or_else (F &&f) &&;
+ template <class F, detail::enable_if_ret_void<F>* = nullptr>
+ optional<T> or_else(F&& f) && {
+ if (has_value())
+ return std::move(*this);
+
+ std::forward<F>(f)();
+ return nullopt;
+ }
+
+ /// \exclude
+ template <class F, detail::disable_if_ret_void<F>* = nullptr>
+ optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) && {
+ return has_value() ? std::move(*this) : std::forward<F>(f)();
+ }
+
+ /// \group or_else
+ /// \synopsis template <class F> optional<T> or_else (F &&f) const &;
+ template <class F, detail::enable_if_ret_void<F>* = nullptr>
+ optional<T> or_else(F&& f) const& {
+ if (has_value())
+ return *this;
+
+ std::forward<F>(f)();
+ return nullopt;
+ }
+
+ /// \exclude
+ template <class F, detail::disable_if_ret_void<F>* = nullptr>
+ optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) const& {
+ return has_value() ? *this : std::forward<F>(f)();
+ }
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+ /// \exclude
+ template <class F, detail::enable_if_ret_void<F>* = nullptr>
+ optional<T> or_else(F&& f) const&& {
+ if (has_value())
+ return std::move(*this);
+
+ std::forward<F>(f)();
+ return nullopt;
+ }
+
+ /// \exclude
+ template <class F, detail::disable_if_ret_void<F>* = nullptr>
+ optional<T> or_else(F&& f) const&& {
+ return has_value() ? std::move(*this) : std::forward<F>(f)();
+ }
+#endif
+
+ /// \brief Maps the stored value with `f` if there is one, otherwise returns
+ /// `u`.
+ ///
+ /// \details If there is a value stored, then `f` is called with `**this`
+ /// and the value is returned. Otherwise `u` is returned.
+ ///
+ /// \group map_or
+ template <class F, class U>
+ U map_or(F&& f, U&& u) & {
+ return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u);
+ }
+
+ /// \group map_or
+ template <class F, class U>
+ U map_or(F&& f, U&& u) && {
+ return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u);
+ }
+
+ /// \group map_or
+ template <class F, class U>
+ U map_or(F&& f, U&& u) const& {
+ return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u);
+ }
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+ /// \group map_or
+ template <class F, class U>
+ U map_or(F&& f, U&& u) const&& {
+ return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u);
+ }
+#endif
+
+ /// \brief Maps the stored value with `f` if there is one, otherwise calls
+ /// `u` and returns the result.
+ ///
+ /// \details If there is a value stored, then `f` is
+ /// called with `**this` and the value is returned. Otherwise
+ /// `std::forward<U>(u)()` is returned.
+ ///
+ /// \group map_or_else
+ /// \synopsis template <class F, class U>\nauto map_or_else(F &&f, U &&u) &;
+ template <class F, class U>
+ detail::invoke_result_t<U> map_or_else(F&& f, U&& u) & {
+ return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u)();
+ }
+
+ /// \group map_or_else
+ /// \synopsis template <class F, class U>\nauto map_or_else(F &&f, U &&u)
+ /// &&;
+ template <class F, class U>
+ detail::invoke_result_t<U> map_or_else(F&& f, U&& u) && {
+ return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u)();
+ }
+
+ /// \group map_or_else
+ /// \synopsis template <class F, class U>\nauto map_or_else(F &&f, U &&u)
+ /// const &;
+ template <class F, class U>
+ detail::invoke_result_t<U> map_or_else(F&& f, U&& u) const& {
+ return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u)();
+ }
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+ /// \group map_or_else
+ /// \synopsis template <class F, class U>\nauto map_or_else(F &&f, U &&u)
+ /// const &&;
+ template <class F, class U>
+ detail::invoke_result_t<U> map_or_else(F&& f, U&& u) const&& {
+ return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u)();
+ }
+#endif
+
+ /// \returns `u` if `*this` has a value, otherwise an empty optional.
+ template <class U>
+ constexpr optional<typename std::decay<U>::type> conjunction(U&& u) const {
+ using result = optional<detail::decay_t<U>>;
+ return has_value() ? result { u } : result { nullopt };
+ }
+
+ /// \returns `rhs` if `*this` is empty, otherwise the current value.
+ /// \group disjunction
+ SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional& rhs) & {
+ return has_value() ? *this : rhs;
+ }
+
+ /// \group disjunction
+ constexpr optional disjunction(const optional& rhs) const& {
+ return has_value() ? *this : rhs;
+ }
+
+ /// \group disjunction
+ SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional& rhs) && {
+ return has_value() ? std::move(*this) : rhs;
+ }
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+ /// \group disjunction
+ constexpr optional disjunction(const optional& rhs) const&& {
+ return has_value() ? std::move(*this) : rhs;
+ }
+#endif
+
+ /// \group disjunction
+ SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional&& rhs) & {
+ return has_value() ? *this : std::move(rhs);
+ }
+
+ /// \group disjunction
+ constexpr optional disjunction(optional&& rhs) const& {
+ return has_value() ? *this : std::move(rhs);
+ }
+
+ /// \group disjunction
+ SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional&& rhs) && {
+ return has_value() ? std::move(*this) : std::move(rhs);
+ }
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+ /// \group disjunction
+ constexpr optional disjunction(optional&& rhs) const&& {
+ return has_value() ? std::move(*this) : std::move(rhs);
+ }
+#endif
+
+ /// Takes the value out of the optional, leaving it empty
+ /// \group take
+ optional take() & {
+ optional ret = *this;
+ reset();
+ return ret;
+ }
+
+ /// \group take
+ optional take() const& {
+ optional ret = *this;
+ reset();
+ return ret;
+ }
+
+ /// \group take
+ optional take() && {
+ optional ret = std::move(*this);
+ reset();
+ return ret;
+ }
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+ /// \group take
+ optional take() const&& {
+ optional ret = std::move(*this);
+ reset();
+ return ret;
+ }
+#endif
+
+ using value_type = T&;
+
+ /// Constructs an optional that does not contain a value.
+ /// \group ctor_empty
+ constexpr optional() noexcept : m_value(nullptr) {
+ }
+
+ /// \group ctor_empty
+ constexpr optional(nullopt_t) noexcept : m_value(nullptr) {
+ }
+
+ /// Copy constructor
+ ///
+ /// If `rhs` contains a value, the stored value is direct-initialized with
+ /// it. Otherwise, the constructed optional is empty.
+ SOL_TL_OPTIONAL_11_CONSTEXPR optional(const optional& rhs) noexcept = default;
+
+ /// Move constructor
+ ///
+ /// If `rhs` contains a value, the stored value is direct-initialized with
+ /// it. Otherwise, the constructed optional is empty.
+ SOL_TL_OPTIONAL_11_CONSTEXPR optional(optional&& rhs) = default;
+
+ /// Constructs the stored value with `u`.
+ /// \synopsis template <class U=T> constexpr optional(U &&u);
+ template <class U = T, detail::enable_if_t<!detail::is_optional<detail::decay_t<U>>::value>* = nullptr>
+ constexpr optional(U&& u) : m_value(std::addressof(u)) {
+ static_assert(std::is_lvalue_reference<U>::value, "U must be an lvalue");
+ }
+
+ /// \exclude
+ template <class U>
+ constexpr explicit optional(const optional<U>& rhs) : optional(*rhs) {
+ }
+
+ /// No-op
+ ~optional() = default;
+
+ /// Assignment to empty.
+ ///
+ /// Destroys the current value if there is one.
+ optional& operator=(nullopt_t) noexcept {
+ m_value = nullptr;
+ return *this;
+ }
+
+ /// Copy assignment.
+ ///
+ /// Rebinds this optional to the referee of `rhs` if there is one. Otherwise
+ /// resets the stored value in `*this`.
+ optional& operator=(const optional& rhs) = default;
+
+ /// Rebinds this optional to `u`.
+ ///
+ /// \requires `U` must be an lvalue reference.
+ /// \synopsis optional &operator=(U &&u);
+ template <class U = T, detail::enable_if_t<!detail::is_optional<detail::decay_t<U>>::value>* = nullptr>
+ optional& operator=(U&& u) {
+ static_assert(std::is_lvalue_reference<U>::value, "U must be an lvalue");
+ m_value = std::addressof(u);
+ return *this;
+ }
+
+ /// Converting copy assignment operator.
+ ///
+ /// Rebinds this optional to the referee of `rhs` if there is one. Otherwise
+ /// resets the stored value in `*this`.
+ template <class U>
+ optional& operator=(const optional<U>& rhs) {
+ m_value = std::addressof(rhs.value());
+ return *this;
+ }
+
+ /// Constructs the value in-place, destroying the current one if there is
+ /// one.
+ ///
+ /// \group emplace
+ template <class... Args>
+ T& emplace(Args&&... args) noexcept {
+ static_assert(std::is_constructible<T, Args&&...>::value, "T must be constructible with Args");
+
+ *this = nullopt;
+ this->construct(std::forward<Args>(args)...);
+ }
+
+ /// Swaps this optional with the other.
+ ///
+ /// If neither optionals have a value, nothing happens.
+ /// If both have a value, the values are swapped.
+ /// If one has a value, it is moved to the other and the movee is left
+ /// valueless.
+ void swap(optional& rhs) noexcept {
+ std::swap(m_value, rhs.m_value);
+ }
+
+ /// \returns a pointer to the stored value
+ /// \requires a value is stored
+ /// \group pointer
+ /// \synopsis constexpr const T *operator->() const;
+ constexpr const T* operator->() const {
+ return m_value;
+ }
+
+ /// \group pointer
+ /// \synopsis constexpr T *operator->();
+ SOL_TL_OPTIONAL_11_CONSTEXPR T* operator->() {
+ return m_value;
+ }
+
+ /// \returns the stored value
+ /// \requires a value is stored
+ /// \group deref
+ /// \synopsis constexpr T &operator*();
+ SOL_TL_OPTIONAL_11_CONSTEXPR T& operator*() {
+ return *m_value;
+ }
+
+ /// \group deref
+ /// \synopsis constexpr const T &operator*() const;
+ constexpr const T& operator*() const {
+ return *m_value;
+ }
+
+ /// \returns whether or not the optional has a value
+ /// \group has_value
+ constexpr bool has_value() const noexcept {
+ return m_value != nullptr;
+ }
+
+ /// \group has_value
+ constexpr explicit operator bool() const noexcept {
+ return m_value != nullptr;
+ }
+
+ /// \returns the contained value if there is one, otherwise throws
+ /// [bad_optional_access]
+ /// \group value
+ /// synopsis constexpr T &value();
+ SOL_TL_OPTIONAL_11_CONSTEXPR T& value() {
+ if (has_value())
+ return *m_value;
+#if SOL_IS_OFF(SOL_EXCEPTIONS_I_)
+ std::abort();
+#else
+ throw bad_optional_access();
+#endif // No exceptions allowed
+ }
+ /// \group value
+ /// \synopsis constexpr const T &value() const;
+ SOL_TL_OPTIONAL_11_CONSTEXPR const T& value() const {
+ if (has_value())
+ return *m_value;
+#if SOL_IS_OFF(SOL_EXCEPTIONS_I_)
+ std::abort();
+#else
+ throw bad_optional_access();
+#endif // No exceptions allowed
+ }
+
+ /// \returns the stored value if there is one, otherwise returns `u`
+ /// \group value_or
+ template <class U>
+ constexpr T& value_or(U&& u) const {
+ static_assert(std::is_convertible<U&&, T&>::value, "T must be convertible from U");
+ return has_value() ? const_cast<T&>(**this) : static_cast<T&>(std::forward<U>(u));
+ }
+
+ /// Destroys the stored value if one exists, making the optional empty
+ void reset() noexcept {
+ m_value = nullptr;
+ }
+
+ private:
+ T* m_value;
+ };
+
+} // namespace sol
+
+namespace std {
+ // TODO SFINAE
+ template <class T>
+ struct hash<::sol::optional<T>> {
+ ::std::size_t operator()(const ::sol::optional<T>& o) const {
+ if (!o.has_value())
+ return 0;
+
+ return ::std::hash<::sol::detail::remove_const_t<T>>()(*o);
+ }
+ };
+} // namespace std
+
+// end of sol/optional_implementation.hpp
+
+#endif // Boost vs. Better optional
+
+#include <optional>
+
+namespace sol {
+
+#if SOL_IS_ON(SOL_USE_BOOST_I_)
+ template <typename T>
+ using optional = boost::optional<T>;
+ using nullopt_t = boost::none_t;
+ const nullopt_t nullopt = boost::none;
+#endif // Boost vs. Better optional
+
+ namespace meta {
+ template <typename T>
+ using is_optional = any<is_specialization_of<T, optional>, is_specialization_of<T, std::optional>>;
+
+ template <typename T>
+ constexpr inline bool is_optional_v = is_optional<T>::value;
+ } // namespace meta
+
+ namespace detail {
+ template <typename T>
+ struct associated_nullopt {
+ inline static constexpr std::nullopt_t value = std::nullopt;
+ };
+
+#if SOL_IS_ON(SOL_USE_BOOST_I_)
+ template <typename T>
+ struct associated_nullopt<boost::optional<T>> {
+ inline static constexpr std::nullopt_t value = boost::nullopt;
+ };
+#endif // Boost nullopt
+
+ template <typename T>
+ inline constexpr auto associated_nullopt_v = associated_nullopt<T>::value;
+ } // namespace detail
+} // namespace sol
+
+// end of sol/optional.hpp
+
+// beginning of sol/raii.hpp
+
+#include <memory>
+
+namespace sol {
+ namespace detail {
+ struct default_construct {
+ template <typename T, typename... Args>
+ static void construct(T&& obj, Args&&... args) {
+ typedef meta::unqualified_t<T> Tu;
+ std::allocator<Tu> alloc{};
+ std::allocator_traits<std::allocator<Tu>>::construct(alloc, std::forward<T>(obj), std::forward<Args>(args)...);
+ }
+
+ template <typename T, typename... Args>
+ void operator()(T&& obj, Args&&... args) const {
+ construct(std::forward<T>(obj), std::forward<Args>(args)...);
+ }
+ };
+
+ struct default_destruct {
+ template <typename T>
+ static void destroy(T&& obj) {
+ std::allocator<meta::unqualified_t<T>> alloc{};
+ alloc.destroy(obj);
+ }
+
+ template <typename T>
+ void operator()(T&& obj) const {
+ destroy(std::forward<T>(obj));
+ }
+ };
+
+ struct deleter {
+ template <typename T>
+ void operator()(T* p) const {
+ delete p;
+ }
+ };
+
+ struct state_deleter {
+ void operator()(lua_State* L) const {
+ lua_close(L);
+ }
+ };
+
+ template <typename T, typename Dx, typename... Args>
+ inline std::unique_ptr<T, Dx> make_unique_deleter(Args&&... args) {
+ return std::unique_ptr<T, Dx>(new T(std::forward<Args>(args)...));
+ }
+
+ template <typename Tag, typename T>
+ struct tagged {
+ private:
+ T value_;
+
+ public:
+ template <typename Arg, typename... Args, meta::disable<std::is_same<meta::unqualified_t<Arg>, tagged>> = meta::enabler>
+ tagged(Arg&& arg, Args&&... args)
+ : value_(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+ }
+
+ T& value() & {
+ return value_;
+ }
+
+ T const& value() const& {
+ return value_;
+ }
+
+ T&& value() && {
+ return std::move(value_);
+ }
+ };
+ } // namespace detail
+
+ template <typename... Args>
+ struct constructor_list {};
+
+ template <typename... Args>
+ using constructors = constructor_list<Args...>;
+
+ const auto default_constructor = constructors<types<>>{};
+
+ struct no_construction {};
+ const auto no_constructor = no_construction{};
+
+ struct call_construction {};
+ const auto call_constructor = call_construction{};
+
+ template <typename... Functions>
+ struct constructor_wrapper {
+ std::tuple<Functions...> functions;
+ template <typename Arg, typename... Args, meta::disable<std::is_same<meta::unqualified_t<Arg>, constructor_wrapper>> = meta::enabler>
+ constructor_wrapper(Arg&& arg, Args&&... args)
+ : functions(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+ }
+ };
+
+ template <typename... Functions>
+ inline auto initializers(Functions&&... functions) {
+ return constructor_wrapper<std::decay_t<Functions>...>(std::forward<Functions>(functions)...);
+ }
+
+ template <typename... Functions>
+ struct factory_wrapper {
+ std::tuple<Functions...> functions;
+ template <typename Arg, typename... Args, meta::disable<std::is_same<meta::unqualified_t<Arg>, factory_wrapper>> = meta::enabler>
+ factory_wrapper(Arg&& arg, Args&&... args)
+ : functions(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+ }
+ };
+
+ template <typename... Functions>
+ inline auto factories(Functions&&... functions) {
+ return factory_wrapper<std::decay_t<Functions>...>(std::forward<Functions>(functions)...);
+ }
+
+ template <typename Function>
+ struct destructor_wrapper {
+ Function fx;
+ destructor_wrapper(Function f)
+ : fx(std::move(f)) {
+ }
+ };
+
+ template <>
+ struct destructor_wrapper<void> {};
+
+ const destructor_wrapper<void> default_destructor{};
+
+ template <typename Fx>
+ inline auto destructor(Fx&& fx) {
+ return destructor_wrapper<std::decay_t<Fx>>(std::forward<Fx>(fx));
+ }
+
+} // namespace sol
+
+// end of sol/raii.hpp
+
+// beginning of sol/policies.hpp
+
+#include <array>
+
+namespace sol {
+ namespace detail {
+ struct policy_base_tag {};
+ } // namespace detail
+
+ template <int Target, int... In>
+ struct static_stack_dependencies : detail::policy_base_tag {};
+ typedef static_stack_dependencies<-1, 1> self_dependency;
+ template <int... In>
+ struct returns_self_with : detail::policy_base_tag {};
+ typedef returns_self_with<> returns_self;
+
+ struct stack_dependencies : detail::policy_base_tag {
+ int target;
+ std::array<int, 64> stack_indices;
+ std::size_t len;
+
+ template <typename... Args>
+ stack_dependencies(int stack_target, Args&&... args) : target(stack_target), stack_indices(), len(sizeof...(Args)) {
+ std::size_t i = 0;
+ (void)detail::swallow{ int(), (stack_indices[i++] = static_cast<int>(std::forward<Args>(args)), int())... };
+ }
+
+ int& operator[](std::size_t i) {
+ return stack_indices[i];
+ }
+
+ const int& operator[](std::size_t i) const {
+ return stack_indices[i];
+ }
+
+ std::size_t size() const {
+ return len;
+ }
+ };
+
+ template <typename F, typename... Policies>
+ struct policy_wrapper {
+ typedef std::index_sequence_for<Policies...> indices;
+
+ F value;
+ std::tuple<Policies...> policies;
+
+ template <typename Fx, typename... Args, meta::enable<meta::neg<std::is_same<meta::unqualified_t<Fx>, policy_wrapper>>> = meta::enabler>
+ policy_wrapper(Fx&& fx, Args&&... args) : value(std::forward<Fx>(fx)), policies(std::forward<Args>(args)...) {
+ }
+
+ policy_wrapper(const policy_wrapper&) = default;
+ policy_wrapper& operator=(const policy_wrapper&) = default;
+ policy_wrapper(policy_wrapper&&) = default;
+ policy_wrapper& operator=(policy_wrapper&&) = default;
+ };
+
+ template <typename F, typename... Args>
+ auto policies(F&& f, Args&&... args) {
+ return policy_wrapper<std::decay_t<F>, std::decay_t<Args>...>(std::forward<F>(f), std::forward<Args>(args)...);
+ }
+
+ namespace detail {
+ template <typename T>
+ using is_policy = meta::is_specialization_of<T, policy_wrapper>;
+
+ template <typename T>
+ inline constexpr bool is_policy_v = is_policy<T>::value;
+ } // namespace detail
+} // namespace sol
+
+// end of sol/policies.hpp
+
+// beginning of sol/ebco.hpp
+
+#include <type_traits>
+#include <utility>
+
+namespace sol { namespace detail {
+
+ template <typename T, std::size_t tag = 0, typename = void>
+ struct ebco {
+ T value_;
+
+ ebco() = default;
+ ebco(const ebco&) = default;
+ ebco(ebco&&) = default;
+ ebco& operator=(const ebco&) = default;
+ ebco& operator=(ebco&&) = default;
+ ebco(const T& v) : value_(v){};
+ ebco(T&& v) : value_(std::move(v)){};
+ ebco& operator=(const T& v) {
+ value_ = v;
+ return *this;
+ }
+ ebco& operator=(T&& v) {
+ value_ = std::move(v);
+ return *this;
+ };
+ template <typename Arg, typename... Args,
+ typename = std::enable_if_t<!std::is_same_v<std::remove_reference_t<std::remove_cv_t<Arg>>,
+ ebco> && !std::is_same_v<std::remove_reference_t<std::remove_cv_t<Arg>>, T>>>
+ ebco(Arg&& arg, Args&&... args) : T(std::forward<Arg>(arg), std::forward<Args>(args)...){}
+
+ T& value() & {
+ return value_;
+ }
+
+ T const& value() const & {
+ return value_;
+ }
+
+ T&& value() && {
+ return std::move(value_);
+ }
+ };
+
+ template <typename T, std::size_t tag>
+ struct ebco<T, tag, std::enable_if_t<!std::is_reference_v<T> && std::is_class_v<T> && !std::is_final_v<T>>> : T {
+ ebco() = default;
+ ebco(const ebco&) = default;
+ ebco(ebco&&) = default;
+ ebco(const T& v) : T(v){};
+ ebco(T&& v) : T(std::move(v)){};
+ template <typename Arg, typename... Args,
+ typename = std::enable_if_t<!std::is_same_v<std::remove_reference_t<std::remove_cv_t<Arg>>,
+ ebco> && !std::is_same_v<std::remove_reference_t<std::remove_cv_t<Arg>>, T>>>
+ ebco(Arg&& arg, Args&&... args) : T(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+ }
+
+ ebco& operator=(const ebco&) = default;
+ ebco& operator=(ebco&&) = default;
+ ebco& operator=(const T& v) {
+ static_cast<T&>(*this) = v;
+ return *this;
+ }
+ ebco& operator=(T&& v) {
+ static_cast<T&>(*this) = std::move(v);
+ return *this;
+ };
+
+ T& value() & {
+ return static_cast<T&>(*this);
+ }
+
+ T const& value() const & {
+ return static_cast<T const&>(*this);
+ }
+
+ T&& value() && {
+ return std::move(static_cast<T&>(*this));
+ }
+ };
+
+ template <typename T, std::size_t tag>
+ struct ebco<T&, tag> {
+ T& ref;
+
+ ebco() = default;
+ ebco(const ebco&) = default;
+ ebco(ebco&&) = default;
+ ebco(T& v) : ref(v){};
+
+ ebco& operator=(const ebco&) = default;
+ ebco& operator=(ebco&&) = default;
+ ebco& operator=(T& v) {
+ ref = v;
+ return *this;
+ }
+
+ T& value() const {
+ return const_cast<ebco<T&, tag>&>(*this).ref;
+ }
+ };
+
+ template <typename T, std::size_t tag>
+ struct ebco<T&&, tag> {
+ T&& ref;
+
+ ebco() = default;
+ ebco(const ebco&) = default;
+ ebco(ebco&&) = default;
+ ebco(T&& v) : ref(v){};
+
+ ebco& operator=(const ebco&) = default;
+ ebco& operator=(ebco&&) = default;
+ ebco& operator=(T&& v) {
+ ref = std::move(v);
+ return *this;
+ }
+
+ T& value() & {
+ return ref;
+ }
+
+ const T& value() const & {
+ return ref;
+ }
+
+ T&& value() && {
+ return std::move(ref);
+ }
+ };
+
+}} // namespace sol::detail
+
+// end of sol/ebco.hpp
+
+#include <array>
+#include <initializer_list>
+#include <string>
+#include <string_view>
+#include <optional>
+#if SOL_IS_ON(SOL_STD_VARIANT_I_)
+#include <variant>
+#endif // variant shenanigans (thanks, Mac OSX)
+
+namespace sol {
+ namespace detail {
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_)
+ typedef int (*lua_CFunction_noexcept)(lua_State* L) noexcept;
+#else
+ typedef int (*lua_CFunction_noexcept)(lua_State* L);
+#endif // noexcept function type for lua_CFunction
+
+ template <typename T>
+ struct unique_usertype { };
+
+ template <typename T>
+ struct implicit_wrapper {
+ T& item;
+ implicit_wrapper(T* item) : item(*item) {
+ }
+ implicit_wrapper(T& item) : item(item) {
+ }
+ operator T&() {
+ return item;
+ }
+ operator T*() {
+ return std::addressof(item);
+ }
+ };
+
+ struct yield_tag_t { };
+ const yield_tag_t yield_tag = yield_tag_t {};
+ } // namespace detail
+
+ struct lua_nil_t { };
+ inline constexpr lua_nil_t lua_nil {};
+ inline bool operator==(lua_nil_t, lua_nil_t) {
+ return true;
+ }
+ inline bool operator!=(lua_nil_t, lua_nil_t) {
+ return false;
+ }
+#if SOL_IS_ON(SOL_NIL_I_)
+ using nil_t = lua_nil_t;
+ inline constexpr const nil_t& nil = lua_nil;
+#endif
+
+ namespace detail {
+ struct non_lua_nil_t { };
+ } // namespace detail
+
+ struct metatable_key_t { };
+ const metatable_key_t metatable_key = {};
+
+ struct env_key_t { };
+ const env_key_t env_key = {};
+
+ struct no_metatable_t { };
+ const no_metatable_t no_metatable = {};
+
+ template <typename T>
+ struct yielding_t {
+ T func;
+
+ yielding_t() = default;
+ yielding_t(const yielding_t&) = default;
+ yielding_t(yielding_t&&) = default;
+ yielding_t& operator=(const yielding_t&) = default;
+ yielding_t& operator=(yielding_t&&) = default;
+ template <typename Arg,
+ meta::enable<meta::neg<std::is_same<meta::unqualified_t<Arg>, yielding_t>>,
+ meta::neg<std::is_base_of<proxy_base_tag, meta::unqualified_t<Arg>>>> = meta::enabler>
+ yielding_t(Arg&& arg) : func(std::forward<Arg>(arg)) {
+ }
+ template <typename Arg0, typename Arg1, typename... Args>
+ yielding_t(Arg0&& arg0, Arg1&& arg1, Args&&... args) : func(std::forward<Arg0>(arg0), std::forward<Arg1>(arg1), std::forward<Args>(args)...) {
+ }
+ };
+
+ template <typename F>
+ inline yielding_t<std::decay_t<F>> yielding(F&& f) {
+ return yielding_t<std::decay_t<F>>(std::forward<F>(f));
+ }
+
+ typedef std::remove_pointer_t<lua_CFunction> lua_CFunction_ref;
+
+ template <typename T>
+ struct non_null { };
+
+ template <typename... Args>
+ struct function_sig { };
+
+ struct upvalue_index {
+ int index;
+ upvalue_index(int idx) : index(lua_upvalueindex(idx)) {
+ }
+
+ operator int() const {
+ return index;
+ }
+ };
+
+ struct raw_index {
+ int index;
+ raw_index(int i) : index(i) {
+ }
+
+ operator int() const {
+ return index;
+ }
+ };
+
+ struct absolute_index {
+ int index;
+ absolute_index(lua_State* L, int idx) : index(lua_absindex(L, idx)) {
+ }
+
+ operator int() const {
+ return index;
+ }
+ };
+
+ struct ref_index {
+ int index;
+ ref_index(int idx) : index(idx) {
+ }
+
+ operator int() const {
+ return index;
+ }
+ };
+
+ struct stack_count {
+ int count;
+
+ stack_count(int cnt) : count(cnt) {
+ }
+ };
+
+ struct lightuserdata_value {
+ void* value;
+ lightuserdata_value(void* data) : value(data) {
+ }
+ operator void*() const {
+ return value;
+ }
+ };
+
+ struct userdata_value {
+ void* value;
+ userdata_value(void* data) : value(data) {
+ }
+ operator void*() const {
+ return value;
+ }
+ };
+
+ template <typename L>
+ struct light {
+ L* value;
+
+ light(L& x) : value(std::addressof(x)) {
+ }
+ light(L* x) : value(x) {
+ }
+ light(void* x) : value(static_cast<L*>(x)) {
+ }
+ operator L*() const {
+ return value;
+ }
+ operator L&() const {
+ return *value;
+ }
+ };
+
+ template <typename T>
+ auto make_light(T& l) {
+ typedef meta::unwrapped_t<std::remove_pointer_t<std::remove_pointer_t<T>>> L;
+ return light<L>(l);
+ }
+
+ template <typename U>
+ struct user {
+ U value;
+
+ user(U&& x) : value(std::forward<U>(x)) {
+ }
+ operator std::add_pointer_t<std::remove_reference_t<U>>() {
+ return std::addressof(value);
+ }
+ operator std::add_lvalue_reference_t<U>() {
+ return value;
+ }
+ operator std::add_const_t<std::add_lvalue_reference_t<U>> &() const {
+ return value;
+ }
+ };
+
+ template <typename T>
+ auto make_user(T&& u) {
+ typedef meta::unwrapped_t<meta::unqualified_t<T>> U;
+ return user<U>(std::forward<T>(u));
+ }
+
+ template <typename T>
+ struct metatable_registry_key {
+ T key;
+
+ metatable_registry_key(T key) : key(std::forward<T>(key)) {
+ }
+ };
+
+ template <typename T>
+ auto meta_registry_key(T&& key) {
+ typedef meta::unqualified_t<T> K;
+ return metatable_registry_key<K>(std::forward<T>(key));
+ }
+
+ template <typename... Upvalues>
+ struct closure {
+ lua_CFunction c_function;
+ std::tuple<Upvalues...> upvalues;
+ closure(lua_CFunction f, Upvalues... targetupvalues) : c_function(f), upvalues(std::forward<Upvalues>(targetupvalues)...) {
+ }
+ };
+
+ template <>
+ struct closure<> {
+ lua_CFunction c_function;
+ int upvalues;
+ closure(lua_CFunction f, int upvalue_count = 0) : c_function(f), upvalues(upvalue_count) {
+ }
+ };
+
+ typedef closure<> c_closure;
+
+ template <typename... Args>
+ closure<Args...> make_closure(lua_CFunction f, Args&&... args) {
+ return closure<Args...>(f, std::forward<Args>(args)...);
+ }
+
+ template <typename Sig, typename... Ps>
+ struct function_arguments {
+ std::tuple<Ps...> arguments;
+ template <typename Arg, typename... Args, meta::disable<std::is_same<meta::unqualified_t<Arg>, function_arguments>> = meta::enabler>
+ function_arguments(Arg&& arg, Args&&... args) : arguments(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+ }
+ };
+
+ template <typename Sig = function_sig<>, typename... Args>
+ auto as_function(Args&&... args) {
+ return function_arguments<Sig, std::decay_t<Args>...>(std::forward<Args>(args)...);
+ }
+
+ template <typename Sig = function_sig<>, typename... Args>
+ auto as_function_reference(Args&&... args) {
+ return function_arguments<Sig, Args...>(std::forward<Args>(args)...);
+ }
+
+ template <typename T>
+ struct as_table_t {
+ private:
+ T value_;
+
+ public:
+ as_table_t() = default;
+ as_table_t(const as_table_t&) = default;
+ as_table_t(as_table_t&&) = default;
+ as_table_t& operator=(const as_table_t&) = default;
+ as_table_t& operator=(as_table_t&&) = default;
+ template <typename Arg,
+ meta::enable<meta::neg<std::is_same<meta::unqualified_t<Arg>, as_table_t>>,
+ meta::neg<std::is_base_of<proxy_base_tag, meta::unqualified_t<Arg>>>> = meta::enabler>
+ as_table_t(Arg&& arg) : value_(std::forward<Arg>(arg)) {
+ }
+ template <typename Arg0, typename Arg1, typename... Args>
+ as_table_t(Arg0&& arg0, Arg1&& arg1, Args&&... args) : value_(std::forward<Arg0>(arg0), std::forward<Arg1>(arg1), std::forward<Args>(args)...) {
+ }
+
+ T& value() & {
+ return value_;
+ }
+
+ T&& value() && {
+ return std::move(value_);
+ }
+
+ const T& value() const& {
+ return value_;
+ }
+
+ operator std::add_lvalue_reference_t<T>() {
+ return value_;
+ }
+ };
+
+ template <typename T>
+ struct nested {
+ private:
+ T value_;
+
+ public:
+ using nested_type = T;
+
+ nested() = default;
+ nested(const nested&) = default;
+ nested(nested&&) = default;
+ nested& operator=(const nested&) = default;
+ nested& operator=(nested&&) = default;
+ template <typename Arg,
+ meta::enable<meta::neg<std::is_same<meta::unqualified_t<Arg>, nested>>,
+ meta::neg<std::is_base_of<proxy_base_tag, meta::unqualified_t<Arg>>>> = meta::enabler>
+ nested(Arg&& arg) : value_(std::forward<Arg>(arg)) {
+ }
+ template <typename Arg0, typename Arg1, typename... Args>
+ nested(Arg0&& arg0, Arg1&& arg1, Args&&... args) : value_(std::forward<Arg0>(arg0), std::forward<Arg1>(arg1), std::forward<Args>(args)...) {
+ }
+
+ T& value() & {
+ return value_;
+ }
+
+ T&& value() && {
+ return std::move(value_);
+ }
+
+ const T& value() const& {
+ return value_;
+ }
+
+ operator std::add_lvalue_reference_t<T>() {
+ return value_;
+ }
+ };
+
+ struct nested_tag_t { };
+ constexpr inline nested_tag_t nested_tag {};
+
+ template <typename T>
+ as_table_t<T> as_table_ref(T&& container) {
+ return as_table_t<T>(std::forward<T>(container));
+ }
+
+ template <typename T>
+ as_table_t<meta::unqualified_t<T>> as_table(T&& container) {
+ return as_table_t<meta::unqualified_t<T>>(std::forward<T>(container));
+ }
+
+ template <typename T>
+ nested<T> as_nested_ref(T&& container) {
+ return nested<T>(std::forward<T>(container));
+ }
+
+ template <typename T>
+ nested<meta::unqualified_t<T>> as_nested(T&& container) {
+ return nested<meta::unqualified_t<T>>(std::forward<T>(container));
+ }
+
+ template <typename T>
+ struct as_container_t {
+ private:
+ T value_;
+
+ public:
+ using type = T;
+
+ as_container_t() = default;
+ as_container_t(const as_container_t&) = default;
+ as_container_t(as_container_t&&) = default;
+ as_container_t& operator=(const as_container_t&) = default;
+ as_container_t& operator=(as_container_t&&) = default;
+ template <typename Arg,
+ meta::enable<meta::neg<std::is_same<meta::unqualified_t<Arg>, as_container_t>>,
+ meta::neg<std::is_base_of<proxy_base_tag, meta::unqualified_t<Arg>>>> = meta::enabler>
+ as_container_t(Arg&& arg) : value_(std::forward<Arg>(arg)) {
+ }
+ template <typename Arg0, typename Arg1, typename... Args>
+ as_container_t(Arg0&& arg0, Arg1&& arg1, Args&&... args) : value_(std::forward<Arg0>(arg0), std::forward<Arg1>(arg1), std::forward<Args>(args)...) {
+ }
+
+ T& value() & {
+ return value_;
+ }
+
+ T&& value() && {
+ return std::move(value_);
+ }
+
+ const T& value() const& {
+ return value_;
+ }
+ };
+
+ template <typename T>
+ struct as_container_t<T&> {
+ private:
+ std::reference_wrapper<T> value_;
+
+ public:
+ as_container_t(T& value) : value_(value) {
+ }
+
+ T& value() {
+ return value_;
+ }
+
+ operator T&() {
+ return value();
+ }
+ };
+
+ template <typename T>
+ auto as_container(T&& value) {
+ return as_container_t<T>(std::forward<T>(value));
+ }
+
+ template <typename T>
+ struct push_invoke_t {
+ private:
+ T value_;
+
+ public:
+ push_invoke_t() = default;
+ push_invoke_t(const push_invoke_t&) = default;
+ push_invoke_t(push_invoke_t&&) = default;
+ push_invoke_t& operator=(const push_invoke_t&) = default;
+ push_invoke_t& operator=(push_invoke_t&&) = default;
+ template <typename Arg,
+ meta::enable<meta::neg<std::is_same<meta::unqualified_t<Arg>, push_invoke_t>>,
+ meta::neg<std::is_base_of<proxy_base_tag, meta::unqualified_t<Arg>>>> = meta::enabler>
+ push_invoke_t(Arg&& arg) : value_(std::forward<Arg>(arg)) {
+ }
+ template <typename Arg0, typename Arg1, typename... Args>
+ push_invoke_t(Arg0&& arg0, Arg1&& arg1, Args&&... args) : value_(std::forward<Arg0>(arg0), std::forward<Arg1>(arg1), std::forward<Args>(args)...) {
+ }
+
+ T& value() & {
+ return value_;
+ }
+
+ T&& value() && {
+ return std::move(value_);
+ }
+
+ const T& value() const& {
+ return value_;
+ }
+ };
+
+ template <typename T>
+ struct push_invoke_t<T&> {
+ std::reference_wrapper<T> value_;
+
+ push_invoke_t(T& value) : value_(value) {
+ }
+
+ T& value() {
+ return value_;
+ }
+ };
+
+ template <typename Fx>
+ auto push_invoke(Fx&& fx) {
+ return push_invoke_t<Fx>(std::forward<Fx>(fx));
+ }
+
+ struct override_value_t { };
+ constexpr inline override_value_t override_value = override_value_t();
+ struct update_if_empty_t { };
+ constexpr inline update_if_empty_t update_if_empty = update_if_empty_t();
+ struct create_if_nil_t { };
+ constexpr inline create_if_nil_t create_if_nil = create_if_nil_t();
+
+ namespace detail {
+ enum insert_mode { none = 0x0, update_if_empty = 0x01, override_value = 0x02, create_if_nil = 0x04 };
+
+ template <typename T, typename...>
+ using is_insert_mode = std::integral_constant<bool,
+ std::is_same_v<T, override_value_t> || std::is_same_v<T, update_if_empty_t> || std::is_same_v<T, create_if_nil_t>>;
+
+ template <typename T, typename...>
+ using is_not_insert_mode = meta::neg<is_insert_mode<T>>;
+ } // namespace detail
+
+ struct this_state {
+ lua_State* L;
+
+ this_state(lua_State* Ls) : L(Ls) {
+ }
+
+ operator lua_State*() const noexcept {
+ return lua_state();
+ }
+
+ lua_State* operator->() const noexcept {
+ return lua_state();
+ }
+
+ lua_State* lua_state() const noexcept {
+ return L;
+ }
+ };
+
+ struct this_main_state {
+ lua_State* L;
+
+ this_main_state(lua_State* Ls) : L(Ls) {
+ }
+
+ operator lua_State*() const noexcept {
+ return lua_state();
+ }
+
+ lua_State* operator->() const noexcept {
+ return lua_state();
+ }
+
+ lua_State* lua_state() const noexcept {
+ return L;
+ }
+ };
+
+ struct new_table {
+ int sequence_hint = 0;
+ int map_hint = 0;
+
+ new_table() = default;
+ new_table(const new_table&) = default;
+ new_table(new_table&&) = default;
+ new_table& operator=(const new_table&) = default;
+ new_table& operator=(new_table&&) = default;
+
+ new_table(int sequence_hint, int map_hint = 0) : sequence_hint(sequence_hint), map_hint(map_hint) {
+ }
+ };
+
+ const new_table create = {};
+
+ enum class lib : char {
+ // print, assert, and other base functions
+ base,
+ // require and other package functions
+ package,
+ // coroutine functions and utilities
+ coroutine,
+ // string library
+ string,
+ // functionality from the OS
+ os,
+ // all things math
+ math,
+ // the table manipulator and observer functions
+ table,
+ // the debug library
+ debug,
+ // the bit library: different based on which you're using
+ bit32,
+ // input/output library
+ io,
+ // LuaJIT only
+ ffi,
+ // LuaJIT only
+ jit,
+ // library for handling utf8: new to Lua
+ utf8,
+ // do not use
+ count
+ };
+
+ enum class call_syntax { dot = 0, colon = 1 };
+
+ enum class load_mode {
+ any = 0,
+ text = 1,
+ binary = 2,
+ };
+
+ enum class call_status : int {
+ ok = LUA_OK,
+ yielded = LUA_YIELD,
+ runtime = LUA_ERRRUN,
+ memory = LUA_ERRMEM,
+ handler = LUA_ERRERR,
+ gc = LUA_ERRGCMM,
+ syntax = LUA_ERRSYNTAX,
+ file = LUA_ERRFILE,
+ };
+
+ enum class thread_status : int {
+ ok = LUA_OK,
+ yielded = LUA_YIELD,
+ runtime = LUA_ERRRUN,
+ memory = LUA_ERRMEM,
+ gc = LUA_ERRGCMM,
+ handler = LUA_ERRERR,
+ dead = -1,
+ };
+
+ enum class load_status : int {
+ ok = LUA_OK,
+ syntax = LUA_ERRSYNTAX,
+ memory = LUA_ERRMEM,
+ gc = LUA_ERRGCMM,
+ file = LUA_ERRFILE,
+ };
+
+ enum class gc_mode : int {
+ incremental = 0,
+ generational = 1,
+ default_value = incremental,
+ };
+
+ enum class type : int {
+ none = LUA_TNONE,
+ lua_nil = LUA_TNIL,
+#if SOL_IS_ON(SOL_NIL_I_)
+ nil = lua_nil,
+#endif // Objective C/C++ Keyword that's found in OSX SDK and OBJC -- check for all forms to protect
+ string = LUA_TSTRING,
+ number = LUA_TNUMBER,
+ thread = LUA_TTHREAD,
+ boolean = LUA_TBOOLEAN,
+ function = LUA_TFUNCTION,
+ userdata = LUA_TUSERDATA,
+ lightuserdata = LUA_TLIGHTUSERDATA,
+ table = LUA_TTABLE,
+ poly = -0xFFFF
+ };
+
+ inline const std::string& to_string(call_status c) {
+ static const std::array<std::string, 10> names { { "ok",
+ "yielded",
+ "runtime",
+ "memory",
+ "handler",
+ "gc",
+ "syntax",
+ "file",
+ "CRITICAL_EXCEPTION_FAILURE",
+ "CRITICAL_INDETERMINATE_STATE_FAILURE" } };
+ switch (c) {
+ case call_status::ok:
+ return names[0];
+ case call_status::yielded:
+ return names[1];
+ case call_status::runtime:
+ return names[2];
+ case call_status::memory:
+ return names[3];
+ case call_status::handler:
+ return names[4];
+ case call_status::gc:
+ return names[5];
+ case call_status::syntax:
+ return names[6];
+ case call_status::file:
+ return names[7];
+ }
+ if (static_cast<std::ptrdiff_t>(c) == -1) {
+ // One of the many cases where a critical exception error has occurred
+ return names[8];
+ }
+ return names[9];
+ }
+
+ inline bool is_indeterminate_call_failure(call_status c) {
+ switch (c) {
+ case call_status::ok:
+ case call_status::yielded:
+ case call_status::runtime:
+ case call_status::memory:
+ case call_status::handler:
+ case call_status::gc:
+ case call_status::syntax:
+ case call_status::file:
+ return false;
+ }
+ return true;
+ }
+
+ inline const std::string& to_string(load_status c) {
+ static const std::array<std::string, 7> names {
+ { "ok", "memory", "gc", "syntax", "file", "CRITICAL_EXCEPTION_FAILURE", "CRITICAL_INDETERMINATE_STATE_FAILURE" }
+ };
+ switch (c) {
+ case load_status::ok:
+ return names[0];
+ case load_status::memory:
+ return names[1];
+ case load_status::gc:
+ return names[2];
+ case load_status::syntax:
+ return names[3];
+ case load_status::file:
+ return names[4];
+ }
+ if (static_cast<int>(c) == -1) {
+ // One of the many cases where a critical exception error has occurred
+ return names[5];
+ }
+ return names[6];
+ }
+
+ inline const std::string& to_string(load_mode c) {
+ static const std::array<std::string, 3> names { {
+ "bt",
+ "t",
+ "b",
+ } };
+ return names[static_cast<std::size_t>(c)];
+ }
+
+ enum class meta_function {
+ construct,
+ index,
+ new_index,
+ mode,
+ call,
+ call_function = call,
+ metatable,
+ to_string,
+ length,
+ unary_minus,
+ addition,
+ subtraction,
+ multiplication,
+ division,
+ modulus,
+ power_of,
+ involution = power_of,
+ concatenation,
+ equal_to,
+ less_than,
+ less_than_or_equal_to,
+ garbage_collect,
+ floor_division,
+ bitwise_left_shift,
+ bitwise_right_shift,
+ bitwise_not,
+ bitwise_and,
+ bitwise_or,
+ bitwise_xor,
+ pairs,
+ ipairs,
+ next,
+ type,
+ type_info,
+ call_construct,
+ storage,
+ gc_names,
+ static_index,
+ static_new_index,
+ };
+
+ typedef meta_function meta_method;
+
+ inline const std::array<std::string, 37>& meta_function_names() {
+ static const std::array<std::string, 37> names = { { "new",
+ "__index",
+ "__newindex",
+ "__mode",
+ "__call",
+ "__metatable",
+ "__tostring",
+ "__len",
+ "__unm",
+ "__add",
+ "__sub",
+ "__mul",
+ "__div",
+ "__mod",
+ "__pow",
+ "__concat",
+ "__eq",
+ "__lt",
+ "__le",
+ "__gc",
+
+ "__idiv",
+ "__shl",
+ "__shr",
+ "__bnot",
+ "__band",
+ "__bor",
+ "__bxor",
+
+ "__pairs",
+ "__ipairs",
+ "next",
+
+ "__type",
+ "__typeinfo",
+ "__sol.call_new",
+ "__sol.storage",
+ "__sol.gc_names",
+ "__sol.static_index",
+ "__sol.static_new_index" } };
+ return names;
+ }
+
+ inline const std::string& to_string(meta_function mf) {
+ return meta_function_names()[static_cast<int>(mf)];
+ }
+
+ inline type type_of(lua_State* L, int index) {
+ return static_cast<type>(lua_type(L, index));
+ }
+
+ inline std::string type_name(lua_State* L, type t) {
+ return lua_typename(L, static_cast<int>(t));
+ }
+
+ template <typename T>
+ struct is_lua_reference
+ : std::integral_constant<bool, std::is_base_of_v<reference, T> || std::is_base_of_v<main_reference, T> || std::is_base_of_v<stack_reference, T>> { };
+
+ template <typename T>
+ inline constexpr bool is_lua_reference_v = is_lua_reference<T>::value;
+
+ template <typename T>
+ struct is_lua_reference_or_proxy : std::integral_constant<bool, is_lua_reference_v<T> || meta::is_specialization_of_v<T, table_proxy>> { };
+
+ template <typename T>
+ inline constexpr bool is_lua_reference_or_proxy_v = is_lua_reference_or_proxy<T>::value;
+
+ template <typename T>
+ struct is_transparent_argument : std::false_type { };
+
+ template <typename T>
+ constexpr inline bool is_transparent_argument_v = is_transparent_argument<T>::value;
+
+ template <>
+ struct is_transparent_argument<this_state> : std::true_type { };
+ template <>
+ struct is_transparent_argument<this_main_state> : std::true_type { };
+ template <>
+ struct is_transparent_argument<this_environment> : std::true_type { };
+ template <>
+ struct is_transparent_argument<variadic_args> : std::true_type { };
+ template <typename T>
+ struct is_variadic_arguments : std::is_same<T, variadic_args> { };
+
+ template <typename T>
+ struct is_container
+ : std::integral_constant<bool,
+ !std::is_same_v<state_view,
+ T> && !std::is_same_v<state, T> && !meta::is_initializer_list_v<T> && !meta::is_string_like_v<T> && !meta::is_string_literal_array_v<T> && !is_transparent_argument_v<T> && !is_lua_reference_v<T> && (meta::has_begin_end_v<T> || std::is_array_v<T>)> {
+ };
+
+ template <typename T>
+ constexpr inline bool is_container_v = is_container<T>::value;
+
+ template <typename T>
+ struct is_to_stringable : meta::any<meta::supports_to_string_member<meta::unqualified_t<T>>, meta::supports_adl_to_string<meta::unqualified_t<T>>,
+ meta::supports_op_left_shift<std::ostream, meta::unqualified_t<T>>> { };
+
+ namespace detail {
+ template <typename T, typename = void>
+ struct lua_type_of : std::integral_constant<type, type::userdata> { };
+
+ template <typename C, typename T, typename A>
+ struct lua_type_of<std::basic_string<C, T, A>> : std::integral_constant<type, type::string> { };
+
+ template <typename C, typename T>
+ struct lua_type_of<basic_string_view<C, T>> : std::integral_constant<type, type::string> { };
+
+ template <std::size_t N>
+ struct lua_type_of<char[N]> : std::integral_constant<type, type::string> { };
+
+ template <std::size_t N>
+ struct lua_type_of<wchar_t[N]> : std::integral_constant<type, type::string> { };
+
+ template <std::size_t N>
+ struct lua_type_of<char16_t[N]> : std::integral_constant<type, type::string> { };
+
+ template <std::size_t N>
+ struct lua_type_of<char32_t[N]> : std::integral_constant<type, type::string> { };
+
+ template <>
+ struct lua_type_of<char> : std::integral_constant<type, type::string> { };
+
+ template <>
+ struct lua_type_of<wchar_t> : std::integral_constant<type, type::string> { };
+
+ template <>
+ struct lua_type_of<char16_t> : std::integral_constant<type, type::string> { };
+
+ template <>
+ struct lua_type_of<char32_t> : std::integral_constant<type, type::string> { };
+
+ template <>
+ struct lua_type_of<const char*> : std::integral_constant<type, type::string> { };
+
+ template <>
+ struct lua_type_of<const char16_t*> : std::integral_constant<type, type::string> { };
+
+ template <>
+ struct lua_type_of<const char32_t*> : std::integral_constant<type, type::string> { };
+
+ template <>
+ struct lua_type_of<bool> : std::integral_constant<type, type::boolean> { };
+
+ template <>
+ struct lua_type_of<lua_nil_t> : std::integral_constant<type, type::lua_nil> { };
+
+ template <>
+ struct lua_type_of<nullopt_t> : std::integral_constant<type, type::lua_nil> { };
+
+ template <>
+ struct lua_type_of<lua_value> : std::integral_constant<type, type::poly> { };
+
+ template <>
+ struct lua_type_of<detail::non_lua_nil_t> : std::integral_constant<type, type::poly> { };
+
+ template <>
+ struct lua_type_of<std::nullptr_t> : std::integral_constant<type, type::lua_nil> { };
+
+ template <>
+ struct lua_type_of<error> : std::integral_constant<type, type::string> { };
+
+ template <bool b, typename Base>
+ struct lua_type_of<basic_table_core<b, Base>> : std::integral_constant<type, type::table> { };
+
+ template <typename Base>
+ struct lua_type_of<basic_lua_table<Base>> : std::integral_constant<type, type::table> { };
+
+ template <typename Base>
+ struct lua_type_of<basic_metatable<Base>> : std::integral_constant<type, type::table> { };
+
+ template <typename T, typename Base>
+ struct lua_type_of<basic_usertype<T, Base>> : std::integral_constant<type, type::table> { };
+
+ template <>
+ struct lua_type_of<metatable_key_t> : std::integral_constant<type, type::table> { };
+
+ template <typename B>
+ struct lua_type_of<basic_environment<B>> : std::integral_constant<type, type::poly> { };
+
+ template <>
+ struct lua_type_of<env_key_t> : std::integral_constant<type, type::poly> { };
+
+ template <>
+ struct lua_type_of<new_table> : std::integral_constant<type, type::table> { };
+
+ template <typename T>
+ struct lua_type_of<as_table_t<T>> : std::integral_constant<type, type::table> { };
+
+ template <typename T>
+ struct lua_type_of<std::initializer_list<T>> : std::integral_constant<type, type::table> { };
+
+ template <bool b>
+ struct lua_type_of<basic_reference<b>> : std::integral_constant<type, type::poly> { };
+
+ template <>
+ struct lua_type_of<stack_reference> : std::integral_constant<type, type::poly> { };
+
+ template <typename Base>
+ struct lua_type_of<basic_object<Base>> : std::integral_constant<type, type::poly> { };
+
+ template <typename... Args>
+ struct lua_type_of<std::tuple<Args...>> : std::integral_constant<type, type::poly> { };
+
+ template <typename A, typename B>
+ struct lua_type_of<std::pair<A, B>> : std::integral_constant<type, type::poly> { };
+
+ template <>
+ struct lua_type_of<void*> : std::integral_constant<type, type::lightuserdata> { };
+
+ template <>
+ struct lua_type_of<const void*> : std::integral_constant<type, type::lightuserdata> { };
+
+ template <>
+ struct lua_type_of<lightuserdata_value> : std::integral_constant<type, type::lightuserdata> { };
+
+ template <>
+ struct lua_type_of<userdata_value> : std::integral_constant<type, type::userdata> { };
+
+ template <typename T>
+ struct lua_type_of<light<T>> : std::integral_constant<type, type::lightuserdata> { };
+
+ template <typename T>
+ struct lua_type_of<user<T>> : std::integral_constant<type, type::userdata> { };
+
+ template <typename Base>
+ struct lua_type_of<basic_lightuserdata<Base>> : std::integral_constant<type, type::lightuserdata> { };
+
+ template <typename Base>
+ struct lua_type_of<basic_userdata<Base>> : std::integral_constant<type, type::userdata> { };
+
+ template <>
+ struct lua_type_of<lua_CFunction> : std::integral_constant<type, type::function> { };
+
+ template <>
+ struct lua_type_of<std::remove_pointer_t<lua_CFunction>> : std::integral_constant<type, type::function> { };
+
+ template <typename Base, bool aligned>
+ struct lua_type_of<basic_function<Base, aligned>> : std::integral_constant<type, type::function> { };
+
+ template <typename Base, bool aligned, typename Handler>
+ struct lua_type_of<basic_protected_function<Base, aligned, Handler>> : std::integral_constant<type, type::function> { };
+
+ template <typename Base>
+ struct lua_type_of<basic_coroutine<Base>> : std::integral_constant<type, type::function> { };
+
+ template <typename Base>
+ struct lua_type_of<basic_thread<Base>> : std::integral_constant<type, type::thread> { };
+
+ template <typename Signature>
+ struct lua_type_of<std::function<Signature>> : std::integral_constant<type, type::function> { };
+
+ template <typename T>
+ struct lua_type_of<optional<T>> : std::integral_constant<type, type::poly> { };
+
+ template <typename T>
+ struct lua_type_of<std::optional<T>> : std::integral_constant<type, type::poly> { };
+
+ template <>
+ struct lua_type_of<variadic_args> : std::integral_constant<type, type::poly> { };
+
+ template <>
+ struct lua_type_of<variadic_results> : std::integral_constant<type, type::poly> { };
+
+ template <>
+ struct lua_type_of<stack_count> : std::integral_constant<type, type::poly> { };
+
+ template <>
+ struct lua_type_of<this_state> : std::integral_constant<type, type::poly> { };
+
+ template <>
+ struct lua_type_of<this_main_state> : std::integral_constant<type, type::poly> { };
+
+ template <>
+ struct lua_type_of<this_environment> : std::integral_constant<type, type::poly> { };
+
+ template <>
+ struct lua_type_of<type> : std::integral_constant<type, type::poly> { };
+
+#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE_I_)
+ template <typename T>
+ struct lua_type_of<T*> : std::integral_constant<type, std::is_function_v<T> ? type::function : type::userdata> { };
+#else
+ template <typename T>
+ struct lua_type_of<T*> : std::integral_constant<type, type::userdata> { };
+#endif
+
+ template <typename T>
+ struct lua_type_of<T, std::enable_if_t<std::is_arithmetic_v<T> || std::is_same_v<T, lua_Number> || std::is_same_v<T, lua_Integer>>>
+ : std::integral_constant<type, type::number> { };
+
+ template <typename T>
+ struct lua_type_of<T, std::enable_if_t<std::is_function_v<T>>> : std::integral_constant<type, type::function> { };
+
+ template <typename T>
+ struct lua_type_of<T, std::enable_if_t<std::is_enum_v<T>>> : std::integral_constant<type, type::number> { };
+
+ template <>
+ struct lua_type_of<meta_function> : std::integral_constant<type, type::string> { };
+
+#if SOL_IS_ON(SOL_STD_VARIANT_I_)
+ template <typename... Tn>
+ struct lua_type_of<std::variant<Tn...>> : std::integral_constant<type, type::poly> { };
+#endif // std::variant deployment sucks on Clang
+
+ template <typename T>
+ struct lua_type_of<nested<T>> : meta::conditional_t<::sol::is_container_v<T>, std::integral_constant<type, type::table>, lua_type_of<T>> { };
+
+ template <typename C, C v, template <typename...> class V, typename... Args>
+ struct accumulate : std::integral_constant<C, v> { };
+
+ template <typename C, C v, template <typename...> class V, typename T, typename... Args>
+ struct accumulate<C, v, V, T, Args...> : accumulate<C, v + V<T>::value, V, Args...> { };
+
+ template <typename C, C v, template <typename...> class V, typename List>
+ struct accumulate_list;
+
+ template <typename C, C v, template <typename...> class V, typename... Args>
+ struct accumulate_list<C, v, V, types<Args...>> : accumulate<C, v, V, Args...> { };
+ } // namespace detail
+
+ template <typename T>
+ struct lua_type_of : detail::lua_type_of<T> {
+ typedef int SOL_INTERNAL_UNSPECIALIZED_MARKER_;
+ };
+
+ template <typename T>
+ inline constexpr type lua_type_of_v = lua_type_of<T>::value;
+
+ template <typename T>
+ struct lua_size : std::integral_constant<int, 1> {
+ typedef int SOL_INTERNAL_UNSPECIALIZED_MARKER_;
+ };
+
+ template <typename A, typename B>
+ struct lua_size<std::pair<A, B>> : std::integral_constant<int, lua_size<A>::value + lua_size<B>::value> { };
+
+ template <typename... Args>
+ struct lua_size<std::tuple<Args...>> : std::integral_constant<int, detail::accumulate<int, 0, lua_size, Args...>::value> { };
+
+ template <typename T>
+ inline constexpr int lua_size_v = lua_size<T>::value;
+
+ namespace detail {
+ template <typename...>
+ struct void_ {
+ typedef void type;
+ };
+ template <typename T, typename = void>
+ struct has_internal_marker_impl : std::false_type { };
+ template <typename T>
+ struct has_internal_marker_impl<T, typename void_<typename T::SOL_INTERNAL_UNSPECIALIZED_MARKER_>::type> : std::true_type { };
+
+ template <typename T>
+ using has_internal_marker = has_internal_marker_impl<T>;
+
+ template <typename T>
+ constexpr inline bool has_internal_marker_v = has_internal_marker<T>::value;
+ } // namespace detail
+
+ template <typename T>
+ struct is_lua_primitive
+ : std::integral_constant<bool,
+ type::userdata
+ != lua_type_of_v<
+ T> || ((type::userdata == lua_type_of_v<T>)&&detail::has_internal_marker_v<lua_type_of<T>> && !detail::has_internal_marker_v<lua_size<T>>)
+ || is_lua_reference_or_proxy_v<T> || meta::is_specialization_of_v<T, std::tuple> || meta::is_specialization_of_v<T, std::pair>> { };
+
+ template <typename T>
+ constexpr inline bool is_lua_primitive_v = is_lua_primitive<T>::value;
+
+ template <typename T>
+ struct is_main_threaded : std::is_base_of<main_reference, T> { };
+
+ template <typename T>
+ struct is_stack_based : std::is_base_of<stack_reference, T> { };
+ template <>
+ struct is_stack_based<variadic_args> : std::true_type { };
+ template <>
+ struct is_stack_based<unsafe_function_result> : std::true_type { };
+ template <>
+ struct is_stack_based<protected_function_result> : std::true_type { };
+ template <>
+ struct is_stack_based<stack_proxy> : std::true_type { };
+ template <>
+ struct is_stack_based<stack_proxy_base> : std::true_type { };
+ template <>
+ struct is_stack_based<stack_count> : std::true_type { };
+
+ template <typename T>
+ constexpr inline bool is_stack_based_v = is_stack_based<T>::value;
+
+ template <typename T>
+ struct is_lua_primitive<T*> : std::true_type { };
+ template <>
+ struct is_lua_primitive<unsafe_function_result> : std::true_type { };
+ template <>
+ struct is_lua_primitive<protected_function_result> : std::true_type { };
+ template <typename T>
+ struct is_lua_primitive<std::reference_wrapper<T>> : std::true_type { };
+ template <typename T>
+ struct is_lua_primitive<user<T>> : std::true_type { };
+ template <typename T>
+ struct is_lua_primitive<light<T>> : is_lua_primitive<T*> { };
+ template <typename T>
+ struct is_lua_primitive<optional<T>> : std::true_type { };
+ template <typename T>
+ struct is_lua_primitive<std::optional<T>> : std::true_type { };
+ template <typename T>
+ struct is_lua_primitive<as_table_t<T>> : std::true_type { };
+ template <typename T>
+ struct is_lua_primitive<nested<T>> : std::true_type { };
+ template <>
+ struct is_lua_primitive<userdata_value> : std::true_type { };
+ template <>
+ struct is_lua_primitive<lightuserdata_value> : std::true_type { };
+ template <>
+ struct is_lua_primitive<stack_proxy> : std::true_type { };
+ template <>
+ struct is_lua_primitive<stack_proxy_base> : std::true_type { };
+ template <typename T>
+ struct is_lua_primitive<non_null<T>> : is_lua_primitive<T*> { };
+
+ template <typename T>
+ struct is_lua_index : std::is_integral<T> { };
+ template <>
+ struct is_lua_index<raw_index> : std::true_type { };
+ template <>
+ struct is_lua_index<absolute_index> : std::true_type { };
+ template <>
+ struct is_lua_index<ref_index> : std::true_type { };
+ template <>
+ struct is_lua_index<upvalue_index> : std::true_type { };
+
+ template <typename Signature>
+ struct lua_bind_traits : meta::bind_traits<Signature> {
+ private:
+ typedef meta::bind_traits<Signature> base_t;
+
+ public:
+ typedef std::integral_constant<bool, meta::count_for<is_variadic_arguments, typename base_t::args_list>::value != 0> runtime_variadics_t;
+ static const std::size_t true_arity = base_t::arity;
+ static const std::size_t arity = detail::accumulate_list<std::size_t, 0, lua_size, typename base_t::args_list>::value
+ - meta::count_for<is_transparent_argument, typename base_t::args_list>::value;
+ static const std::size_t true_free_arity = base_t::free_arity;
+ static const std::size_t free_arity = detail::accumulate_list<std::size_t, 0, lua_size, typename base_t::free_args_list>::value
+ - meta::count_for<is_transparent_argument, typename base_t::args_list>::value;
+ };
+
+ template <typename T>
+ struct is_table : std::false_type { };
+ template <bool x, typename T>
+ struct is_table<basic_table_core<x, T>> : std::true_type { };
+ template <typename T>
+ struct is_table<basic_lua_table<T>> : std::true_type { };
+
+ template <typename T>
+ inline constexpr bool is_table_v = is_table<T>::value;
+
+ template <typename T>
+ struct is_stack_table : std::false_type { };
+ template <bool x, typename T>
+ struct is_stack_table<basic_table_core<x, T>> : std::integral_constant<bool, std::is_base_of_v<stack_reference, T>> { };
+ template <typename T>
+ struct is_stack_table<basic_lua_table<T>> : std::integral_constant<bool, std::is_base_of_v<stack_reference, T>> { };
+
+ template <typename T>
+ inline constexpr bool is_stack_table_v = is_stack_table<T>::value;
+
+ template <typename T>
+ struct is_function : std::false_type { };
+ template <typename T, bool aligned>
+ struct is_function<basic_function<T, aligned>> : std::true_type { };
+ template <typename T, bool aligned, typename Handler>
+ struct is_function<basic_protected_function<T, aligned, Handler>> : std::true_type { };
+
+ template <typename T>
+ using is_lightuserdata = meta::is_specialization_of<T, basic_lightuserdata>;
+
+ template <typename T>
+ inline constexpr bool is_lightuserdata_v = is_lightuserdata<T>::value;
+
+ template <typename T>
+ using is_userdata = meta::is_specialization_of<T, basic_userdata>;
+
+ template <typename T>
+ inline constexpr bool is_userdata_v = is_userdata<T>::value;
+
+ template <typename T>
+ using is_environment = std::integral_constant<bool, is_userdata_v<T> || is_table_v<T> || meta::is_specialization_of_v<T, basic_environment>>;
+
+ template <typename T>
+ inline constexpr bool is_environment_v = is_environment<T>::value;
+
+ template <typename T>
+ using is_table_like = std::integral_constant<bool, is_table_v<T> || is_environment_v<T> || is_userdata_v<T>>;
+
+ template <typename T>
+ inline constexpr bool is_table_like_v = is_table_like<T>::value;
+
+ template <typename T>
+ struct is_automagical
+ : std::integral_constant<bool,
+ (SOL_IS_ON(SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_))
+ || (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>))> {
+ };
+
+ template <typename T>
+ inline type type_of() {
+ return lua_type_of<meta::unqualified_t<T>>::value;
+ }
+
+ namespace detail {
+ template <typename T>
+ struct is_non_factory_constructor : std::false_type { };
+
+ template <typename... Args>
+ struct is_non_factory_constructor<constructors<Args...>> : std::true_type { };
+
+ template <typename... Args>
+ struct is_non_factory_constructor<constructor_wrapper<Args...>> : std::true_type { };
+
+ template <>
+ struct is_non_factory_constructor<no_construction> : std::true_type { };
+
+ template <typename T>
+ inline constexpr bool is_non_factory_constructor_v = is_non_factory_constructor<T>::value;
+
+ template <typename T>
+ struct is_constructor : is_non_factory_constructor<T> { };
+
+ template <typename... Args>
+ struct is_constructor<factory_wrapper<Args...>> : std::true_type { };
+
+ template <typename T>
+ struct is_constructor<protect_t<T>> : is_constructor<meta::unqualified_t<T>> { };
+
+ template <typename F, typename... Policies>
+ struct is_constructor<policy_wrapper<F, Policies...>> : is_constructor<meta::unqualified_t<F>> { };
+
+ template <typename T>
+ inline constexpr bool is_constructor_v = is_constructor<T>::value;
+
+ template <typename... Args>
+ using any_is_constructor = meta::any<is_constructor<meta::unqualified_t<Args>>...>;
+
+ template <typename... Args>
+ inline constexpr bool any_is_constructor_v = any_is_constructor<Args...>::value;
+
+ template <typename T>
+ struct is_destructor : std::false_type { };
+
+ template <typename Fx>
+ struct is_destructor<destructor_wrapper<Fx>> : std::true_type { };
+
+ template <typename... Args>
+ using any_is_destructor = meta::any<is_destructor<meta::unqualified_t<Args>>...>;
+
+ template <typename... Args>
+ inline constexpr bool any_is_destructor_v = any_is_destructor<Args...>::value;
+ } // namespace detail
+
+ template <typename T>
+ using is_lua_c_function = meta::any<std::is_same<lua_CFunction, T>, std::is_same<detail::lua_CFunction_noexcept, T>, std::is_same<lua_CFunction_ref, T>>;
+
+ template <typename T>
+ inline constexpr bool is_lua_c_function_v = is_lua_c_function<T>::value;
+
+ struct automagic_enrollments {
+ bool default_constructor = true;
+ bool destructor = true;
+ bool pairs_operator = true;
+ bool to_string_operator = true;
+ bool call_operator = true;
+ bool less_than_operator = true;
+ bool less_than_or_equal_to_operator = true;
+ bool length_operator = true;
+ bool equal_to_operator = true;
+ };
+
+} // namespace sol
+
+// end of sol/types.hpp
+
+#include <exception>
+#include <cstring>
+
+#if SOL_IS_ON(SOL_PRINT_ERRORS_I_)
+#include <iostream>
+#endif
+
+namespace sol {
+ // must push a single object to be the error object
+ // NOTE: the VAST MAJORITY of all Lua libraries -- C or otherwise -- expect a string for the type of error
+ // break this convention at your own risk
+ using exception_handler_function = int (*)(lua_State*, optional<const std::exception&>, string_view);
+
+ namespace detail {
+ inline const char (&default_exception_handler_name())[11] {
+ static const char name[11] = "sol.\xE2\x98\xA2\xE2\x98\xA2";
+ return name;
+ }
+
+ // must push at least 1 object on the stack
+ inline int default_exception_handler(lua_State* L, optional<const std::exception&>, string_view what) {
+#if SOL_IS_ON(SOL_PRINT_ERRORS_I_)
+ std::cerr << "[sol3] An exception occurred: ";
+ std::cerr.write(what.data(), what.size());
+ std::cerr << std::endl;
+#endif
+ lua_pushlstring(L, what.data(), what.size());
+ return 1;
+ }
+
+ inline int call_exception_handler(lua_State* L, optional<const std::exception&> maybe_ex, string_view what) {
+ lua_getglobal(L, default_exception_handler_name());
+ type t = static_cast<type>(lua_type(L, -1));
+ if (t != type::lightuserdata) {
+ lua_pop(L, 1);
+ return default_exception_handler(L, std::move(maybe_ex), std::move(what));
+ }
+ void* vfunc = lua_touserdata(L, -1);
+ lua_pop(L, 1);
+ if (vfunc == nullptr) {
+ return default_exception_handler(L, std::move(maybe_ex), std::move(what));
+ }
+ exception_handler_function exfunc = reinterpret_cast<exception_handler_function>(vfunc);
+ return exfunc(L, std::move(maybe_ex), std::move(what));
+ }
+
+#if SOL_IS_OFF(SOL_EXCEPTIONS_I_)
+ template <lua_CFunction f>
+ int static_trampoline(lua_State* L) noexcept {
+ return f(L);
+ }
+
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_)
+ template <lua_CFunction_noexcept f>
+ int static_trampoline_noexcept(lua_State* L) noexcept {
+ return f(L);
+ }
+#else
+ template <lua_CFunction f>
+ int static_trampoline_noexcept(lua_State* L) noexcept {
+ return f(L);
+ }
+#endif
+
+ template <typename Fx, typename... Args>
+ int trampoline(lua_State* L, Fx&& f, Args&&... args) noexcept {
+ return f(L, std::forward<Args>(args)...);
+ }
+
+ inline int c_trampoline(lua_State* L, lua_CFunction f) noexcept {
+ return trampoline(L, f);
+ }
+#else
+
+ inline int lua_cfunction_trampoline(lua_State* L, lua_CFunction f) {
+#if SOL_IS_ON(SOL_PROPAGATE_EXCEPTIONS_I_)
+ return f(L);
+
+#else
+ try {
+ return f(L);
+ }
+ catch (const char* cs) {
+ call_exception_handler(L, optional<const std::exception&>(nullopt), string_view(cs));
+ }
+ catch (const std::string& s) {
+ call_exception_handler(L, optional<const std::exception&>(nullopt), string_view(s.c_str(), s.size()));
+ }
+ catch (const std::exception& e) {
+ call_exception_handler(L, optional<const std::exception&>(e), e.what());
+ }
+#if SOL_IS_OFF(SOL_USE_LUAJIT_I_)
+ // LuaJIT cannot have the catchall when the safe propagation is on
+ // but LuaJIT will swallow all C++ errors
+ // if we don't at least catch std::exception ones
+ catch (...) {
+ 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
+ return lua_error(L);
+#endif // Safe exceptions
+ }
+
+ template <lua_CFunction f>
+ int static_trampoline(lua_State* L) {
+ return lua_cfunction_trampoline(L, f);
+ }
+
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_)
+ template <lua_CFunction_noexcept f>
+ int static_trampoline_noexcept(lua_State* L) noexcept {
+ return f(L);
+ }
+#else
+ template <lua_CFunction f>
+ int static_trampoline_noexcept(lua_State* L) noexcept {
+ return f(L);
+ }
+#endif
+
+ template <typename Fx, typename... Args>
+ int trampoline(lua_State* L, Fx&& f, Args&&... args) {
+ if constexpr (meta::bind_traits<meta::unqualified_t<Fx>>::is_noexcept) {
+ return f(L, std::forward<Args>(args)...);
+ }
+ else {
+#if SOL_IS_ON(SOL_PROPAGATE_EXCEPTIONS_I_)
+ return f(L, std::forward<Args>(args)...);
+#else
+ try {
+ return f(L, std::forward<Args>(args)...);
+ }
+ catch (const char* cs) {
+ call_exception_handler(L, optional<const std::exception&>(nullopt), string_view(cs));
+ }
+ catch (const std::string& s) {
+ call_exception_handler(L, optional<const std::exception&>(nullopt), string_view(s.c_str(), s.size()));
+ }
+ catch (const std::exception& e) {
+ call_exception_handler(L, optional<const std::exception&>(e), e.what());
+ }
+#if SOL_IS_OFF(SOL_USE_LUAJIT_I_)
+ // LuaJIT cannot have the catchall when the safe propagation is on
+ // but LuaJIT will swallow all C++ errors
+ // if we don't at least catch std::exception ones
+ catch (...) {
+ call_exception_handler(L, optional<const std::exception&>(nullopt), "caught (...) exception");
+ }
+#endif
+ return lua_error(L);
+#endif
+ }
+ }
+
+ inline int c_trampoline(lua_State* L, lua_CFunction f) {
+ return trampoline(L, f);
+ }
+#endif // Exceptions vs. No Exceptions
+
+ template <typename F, F fx>
+ inline int typed_static_trampoline(lua_State* L) {
+ if constexpr (meta::bind_traits<F>::is_noexcept) {
+ return static_trampoline_noexcept<fx>(L);
+ }
+ else {
+ return static_trampoline<fx>(L);
+ }
+ }
+ } // namespace detail
+
+ inline void set_default_exception_handler(lua_State* L, exception_handler_function exf = &detail::default_exception_handler) {
+ static_assert(sizeof(void*) >= sizeof(exception_handler_function),
+ "void* storage is too small to transport the exception handler: please file a bug on the sol2 issue tracker to get this looked at!");
+ void* storage;
+ std::memcpy(&storage, &exf, sizeof(exception_handler_function));
+ lua_pushlightuserdata(L, storage);
+ lua_setglobal(L, detail::default_exception_handler_name());
+ }
+} // namespace sol
+
+// end of sol/trampoline.hpp
+
+// beginning of sol/stack_core.hpp
+
+// beginning of sol/inheritance.hpp
+
+// beginning of sol/usertype_traits.hpp
+
+// beginning of sol/demangle.hpp
+
+#include <string>
+#include <array>
+#include <cctype>
+#if SOL_IS_ON(SOL_MINGW_CCTYPE_IS_POISONED_I_)
+extern "C" {
+#include <ctype.h>
+}
+#endif // MinGW is on some stuff
+#include <locale>
+
+namespace sol { namespace detail {
+ inline constexpr std::array<string_view, 9> removals { { "{anonymous}",
+ "(anonymous namespace)",
+ "public:",
+ "private:",
+ "protected:",
+ "struct ",
+ "class ",
+ "`anonymous-namespace'",
+ "`anonymous namespace'" } };
+
+#if SOL_IS_ON(SOL_COMPILER_GCC_I_) || SOL_IS_ON(SOL_COMPILER_CLANG_I_)
+ inline std::string ctti_get_type_name_from_sig(std::string name) {
+ // cardinal sins from MINGW
+ using namespace std;
+ std::size_t start = name.find_first_of('[');
+ start = name.find_first_of('=', start);
+ std::size_t end = name.find_last_of(']');
+ if (end == std::string::npos)
+ end = name.size();
+ if (start == std::string::npos)
+ start = 0;
+ if (start < name.size() - 1)
+ start += 1;
+ name = name.substr(start, end - start);
+ start = name.rfind("seperator_mark");
+ if (start != std::string::npos) {
+ name.erase(start - 2, name.length());
+ }
+ while (!name.empty() && isblank(name.front()))
+ name.erase(name.begin());
+ while (!name.empty() && isblank(name.back()))
+ name.pop_back();
+
+ for (std::size_t r = 0; r < removals.size(); ++r) {
+ auto found = name.find(removals[r]);
+ while (found != std::string::npos) {
+ name.erase(found, removals[r].size());
+ found = name.find(removals[r]);
+ }
+ }
+
+ return name;
+ }
+
+ template <typename T, class seperator_mark = int>
+ inline std::string ctti_get_type_name() {
+ return ctti_get_type_name_from_sig(__PRETTY_FUNCTION__);
+ }
+#elif SOL_IS_ON(SOL_COMPILER_VCXX_I_)
+ inline std::string ctti_get_type_name_from_sig(std::string name) {
+ std::size_t start = name.find("get_type_name");
+ if (start == std::string::npos)
+ start = 0;
+ else
+ start += 13;
+ if (start < name.size() - 1)
+ start += 1;
+ std::size_t end = name.find_last_of('>');
+ if (end == std::string::npos)
+ end = name.size();
+ name = name.substr(start, end - start);
+ if (name.find("struct", 0) == 0)
+ name.replace(0, 6, "", 0);
+ if (name.find("class", 0) == 0)
+ name.replace(0, 5, "", 0);
+ while (!name.empty() && isblank(name.front()))
+ name.erase(name.begin());
+ while (!name.empty() && isblank(name.back()))
+ name.pop_back();
+
+ for (std::size_t r = 0; r < removals.size(); ++r) {
+ auto found = name.find(removals[r]);
+ while (found != std::string::npos) {
+ name.erase(found, removals[r].size());
+ found = name.find(removals[r]);
+ }
+ }
+
+ return name;
+ }
+
+ template <typename T>
+ std::string ctti_get_type_name() {
+ return ctti_get_type_name_from_sig(__FUNCSIG__);
+ }
+#else
+#error Compiler not supported for demangling
+#endif // compilers
+
+ template <typename T>
+ std::string demangle_once() {
+ std::string realname = ctti_get_type_name<T>();
+ return realname;
+ }
+
+ inline std::string short_demangle_from_type_name(std::string realname) {
+ // This isn't the most complete but it'll do for now...?
+ static const std::array<std::string, 10> ops = {
+ { "operator<", "operator<<", "operator<<=", "operator<=", "operator>", "operator>>", "operator>>=", "operator>=", "operator->", "operator->*" }
+ };
+ int level = 0;
+ std::ptrdiff_t idx = 0;
+ for (idx = static_cast<std::ptrdiff_t>(realname.empty() ? 0 : realname.size() - 1); idx > 0; --idx) {
+ if (level == 0 && realname[idx] == ':') {
+ break;
+ }
+ bool isleft = realname[idx] == '<';
+ bool isright = realname[idx] == '>';
+ if (!isleft && !isright)
+ continue;
+ bool earlybreak = false;
+ for (const auto& op : ops) {
+ std::size_t nisop = realname.rfind(op, idx);
+ if (nisop == std::string::npos)
+ continue;
+ std::size_t nisopidx = idx - op.size() + 1;
+ if (nisop == nisopidx) {
+ idx = static_cast<std::ptrdiff_t>(nisopidx);
+ earlybreak = true;
+ }
+ break;
+ }
+ if (earlybreak) {
+ continue;
+ }
+ level += isleft ? -1 : 1;
+ }
+ if (idx > 0) {
+ realname.erase(0, realname.length() < static_cast<std::size_t>(idx) ? realname.length() : idx + 1);
+ }
+ return realname;
+ }
+
+ template <typename T>
+ std::string short_demangle_once() {
+ std::string realname = ctti_get_type_name<T>();
+ return short_demangle_from_type_name(realname);
+ }
+
+ template <typename T>
+ const std::string& demangle() {
+ static const std::string d = demangle_once<T>();
+ return d;
+ }
+
+ template <typename T>
+ const std::string& short_demangle() {
+ static const std::string d = short_demangle_once<T>();
+ return d;
+ }
+}} // namespace sol::detail
+
+// end of sol/demangle.hpp
+
+namespace sol {
+
+ template <typename T>
+ struct usertype_traits {
+ static const std::string& name() {
+ static const std::string& n = detail::short_demangle<T>();
+ return n;
+ }
+ static const std::string& qualified_name() {
+ static const std::string& q_n = detail::demangle<T>();
+ return q_n;
+ }
+ static const std::string& metatable() {
+ static const std::string m = std::string("sol.").append(detail::demangle<T>());
+ return m;
+ }
+ static const std::string& user_metatable() {
+ static const std::string u_m = std::string("sol.").append(detail::demangle<T>()).append(".user");
+ return u_m;
+ }
+ static const std::string& user_gc_metatable() {
+ static const std::string u_g_m = std::string("sol.").append(detail::demangle<T>()).append(".user\xE2\x99\xBB");
+ return u_g_m;
+ }
+ static const std::string& gc_table() {
+ static const std::string g_t = std::string("sol.").append(detail::demangle<T>()).append(".\xE2\x99\xBB");
+ return g_t;
+ }
+ };
+
+} // namespace sol
+
+// end of sol/usertype_traits.hpp
+
+// beginning of sol/unique_usertype_traits.hpp
+
+#include <memory>
+
+namespace sol {
+
+ template <typename T>
+ struct unique_usertype_traits {
+ typedef T type;
+ typedef T actual_type;
+ template <typename X>
+ using rebind_base = void;
+
+ static const bool value = false;
+
+ template <typename U>
+ static bool is_null(U&&) {
+ return false;
+ }
+
+ template <typename U>
+ static auto get(U&& value) {
+ return std::addressof(detail::deref(value));
+ }
+ };
+
+ template <typename T>
+ struct unique_usertype_traits<std::shared_ptr<T>> {
+ typedef T type;
+ typedef std::shared_ptr<T> actual_type;
+ // rebind is non-void
+ // if and only if unique usertype
+ // is cast-capable
+ template <typename X>
+ using rebind_base = std::shared_ptr<X>;
+
+ static const bool value = true;
+
+ static bool is_null(const actual_type& p) {
+ return p == nullptr;
+ }
+
+ static type* get(const actual_type& p) {
+ return p.get();
+ }
+ };
+
+ template <typename T, typename D>
+ struct unique_usertype_traits<std::unique_ptr<T, D>> {
+ using type = T;
+ using actual_type = std::unique_ptr<T, D>;
+
+ static const bool value = true;
+
+ static bool is_null(const actual_type& p) {
+ return p == nullptr;
+ }
+
+ static type* get(const actual_type& p) {
+ return p.get();
+ }
+ };
+
+ template <typename T>
+ struct is_unique_usertype : std::integral_constant<bool, unique_usertype_traits<T>::value> {};
+
+ template <typename T>
+ inline constexpr bool is_unique_usertype_v = is_unique_usertype<T>::value;
+
+ namespace detail {
+ template <typename T, typename Rebind = void>
+ using is_base_rebindable_test = typename T::template rebind_base<Rebind>;
+ }
+
+ template <typename T>
+ using is_base_rebindable = meta::is_detected<detail::is_base_rebindable_test, T>;
+
+ template <typename T>
+ inline constexpr bool is_base_rebindable_v = is_base_rebindable<T>::value;
+
+ namespace detail {
+ template <typename T, typename = void>
+ struct is_base_rebindable_non_void_sfinae : std::false_type {};
+
+ template <typename T>
+ struct is_base_rebindable_non_void_sfinae<T, std::enable_if_t<is_base_rebindable_v<T>>>
+ : std::integral_constant<bool, !std::is_void_v<typename T::template rebind_base<void>>> {};
+ } // namespace detail
+
+ template <typename T>
+ using is_base_rebindable_non_void = meta::is_detected<detail::is_base_rebindable_test, T>;
+
+ template <typename T>
+ inline constexpr bool is_base_rebindable_non_void_v = is_base_rebindable_non_void<T>::value;
+
+} // namespace sol
+
+// end of sol/unique_usertype_traits.hpp
+
+namespace sol {
+ template <typename... Args>
+ struct base_list {};
+ template <typename... Args>
+ using bases = base_list<Args...>;
+
+ typedef bases<> base_classes_tag;
+ const auto base_classes = base_classes_tag();
+
+ template <typename... Args>
+ struct is_to_stringable<base_list<Args...>> : std::false_type {};
+
+ namespace detail {
+
+ inline decltype(auto) base_class_check_key() {
+ static const auto& key = "class_check";
+ return key;
+ }
+
+ inline decltype(auto) base_class_cast_key() {
+ static const auto& key = "class_cast";
+ return key;
+ }
+
+ inline decltype(auto) base_class_index_propogation_key() {
+ static const auto& key = u8"\xF0\x9F\x8C\xB2.index";
+ return key;
+ }
+
+ inline decltype(auto) base_class_new_index_propogation_key() {
+ static const auto& key = u8"\xF0\x9F\x8C\xB2.new_index";
+ return key;
+ }
+
+ template <typename T>
+ struct inheritance {
+ typedef typename base<T>::type bases_t;
+
+ static bool type_check_bases(types<>, const string_view&) {
+ return false;
+ }
+
+ template <typename Base, typename... Args>
+ static bool type_check_bases(types<Base, Args...>, const string_view& ti) {
+ return ti == usertype_traits<Base>::qualified_name() || type_check_bases(types<Args...>(), ti);
+ }
+
+ static bool type_check(const string_view& ti) {
+ return ti == usertype_traits<T>::qualified_name() || type_check_bases(bases_t(), ti);
+ }
+
+ template <typename ...Bases>
+ static bool type_check_with(const string_view& ti) {
+ return ti == usertype_traits<T>::qualified_name() || type_check_bases(types<Bases...>(), ti);
+ }
+
+ static void* type_cast_bases(types<>, T*, const string_view&) {
+ return nullptr;
+ }
+
+ template <typename Base, typename... Args>
+ static void* type_cast_bases(types<Base, Args...>, T* data, const string_view& ti) {
+ // Make sure to convert to T first, and then dynamic cast to the proper type
+ return ti != usertype_traits<Base>::qualified_name() ? type_cast_bases(types<Args...>(), data, ti) : static_cast<void*>(static_cast<Base*>(data));
+ }
+
+ static void* type_cast(void* voiddata, const string_view& ti) {
+ T* data = static_cast<T*>(voiddata);
+ return static_cast<void*>(ti != usertype_traits<T>::qualified_name() ? type_cast_bases(bases_t(), data, ti) : data);
+ }
+
+ template <typename... Bases>
+ static void* type_cast_with(void* voiddata, const string_view& ti) {
+ T* data = static_cast<T*>(voiddata);
+ return static_cast<void*>(ti != usertype_traits<T>::qualified_name() ? type_cast_bases(types<Bases...>(), data, ti) : data);
+ }
+
+ template <typename U>
+ static bool type_unique_cast_bases(types<>, void*, void*, const string_view&) {
+ return 0;
+ }
+
+ template <typename U, typename Base, typename... Args>
+ static int type_unique_cast_bases(types<Base, Args...>, void* source_data, void* target_data, const string_view& ti) {
+ using uu_traits = unique_usertype_traits<U>;
+ using base_ptr = typename uu_traits::template rebind_base<Base>;
+ string_view base_ti = usertype_traits<Base>::qualified_name();
+ if (base_ti == ti) {
+ if (target_data != nullptr) {
+ U* source = static_cast<U*>(source_data);
+ base_ptr* target = static_cast<base_ptr*>(target_data);
+ // perform proper derived -> base conversion
+ *target = *source;
+ }
+ return 2;
+ }
+ return type_unique_cast_bases<U>(types<Args...>(), source_data, target_data, ti);
+ }
+
+ template <typename U>
+ static int type_unique_cast(void* source_data, void* target_data, const string_view& ti, const string_view& rebind_ti) {
+ typedef unique_usertype_traits<U> uu_traits;
+ if constexpr (is_base_rebindable_v<uu_traits>) {
+ typedef typename uu_traits::template rebind_base<void> rebind_t;
+ typedef meta::conditional_t<std::is_void<rebind_t>::value, types<>, bases_t> cond_bases_t;
+ string_view this_rebind_ti = usertype_traits<rebind_t>::qualified_name();
+ if (rebind_ti != this_rebind_ti) {
+ // this is not even of the same unique type
+ return 0;
+ }
+ string_view this_ti = usertype_traits<T>::qualified_name();
+ if (ti == this_ti) {
+ // direct match, return 1
+ return 1;
+ }
+ return type_unique_cast_bases<U>(cond_bases_t(), source_data, target_data, ti);
+ }
+ else {
+ (void)rebind_ti;
+ string_view this_ti = usertype_traits<T>::qualified_name();
+ if (ti == this_ti) {
+ // direct match, return 1
+ return 1;
+ }
+ return type_unique_cast_bases<U>(types<>(), source_data, target_data, ti);
+ }
+ }
+
+ template <typename U, typename... Bases>
+ static int type_unique_cast_with(void* source_data, void* target_data, const string_view& ti, const string_view& rebind_ti) {
+ using uc_bases_t = types<Bases...>;
+ typedef unique_usertype_traits<U> uu_traits;
+ if constexpr (is_base_rebindable_v<uu_traits>) {
+ using rebind_t = typename uu_traits::template rebind_base<void>;
+ using cond_bases_t = meta::conditional_t<std::is_void<rebind_t>::value, types<>, uc_bases_t>;
+ string_view this_rebind_ti = usertype_traits<rebind_t>::qualified_name();
+ if (rebind_ti != this_rebind_ti) {
+ // this is not even of the same unique type
+ return 0;
+ }
+ string_view this_ti = usertype_traits<T>::qualified_name();
+ if (ti == this_ti) {
+ // direct match, return 1
+ return 1;
+ }
+ return type_unique_cast_bases<U>(cond_bases_t(), source_data, target_data, ti);
+ }
+ else {
+ (void)rebind_ti;
+ string_view this_ti = usertype_traits<T>::qualified_name();
+ if (ti == this_ti) {
+ // direct match, return 1
+ return 1;
+ }
+ return type_unique_cast_bases<U>(types<>(), source_data, target_data, ti);
+ }
+ }
+ };
+
+ using inheritance_check_function = decltype(&inheritance<void>::type_check);
+ using inheritance_cast_function = decltype(&inheritance<void>::type_cast);
+ using inheritance_unique_cast_function = decltype(&inheritance<void>::type_unique_cast<void>);
+ } // namespace detail
+} // namespace sol
+
+// end of sol/inheritance.hpp
+
+// beginning of sol/error_handler.hpp
+
+#include <cstdio>
+
+namespace sol {
+
+ namespace detail {
+ constexpr const char* not_a_number = "not a numeric type";
+ constexpr const char* not_a_number_or_number_string = "not a numeric type or numeric string";
+ constexpr const char* not_a_number_integral = "not a numeric type that fits exactly an integer (number maybe has significant decimals)";
+ constexpr const char* not_a_number_or_number_string_integral
+ = "not a numeric type or a numeric string that fits exactly an integer (e.g. number maybe has significant decimals)";
+
+ constexpr const char* not_enough_stack_space = "not enough space left on Lua stack";
+ constexpr const char* not_enough_stack_space_floating = "not enough space left on Lua stack for a floating point number";
+ constexpr const char* not_enough_stack_space_integral = "not enough space left on Lua stack for an integral number";
+ constexpr const char* not_enough_stack_space_string = "not enough space left on Lua stack for a string";
+ constexpr const char* not_enough_stack_space_meta_function_name = "not enough space left on Lua stack for the name of a meta_function";
+ constexpr const char* not_enough_stack_space_userdata = "not enough space left on Lua stack to create a sol3 userdata";
+ constexpr const char* not_enough_stack_space_generic = "not enough space left on Lua stack to push valuees";
+ constexpr const char* not_enough_stack_space_environment = "not enough space left on Lua stack to retrieve environment";
+ constexpr const char* protected_function_error = "caught (...) unknown error during protected_function call";
+
+ inline void accumulate_and_mark(const std::string& n, std::string& aux_message, int& marker) {
+ if (marker > 0) {
+ aux_message += ", ";
+ }
+ aux_message += n;
+ ++marker;
+ }
+ } // namespace detail
+
+ inline std::string associated_type_name(lua_State* L, int index, type t) {
+ switch (t) {
+ case type::poly:
+ return "anything";
+ case type::userdata: {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 2, "not enough space to push get the type name");
+#endif // make sure stack doesn't overflow
+ if (lua_getmetatable(L, index) == 0) {
+ break;
+ }
+ lua_pushlstring(L, "__name", 6);
+ lua_rawget(L, -2);
+ size_t sz;
+ const char* name = lua_tolstring(L, -1, &sz);
+ std::string tn(name, static_cast<std::string::size_type>(sz));
+ lua_pop(L, 2);
+ return tn;
+ }
+ default:
+ break;
+ }
+ return lua_typename(L, static_cast<int>(t));
+ }
+
+ 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
+ ? (aux_message.size() == 0 ? "stack index %d, expected %s, received %s" : "stack index %d, expected %s, received %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));
+ {
+ std::string actual_name = associated_type_name(L, index, actual);
+ lua_pushfstring(L, err, index, type_name, actual_name.c_str(), message.data(), aux_message.data());
+ }
+ return 1;
+ }
+
+ 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, "");
+ return lua_error(L);
+ }
+
+ 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, "");
+ return lua_error(L);
+ }
+
+ struct type_panic_t {
+ int operator()(lua_State* L, int index, type expected, type actual) const noexcept(false) {
+ return type_panic_c_str(L, index, expected, actual, nullptr);
+ }
+ int operator()(lua_State* L, int index, type expected, type actual, string_view message) const noexcept(false) {
+ return type_panic_c_str(L, index, expected, actual, message.data());
+ }
+ };
+
+ const type_panic_t type_panic = {};
+
+ struct constructor_handler {
+ 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)");
+ return lua_error(L);
+ }
+ };
+
+ template <typename F = void>
+ struct argument_handler {
+ 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)");
+ return lua_error(L);
+ }
+ };
+
+ template <typename R, typename... Args>
+ struct argument_handler<types<R, Args...>> {
+ int operator()(lua_State* L, int index, type expected, type actual, string_view message) const noexcept(false) {
+ {
+ std::string aux_message = "(bad argument into '";
+ aux_message += detail::demangle<R>();
+ aux_message += "(";
+ int marker = 0;
+ (void)detail::swallow { int(), (detail::accumulate_and_mark(detail::demangle<Args>(), aux_message, marker), int())... };
+ aux_message += ")')";
+ push_type_panic_string(L, index, expected, actual, message, aux_message);
+ }
+ return lua_error(L);
+ }
+ };
+
+ // Specify this function as the handler for lua::check if you know there's nothing wrong
+ inline int no_panic(lua_State*, int, type, type, const char* = nullptr) noexcept {
+ return 0;
+ }
+
+ inline void type_error(lua_State* L, int expected, int actual) noexcept(false) {
+ luaL_error(L, "expected %s, received %s", lua_typename(L, expected), lua_typename(L, actual));
+ }
+
+ inline void type_error(lua_State* L, type expected, type actual) noexcept(false) {
+ type_error(L, static_cast<int>(expected), static_cast<int>(actual));
+ }
+
+ inline void type_assert(lua_State* L, int index, type expected, type actual) noexcept(false) {
+ if (expected != type::poly && expected != actual) {
+ type_panic_c_str(L, index, expected, actual, nullptr);
+ }
+ }
+
+ inline void type_assert(lua_State* L, int index, type expected) {
+ type actual = type_of(L, index);
+ type_assert(L, index, expected, actual);
+ }
+
+} // namespace sol
+
+// end of sol/error_handler.hpp
+
+// beginning of sol/reference.hpp
+
+// beginning of sol/stack_reference.hpp
+
+namespace sol {
+ namespace detail {
+ inline bool xmovable(lua_State* leftL, lua_State* rightL) {
+ if (rightL == nullptr || leftL == nullptr || leftL == rightL) {
+ return false;
+ }
+ const void* leftregistry = lua_topointer(leftL, LUA_REGISTRYINDEX);
+ const void* rightregistry = lua_topointer(rightL, LUA_REGISTRYINDEX);
+ return leftregistry == rightregistry;
+ }
+ } // namespace detail
+
+ class stateless_stack_reference {
+ private:
+ friend class stack_reference;
+
+ int index = 0;
+
+ int registry_index() const noexcept {
+ return LUA_NOREF;
+ }
+
+ public:
+ stateless_stack_reference() noexcept = default;
+ stateless_stack_reference(lua_nil_t) noexcept : stateless_stack_reference(){};
+ stateless_stack_reference(lua_State* L, int i) noexcept : stateless_stack_reference(absolute_index(L, i)) {
+ }
+ stateless_stack_reference(lua_State*, absolute_index i) noexcept : stateless_stack_reference(i) {
+ }
+ stateless_stack_reference(lua_State*, raw_index i) noexcept : stateless_stack_reference(i) {
+ }
+ stateless_stack_reference(absolute_index i) noexcept : index(i) {
+ }
+ stateless_stack_reference(raw_index i) noexcept : index(i) {
+ }
+ stateless_stack_reference(lua_State*, ref_index) noexcept = delete;
+ stateless_stack_reference(ref_index) noexcept = delete;
+ stateless_stack_reference(const reference&) noexcept = delete;
+ stateless_stack_reference(const stateless_stack_reference&) noexcept = default;
+ stateless_stack_reference(stateless_stack_reference&& o) noexcept = default;
+ stateless_stack_reference& operator=(stateless_stack_reference&&) noexcept = default;
+ stateless_stack_reference& operator=(const stateless_stack_reference&) noexcept = default;
+
+ int push(lua_State* L) const noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, "not enough Lua stack space to push a single reference value");
+#endif // make sure stack doesn't overflow
+ lua_pushvalue(L, index);
+ return 1;
+ }
+
+ void pop(lua_State* L, int n = 1) const noexcept {
+ lua_pop(L, n);
+ }
+
+ int stack_index() const noexcept {
+ return index;
+ }
+
+ const void* pointer(lua_State* L) const noexcept {
+ const void* vp = lua_topointer(L, stack_index());
+ return vp;
+ }
+
+ type get_type(lua_State* L) const noexcept {
+ int result = lua_type(L, index);
+ return static_cast<type>(result);
+ }
+
+ bool valid(lua_State* L) const noexcept {
+ type t = get_type(L);
+ return t != type::lua_nil && t != type::none;
+ }
+
+ void abandon(lua_State* = nullptr) {
+ index = 0;
+ }
+ };
+
+ class stack_reference : public stateless_stack_reference {
+ private:
+ lua_State* luastate = nullptr;
+
+ public:
+ stack_reference() noexcept = default;
+ stack_reference(lua_nil_t) noexcept
+ : stack_reference() {};
+ stack_reference(lua_State* L, lua_nil_t) noexcept : stateless_stack_reference(L, 0), luastate(L) {
+ }
+ stack_reference(lua_State* L, int i) noexcept : stateless_stack_reference(L, i), luastate(L) {
+ }
+ stack_reference(lua_State* L, absolute_index i) noexcept : stateless_stack_reference(L, i), luastate(L) {
+ }
+ stack_reference(lua_State* L, raw_index i) noexcept : stateless_stack_reference(L, i), luastate(L) {
+ }
+ stack_reference(lua_State* L, ref_index i) noexcept = delete;
+ stack_reference(lua_State* L, const reference& r) noexcept = delete;
+ stack_reference(lua_State* L, const stack_reference& r) noexcept
+ : luastate(L) {
+ if (!r.valid()) {
+ index = 0;
+ return;
+ }
+ int i = r.stack_index();
+ if (detail::xmovable(lua_state(), r.lua_state())) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, "not enough Lua stack space to push a single reference value");
+#endif // make sure stack doesn't overflow
+ lua_pushvalue(r.lua_state(), r.index);
+ lua_xmove(r.lua_state(), luastate, 1);
+ i = absolute_index(luastate, -1);
+ }
+ index = i;
+ }
+ stack_reference(stack_reference&& o) noexcept = default;
+ stack_reference& operator=(stack_reference&&) noexcept = default;
+ stack_reference(const stack_reference&) noexcept = default;
+ stack_reference& operator=(const stack_reference&) noexcept = default;
+
+ int push() const noexcept {
+ return push(lua_state());
+ }
+
+ int push(lua_State* Ls) const noexcept {
+ return stateless_stack_reference::push(Ls);
+ }
+
+ void pop() const noexcept {
+ pop(lua_state());
+ }
+
+ void pop(lua_State* Ls, int n = 1) const noexcept {
+ stateless_stack_reference::pop(Ls, n);
+ }
+
+ const void* pointer() const noexcept {
+ return stateless_stack_reference::pointer(lua_state());
+ }
+
+ type get_type() const noexcept {
+ return stateless_stack_reference::get_type(lua_state());
+ }
+
+ lua_State* lua_state() const noexcept {
+ return luastate;
+ }
+
+ bool valid() const noexcept {
+ return stateless_stack_reference::valid(lua_state());
+ }
+
+ void abandon () {
+ stateless_stack_reference::abandon(lua_state());
+ }
+ };
+
+ inline bool operator==(const stack_reference& l, const stack_reference& r) {
+ return lua_compare(l.lua_state(), l.stack_index(), r.stack_index(), LUA_OPEQ) == 0;
+ }
+
+ inline bool operator!=(const stack_reference& l, const stack_reference& r) {
+ return !operator==(l, r);
+ }
+
+ inline bool operator==(const stack_reference& lhs, const lua_nil_t&) {
+ return !lhs.valid();
+ }
+
+ inline bool operator==(const lua_nil_t&, const stack_reference& rhs) {
+ return !rhs.valid();
+ }
+
+ inline bool operator!=(const stack_reference& lhs, const lua_nil_t&) {
+ return lhs.valid();
+ }
+
+ inline bool operator!=(const lua_nil_t&, const stack_reference& rhs) {
+ return rhs.valid();
+ }
+
+ struct stack_reference_equals {
+ bool operator()(const lua_nil_t& lhs, const stack_reference& rhs) const {
+ return lhs == rhs;
+ }
+
+ bool operator()(const stack_reference& lhs, const lua_nil_t& rhs) const {
+ return lhs == rhs;
+ }
+
+ bool operator()(const stack_reference& lhs, const stack_reference& rhs) const {
+ return lhs == rhs;
+ }
+ };
+
+ struct stack_reference_hash {
+ typedef stack_reference argument_type;
+ typedef std::size_t result_type;
+
+ result_type operator()(const argument_type& lhs) const {
+ std::hash<const void*> h;
+ return h(lhs.pointer());
+ }
+ };
+} // namespace sol
+
+// end of sol/stack_reference.hpp
+
+#include <functional>
+
+namespace sol {
+ namespace detail {
+ inline const char (&default_main_thread_name())[9] {
+ static const char name[9] = "sol.\xF0\x9F\x93\x8C";
+ return name;
+ }
+ } // namespace detail
+
+ namespace stack {
+ inline void remove(lua_State* L, int rawindex, int count) {
+ if (count < 1)
+ return;
+ int top = lua_gettop(L);
+ if (top < 1) {
+ return;
+ }
+ if (rawindex == -count || top == rawindex) {
+ // Slice them right off the top
+ lua_pop(L, static_cast<int>(count));
+ return;
+ }
+
+ // Remove each item one at a time using stack operations
+ // Probably slower, maybe, haven't benchmarked,
+ // but necessary
+ int index = lua_absindex(L, rawindex);
+ if (index < 0) {
+ index = lua_gettop(L) + (index + 1);
+ }
+ int last = index + count;
+ for (int i = index; i < last; ++i) {
+ lua_remove(L, index);
+ }
+ }
+
+ struct push_popper_at {
+ lua_State* L;
+ int index;
+ int count;
+ push_popper_at(lua_State* luastate, int index = -1, int count = 1) : L(luastate), index(index), count(count) {
+ }
+ ~push_popper_at() {
+ remove(L, index, count);
+ }
+ };
+
+ template <bool top_level>
+ struct push_popper_n {
+ lua_State* L;
+ int t;
+ push_popper_n(lua_State* luastate, int x) : L(luastate), t(x) {
+ }
+ push_popper_n(const push_popper_n&) = delete;
+ push_popper_n(push_popper_n&&) = default;
+ push_popper_n& operator=(const push_popper_n&) = delete;
+ push_popper_n& operator=(push_popper_n&&) = default;
+ ~push_popper_n() {
+ lua_pop(L, t);
+ }
+ };
+
+ template <>
+ struct push_popper_n<true> {
+ push_popper_n(lua_State*, int) {
+ }
+ };
+
+ template <bool, typename T, typename = void>
+ struct push_popper {
+ using Tu = meta::unqualified_t<T>;
+ T t;
+ int idx;
+
+ push_popper(T x) : t(x), idx(lua_absindex(t.lua_state(), -t.push())) {
+ }
+
+ int index_of(const Tu&) {
+ return idx;
+ }
+
+ ~push_popper() {
+ t.pop();
+ }
+ };
+
+ template <typename T, typename C>
+ struct push_popper<true, T, C> {
+ using Tu = meta::unqualified_t<T>;
+
+ push_popper(T) {
+ }
+
+ int index_of(const Tu&) {
+ return -1;
+ }
+
+ ~push_popper() {
+ }
+ };
+
+ template <typename T>
+ struct push_popper<false, T, std::enable_if_t<is_stack_based_v<meta::unqualified_t<T>>>> {
+ using Tu = meta::unqualified_t<T>;
+
+ push_popper(T) {
+ }
+
+ int index_of(const Tu& r) {
+ return r.stack_index();
+ }
+
+ ~push_popper() {
+ }
+ };
+
+ template <bool top_level = false, typename T>
+ push_popper<top_level, T> push_pop(T&& x) {
+ return push_popper<top_level, T>(std::forward<T>(x));
+ }
+
+ template <typename T>
+ push_popper_at push_pop_at(T&& x) {
+ int c = x.push();
+ lua_State* L = x.lua_state();
+ return push_popper_at(L, lua_absindex(L, -c), c);
+ }
+
+ template <bool top_level = false>
+ push_popper_n<top_level> pop_n(lua_State* L, int x) {
+ return push_popper_n<top_level>(L, x);
+ }
+ } // namespace stack
+
+ inline lua_State* main_thread(lua_State* L, lua_State* backup_if_unsupported = nullptr) {
+#if SOL_LUA_VESION_I_ < 502
+ if (L == nullptr)
+ return backup_if_unsupported;
+ lua_getglobal(L, detail::default_main_thread_name());
+ auto pp = stack::pop_n(L, 1);
+ if (type_of(L, -1) == type::thread) {
+ return lua_tothread(L, -1);
+ }
+ return backup_if_unsupported;
+#else
+ if (L == nullptr)
+ return backup_if_unsupported;
+ lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_MAINTHREAD);
+ lua_State* Lmain = lua_tothread(L, -1);
+ lua_pop(L, 1);
+ return Lmain;
+#endif // Lua 5.2+ has the main thread unqualified_getter
+ }
+
+ namespace detail {
+ struct global_tag {
+ } const global_ {};
+ struct no_safety_tag {
+ } const no_safety {};
+
+ template <bool b>
+ inline lua_State* pick_main_thread(lua_State* L, lua_State* backup_if_unsupported = nullptr) {
+ (void)L;
+ (void)backup_if_unsupported;
+ if (b) {
+ return main_thread(L, backup_if_unsupported);
+ }
+ return L;
+ }
+ } // namespace detail
+
+ class stateless_reference {
+ private:
+ template <bool o_main_only>
+ friend class basic_reference;
+
+ int ref = LUA_NOREF;
+
+ int copy(lua_State* L) const noexcept {
+ if (ref == LUA_NOREF)
+ return LUA_NOREF;
+ push(L);
+ return luaL_ref(L, LUA_REGISTRYINDEX);
+ }
+
+ lua_State* copy_assign(lua_State* L, lua_State* rL, const stateless_reference& r) {
+ if (valid(L)) {
+ deref(L);
+ }
+ ref = r.copy(L);
+ return rL;
+ }
+
+ lua_State* move_assign(lua_State* L, lua_State* rL, stateless_reference&& r) {
+ if (valid(L)) {
+ deref(L);
+ }
+ ref = r.ref;
+ r.ref = LUA_NOREF;
+ return rL;
+ }
+
+ protected:
+ int stack_index() const noexcept {
+ return -1;
+ }
+
+ stateless_reference(lua_State* L, detail::global_tag) noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, "not enough Lua stack space to push this reference value");
+#endif // make sure stack doesn't overflow
+ lua_pushglobaltable(L);
+ ref = luaL_ref(L, LUA_REGISTRYINDEX);
+ }
+
+ stateless_reference(int raw_ref_index) noexcept : ref(raw_ref_index) {
+ }
+
+ public:
+ stateless_reference() noexcept = default;
+ stateless_reference(lua_nil_t) noexcept : stateless_reference() {
+ }
+ stateless_reference(const stack_reference& r) noexcept : stateless_reference(r.lua_state(), r.stack_index()) {
+ }
+ stateless_reference(stack_reference&& r) noexcept : stateless_reference(r.lua_state(), r.stack_index()) {
+ }
+ stateless_reference(lua_State* L, const stateless_reference& r) noexcept {
+ if (r.ref == LUA_REFNIL) {
+ ref = LUA_REFNIL;
+ return;
+ }
+ if (r.ref == LUA_NOREF || L == nullptr) {
+ ref = LUA_NOREF;
+ return;
+ }
+ ref = r.copy(L);
+ }
+
+ stateless_reference(lua_State* L, stateless_reference&& r) noexcept {
+ if (r.ref == LUA_REFNIL) {
+ ref = LUA_REFNIL;
+ return;
+ }
+ if (r.ref == LUA_NOREF || L == nullptr) {
+ ref = LUA_NOREF;
+ return;
+ }
+ ref = r.ref;
+ r.ref = LUA_NOREF;
+ }
+
+ stateless_reference(lua_State* L, const stack_reference& r) noexcept {
+ if (L == nullptr || r.lua_state() == nullptr || r.get_type() == type::none) {
+ ref = LUA_NOREF;
+ return;
+ }
+ if (r.get_type() == type::lua_nil) {
+ ref = LUA_REFNIL;
+ return;
+ }
+ if (L != r.lua_state() && !detail::xmovable(L, r.lua_state())) {
+ return;
+ }
+ r.push(L);
+ ref = luaL_ref(L, LUA_REGISTRYINDEX);
+ }
+
+ stateless_reference(lua_State* L, int index = -1) noexcept {
+ // use L to stick with that state's execution stack
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, "not enough Lua stack space to push this reference value");
+#endif // make sure stack doesn't overflow
+ lua_pushvalue(L, index);
+ ref = luaL_ref(L, LUA_REGISTRYINDEX);
+ }
+ stateless_reference(lua_State* L, ref_index index) noexcept {
+ lua_rawgeti(L, LUA_REGISTRYINDEX, index.index);
+ ref = luaL_ref(L, LUA_REGISTRYINDEX);
+ }
+ stateless_reference(lua_State*, lua_nil_t) noexcept {
+ }
+
+ ~stateless_reference() noexcept = default;
+
+ stateless_reference(const stateless_reference& o) noexcept = delete;
+ stateless_reference& operator=(const stateless_reference& r) noexcept = delete;
+
+ stateless_reference(stateless_reference&& o) noexcept : ref(o.ref) {
+ o.ref = LUA_NOREF;
+ }
+
+ stateless_reference& operator=(stateless_reference&& o) noexcept {
+ ref = o.ref;
+ o.ref = LUA_NOREF;
+ return *this;
+ }
+
+ int push(lua_State* L) const noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, "not enough Lua stack space to push this reference value");
+#endif // make sure stack doesn't overflow
+ lua_rawgeti(L, LUA_REGISTRYINDEX, ref);
+ return 1;
+ }
+
+ void pop(lua_State* L, int n = 1) const noexcept {
+ lua_pop(L, n);
+ }
+
+ int registry_index() const noexcept {
+ return ref;
+ }
+
+ bool valid(lua_State*) const noexcept {
+ return !(ref == LUA_NOREF || ref == LUA_REFNIL);
+ }
+
+ const void* pointer(lua_State* L) const noexcept {
+ int si = push(L);
+ const void* vp = lua_topointer(L, -si);
+ lua_pop(L, si);
+ return vp;
+ }
+
+ type get_type(lua_State* L) const noexcept {
+ int p = push(L);
+ int result = lua_type(L, -1);
+ pop(L, p);
+ return static_cast<type>(result);
+ }
+
+ void abandon(lua_State* = nullptr) {
+ ref = LUA_NOREF;
+ }
+
+ void deref(lua_State* L) const noexcept {
+ luaL_unref(L, LUA_REGISTRYINDEX, ref);
+ }
+ };
+
+ template <bool main_only = false>
+ class basic_reference : public stateless_reference {
+ private:
+ template <bool o_main_only>
+ friend class basic_reference;
+ lua_State* luastate = nullptr; // non-owning
+
+ template <bool r_main_only>
+ void copy_assign(const basic_reference<r_main_only>& r) {
+ if (valid()) {
+ deref();
+ }
+ if (r.ref == LUA_REFNIL) {
+ luastate = detail::pick_main_thread < main_only && !r_main_only > (r.lua_state(), r.lua_state());
+ ref = LUA_REFNIL;
+ return;
+ }
+ if (r.ref == LUA_NOREF) {
+ luastate = r.luastate;
+ ref = LUA_NOREF;
+ return;
+ }
+ if (detail::xmovable(lua_state(), r.lua_state())) {
+ r.push(lua_state());
+ ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
+ return;
+ }
+ luastate = detail::pick_main_thread < main_only && !r_main_only > (r.lua_state(), r.lua_state());
+ ref = r.copy();
+ }
+
+ template <bool r_main_only>
+ void move_assign(basic_reference<r_main_only>&& r) {
+ if (valid()) {
+ deref();
+ }
+ if (r.ref == LUA_REFNIL) {
+ luastate = detail::pick_main_thread < main_only && !r_main_only > (r.lua_state(), r.lua_state());
+ ref = LUA_REFNIL;
+ return;
+ }
+ if (r.ref == LUA_NOREF) {
+ luastate = r.luastate;
+ ref = LUA_NOREF;
+ return;
+ }
+ if (detail::xmovable(lua_state(), r.lua_state())) {
+ r.push(lua_state());
+ ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
+ return;
+ }
+
+ luastate = detail::pick_main_thread < main_only && !r_main_only > (r.lua_state(), r.lua_state());
+ ref = r.ref;
+ r.ref = LUA_NOREF;
+ r.luastate = nullptr;
+ }
+
+ protected:
+ basic_reference(lua_State* L, detail::global_tag) noexcept
+ : basic_reference(detail::pick_main_thread<main_only>(L, L), detail::global_, detail::global_) {
+ }
+
+ basic_reference(lua_State* L, detail::global_tag, detail::global_tag) noexcept : stateless_reference(L, detail::global_), luastate(L) {
+ }
+
+ basic_reference(lua_State* oL, const basic_reference<!main_only>& o) noexcept : stateless_reference(oL, o), luastate(oL) {
+ }
+
+ void deref() const noexcept {
+ return stateless_reference::deref(lua_state());
+ }
+
+ int copy() const noexcept {
+ return copy(lua_state());
+ }
+
+ int copy(lua_State* L) const noexcept {
+ return stateless_reference::copy(L);
+ }
+
+ public:
+ basic_reference() noexcept = default;
+ basic_reference(lua_nil_t) noexcept : basic_reference() {
+ }
+ basic_reference(const stack_reference& r) noexcept : basic_reference(r.lua_state(), r.stack_index()) {
+ }
+ basic_reference(stack_reference&& r) noexcept : basic_reference(r.lua_state(), r.stack_index()) {
+ }
+ template <bool r_main_only>
+ basic_reference(lua_State* L, const basic_reference<r_main_only>& r) noexcept : luastate(detail::pick_main_thread<main_only>(L, L)) {
+ if (r.ref == LUA_REFNIL) {
+ ref = LUA_REFNIL;
+ return;
+ }
+ if (r.ref == LUA_NOREF || lua_state() == nullptr) {
+ ref = LUA_NOREF;
+ return;
+ }
+ if (detail::xmovable(lua_state(), r.lua_state())) {
+ r.push(lua_state());
+ ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
+ return;
+ }
+ ref = r.copy();
+ }
+
+ template <bool r_main_only>
+ basic_reference(lua_State* L, basic_reference<r_main_only>&& r) noexcept : luastate(detail::pick_main_thread<main_only>(L, L)) {
+ if (r.ref == LUA_REFNIL) {
+ ref = LUA_REFNIL;
+ return;
+ }
+ if (r.ref == LUA_NOREF || lua_state() == nullptr) {
+ ref = LUA_NOREF;
+ return;
+ }
+ if (detail::xmovable(lua_state(), r.lua_state())) {
+ r.push(lua_state());
+ ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
+ return;
+ }
+ ref = r.ref;
+ r.ref = LUA_NOREF;
+ r.luastate = nullptr;
+ }
+
+ basic_reference(lua_State* L, const stack_reference& r) noexcept : luastate(detail::pick_main_thread<main_only>(L, L)) {
+ if (lua_state() == nullptr || r.lua_state() == nullptr || r.get_type() == type::none) {
+ ref = LUA_NOREF;
+ return;
+ }
+ if (r.get_type() == type::lua_nil) {
+ ref = LUA_REFNIL;
+ return;
+ }
+ if (lua_state() != r.lua_state() && !detail::xmovable(lua_state(), r.lua_state())) {
+ return;
+ }
+ r.push(lua_state());
+ ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
+ }
+ 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
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, "not enough Lua stack space to push this reference value");
+#endif // make sure stack doesn't overflow
+ lua_pushvalue(L, index);
+ ref = luaL_ref(L, LUA_REGISTRYINDEX);
+ }
+ basic_reference(lua_State* L, ref_index index) noexcept : luastate(detail::pick_main_thread<main_only>(L, L)) {
+ lua_rawgeti(lua_state(), LUA_REGISTRYINDEX, index.index);
+ ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
+ }
+ basic_reference(lua_State* L, lua_nil_t) noexcept : luastate(detail::pick_main_thread<main_only>(L, L)) {
+ }
+
+ ~basic_reference() noexcept {
+ if (lua_state() == nullptr || ref == LUA_NOREF)
+ return;
+ deref();
+ }
+
+ basic_reference(const basic_reference& o) noexcept : stateless_reference(o.copy()), luastate(o.lua_state()) {
+ }
+
+ basic_reference(basic_reference&& o) noexcept : stateless_reference(std::move(o)), luastate(o.lua_state()) {
+ o.luastate = nullptr;
+ }
+
+ basic_reference(const basic_reference<!main_only>& o) noexcept
+ : basic_reference(detail::pick_main_thread<main_only>(o.lua_state(), o.lua_state()), o) {
+ }
+
+ basic_reference(basic_reference<!main_only>&& o) noexcept
+ : stateless_reference(std::move(o)), luastate(detail::pick_main_thread<main_only>(o.lua_state(), o.lua_state())) {
+ o.luastate = nullptr;
+ o.ref = LUA_NOREF;
+ }
+
+ basic_reference& operator=(basic_reference&& r) noexcept {
+ move_assign(std::move(r));
+ return *this;
+ }
+
+ basic_reference& operator=(const basic_reference& r) noexcept {
+ copy_assign(r);
+ return *this;
+ }
+
+ basic_reference& operator=(basic_reference<!main_only>&& r) noexcept {
+ move_assign(std::move(r));
+ return *this;
+ }
+
+ basic_reference& operator=(const basic_reference<!main_only>& r) noexcept {
+ copy_assign(r);
+ return *this;
+ }
+
+ basic_reference& operator=(const lua_nil_t&) noexcept {
+ if (valid()) {
+ deref();
+ }
+ luastate = nullptr;
+ ref = LUA_NOREF;
+ return *this;
+ }
+
+ template <typename Super>
+ basic_reference& operator=(proxy_base<Super>&& r);
+
+ template <typename Super>
+ basic_reference& operator=(const proxy_base<Super>& r);
+
+ int push() const noexcept {
+ return push(lua_state());
+ }
+
+ int push(lua_State* L) const noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, "not enough Lua stack space to push this reference value");
+#endif // make sure stack doesn't overflow
+ if (lua_state() == nullptr) {
+ lua_pushnil(L);
+ return 1;
+ }
+ lua_rawgeti(lua_state(), LUA_REGISTRYINDEX, ref);
+ if (L != lua_state()) {
+ lua_xmove(lua_state(), L, 1);
+ }
+ return 1;
+ }
+
+ void pop() const noexcept {
+ pop(lua_state());
+ }
+
+ void pop(lua_State* L, int n = 1) const noexcept {
+ stateless_reference::pop(L, n);
+ }
+
+ int registry_index() const noexcept {
+ return stateless_reference::registry_index();
+ }
+
+ bool valid() const noexcept {
+ return stateless_reference::valid(lua_state());
+ }
+
+ const void* pointer() const noexcept {
+ return stateless_reference::pointer(lua_state());
+ }
+
+ explicit operator bool() const noexcept {
+ return valid();
+ }
+
+ type get_type() const noexcept {
+ return stateless_reference::get_type(lua_state());
+ }
+
+ lua_State* lua_state() const noexcept {
+ return luastate;
+ }
+ };
+
+ template <bool lb, bool rb>
+ inline bool operator==(const basic_reference<lb>& l, const basic_reference<rb>& r) {
+ auto ppl = stack::push_pop(l);
+ auto ppr = stack::push_pop(r);
+ return lua_compare(l.lua_state(), -1, -2, LUA_OPEQ) == 1;
+ }
+
+ template <bool lb, bool rb>
+ inline bool operator!=(const basic_reference<lb>& l, const basic_reference<rb>& r) {
+ return !operator==(l, r);
+ }
+
+ template <bool lb>
+ inline bool operator==(const basic_reference<lb>& l, const stack_reference& r) {
+ auto ppl = stack::push_pop(l);
+ return lua_compare(l.lua_state(), -1, r.stack_index(), LUA_OPEQ) == 1;
+ }
+
+ template <bool lb>
+ inline bool operator!=(const basic_reference<lb>& l, const stack_reference& r) {
+ return !operator==(l, r);
+ }
+
+ template <bool rb>
+ inline bool operator==(const stack_reference& l, const basic_reference<rb>& r) {
+ auto ppr = stack::push_pop(r);
+ return lua_compare(l.lua_state(), -1, r.stack_index(), LUA_OPEQ) == 1;
+ }
+
+ template <bool rb>
+ inline bool operator!=(const stack_reference& l, const basic_reference<rb>& r) {
+ return !operator==(l, r);
+ }
+
+ template <bool lb>
+ inline bool operator==(const basic_reference<lb>& lhs, const lua_nil_t&) {
+ return !lhs.valid();
+ }
+
+ template <bool rb>
+ inline bool operator==(const lua_nil_t&, const basic_reference<rb>& rhs) {
+ return !rhs.valid();
+ }
+
+ template <bool lb>
+ inline bool operator!=(const basic_reference<lb>& lhs, const lua_nil_t&) {
+ return lhs.valid();
+ }
+
+ template <bool rb>
+ inline bool operator!=(const lua_nil_t&, const basic_reference<rb>& rhs) {
+ return rhs.valid();
+ }
+
+ struct reference_equals : public stack_reference_equals {
+ template <bool rb>
+ bool operator()(const lua_nil_t& lhs, const basic_reference<rb>& rhs) const {
+ return lhs == rhs;
+ }
+
+ template <bool lb>
+ bool operator()(const basic_reference<lb>& lhs, const lua_nil_t& rhs) const {
+ return lhs == rhs;
+ }
+
+ template <bool lb, bool rb>
+ bool operator()(const basic_reference<lb>& lhs, const basic_reference<rb>& rhs) const {
+ return lhs == rhs;
+ }
+
+ template <bool lb>
+ bool operator()(const basic_reference<lb>& lhs, const stack_reference& rhs) const {
+ return lhs == rhs;
+ }
+
+ template <bool rb>
+ bool operator()(const stack_reference& lhs, const basic_reference<rb>& rhs) const {
+ return lhs == rhs;
+ }
+ };
+
+ struct reference_hash : public stack_reference_hash {
+ typedef reference argument_type;
+ typedef std::size_t result_type;
+
+ template <bool lb>
+ result_type operator()(const basic_reference<lb>& lhs) const {
+ std::hash<const void*> h;
+ return h(lhs.pointer());
+ }
+ };
+} // namespace sol
+
+// end of sol/reference.hpp
+
+// beginning of sol/tie.hpp
+
+namespace sol {
+
+ namespace detail {
+ template <typename T>
+ struct is_speshul : std::false_type {};
+ } // namespace detail
+
+ template <typename T>
+ struct tie_size : std::tuple_size<T> {};
+
+ template <typename T>
+ struct is_tieable : std::integral_constant<bool, (::sol::tie_size<T>::value > 0)> {};
+
+ template <typename... Tn>
+ struct tie_t : public std::tuple<std::add_lvalue_reference_t<Tn>...> {
+ private:
+ typedef std::tuple<std::add_lvalue_reference_t<Tn>...> base_t;
+
+ template <typename T>
+ void set(std::false_type, T&& target) {
+ std::get<0>(*this) = std::forward<T>(target);
+ }
+
+ template <typename T>
+ void set(std::true_type, T&& target) {
+ typedef tie_size<meta::unqualified_t<T>> value_size;
+ typedef tie_size<std::tuple<Tn...>> tie_size;
+ typedef meta::conditional_t<(value_size::value < tie_size::value), value_size, tie_size> indices_size;
+ typedef std::make_index_sequence<indices_size::value> indices;
+ set_extra(detail::is_speshul<meta::unqualified_t<T>>(), indices(), std::forward<T>(target));
+ }
+
+ template <std::size_t... I, typename T>
+ void set_extra(std::true_type, std::index_sequence<I...>, T&& target) {
+ using std::get;
+ (void)detail::swallow{0,
+ (get<I>(static_cast<base_t&>(*this)) = get<I>(types<Tn...>(), target), 0)..., 0};
+ }
+
+ template <std::size_t... I, typename T>
+ void set_extra(std::false_type, std::index_sequence<I...>, T&& target) {
+ using std::get;
+ (void)detail::swallow{0,
+ (get<I>(static_cast<base_t&>(*this)) = get<I>(target), 0)..., 0};
+ }
+
+ public:
+ using base_t::base_t;
+
+ template <typename T>
+ tie_t& operator=(T&& value) {
+ typedef is_tieable<meta::unqualified_t<T>> tieable;
+ set(tieable(), std::forward<T>(value));
+ return *this;
+ }
+ };
+
+ template <typename... Tn>
+ struct tie_size<tie_t<Tn...>> : std::tuple_size<std::tuple<Tn...>> {};
+
+ namespace adl_barrier_detail {
+ template <typename... Tn>
+ inline tie_t<std::remove_reference_t<Tn>...> tie(Tn&&... argn) {
+ return tie_t<std::remove_reference_t<Tn>...>(std::forward<Tn>(argn)...);
+ }
+ } // namespace adl_barrier_detail
+
+ using namespace adl_barrier_detail;
+
+} // namespace sol
+
+// end of sol/tie.hpp
+
+// beginning of sol/stack_guard.hpp
+
+#include <functional>
+
+namespace sol {
+ namespace detail {
+ inline void stack_fail(int, int) {
+#if !(defined(SOL_NO_EXCEPTIONS) && SOL_NO_EXCEPTIONS)
+ throw error(detail::direct_error, "imbalanced stack after operation finish");
+#else
+ // Lol, what do you want, an error printout? :3c
+ // There's no sane default here. The right way would be C-style abort(), and that's not acceptable, so
+ // hopefully someone will register their own stack_fail thing for the `fx` parameter of stack_guard.
+#endif // No Exceptions
+ }
+ } // namespace detail
+
+ struct stack_guard {
+ lua_State* L;
+ int top;
+ std::function<void(int, int)> on_mismatch;
+
+ stack_guard(lua_State* L) : stack_guard(L, lua_gettop(L)) {
+ }
+ stack_guard(lua_State* L, int top, std::function<void(int, int)> fx = detail::stack_fail) : L(L), top(top), on_mismatch(std::move(fx)) {
+ }
+ bool check_stack(int modification = 0) const {
+ int bottom = lua_gettop(L) + modification;
+ if (top == bottom) {
+ return true;
+ }
+ on_mismatch(top, bottom);
+ return false;
+ }
+ ~stack_guard() {
+ check_stack();
+ }
+ };
+} // namespace sol
+
+// end of sol/stack_guard.hpp
+
+#include <vector>
+#include <bitset>
+#include <forward_list>
+#include <string>
+#include <algorithm>
+#include <sstream>
+#include <optional>
+
+namespace sol {
+ namespace detail {
+ struct with_function_tag { };
+ struct as_reference_tag { };
+ template <typename T>
+ struct as_pointer_tag { };
+ template <typename T>
+ struct as_value_tag { };
+ template <typename T>
+ struct as_unique_tag { };
+ template <typename T>
+ struct as_table_tag { };
+
+ using lua_reg_table = luaL_Reg[64];
+
+ using unique_destructor = void (*)(void*);
+ using unique_tag = detail::inheritance_unique_cast_function;
+
+ inline void* align(std::size_t alignment, std::size_t size, void*& ptr, std::size_t& space, std::size_t& required_space) {
+ // this handels arbitrary alignments...
+ // make this into a power-of-2-only?
+ // actually can't: this is a C++14-compatible framework,
+ // power of 2 alignment is C++17
+ std::uintptr_t initial = reinterpret_cast<std::uintptr_t>(ptr);
+ std::uintptr_t offby = static_cast<std::uintptr_t>(initial % alignment);
+ std::uintptr_t padding = (alignment - offby) % alignment;
+ required_space += size + padding;
+ if (space < required_space) {
+ return nullptr;
+ }
+ ptr = static_cast<void*>(static_cast<char*>(ptr) + padding);
+ space -= padding;
+ return ptr;
+ }
+
+ inline void* align(std::size_t alignment, std::size_t size, void*& ptr, std::size_t& space) {
+ std::size_t required_space = 0;
+ return align(alignment, size, ptr, space, required_space);
+ }
+
+ inline void align_one(std::size_t a, std::size_t s, void*& target_alignment) {
+ std::size_t space = (std::numeric_limits<std::size_t>::max)();
+ target_alignment = align(a, s, target_alignment, space);
+ target_alignment = static_cast<void*>(static_cast<char*>(target_alignment) + s);
+ }
+
+ template <typename... Args>
+ std::size_t aligned_space_for(void* alignment = nullptr) {
+ // use temporary storage to prevent strict UB shenanigans
+ char alignment_shim[(std::max)({ sizeof(Args)... }) + (std::max)({ alignof(Args)... })] {};
+ char* start = alignment == nullptr ? static_cast<char*>(alignment) : alignment_shim;
+ (void)detail::swallow { int {}, (align_one(std::alignment_of_v<Args>, sizeof(Args), alignment), int {})... };
+ return static_cast<char*>(alignment) - start;
+ }
+
+ inline void* align_usertype_pointer(void* ptr) {
+ using use_align = std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY_I_)
+ false
+#else
+ (std::alignment_of<void*>::value > 1)
+#endif
+ >;
+ if (!use_align::value) {
+ return ptr;
+ }
+ std::size_t space = (std::numeric_limits<std::size_t>::max)();
+ return align(std::alignment_of<void*>::value, sizeof(void*), ptr, space);
+ }
+
+ template <bool pre_aligned = false, bool pre_shifted = false>
+ void* align_usertype_unique_destructor(void* ptr) {
+ using use_align = std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY_I_)
+ false
+#else
+ (std::alignment_of<unique_destructor>::value > 1)
+#endif
+ >;
+ if (!pre_aligned) {
+ ptr = align_usertype_pointer(ptr);
+ }
+ if (!pre_shifted) {
+ ptr = static_cast<void*>(static_cast<char*>(ptr) + sizeof(void*));
+ }
+ if (!use_align::value) {
+ return static_cast<void*>(static_cast<void**>(ptr) + 1);
+ }
+ std::size_t space = (std::numeric_limits<std::size_t>::max)();
+ return align(std::alignment_of<unique_destructor>::value, sizeof(unique_destructor), ptr, space);
+ }
+
+ template <bool pre_aligned = false, bool pre_shifted = false>
+ void* align_usertype_unique_tag(void* ptr) {
+ using use_align = std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY_I_)
+ false
+#else
+ (std::alignment_of<unique_tag>::value > 1)
+#endif
+ >;
+ if (!pre_aligned) {
+ ptr = align_usertype_unique_destructor(ptr);
+ }
+ if (!pre_shifted) {
+ ptr = static_cast<void*>(static_cast<char*>(ptr) + sizeof(unique_destructor));
+ }
+ if (!use_align::value) {
+ return ptr;
+ }
+ std::size_t space = (std::numeric_limits<std::size_t>::max)();
+ return align(std::alignment_of<unique_tag>::value, sizeof(unique_tag), ptr, space);
+ }
+
+ template <typename T, bool pre_aligned = false, bool pre_shifted = false>
+ void* align_usertype_unique(void* ptr) {
+ typedef std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY_I_)
+ false
+#else
+ (std::alignment_of_v<T> > 1)
+#endif
+ >
+ use_align;
+ if (!pre_aligned) {
+ ptr = align_usertype_unique_tag(ptr);
+ }
+ if (!pre_shifted) {
+ ptr = static_cast<void*>(static_cast<char*>(ptr) + sizeof(unique_tag));
+ }
+ if (!use_align::value) {
+ return ptr;
+ }
+ std::size_t space = (std::numeric_limits<std::size_t>::max)();
+ return align(std::alignment_of_v<T>, sizeof(T), ptr, space);
+ }
+
+ template <typename T>
+ void* align_user(void* ptr) {
+ typedef std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY_I_)
+ false
+#else
+ (std::alignment_of_v<T> > 1)
+#endif
+ >
+ use_align;
+ if (!use_align::value) {
+ return ptr;
+ }
+ std::size_t space = (std::numeric_limits<std::size_t>::max)();
+ return align(std::alignment_of_v<T>, sizeof(T), ptr, space);
+ }
+
+ template <typename T>
+ T** usertype_allocate_pointer(lua_State* L) {
+ typedef std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY_I_)
+ false
+#else
+ (std::alignment_of<T*>::value > 1)
+#endif
+ >
+ use_align;
+ if (!use_align::value) {
+ T** pointerpointer = static_cast<T**>(lua_newuserdata(L, sizeof(T*)));
+ return pointerpointer;
+ }
+ static const std::size_t initial_size = aligned_space_for<T*>(nullptr);
+ static const std::size_t misaligned_size = aligned_space_for<T*>(reinterpret_cast<void*>(0x1));
+
+ std::size_t allocated_size = initial_size;
+ void* unadjusted = lua_newuserdata(L, initial_size);
+ void* adjusted = align(std::alignment_of<T*>::value, sizeof(T*), unadjusted, allocated_size);
+ if (adjusted == nullptr) {
+ lua_pop(L, 1);
+ // what kind of absolute garbage trash allocator are we dealing with?
+ // whatever, add some padding in the case of MAXIMAL alignment waste...
+ allocated_size = misaligned_size;
+ unadjusted = lua_newuserdata(L, allocated_size);
+ adjusted = align(std::alignment_of<T*>::value, sizeof(T*), unadjusted, allocated_size);
+ if (adjusted == nullptr) {
+ // trash allocator can burn in hell
+ lua_pop(L, 1);
+ // luaL_error(L, "if you are the one that wrote this allocator you should feel bad for doing a
+ // worse job than malloc/realloc and should go read some books, yeah?");
+ luaL_error(L, "cannot properly align memory for '%s'", detail::demangle<T*>().data());
+ }
+ }
+ return static_cast<T**>(adjusted);
+ }
+
+ inline bool attempt_alloc(lua_State* L, std::size_t ptr_align, std::size_t ptr_size, std::size_t value_align, std::size_t value_size,
+ std::size_t allocated_size, void*& pointer_adjusted, void*& data_adjusted) {
+ void* adjusted = lua_newuserdata(L, allocated_size);
+ pointer_adjusted = align(ptr_align, ptr_size, adjusted, allocated_size);
+ if (pointer_adjusted == nullptr) {
+ lua_pop(L, 1);
+ return false;
+ }
+ // subtract size of what we're going to allocate there
+ allocated_size -= ptr_size;
+ adjusted = static_cast<void*>(static_cast<char*>(pointer_adjusted) + ptr_size);
+ data_adjusted = align(value_align, value_size, adjusted, allocated_size);
+ if (data_adjusted == nullptr) {
+ lua_pop(L, 1);
+ return false;
+ }
+ return true;
+ }
+
+ inline bool attempt_alloc_unique(lua_State* L, std::size_t ptr_align, std::size_t ptr_size, std::size_t real_align, std::size_t real_size,
+ std::size_t allocated_size, void*& pointer_adjusted, void*& dx_adjusted, void*& id_adjusted, void*& data_adjusted) {
+ void* adjusted = lua_newuserdata(L, allocated_size);
+ pointer_adjusted = align(ptr_align, ptr_size, adjusted, allocated_size);
+ if (pointer_adjusted == nullptr) {
+ lua_pop(L, 1);
+ return false;
+ }
+ allocated_size -= ptr_size;
+
+ adjusted = static_cast<void*>(static_cast<char*>(pointer_adjusted) + ptr_size);
+ dx_adjusted = align(std::alignment_of_v<unique_destructor>, sizeof(unique_destructor), adjusted, allocated_size);
+ if (dx_adjusted == nullptr) {
+ lua_pop(L, 1);
+ return false;
+ }
+ allocated_size -= sizeof(unique_destructor);
+
+ adjusted = static_cast<void*>(static_cast<char*>(dx_adjusted) + sizeof(unique_destructor));
+
+ id_adjusted = align(std::alignment_of_v<unique_tag>, sizeof(unique_tag), adjusted, allocated_size);
+ if (id_adjusted == nullptr) {
+ lua_pop(L, 1);
+ return false;
+ }
+ allocated_size -= sizeof(unique_tag);
+
+ adjusted = static_cast<void*>(static_cast<char*>(id_adjusted) + sizeof(unique_tag));
+ data_adjusted = align(real_align, real_size, adjusted, allocated_size);
+ if (data_adjusted == nullptr) {
+ lua_pop(L, 1);
+ return false;
+ }
+ return true;
+ }
+
+ template <typename T>
+ T* usertype_allocate(lua_State* L) {
+ typedef std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY_I_)
+ false
+#else
+ (std::alignment_of<T*>::value > 1 || std::alignment_of_v<T> > 1)
+#endif
+ >
+ use_align;
+ if (!use_align::value) {
+ T** pointerpointer = static_cast<T**>(lua_newuserdata(L, sizeof(T*) + sizeof(T)));
+ T*& pointerreference = *pointerpointer;
+ T* allocationtarget = reinterpret_cast<T*>(pointerpointer + 1);
+ pointerreference = allocationtarget;
+ return allocationtarget;
+ }
+
+ /* the assumption is that `lua_newuserdata` -- unless someone
+ passes a specific lua_Alloc that gives us bogus, un-aligned pointers
+ -- uses malloc, which tends to hand out more or less aligned pointers to memory
+ (most of the time, anyhow)
+
+ but it's not guaranteed, so we have to do a post-adjustment check and increase padding
+
+ we do this preliminarily with compile-time stuff, to see
+ if we strike lucky with the allocator and alignment values
+
+ otherwise, we have to re-allocate the userdata and
+ over-allocate some space for additional padding because
+ compilers are optimized for aligned reads/writes
+ (and clang will barf UBsan errors on us for not being aligned)
+ */
+ static const std::size_t initial_size = aligned_space_for<T*, T>(nullptr);
+ static const std::size_t misaligned_size = aligned_space_for<T*, T>(reinterpret_cast<void*>(0x1));
+
+ void* pointer_adjusted;
+ void* data_adjusted;
+ bool result
+ = attempt_alloc(L, std::alignment_of_v<T*>, sizeof(T*), std::alignment_of_v<T>, sizeof(T), initial_size, pointer_adjusted, data_adjusted);
+ if (!result) {
+ // we're likely to get something that fails to perform the proper allocation a second time,
+ // so we use the suggested_new_size bump to help us out here
+ pointer_adjusted = nullptr;
+ data_adjusted = nullptr;
+ result = attempt_alloc(
+ L, std::alignment_of_v<T*>, sizeof(T*), std::alignment_of_v<T>, sizeof(T), misaligned_size, pointer_adjusted, data_adjusted);
+ if (!result) {
+ if (pointer_adjusted == nullptr) {
+ luaL_error(L, "aligned allocation of userdata block (pointer section) for '%s' failed", detail::demangle<T>().c_str());
+ }
+ else {
+ luaL_error(L, "aligned allocation of userdata block (data section) for '%s' failed", detail::demangle<T>().c_str());
+ }
+ return nullptr;
+ }
+ }
+
+ T** pointerpointer = reinterpret_cast<T**>(pointer_adjusted);
+ T*& pointerreference = *pointerpointer;
+ T* allocationtarget = reinterpret_cast<T*>(data_adjusted);
+ pointerreference = allocationtarget;
+ return allocationtarget;
+ }
+
+ template <typename T, typename Real>
+ Real* usertype_unique_allocate(lua_State* L, T**& pref, unique_destructor*& dx, unique_tag*& id) {
+ typedef std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY_I_)
+ false
+#else
+ (std::alignment_of<T*>::value > 1 || std::alignment_of<unique_tag>::value > 1 || std::alignment_of<unique_destructor>::value > 1
+ || std::alignment_of<Real>::value > 1)
+#endif
+ >
+ use_align;
+ if (!use_align::value) {
+ pref = static_cast<T**>(lua_newuserdata(L, sizeof(T*) + sizeof(detail::unique_destructor) + sizeof(unique_tag) + sizeof(Real)));
+ dx = static_cast<detail::unique_destructor*>(static_cast<void*>(pref + 1));
+ id = static_cast<unique_tag*>(static_cast<void*>(dx + 1));
+ Real* mem = static_cast<Real*>(static_cast<void*>(id + 1));
+ return mem;
+ }
+
+ static const std::size_t initial_size = aligned_space_for<T*, unique_destructor, unique_tag, Real>(nullptr);
+ static const std::size_t misaligned_size = aligned_space_for<T*, unique_destructor, unique_tag, Real>(reinterpret_cast<void*>(0x1));
+
+ void* pointer_adjusted;
+ void* dx_adjusted;
+ void* id_adjusted;
+ void* data_adjusted;
+ bool result = attempt_alloc_unique(L,
+ std::alignment_of_v<T*>,
+ sizeof(T*),
+ std::alignment_of_v<Real>,
+ sizeof(Real),
+ initial_size,
+ pointer_adjusted,
+ dx_adjusted,
+ id_adjusted,
+ data_adjusted);
+ if (!result) {
+ // we're likely to get something that fails to perform the proper allocation a second time,
+ // so we use the suggested_new_size bump to help us out here
+ pointer_adjusted = nullptr;
+ dx_adjusted = nullptr;
+ id_adjusted = nullptr;
+ data_adjusted = nullptr;
+ result = attempt_alloc_unique(L,
+ std::alignment_of_v<T*>,
+ sizeof(T*),
+ std::alignment_of_v<Real>,
+ sizeof(Real),
+ misaligned_size,
+ pointer_adjusted,
+ dx_adjusted,
+ id_adjusted,
+ data_adjusted);
+ if (!result) {
+ if (pointer_adjusted == nullptr) {
+ luaL_error(L, "aligned allocation of userdata block (pointer section) for '%s' failed", detail::demangle<T>().c_str());
+ }
+ else if (dx_adjusted == nullptr) {
+ luaL_error(L, "aligned allocation of userdata block (deleter section) for '%s' failed", detail::demangle<T>().c_str());
+ }
+ else {
+ luaL_error(L, "aligned allocation of userdata block (data section) for '%s' failed", detail::demangle<T>().c_str());
+ }
+ return nullptr;
+ }
+ }
+
+ pref = static_cast<T**>(pointer_adjusted);
+ dx = static_cast<detail::unique_destructor*>(dx_adjusted);
+ id = static_cast<unique_tag*>(id_adjusted);
+ Real* mem = static_cast<Real*>(data_adjusted);
+ return mem;
+ }
+
+ template <typename T>
+ T* user_allocate(lua_State* L) {
+ typedef std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY_I_)
+ false
+#else
+ (std::alignment_of_v<T> > 1)
+#endif
+ >
+ use_align;
+ if (!use_align::value) {
+ T* pointer = static_cast<T*>(lua_newuserdata(L, sizeof(T)));
+ return pointer;
+ }
+
+ static const std::size_t initial_size = aligned_space_for<T>(nullptr);
+ static const std::size_t misaligned_size = aligned_space_for<T>(reinterpret_cast<void*>(0x1));
+
+ std::size_t allocated_size = initial_size;
+ void* unadjusted = lua_newuserdata(L, allocated_size);
+ void* adjusted = align(std::alignment_of_v<T>, sizeof(T), unadjusted, allocated_size);
+ if (adjusted == nullptr) {
+ lua_pop(L, 1);
+ // try again, add extra space for alignment padding
+ allocated_size = misaligned_size;
+ unadjusted = lua_newuserdata(L, allocated_size);
+ adjusted = align(std::alignment_of_v<T>, sizeof(T), unadjusted, allocated_size);
+ if (adjusted == nullptr) {
+ lua_pop(L, 1);
+ luaL_error(L, "cannot properly align memory for '%s'", detail::demangle<T>().data());
+ }
+ }
+ return static_cast<T*>(adjusted);
+ }
+
+ template <typename T>
+ int usertype_alloc_destruct(lua_State* L) {
+ void* memory = lua_touserdata(L, 1);
+ memory = align_usertype_pointer(memory);
+ T** pdata = static_cast<T**>(memory);
+ T* data = *pdata;
+ std::allocator<T> alloc {};
+ std::allocator_traits<std::allocator<T>>::destroy(alloc, data);
+ return 0;
+ }
+
+ template <typename T>
+ int unique_destruct(lua_State* L) {
+ void* memory = lua_touserdata(L, 1);
+ memory = align_usertype_unique_destructor(memory);
+ unique_destructor& dx = *static_cast<unique_destructor*>(memory);
+ memory = align_usertype_unique_tag<true>(memory);
+ (dx)(memory);
+ return 0;
+ }
+
+ template <typename T>
+ int user_alloc_destruct(lua_State* L) {
+ void* memory = lua_touserdata(L, 1);
+ memory = align_user<T>(memory);
+ T* data = static_cast<T*>(memory);
+ std::allocator<T> alloc;
+ std::allocator_traits<std::allocator<T>>::destroy(alloc, data);
+ return 0;
+ }
+
+ template <typename T, typename Real>
+ void usertype_unique_alloc_destroy(void* memory) {
+ memory = align_usertype_unique<Real, true>(memory);
+ Real* target = static_cast<Real*>(memory);
+ std::allocator<Real> alloc;
+ std::allocator_traits<std::allocator<Real>>::destroy(alloc, target);
+ }
+
+ template <typename T>
+ int cannot_destruct(lua_State* L) {
+ return luaL_error(L,
+ "cannot call the destructor for '%s': it is either hidden (protected/private) or removed with '= "
+ "delete' and thusly this type is being destroyed without properly destructing, invoking undefined "
+ "behavior: please bind a usertype and specify a custom destructor to define the behavior properly",
+ detail::demangle<T>().data());
+ }
+
+ template <typename T>
+ void reserve(T&, std::size_t) {
+ }
+
+ template <typename T, typename Al>
+ void reserve(std::vector<T, Al>& vec, std::size_t hint) {
+ vec.reserve(hint);
+ }
+
+ template <typename T, typename Tr, typename Al>
+ void reserve(std::basic_string<T, Tr, Al>& str, std::size_t hint) {
+ str.reserve(hint);
+ }
+
+ inline bool property_always_true(meta_function) {
+ return true;
+ }
+
+ struct properties_enrollment_allowed {
+ int& times_through;
+ std::bitset<64>& properties;
+ automagic_enrollments& enrollments;
+
+ properties_enrollment_allowed(int& times, std::bitset<64>& props, automagic_enrollments& enroll)
+ : times_through(times), properties(props), enrollments(enroll) {
+ }
+
+ bool operator()(meta_function mf) const {
+ bool p = properties[static_cast<int>(mf)];
+ if (times_through > 0) {
+ return p;
+ }
+ switch (mf) {
+ case meta_function::length:
+ return enrollments.length_operator && !p;
+ case meta_function::pairs:
+ return enrollments.pairs_operator && !p;
+ case meta_function::call:
+ return enrollments.call_operator && !p;
+ case meta_function::less_than:
+ return enrollments.less_than_operator && !p;
+ case meta_function::less_than_or_equal_to:
+ return enrollments.less_than_or_equal_to_operator && !p;
+ case meta_function::equal_to:
+ return enrollments.equal_to_operator && !p;
+ default:
+ break;
+ }
+ return !p;
+ }
+ };
+
+ struct indexed_insert {
+ lua_reg_table& l;
+ int& index;
+
+ indexed_insert(lua_reg_table& cont, int& idx) : l(cont), index(idx) {
+ }
+ void operator()(meta_function mf, lua_CFunction f) {
+ l[index] = luaL_Reg { to_string(mf).c_str(), f };
+ ++index;
+ }
+ };
+ } // namespace detail
+
+ namespace stack {
+
+ template <typename T, bool global = false, bool raw = false, typename = void>
+ struct field_getter;
+ template <typename T, typename P, bool global = false, bool raw = false, typename = void>
+ struct probe_field_getter;
+
+ template <typename T, bool global = false, bool raw = false, typename = void>
+ struct field_setter;
+
+ template <typename T, typename = void>
+ struct unqualified_getter;
+ template <typename T, typename = void>
+ struct qualified_getter;
+
+ template <typename T, typename = void>
+ struct qualified_interop_getter;
+ template <typename T, typename = void>
+ struct unqualified_interop_getter;
+
+ template <typename T, typename = void>
+ struct popper;
+
+ template <typename T, typename = void>
+ struct unqualified_pusher;
+
+ template <typename T, type t, typename = void>
+ struct unqualified_checker;
+ template <typename T, type t, typename = void>
+ struct qualified_checker;
+
+ template <typename T, typename = void>
+ struct unqualified_check_getter;
+ template <typename T, typename = void>
+ struct qualified_check_getter;
+
+ struct probe {
+ bool success;
+ int levels;
+
+ probe(bool s, int l) : success(s), levels(l) {
+ }
+
+ operator bool() const {
+ return success;
+ };
+ };
+
+ struct record {
+ int last;
+ int used;
+
+ record() noexcept : last(), used() {
+ }
+ void use(int count) noexcept {
+ last = count;
+ used += count;
+ }
+ };
+
+ namespace stack_detail {
+ template <typename Function>
+ Function* get_function_pointer(lua_State*, int, record&) noexcept;
+ template <typename Function, typename Handler>
+ bool check_function_pointer(lua_State* L, int index, Handler&& handler, record& tracking) noexcept;
+ } // namespace stack_detail
+
+ } // namespace stack
+
+ namespace meta { namespace meta_detail {
+
+ template <typename T>
+ using adl_sol_lua_get_test_t = decltype(sol_lua_get(types<T>(), static_cast<lua_State*>(nullptr), -1, std::declval<stack::record&>()));
+
+ template <typename T>
+ using adl_sol_lua_interop_get_test_t
+ = decltype(sol_lua_interop_get(types<T>(), static_cast<lua_State*>(nullptr), -1, static_cast<void*>(nullptr), std::declval<stack::record&>()));
+
+ template <typename T>
+ using adl_sol_lua_check_test_t = decltype(sol_lua_check(types<T>(), static_cast<lua_State*>(nullptr), -1, no_panic, std::declval<stack::record&>()));
+
+ template <typename T>
+ using adl_sol_lua_interop_check_test_t
+ = decltype(sol_lua_interop_check(types<T>(), static_cast<lua_State*>(nullptr), -1, type::none, no_panic, std::declval<stack::record&>()));
+
+ template <typename T>
+ using adl_sol_lua_check_get_test_t
+ = decltype(sol_lua_check_get(types<T>(), static_cast<lua_State*>(nullptr), -1, no_panic, std::declval<stack::record&>()));
+
+ template <typename... Args>
+ using adl_sol_lua_push_test_t = decltype(sol_lua_push(static_cast<lua_State*>(nullptr), std::declval<Args>()...));
+
+ template <typename T, typename... Args>
+ using adl_sol_lua_push_exact_test_t = decltype(sol_lua_push(types<T>(), static_cast<lua_State*>(nullptr), std::declval<Args>()...));
+
+ template <typename T>
+ inline constexpr bool is_adl_sol_lua_get_v = meta::is_detected_v<adl_sol_lua_get_test_t, T>;
+
+ template <typename T>
+ inline constexpr bool is_adl_sol_lua_interop_get_v = meta::is_detected_v<adl_sol_lua_interop_get_test_t, T>;
+
+ template <typename T>
+ inline constexpr bool is_adl_sol_lua_check_v = meta::is_detected_v<adl_sol_lua_check_test_t, T>;
+
+ template <typename T>
+ inline constexpr bool is_adl_sol_lua_interop_check_v = meta::is_detected_v<adl_sol_lua_interop_check_test_t, T>;
+
+ template <typename T>
+ inline constexpr bool is_adl_sol_lua_check_get_v = meta::is_detected_v<adl_sol_lua_check_get_test_t, T>;
+
+ template <typename... Args>
+ inline constexpr bool is_adl_sol_lua_push_v = meta::is_detected_v<adl_sol_lua_push_test_t, Args...>;
+
+ template <typename T, typename... Args>
+ inline constexpr bool is_adl_sol_lua_push_exact_v = meta::is_detected_v<adl_sol_lua_push_exact_test_t, T, Args...>;
+ }} // namespace meta::meta_detail
+
+ namespace stack {
+ namespace stack_detail {
+ constexpr const char* not_enough_stack_space = "not enough space left on Lua stack";
+ constexpr const char* not_enough_stack_space_floating = "not enough space left on Lua stack for a floating point number";
+ constexpr const char* not_enough_stack_space_integral = "not enough space left on Lua stack for an integral number";
+ constexpr const char* not_enough_stack_space_string = "not enough space left on Lua stack for a string";
+ constexpr const char* not_enough_stack_space_meta_function_name = "not enough space left on Lua stack for the name of a meta_function";
+ constexpr const char* not_enough_stack_space_userdata = "not enough space left on Lua stack to create a sol3 userdata";
+ constexpr const char* not_enough_stack_space_generic = "not enough space left on Lua stack to push valuees";
+ constexpr const char* not_enough_stack_space_environment = "not enough space left on Lua stack to retrieve environment";
+
+ template <typename T>
+ struct strip {
+ typedef T type;
+ };
+ template <typename T>
+ struct strip<std::reference_wrapper<T>> {
+ typedef T& type;
+ };
+ template <typename T>
+ struct strip<user<T>> {
+ typedef T& type;
+ };
+ template <typename T>
+ struct strip<non_null<T>> {
+ typedef T type;
+ };
+ template <typename T>
+ using strip_t = typename strip<T>::type;
+
+ template <typename C>
+ static int get_size_hint(C& c) {
+ return static_cast<int>(c.size());
+ }
+
+ template <typename V, typename Al>
+ static int get_size_hint(const std::forward_list<V, Al>&) {
+ // forward_list makes me sad
+ return static_cast<int>(32);
+ }
+
+ template <typename T>
+ decltype(auto) unchecked_unqualified_get(lua_State* L, int index, record& tracking) {
+ using Tu = meta::unqualified_t<T>;
+ if constexpr (meta::meta_detail::is_adl_sol_lua_get_v<Tu>) {
+ return sol_lua_get(types<Tu>(), L, index, tracking);
+ }
+ else {
+ unqualified_getter<Tu> g {};
+ (void)g;
+ return g.get(L, index, tracking);
+ }
+ }
+
+ template <typename T>
+ decltype(auto) unchecked_get(lua_State* L, int index, record& tracking) {
+ if constexpr (meta::meta_detail::is_adl_sol_lua_get_v<T>) {
+ return sol_lua_get(types<T>(), L, index, tracking);
+ }
+ else {
+ qualified_getter<T> g {};
+ (void)g;
+ return g.get(L, index, tracking);
+ }
+ }
+
+ template <typename T>
+ decltype(auto) unqualified_interop_get(lua_State* L, int index, void* unadjusted_pointer, record& tracking) {
+ using Tu = meta::unqualified_t<T>;
+ if constexpr (meta::meta_detail::is_adl_sol_lua_interop_get_v<Tu>) {
+ return sol_lua_interop_get(types<Tu>(), L, index, unadjusted_pointer, tracking);
+ }
+ else {
+ (void)L;
+ (void)index;
+ (void)unadjusted_pointer;
+ (void)tracking;
+ using Ti = stack_detail::strip_t<Tu>;
+ return std::pair<bool, Ti*> { false, nullptr };
+ }
+ }
+
+ template <typename T>
+ decltype(auto) interop_get(lua_State* L, int index, void* unadjusted_pointer, record& tracking) {
+ if constexpr (meta::meta_detail::is_adl_sol_lua_interop_get_v<T>) {
+ return sol_lua_interop_get(types<T>(), L, index, unadjusted_pointer, tracking);
+ }
+ else {
+ return unqualified_interop_get<T>(L, index, unadjusted_pointer, tracking);
+ }
+ }
+
+ template <typename T, typename Handler>
+ bool unqualified_interop_check(lua_State* L, int index, type index_type, Handler&& handler, record& tracking) {
+ using Tu = meta::unqualified_t<T>;
+ if constexpr (meta::meta_detail::is_adl_sol_lua_interop_check_v<Tu>) {
+ return sol_lua_interop_check(types<Tu>(), L, index, index_type, std::forward<Handler>(handler), tracking);
+ }
+ else {
+ (void)L;
+ (void)index;
+ (void)index_type;
+ (void)handler;
+ (void)tracking;
+ return false;
+ }
+ }
+
+ template <typename T, typename Handler>
+ bool interop_check(lua_State* L, int index, type index_type, Handler&& handler, record& tracking) {
+ if constexpr (meta::meta_detail::is_adl_sol_lua_interop_check_v<T>) {
+ return sol_lua_interop_check(types<T>(), L, index, index_type, std::forward<Handler>(handler), tracking);
+ }
+ else {
+ return unqualified_interop_check<T>(L, index, index_type, std::forward<Handler>(handler), tracking);
+ }
+ }
+
+ using undefined_method_func = void (*)(stack_reference);
+
+ struct undefined_metatable {
+ lua_State* L;
+ const char* key;
+ undefined_method_func on_new_table;
+
+ undefined_metatable(lua_State* l, const char* k, undefined_method_func umf) : L(l), key(k), on_new_table(umf) {
+ }
+
+ void operator()() const {
+ if (luaL_newmetatable(L, key) == 1) {
+ on_new_table(stack_reference(L, -1));
+ }
+ lua_setmetatable(L, -2);
+ }
+ };
+ } // namespace stack_detail
+
+ inline bool maybe_indexable(lua_State* L, int index = -1) {
+ type t = type_of(L, index);
+ return t == type::userdata || t == type::table;
+ }
+
+ inline int top(lua_State* L) {
+ return lua_gettop(L);
+ }
+
+ inline bool is_main_thread(lua_State* L) {
+ int ismainthread = lua_pushthread(L);
+ lua_pop(L, 1);
+ return ismainthread == 1;
+ }
+
+ inline void coroutine_create_guard(lua_State* L) {
+ if (is_main_thread(L)) {
+ return;
+ }
+ int stacksize = lua_gettop(L);
+ if (stacksize < 1) {
+ return;
+ }
+ if (type_of(L, 1) != type::function) {
+ return;
+ }
+ // well now we're screwed...
+ // we can clean the stack and pray it doesn't destroy anything?
+ lua_pop(L, stacksize);
+ }
+
+ inline void clear(lua_State* L, int table_index) {
+ lua_pushnil(L);
+ while (lua_next(L, table_index) != 0) {
+ // remove value
+ lua_pop(L, 1);
+ // duplicate key to protect form rawset
+ lua_pushvalue(L, -1);
+ // push new value
+ lua_pushnil(L);
+ // table_index%[key] = nil
+ lua_rawset(L, table_index);
+ }
+ }
+
+ inline void clear(reference& r) {
+ auto pp = push_pop<false>(r);
+ int stack_index = pp.index_of(r);
+ clear(r.lua_state(), stack_index);
+ }
+
+ inline void clear(stack_reference& r) {
+ clear(r.lua_state(), r.stack_index());
+ }
+
+ template <typename T, typename... Args>
+ int push(lua_State* L, T&& t, Args&&... args) {
+ using Tu = meta::unqualified_t<T>;
+ if constexpr (meta::meta_detail::is_adl_sol_lua_push_exact_v<T, T, Args...>) {
+ return sol_lua_push(types<T>(), L, std::forward<T>(t), std::forward<Args>(args)...);
+ }
+ else if constexpr (meta::meta_detail::is_adl_sol_lua_push_exact_v<Tu, T, Args...>) {
+ return sol_lua_push(types<Tu>(), L, std::forward<T>(t), std::forward<Args>(args)...);
+ }
+ else if constexpr (meta::meta_detail::is_adl_sol_lua_push_v<T, Args...>) {
+ return sol_lua_push(L, std::forward<T>(t), std::forward<Args>(args)...);
+ }
+ else {
+ unqualified_pusher<Tu> p {};
+ (void)p;
+ return p.push(L, std::forward<T>(t), std::forward<Args>(args)...);
+ }
+ }
+
+ // overload allows to use a pusher of a specific type, but pass in any kind of args
+ template <typename T, typename Arg, typename... Args, typename = std::enable_if_t<!std::is_same<T, Arg>::value>>
+ int push(lua_State* L, Arg&& arg, Args&&... args) {
+ using Tu = meta::unqualified_t<T>;
+ if constexpr (meta::meta_detail::is_adl_sol_lua_push_exact_v<T, Arg, Args...>) {
+ return sol_lua_push(types<T>(), L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+ }
+ else if constexpr (meta::meta_detail::is_adl_sol_lua_push_exact_v<Tu, Arg, Args...>) {
+ return sol_lua_push(types<Tu>(), L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+ }
+ else if constexpr (meta::meta_detail::is_adl_sol_lua_push_v<Arg, Args...>) {
+ return sol_lua_push(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+ }
+ else {
+ unqualified_pusher<Tu> p {};
+ (void)p;
+ return p.push(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+ }
+ }
+
+ template <typename T, typename... Args>
+ int push_userdata(lua_State* L, T&& t, Args&&... args) {
+ using U = meta::unqualified_t<T>;
+ using Tr = meta::conditional_t<std::is_pointer_v<U>,
+ detail::as_pointer_tag<std::remove_pointer_t<U>>,
+ meta::conditional_t<is_unique_usertype_v<U>, detail::as_unique_tag<U>, detail::as_value_tag<U>>>;
+ return stack::push<Tr>(L, std::forward<T>(t), std::forward<Args>(args)...);
+ }
+
+ template <typename T, typename Arg, typename... Args>
+ int push_userdata(lua_State* L, Arg&& arg, Args&&... args) {
+ using U = meta::unqualified_t<T>;
+ using Tr = meta::conditional_t<std::is_pointer_v<U>,
+ detail::as_pointer_tag<std::remove_pointer_t<U>>,
+ meta::conditional_t<is_unique_usertype_v<U>, detail::as_unique_tag<U>, detail::as_value_tag<U>>>;
+ return stack::push<Tr>(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+ }
+
+ namespace stack_detail {
+
+ template <typename T, typename Arg, typename... Args>
+ int push_reference(lua_State* L, Arg&& arg, Args&&... args) {
+ using use_reference_tag = meta::all<std::is_lvalue_reference<T>,
+ meta::neg<std::is_const<std::remove_reference_t<T>>>,
+ meta::neg<is_lua_primitive<meta::unqualified_t<T>>>,
+ meta::neg<is_unique_usertype<meta::unqualified_t<T>>>>;
+ using Tr = meta::conditional_t<use_reference_tag::value, detail::as_reference_tag, meta::unqualified_t<T>>;
+ return stack::push<Tr>(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+ }
+
+ } // namespace stack_detail
+
+ template <typename T, typename... Args>
+ int push_reference(lua_State* L, T&& t, Args&&... args) {
+ return stack_detail::push_reference<T>(L, std::forward<T>(t), std::forward<Args>(args)...);
+ }
+
+ template <typename T, typename Arg, typename... Args>
+ int push_reference(lua_State* L, Arg&& arg, Args&&... args) {
+ return stack_detail::push_reference<T>(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+ }
+
+ inline int multi_push(lua_State*) {
+ // do nothing
+ return 0;
+ }
+
+ template <typename T, typename... Args>
+ int multi_push(lua_State* L, T&& t, Args&&... args) {
+ int pushcount = push(L, std::forward<T>(t));
+ void(detail::swallow { (pushcount += stack::push(L, std::forward<Args>(args)), 0)... });
+ return pushcount;
+ }
+
+ inline int multi_push_reference(lua_State*) {
+ // do nothing
+ return 0;
+ }
+
+ template <typename T, typename... Args>
+ int multi_push_reference(lua_State* L, T&& t, Args&&... args) {
+ int pushcount = push_reference(L, std::forward<T>(t));
+ void(detail::swallow { (pushcount += stack::push_reference(L, std::forward<Args>(args)), 0)... });
+ return pushcount;
+ }
+
+ template <typename T, typename Handler>
+ bool unqualified_check(lua_State* L, int index, Handler&& handler, record& tracking) {
+ using Tu = meta::unqualified_t<T>;
+ if constexpr (meta::meta_detail::is_adl_sol_lua_check_v<Tu>) {
+ return sol_lua_check(types<Tu>(), L, index, std::forward<Handler>(handler), tracking);
+ }
+ else {
+ 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);
+ }
+ }
+
+ template <typename T, typename Handler>
+ bool unqualified_check(lua_State* L, int index, Handler&& handler) {
+ record tracking {};
+ return unqualified_check<T>(L, index, std::forward<Handler>(handler), tracking);
+ }
+
+ template <typename T>
+ bool unqualified_check(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+ auto handler = no_panic;
+ return unqualified_check<T>(L, index, handler);
+ }
+
+ template <typename T, typename Handler>
+ bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
+ if constexpr (meta::meta_detail::is_adl_sol_lua_check_v<T>) {
+ return sol_lua_check(types<T>(), L, index, std::forward<Handler>(handler), tracking);
+ }
+ else {
+ using Tu = meta::unqualified_t<T>;
+ 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);
+ }
+ }
+
+ template <typename T, typename Handler>
+ bool check(lua_State* L, int index, Handler&& handler) {
+ record tracking {};
+ return check<T>(L, index, std::forward<Handler>(handler), tracking);
+ }
+
+ template <typename T>
+ bool check(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+ auto handler = no_panic;
+ return check<T>(L, index, handler);
+ }
+
+ template <typename T, typename Handler>
+ bool check_usertype(lua_State* L, int index, type, Handler&& handler, record& tracking) {
+ using Tu = meta::unqualified_t<T>;
+ using detail_t = meta::conditional_t<std::is_pointer_v<T>, detail::as_pointer_tag<Tu>, detail::as_value_tag<Tu>>;
+ return check<detail_t>(L, index, std::forward<Handler>(handler), tracking);
+ }
+
+ template <typename T, typename Handler>
+ bool check_usertype(lua_State* L, int index, Handler&& handler, record& tracking) {
+ using Tu = meta::unqualified_t<T>;
+ using detail_t = meta::conditional_t<std::is_pointer_v<T>, detail::as_pointer_tag<Tu>, detail::as_value_tag<Tu>>;
+ return check<detail_t>(L, index, std::forward<Handler>(handler), tracking);
+ }
+
+ template <typename T, typename Handler>
+ bool check_usertype(lua_State* L, int index, Handler&& handler) {
+ record tracking {};
+ return check_usertype<T>(L, index, std::forward<Handler>(handler), tracking);
+ }
+
+ template <typename T>
+ bool check_usertype(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+ auto handler = no_panic;
+ return check_usertype<T>(L, index, handler);
+ }
+
+ template <typename T, typename Handler>
+ decltype(auto) unqualified_check_get(lua_State* L, int index, Handler&& handler, record& tracking) {
+ using Tu = meta::unqualified_t<T>;
+ if constexpr (meta::meta_detail::is_adl_sol_lua_check_get_v<T>) {
+ return sol_lua_check_get(types<T>(), L, index, std::forward<Handler>(handler), tracking);
+ }
+ else if constexpr (meta::meta_detail::is_adl_sol_lua_check_get_v<Tu>) {
+ return sol_lua_check_get(types<Tu>(), L, index, std::forward<Handler>(handler), tracking);
+ }
+ else {
+ unqualified_check_getter<Tu> cg {};
+ (void)cg;
+ return cg.get(L, index, std::forward<Handler>(handler), tracking);
+ }
+ }
+
+ template <typename T, typename Handler>
+ decltype(auto) unqualified_check_get(lua_State* L, int index, Handler&& handler) {
+ record tracking {};
+ return unqualified_check_get<T>(L, index, handler, tracking);
+ }
+
+ template <typename T>
+ decltype(auto) unqualified_check_get(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+ auto handler = no_panic;
+ return unqualified_check_get<T>(L, index, handler);
+ }
+
+ template <typename T, typename Handler>
+ decltype(auto) check_get(lua_State* L, int index, Handler&& handler, record& tracking) {
+ if constexpr (meta::meta_detail::is_adl_sol_lua_check_get_v<T>) {
+ return sol_lua_check_get(types<T>(), L, index, std::forward<Handler>(handler), tracking);
+ }
+ else {
+ qualified_check_getter<T> cg {};
+ (void)cg;
+ return cg.get(L, index, std::forward<Handler>(handler), tracking);
+ }
+ }
+
+ template <typename T, typename Handler>
+ decltype(auto) check_get(lua_State* L, int index, Handler&& handler) {
+ record tracking {};
+ return check_get<T>(L, index, handler, tracking);
+ }
+
+ template <typename T>
+ decltype(auto) check_get(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+ auto handler = no_panic;
+ return check_get<T>(L, index, handler);
+ }
+
+ namespace stack_detail {
+
+ template <typename Handler>
+ bool check_types(lua_State*, int, Handler&&, record&) {
+ return true;
+ }
+
+ template <typename T, typename... Args, typename Handler>
+ bool check_types(lua_State* L, int firstargument, Handler&& handler, record& tracking) {
+ if (!stack::check<T>(L, firstargument + tracking.used, handler, tracking))
+ return false;
+ return check_types<Args...>(L, firstargument, std::forward<Handler>(handler), tracking);
+ }
+
+ template <typename... Args, typename Handler>
+ bool check_types(types<Args...>, lua_State* L, int index, Handler&& handler, record& tracking) {
+ return check_types<Args...>(L, index, std::forward<Handler>(handler), tracking);
+ }
+
+ } // namespace stack_detail
+
+ template <typename... Args, typename Handler>
+ bool multi_check(lua_State* L, int index, Handler&& handler, record& tracking) {
+ return stack_detail::check_types<Args...>(L, index, std::forward<Handler>(handler), tracking);
+ }
+
+ template <typename... Args, typename Handler>
+ bool multi_check(lua_State* L, int index, Handler&& handler) {
+ record tracking {};
+ return multi_check<Args...>(L, index, std::forward<Handler>(handler), tracking);
+ }
+
+ template <typename... Args>
+ bool multi_check(lua_State* L, int index) {
+ return multi_check<Args...>(L, index);
+ }
+
+ template <typename T>
+ 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_)
+ static constexpr bool is_op = meta::is_optional_v<T>;
+ if constexpr (is_op) {
+ return stack_detail::unchecked_unqualified_get<T>(L, index, tracking);
+ }
+ else {
+ if (is_lua_reference<T>::value) {
+ return stack_detail::unchecked_unqualified_get<T>(L, index, tracking);
+ }
+ auto op = unqualified_check_get<T>(L, index, type_panic_c_str, tracking);
+ return *std::move(op);
+ }
+#else
+ return stack_detail::unchecked_unqualified_get<T>(L, index, tracking);
+#endif
+ }
+
+ template <typename T>
+ decltype(auto) unqualified_get(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+ record tracking {};
+ return unqualified_get<T>(L, index, tracking);
+ }
+
+ template <typename T>
+ 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_)
+ static constexpr bool is_op = meta::is_optional_v<T>;
+ if constexpr (is_op) {
+ return stack_detail::unchecked_get<T>(L, index, tracking);
+ }
+ else {
+ if (is_lua_reference<T>::value) {
+ return stack_detail::unchecked_get<T>(L, index, tracking);
+ }
+ auto op = check_get<T>(L, index, type_panic_c_str, tracking);
+ return *std::move(op);
+ }
+#else
+ return stack_detail::unchecked_get<T>(L, index, tracking);
+#endif
+ }
+
+ template <typename T>
+ decltype(auto) get(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+ record tracking {};
+ return get<T>(L, index, tracking);
+ }
+
+ template <typename T>
+ decltype(auto) get_usertype(lua_State* L, int index, record& tracking) {
+ using UT = meta::conditional_t<std::is_pointer<T>::value, detail::as_pointer_tag<std::remove_pointer_t<T>>, detail::as_value_tag<T>>;
+ return get<UT>(L, index, tracking);
+ }
+
+ template <typename T>
+ decltype(auto) get_usertype(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+ record tracking {};
+ return get_usertype<T>(L, index, tracking);
+ }
+
+ template <typename T>
+ decltype(auto) pop(lua_State* L) {
+ return popper<meta::unqualified_t<T>> {}.pop(L);
+ }
+
+ template <bool global = false, bool raw = false, typename Key>
+ void get_field(lua_State* L, Key&& key) {
+ field_getter<meta::unqualified_t<Key>, global, raw> {}.get(L, std::forward<Key>(key));
+ }
+
+ template <bool global = false, bool raw = false, typename Key>
+ void get_field(lua_State* L, Key&& key, int tableindex) {
+ field_getter<meta::unqualified_t<Key>, global, raw> {}.get(L, std::forward<Key>(key), tableindex);
+ }
+
+ template <bool global = false, typename Key>
+ void raw_get_field(lua_State* L, Key&& key) {
+ get_field<global, true>(L, std::forward<Key>(key));
+ }
+
+ template <bool global = false, typename Key>
+ void raw_get_field(lua_State* L, Key&& key, int tableindex) {
+ get_field<global, true>(L, std::forward<Key>(key), tableindex);
+ }
+
+ template <bool global = false, bool raw = false, typename C = detail::non_lua_nil_t, typename Key>
+ probe probe_get_field(lua_State* L, Key&& key) {
+ return probe_field_getter<meta::unqualified_t<Key>, C, global, raw> {}.get(L, std::forward<Key>(key));
+ }
+
+ template <bool global = false, bool raw = false, typename C = detail::non_lua_nil_t, typename Key>
+ probe probe_get_field(lua_State* L, Key&& key, int tableindex) {
+ return probe_field_getter<meta::unqualified_t<Key>, C, global, raw> {}.get(L, std::forward<Key>(key), tableindex);
+ }
+
+ template <bool global = false, typename C = detail::non_lua_nil_t, typename Key>
+ probe probe_raw_get_field(lua_State* L, Key&& key) {
+ return probe_get_field<global, true, C>(L, std::forward<Key>(key));
+ }
+
+ template <bool global = false, typename C = detail::non_lua_nil_t, typename Key>
+ probe probe_raw_get_field(lua_State* L, Key&& key, int tableindex) {
+ return probe_get_field<global, true, C>(L, std::forward<Key>(key), tableindex);
+ }
+
+ template <bool global = false, bool raw = false, typename Key, typename Value>
+ void set_field(lua_State* L, Key&& key, Value&& value) {
+ field_setter<meta::unqualified_t<Key>, global, raw> {}.set(L, std::forward<Key>(key), std::forward<Value>(value));
+ }
+
+ template <bool global = false, bool raw = false, typename Key, typename Value>
+ void set_field(lua_State* L, Key&& key, Value&& value, int tableindex) {
+ field_setter<meta::unqualified_t<Key>, global, raw> {}.set(L, std::forward<Key>(key), std::forward<Value>(value), tableindex);
+ }
+
+ template <bool global = false, typename Key, typename Value>
+ void raw_set_field(lua_State* L, Key&& key, Value&& value) {
+ set_field<global, true>(L, std::forward<Key>(key), std::forward<Value>(value));
+ }
+
+ template <bool global = false, typename Key, typename Value>
+ void raw_set_field(lua_State* L, Key&& key, Value&& value, int tableindex) {
+ set_field<global, true>(L, std::forward<Key>(key), std::forward<Value>(value), tableindex);
+ }
+
+ template <typename T, typename F>
+ void modify_unique_usertype_as(const stack_reference& obj, F&& f) {
+ using u_traits = unique_usertype_traits<T>;
+ void* raw = lua_touserdata(obj.lua_state(), obj.stack_index());
+ void* ptr_memory = detail::align_usertype_pointer(raw);
+ void* uu_memory = detail::align_usertype_unique<T>(raw);
+ T& uu = *static_cast<T*>(uu_memory);
+ f(uu);
+ *static_cast<void**>(ptr_memory) = static_cast<void*>(u_traits::get(uu));
+ }
+
+ template <typename F>
+ void modify_unique_usertype(const stack_reference& obj, F&& f) {
+ using bt = meta::bind_traits<meta::unqualified_t<F>>;
+ using T = typename bt::template arg_at<0>;
+ using Tu = meta::unqualified_t<T>;
+ modify_unique_usertype_as<Tu>(obj, std::forward<F>(f));
+ }
+
+ } // namespace stack
+
+ namespace detail {
+
+ template <typename T>
+ lua_CFunction make_destructor(std::true_type) {
+ if constexpr (is_unique_usertype_v<T>) {
+ return &unique_destruct<T>;
+ }
+ else if constexpr (!std::is_pointer_v<T>) {
+ return &usertype_alloc_destruct<T>;
+ }
+ else {
+ return &cannot_destruct<T>;
+ }
+ }
+
+ template <typename T>
+ lua_CFunction make_destructor(std::false_type) {
+ return &cannot_destruct<T>;
+ }
+
+ template <typename T>
+ lua_CFunction make_destructor() {
+ return make_destructor<T>(std::is_destructible<T>());
+ }
+
+ struct no_comp {
+ template <typename A, typename B>
+ bool operator()(A&&, B&&) const {
+ return false;
+ }
+ };
+
+ template <typename T>
+ int is_check(lua_State* L) {
+ return stack::push(L, stack::check<T>(L, 1, &no_panic));
+ }
+
+ template <typename T>
+ int member_default_to_string(std::true_type, lua_State* L) {
+ decltype(auto) ts = stack::get<T>(L, 1).to_string();
+ return stack::push(L, std::forward<decltype(ts)>(ts));
+ }
+
+ template <typename T>
+ int member_default_to_string(std::false_type, lua_State* L) {
+ return luaL_error(L,
+ "cannot perform to_string on '%s': no 'to_string' overload in namespace, 'to_string' member "
+ "function, or operator<<(ostream&, ...) present",
+ detail::demangle<T>().data());
+ }
+
+ template <typename T>
+ int adl_default_to_string(std::true_type, lua_State* L) {
+ using namespace std;
+ decltype(auto) ts = to_string(stack::get<T>(L, 1));
+ return stack::push(L, std::forward<decltype(ts)>(ts));
+ }
+
+ template <typename T>
+ int adl_default_to_string(std::false_type, lua_State* L) {
+ return member_default_to_string<T>(meta::supports_to_string_member<T>(), L);
+ }
+
+ template <typename T>
+ int oss_default_to_string(std::true_type, lua_State* L) {
+ std::ostringstream oss;
+ oss << stack::unqualified_get<T>(L, 1);
+ return stack::push(L, oss.str());
+ }
+
+ template <typename T>
+ int oss_default_to_string(std::false_type, lua_State* L) {
+ return adl_default_to_string<T>(meta::supports_adl_to_string<T>(), L);
+ }
+
+ template <typename T>
+ int default_to_string(lua_State* L) {
+ return oss_default_to_string<T>(meta::supports_op_left_shift<std::ostream, T>(), L);
+ }
+
+ template <typename T>
+ int default_size(lua_State* L) {
+ decltype(auto) self = stack::unqualified_get<T>(L, 1);
+ return stack::push(L, self.size());
+ }
+
+ template <typename T, typename Op>
+ int comparsion_operator_wrap(lua_State* L) {
+ if constexpr (std::is_void_v<T>) {
+ return stack::push(L, false);
+ }
+ else {
+ auto maybel = stack::unqualified_check_get<T>(L, 1);
+ if (!maybel) {
+ return stack::push(L, false);
+ }
+ auto mayber = stack::unqualified_check_get<T>(L, 2);
+ if (!mayber) {
+ return stack::push(L, false);
+ }
+ decltype(auto) l = *maybel;
+ decltype(auto) r = *mayber;
+ if constexpr (std::is_same_v<no_comp, Op>) {
+ std::equal_to<> op;
+ return stack::push(L, op(detail::ptr(l), detail::ptr(r)));
+ }
+ else {
+ if constexpr (std::is_same_v<std::equal_to<>, Op> // clang-format hack
+ || std::is_same_v<std::less_equal<>, Op> //
+ || std::is_same_v<std::less_equal<>, Op>) { //
+ if (detail::ptr(l) == detail::ptr(r)) {
+ return stack::push(L, true);
+ }
+ }
+ Op op;
+ return stack::push(L, op(detail::deref(l), detail::deref(r)));
+ }
+ }
+ }
+
+ template <typename T, typename IFx, typename Fx>
+ void insert_default_registrations(IFx&& ifx, Fx&& fx);
+
+ template <typename T, bool, bool>
+ struct get_is_primitive : is_lua_primitive<T> { };
+
+ template <typename T>
+ struct get_is_primitive<T, true, false>
+ : meta::neg<std::is_reference<decltype(sol_lua_get(types<T>(), nullptr, -1, std::declval<stack::record&>()))>> { };
+
+ template <typename T>
+ struct get_is_primitive<T, false, true>
+ : meta::neg<std::is_reference<decltype(sol_lua_get(types<meta::unqualified_t<T>>(), nullptr, -1, std::declval<stack::record&>()))>> { };
+
+ template <typename T>
+ struct get_is_primitive<T, true, true> : get_is_primitive<T, true, false> { };
+
+ } // namespace detail
+
+ template <typename T>
+ struct is_proxy_primitive
+ : detail::get_is_primitive<T, meta::meta_detail::is_adl_sol_lua_get_v<T>, meta::meta_detail::is_adl_sol_lua_get_v<meta::unqualified_t<T>>> { };
+
+} // namespace sol
+
+// end of sol/stack_core.hpp
+
+// beginning of sol/stack_check.hpp
+
+// beginning of sol/stack_check_unqualified.hpp
+
+#include <memory>
+#include <functional>
+#include <utility>
+#include <cmath>
+#include <optional>
+#if SOL_IS_ON(SOL_STD_VARIANT_I_)
+#include <variant>
+#endif // variant shenanigans
+
+namespace sol { namespace stack {
+ namespace stack_detail {
+ inline bool impl_check_metatable(lua_State* L, int index, const std::string& metakey, bool poptable) {
+ luaL_getmetatable(L, &metakey[0]);
+ const type expectedmetatabletype = static_cast<type>(lua_type(L, -1));
+ if (expectedmetatabletype != type::lua_nil) {
+ if (lua_rawequal(L, -1, index) == 1) {
+ lua_pop(L, 1 + static_cast<int>(poptable));
+ return true;
+ }
+ }
+ lua_pop(L, 1);
+ return false;
+ }
+
+ template <typename T, bool poptable = true>
+ inline bool check_metatable(lua_State* L, int index = -2) {
+ return impl_check_metatable(L, index, usertype_traits<T>::metatable(), poptable);
+ }
+
+ template <type expected, int (*check_func)(lua_State*, int)>
+ struct basic_check {
+ template <typename Handler>
+ static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
+ tracking.use(1);
+ bool success = check_func(L, index) == 1;
+ if (!success) {
+ // expected type, actual type
+ handler(L, index, expected, type_of(L, index), "");
+ }
+ return success;
+ }
+ };
+ } // namespace stack_detail
+
+ template <typename T, typename>
+ struct unqualified_interop_checker {
+ template <typename Handler>
+ static bool check(lua_State*, int, type, Handler&&, record&) {
+ return false;
+ }
+ };
+
+ template <typename T, typename>
+ struct qualified_interop_checker {
+ template <typename Handler>
+ static bool check(lua_State* L, int index, type index_type, Handler&& handler, record& tracking) {
+ return stack_detail::unqualified_interop_check<T>(L, index, index_type, std::forward<Handler>(handler), tracking);
+ }
+ };
+
+ template <typename T, type expected, typename>
+ struct unqualified_checker {
+ template <typename Handler>
+ static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
+ if constexpr (std::is_same_v<T, bool>) {
+ tracking.use(1);
+ bool success = lua_isboolean(L, index) == 1;
+ if (!success) {
+ // expected type, actual type
+ handler(L, index, expected, type_of(L, index), "");
+ }
+ return success;
+ }
+ else if constexpr (meta::any_same_v<T, char /* , char8_t*/, char16_t, char32_t>) {
+ return stack::check<std::basic_string<T>>(L, index, std::forward<Handler>(handler), tracking);
+ }
+ else if constexpr (std::is_integral_v<T> || std::is_same_v<T, lua_Integer>) {
+ tracking.use(1);
+#if SOL_LUA_VESION_I_ >= 503
+ // Lua 5.3 and greater checks for numeric precision
+#if SOL_IS_ON(SOL_STRINGS_ARE_NUMBERS_I_)
+ // imprecise, sloppy conversions
+ int isnum = 0;
+ lua_tointegerx(L, index, &isnum);
+ const bool success = isnum != 0;
+ if (!success) {
+ // expected type, actual type
+ 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_)
+ // this check is precise, do not convert
+ if (lua_isinteger(L, index) == 1) {
+ return true;
+ }
+ const bool success = false;
+ if (!success) {
+ // expected type, actual type
+ handler(L, index, type::number, type_of(L, index), detail::not_a_number_integral);
+ }
+#else
+ // Numerics are neither safe nor string-convertible
+ type t = type_of(L, index);
+ const bool success = t == type::number;
+#endif
+ if (!success) {
+ // expected type, actual type
+ handler(L, index, type::number, type_of(L, index), detail::not_a_number);
+ }
+ return success;
+#else
+ // Lua 5.2 and below checks
+#if SOL_IS_OFF(SOL_STRINGS_ARE_NUMBERS_I_)
+ // must pre-check, because it will convert
+ type t = type_of(L, index);
+ if (t != type::number) {
+ // expected type, actual type
+ handler(L, index, type::number, t, detail::not_a_number);
+ return false;
+ }
+#endif // Do not allow strings to be numbers
+
+#if SOL_IS_ON(SOL_NUMBER_PRECISION_CHECKS_I_)
+ int isnum = 0;
+ const lua_Number v = lua_tonumberx(L, index, &isnum);
+ const bool success = isnum != 0 && static_cast<lua_Number>(llround(v)) == v;
+#else
+ const bool success = true;
+#endif // Safe numerics and number precision checking
+ if (!success) {
+ // Use defines to provide a better error message!
+#if SOL_IS_ON(SOL_STRINGS_ARE_NUMBERS_I_)
+ 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_)
+ handler(L, index, type::number, t, detail::not_a_number_or_number_string);
+#else
+ handler(L, index, type::number, t, detail::not_a_number);
+#endif
+ }
+ return success;
+#endif
+ }
+ else if constexpr (std::is_floating_point_v<T> || std::is_same_v<T, lua_Number>) {
+ tracking.use(1);
+#if SOL_IS_ON(SOL_STRINGS_ARE_NUMBERS_I_)
+ bool success = lua_isnumber(L, index) == 1;
+ if (!success) {
+ // expected type, actual type
+ handler(L, index, type::number, type_of(L, index), detail::not_a_number_or_number_string);
+ }
+ return success;
+#else
+ type t = type_of(L, index);
+ bool success = t == type::number;
+ if (!success) {
+ // expected type, actual type
+ handler(L, index, type::number, t, detail::not_a_number);
+ }
+ return success;
+#endif // Strings are Numbers
+ }
+ else if constexpr (meta::any_same_v<T, type, this_state, this_main_state, this_environment, variadic_args>) {
+ (void)L;
+ (void)index;
+ (void)handler;
+ tracking.use(0);
+ return true;
+ }
+ else if constexpr (is_unique_usertype_v<T>) {
+ using proper_T = typename unique_usertype_traits<T>::type;
+ const type indextype = type_of(L, index);
+ tracking.use(1);
+ if (indextype != type::userdata) {
+ handler(L, index, type::userdata, indextype, "value is not a userdata");
+ return false;
+ }
+ if (lua_getmetatable(L, index) == 0) {
+ return true;
+ }
+ int metatableindex = lua_gettop(L);
+ if (stack_detail::check_metatable<detail::unique_usertype<proper_T>>(L, metatableindex)) {
+ void* memory = lua_touserdata(L, index);
+ memory = detail::align_usertype_unique_destructor(memory);
+ detail::unique_destructor& pdx = *static_cast<detail::unique_destructor*>(memory);
+ bool success = &detail::usertype_unique_alloc_destroy<proper_T, T> == pdx;
+ if (!success) {
+ memory = detail::align_usertype_unique_tag<true>(memory);
+#if 0
+ // New version
+#else
+ const char*& name_tag = *static_cast<const char**>(memory);
+ success = usertype_traits<T>::qualified_name() == name_tag;
+#endif
+ if (!success) {
+ handler(L, index, type::userdata, indextype, "value is a userdata but is not the correct unique usertype");
+ }
+ }
+ return success;
+ }
+ lua_pop(L, 1);
+ handler(L, index, type::userdata, indextype, "unrecognized userdata (not pushed by sol?)");
+ return false;
+ }
+ else if constexpr (meta::any_same_v<T, lua_nil_t, std::nullopt_t, nullopt_t>) {
+ bool success = lua_isnil(L, index);
+ if (success) {
+ tracking.use(1);
+ return success;
+ }
+ tracking.use(0);
+ success = lua_isnone(L, index);
+ if (!success) {
+ // expected type, actual type
+ handler(L, index, expected, type_of(L, index), "");
+ }
+ return success;
+ }
+ else if constexpr (std::is_same_v<T, env_key_t>) {
+ tracking.use(1);
+ type t = type_of(L, index);
+ if (t == type::table || t == type::none || t == type::lua_nil || t == type::userdata) {
+ return true;
+ }
+ handler(L, index, type::table, t, "value cannot not have a valid environment");
+ return true;
+ }
+ else if constexpr (std::is_same_v<T, detail::non_lua_nil_t>) {
+ return !stack::unqualified_check<lua_nil_t>(L, index, std::forward<Handler>(handler), tracking);
+ }
+ else if constexpr (meta::is_specialization_of_v<T, basic_lua_table>) {
+ tracking.use(1);
+ type t = type_of(L, index);
+ if (t != type::table) {
+ handler(L, index, type::table, t, "value is not a table");
+ return false;
+ }
+ return true;
+ }
+ else if constexpr (meta::is_specialization_of_v<T, basic_bytecode>) {
+ tracking.use(1);
+ type t = type_of(L, index);
+ if (t != type::function) {
+ handler(L, index, type::function, t, "value is not a function that can be dumped");
+ return false;
+ }
+ return true;
+ }
+ else if constexpr (meta::is_specialization_of_v<T, basic_environment>) {
+ tracking.use(1);
+ if (lua_getmetatable(L, index) == 0) {
+ return true;
+ }
+ type t = type_of(L, -1);
+ if (t == type::table || t == type::none || t == type::lua_nil) {
+ lua_pop(L, 1);
+ return true;
+ }
+ if (t != type::userdata) {
+ lua_pop(L, 1);
+ handler(L, index, type::table, t, "value does not have a valid metatable");
+ return false;
+ }
+ return true;
+ }
+ else if constexpr (std::is_same_v<T, metatable_key_t>) {
+ tracking.use(1);
+ if (lua_getmetatable(L, index) == 0) {
+ return true;
+ }
+ type t = type_of(L, -1);
+ if (t == type::table || t == type::none || t == type::lua_nil) {
+ lua_pop(L, 1);
+ return true;
+ }
+ if (t != type::userdata) {
+ lua_pop(L, 1);
+ handler(L, index, expected, t, "value does not have a valid metatable");
+ return false;
+ }
+ return true;
+ }
+ else if constexpr (std::is_same_v<T, luaL_Stream*> || std::is_same_v<T, luaL_Stream>) {
+ if (lua_getmetatable(L, index) == 0) {
+ type t = type_of(L, index);
+ handler(L, index, expected, t, "value is not a valid luaL_Stream (has no metatable/is not a valid value)");
+ return false;
+ }
+ luaL_getmetatable(L, LUA_FILEHANDLE);
+ if (type_of(L, index) != type::table) {
+ type t = type_of(L, index);
+ lua_pop(L, 1);
+ handler(L,
+ index,
+ expected,
+ t,
+ "value is not a valid luaL_Stream (there is no metatable for luaL_Stream -- did you forget to "
+ "my_lua_state.open_libraries(sol::lib::state) or equivalent?)");
+ return false;
+ }
+ int is_stream_table = lua_compare(L, -1, -2, LUA_OPEQ);
+ lua_pop(L, 2);
+ if (is_stream_table == 0) {
+ type t = type_of(L, index);
+ handler(L, index, expected, t, "value is not a valid luaL_Stream (incorrect metatable)");
+ return false;
+ }
+ return true;
+ }
+ else if constexpr (meta::is_optional_v<T>) {
+ using ValueType = typename T::value_type;
+ (void)handler;
+ type t = type_of(L, index);
+ if (t == type::none) {
+ tracking.use(0);
+ return true;
+ }
+ if (t == type::lua_nil) {
+ tracking.use(1);
+ return true;
+ }
+ return stack::unqualified_check<ValueType>(L, index, no_panic, tracking);
+ }
+#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE_I_)
+ 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);
+ }
+#endif
+ else if constexpr (expected == type::userdata) {
+ if constexpr (meta::any_same_v<T, userdata_value> || meta::is_specialization_of_v<T, basic_userdata>) {
+ tracking.use(1);
+ type t = type_of(L, index);
+ bool success = t == type::userdata;
+ if (!success) {
+ // expected type, actual type
+ handler(L, index, type::userdata, t, "");
+ }
+ return success;
+ }
+ else if constexpr (meta::is_specialization_of_v<T, user>) {
+ unqualified_checker<lightuserdata_value, type::userdata> c;
+ (void)c;
+ return c.check(L, index, std::forward<Handler>(handler), tracking);
+ }
+ else {
+ if constexpr (std::is_pointer_v<T>) {
+ return check_usertype<T>(L, index, std::forward<Handler>(handler), tracking);
+ }
+ else if constexpr (meta::is_specialization_of_v<T, std::reference_wrapper>) {
+ using T_internal = typename T::type;
+ return stack::check<T_internal>(L, index, std::forward<Handler>(handler), tracking);
+ }
+ else {
+ return check_usertype<T>(L, index, std::forward<Handler>(handler), tracking);
+ }
+ }
+ }
+ else if constexpr (expected == type::poly) {
+ tracking.use(1);
+ bool success = is_lua_reference_v<T> || !lua_isnone(L, index);
+ if (!success) {
+ // expected type, actual type
+ handler(L, index, type::poly, type_of(L, index), "");
+ }
+ return success;
+ }
+ else if constexpr (expected == type::lightuserdata) {
+ tracking.use(1);
+ type t = type_of(L, index);
+ bool success = t == type::userdata || t == type::lightuserdata;
+ if (!success) {
+ // expected type, actual type
+ handler(L, index, type::lightuserdata, t, "");
+ }
+ return success;
+ }
+ else if constexpr (expected == type::function) {
+ if constexpr (meta::any_same_v<T, lua_CFunction, std::remove_pointer_t<lua_CFunction>, c_closure>) {
+ tracking.use(1);
+ bool success = lua_iscfunction(L, index) == 1;
+ if (!success) {
+ // expected type, actual type
+ handler(L, index, expected, type_of(L, index), "");
+ }
+ return success;
+ }
+ else {
+ tracking.use(1);
+ type t = type_of(L, index);
+ if (t == type::lua_nil || t == type::none || t == type::function) {
+ // allow for lua_nil to be returned
+ return true;
+ }
+ if (t != type::userdata && t != type::table) {
+ handler(L, index, type::function, t, "must be a function or table or a userdata");
+ return false;
+ }
+ // Do advanced check for call-style userdata?
+ static const auto& callkey = to_string(meta_function::call);
+ if (lua_getmetatable(L, index) == 0) {
+ // No metatable, no __call key possible
+ handler(L, index, type::function, t, "value is not a function and does not have overriden metatable");
+ return false;
+ }
+ if (lua_isnoneornil(L, -1)) {
+ lua_pop(L, 1);
+ handler(L, index, type::function, t, "value is not a function and does not have valid metatable");
+ return false;
+ }
+ lua_getfield(L, -1, &callkey[0]);
+ if (lua_isnoneornil(L, -1)) {
+ lua_pop(L, 2);
+ handler(L, index, type::function, t, "value's metatable does not have __call overridden in metatable, cannot call this type");
+ return false;
+ }
+ // has call, is definitely a function
+ lua_pop(L, 2);
+ return true;
+ }
+ }
+ else if constexpr (expected == type::table) {
+ tracking.use(1);
+ type t = type_of(L, index);
+ if (t == type::table) {
+ return true;
+ }
+ if (t != type::userdata) {
+ handler(L, index, type::table, t, "value is not a table or a userdata that can behave like one");
+ return false;
+ }
+ return true;
+ }
+ else {
+ tracking.use(1);
+ const type indextype = type_of(L, index);
+ bool success = expected == indextype;
+ if (!success) {
+ // expected type, actual type, message
+ handler(L, index, expected, indextype, "");
+ }
+ return success;
+ }
+ }
+ };
+
+ template <typename T>
+ struct unqualified_checker<non_null<T>, type::userdata> : unqualified_checker<T, lua_type_of_v<T>> { };
+
+ template <typename T>
+ struct unqualified_checker<detail::as_value_tag<T>, type::userdata> {
+ template <typename Handler>
+ static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
+ const type indextype = type_of(L, index);
+ return check(types<T>(), L, index, indextype, std::forward<Handler>(handler), tracking);
+ }
+
+ template <typename U, typename Handler>
+ static bool check(types<U>, lua_State* L, int index, type indextype, Handler&& handler, record& tracking) {
+ if constexpr (
+ std::is_same_v<T,
+ lightuserdata_value> || std::is_same_v<T, userdata_value> || std::is_same_v<T, userdata> || std::is_same_v<T, lightuserdata>) {
+ tracking.use(1);
+ if (indextype != type::userdata) {
+ handler(L, index, type::userdata, indextype, "value is not a valid userdata");
+ return false;
+ }
+ return true;
+ }
+ else {
+#if SOL_IS_ON(SOL_USE_INTEROP_I_)
+ if (stack_detail::interop_check<U>(L, index, indextype, handler, tracking)) {
+ return true;
+ }
+#endif // interop extensibility
+ tracking.use(1);
+ if (indextype != type::userdata) {
+ handler(L, index, type::userdata, indextype, "value is not a valid userdata");
+ return false;
+ }
+ if (lua_getmetatable(L, index) == 0) {
+ return true;
+ }
+ int metatableindex = lua_gettop(L);
+ if (stack_detail::check_metatable<U>(L, metatableindex))
+ return true;
+ if (stack_detail::check_metatable<U*>(L, metatableindex))
+ return true;
+ if (stack_detail::check_metatable<detail::unique_usertype<U>>(L, metatableindex))
+ return true;
+ if (stack_detail::check_metatable<as_container_t<U>>(L, metatableindex))
+ return true;
+ bool success = false;
+ bool has_derived = derive<T>::value || weak_derive<T>::value;
+ if (has_derived) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+ auto pn = stack::pop_n(L, 1);
+ lua_pushstring(L, &detail::base_class_check_key()[0]);
+ lua_rawget(L, metatableindex);
+ if (type_of(L, -1) != type::lua_nil) {
+ void* basecastdata = lua_touserdata(L, -1);
+ detail::inheritance_check_function ic = reinterpret_cast<detail::inheritance_check_function>(basecastdata);
+ success = ic(usertype_traits<T>::qualified_name());
+ }
+ }
+ lua_pop(L, 1);
+ if (!success) {
+ handler(L, index, type::userdata, indextype, "value at this index does not properly reflect the desired type");
+ return false;
+ }
+ return true;
+ }
+ }
+ };
+
+ template <typename T>
+ struct unqualified_checker<detail::as_pointer_tag<T>, type::userdata> {
+ template <typename Handler>
+ static bool check(lua_State* L, int index, type indextype, Handler&& handler, record& tracking) {
+ if (indextype == type::lua_nil) {
+ tracking.use(1);
+ return true;
+ }
+ return check_usertype<std::remove_pointer_t<T>>(L, index, std::forward<Handler>(handler), tracking);
+ }
+
+ template <typename Handler>
+ static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
+ const type indextype = type_of(L, index);
+ return check(L, index, indextype, std::forward<Handler>(handler), tracking);
+ }
+ };
+
+ template <typename... Args>
+ struct unqualified_checker<std::tuple<Args...>, type::poly> {
+ template <typename Handler>
+ static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
+ return stack::multi_check<Args...>(L, index, std::forward<Handler>(handler), tracking);
+ }
+ };
+
+ template <typename A, typename B>
+ struct unqualified_checker<std::pair<A, B>, type::poly> {
+ template <typename Handler>
+ static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
+ return stack::multi_check<A, B>(L, index, std::forward<Handler>(handler), tracking);
+ }
+ };
+
+#if SOL_IS_ON(SOL_STD_VARIANT_I_)
+
+ template <typename... Tn>
+ struct unqualified_checker<std::variant<Tn...>, type::poly> {
+ typedef std::variant<Tn...> V;
+ typedef std::variant_size<V> V_size;
+ typedef std::integral_constant<bool, V_size::value == 0> V_is_empty;
+
+ template <typename Handler>
+ static bool is_one(std::integral_constant<std::size_t, 0>, lua_State* L, int index, Handler&& handler, record& tracking) {
+ if constexpr (V_is_empty::value) {
+ if (lua_isnone(L, index)) {
+ return true;
+ }
+ }
+ tracking.use(1);
+ handler(L, index, type::poly, type_of(L, index), "value does not fit any type present in the variant");
+ return false;
+ }
+
+ template <std::size_t I, typename Handler>
+ static bool is_one(std::integral_constant<std::size_t, I>, lua_State* L, int index, Handler&& handler, record& tracking) {
+ typedef std::variant_alternative_t<I - 1, V> T;
+ record temp_tracking = tracking;
+ if (stack::check<T>(L, index, no_panic, temp_tracking)) {
+ tracking = temp_tracking;
+ return true;
+ }
+ return is_one(std::integral_constant<std::size_t, I - 1>(), L, index, std::forward<Handler>(handler), tracking);
+ }
+
+ template <typename Handler>
+ static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
+ return is_one(std::integral_constant<std::size_t, V_size::value>(), L, index, std::forward<Handler>(handler), tracking);
+ }
+ };
+
+#endif // variant shenanigans
+
+}} // namespace sol::stack
+
+// end of sol/stack_check_unqualified.hpp
+
+// beginning of sol/stack_check_qualified.hpp
+
+namespace sol {
+namespace stack {
+
+ template <typename X, type expected, typename>
+ struct qualified_checker {
+ template <typename Handler>
+ static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
+ if constexpr (!std::is_reference_v<X> && is_unique_usertype_v<X>) {
+ using u_traits = unique_usertype_traits<meta::unqualified_t<X>>;
+ using T = typename u_traits::type;
+ if constexpr (is_base_rebindable_non_void_v<u_traits>) {
+ using rebind_t = typename u_traits::template rebind_base<void>;
+ // we have a unique pointer type that can be
+ // rebound to a base/derived type
+ const type indextype = type_of(L, index);
+ tracking.use(1);
+ if (indextype != type::userdata) {
+ handler(L, index, type::userdata, indextype, "value is not a userdata");
+ return false;
+ }
+ void* memory = lua_touserdata(L, index);
+ memory = detail::align_usertype_unique_destructor(memory);
+ detail::unique_destructor& pdx = *static_cast<detail::unique_destructor*>(memory);
+ if (&detail::usertype_unique_alloc_destroy<T, X> == pdx) {
+ return true;
+ }
+ if constexpr (derive<T>::value) {
+ memory = detail::align_usertype_unique_tag<true, false>(memory);
+ detail::unique_tag& ic = *reinterpret_cast<detail::unique_tag*>(memory);
+ string_view ti = usertype_traits<T>::qualified_name();
+ string_view rebind_ti = usertype_traits<rebind_t>::qualified_name();
+ if (ic(nullptr, nullptr, ti, rebind_ti) != 0) {
+ return true;
+ }
+ }
+ handler(L, index, type::userdata, indextype, "value is a userdata but is not the correct unique usertype");
+ return false;
+ }
+ else {
+ return stack::unqualified_check<X>(L, index, std::forward<Handler>(handler), tracking);
+ }
+ }
+ else if constexpr (!std::is_reference_v<X> && is_container_v<X>) {
+ if (type_of(L, index) == type::userdata) {
+ return stack::unqualified_check<X>(L, index, std::forward<Handler>(handler), tracking);
+ }
+ else {
+ return stack::unqualified_check<nested<X>>(L, index, std::forward<Handler>(handler), tracking);
+ }
+ }
+ else if constexpr (!std::is_reference_v<X> && meta::is_specialization_of_v<X, nested>) {
+ using NestedX = typename meta::unqualified_t<X>::nested_type;
+ return stack::check<NestedX>(L, index, ::std::forward<Handler>(handler), tracking);
+ }
+ else {
+ return stack::unqualified_check<X>(L, index, std::forward<Handler>(handler), tracking);
+ }
+ }
+ };
+}
+} // namespace sol::stack
+
+// end of sol/stack_check_qualified.hpp
+
+// end of sol/stack_check.hpp
+
+// beginning of sol/stack_get.hpp
+
+// beginning of sol/stack_get_unqualified.hpp
+
+// beginning of sol/overload.hpp
+
+#include <utility>
+
+namespace sol {
+ template <typename... Functions>
+ struct overload_set {
+ std::tuple<Functions...> functions;
+ template <typename Arg, typename... Args, meta::disable<std::is_same<overload_set, meta::unqualified_t<Arg>>> = meta::enabler>
+ overload_set(Arg&& arg, Args&&... args)
+ : functions(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+ }
+ overload_set(const overload_set&) = default;
+ overload_set(overload_set&&) = default;
+ overload_set& operator=(const overload_set&) = default;
+ overload_set& operator=(overload_set&&) = default;
+ };
+
+ template <typename... Args>
+ decltype(auto) overload(Args&&... args) {
+ return overload_set<std::decay_t<Args>...>(std::forward<Args>(args)...);
+ }
+} // namespace sol
+
+// end of sol/overload.hpp
+
+// beginning of sol/unicode.hpp
+
+#include <array>
+#include <cstring>
+
+namespace sol {
+ // Everything here was lifted pretty much straight out of
+ // ogonek, because fuck figuring it out=
+ namespace unicode {
+ enum class error_code {
+ ok = 0,
+ invalid_code_point,
+ invalid_code_unit,
+ invalid_leading_surrogate,
+ invalid_trailing_surrogate,
+ sequence_too_short,
+ overlong_sequence,
+ };
+
+ inline const string_view& to_string(error_code ec) {
+ static const string_view storage[7] = {
+ "ok",
+ "invalid code points",
+ "invalid code unit",
+ "invalid leading surrogate",
+ "invalid trailing surrogate",
+ "sequence too short",
+ "overlong sequence"
+ };
+ return storage[static_cast<std::size_t>(ec)];
+ }
+
+ template <typename It>
+ struct decoded_result {
+ error_code error;
+ char32_t codepoint;
+ It next;
+ };
+
+ template <typename C>
+ struct encoded_result {
+ error_code error;
+ std::size_t code_units_size;
+ std::array<C, 4> code_units;
+ };
+
+ struct unicode_detail {
+ // codepoint related
+ static constexpr char32_t last_code_point = 0x10FFFF;
+
+ static constexpr char32_t first_lead_surrogate = 0xD800;
+ static constexpr char32_t last_lead_surrogate = 0xDBFF;
+
+ static constexpr char32_t first_trail_surrogate = 0xDC00;
+ static constexpr char32_t last_trail_surrogate = 0xDFFF;
+
+ static constexpr char32_t first_surrogate = first_lead_surrogate;
+ static constexpr char32_t last_surrogate = last_trail_surrogate;
+
+ static constexpr bool is_lead_surrogate(char32_t u) {
+ return u >= first_lead_surrogate && u <= last_lead_surrogate;
+ }
+ static constexpr bool is_trail_surrogate(char32_t u) {
+ return u >= first_trail_surrogate && u <= last_trail_surrogate;
+ }
+ static constexpr bool is_surrogate(char32_t u) {
+ return u >= first_surrogate && u <= last_surrogate;
+ }
+
+ // utf8 related
+ static constexpr auto last_1byte_value = 0x7Fu;
+ static constexpr auto last_2byte_value = 0x7FFu;
+ static constexpr auto last_3byte_value = 0xFFFFu;
+
+ static constexpr auto start_2byte_mask = 0x80u;
+ static constexpr auto start_3byte_mask = 0xE0u;
+ static constexpr auto start_4byte_mask = 0xF0u;
+
+ static constexpr auto continuation_mask = 0xC0u;
+ static constexpr auto continuation_signature = 0x80u;
+
+ static constexpr bool is_invalid(unsigned char b) {
+ return b == 0xC0 || b == 0xC1 || b > 0xF4;
+ }
+
+ static constexpr bool is_continuation(unsigned char b) {
+ return (b & unicode_detail::continuation_mask) == unicode_detail::continuation_signature;
+ }
+
+ static constexpr bool is_overlong(char32_t u, std::size_t bytes) {
+ return u <= unicode_detail::last_1byte_value || (u <= unicode_detail::last_2byte_value && bytes > 2)
+ || (u <= unicode_detail::last_3byte_value && bytes > 3);
+ }
+
+ static constexpr int sequence_length(unsigned char b) {
+ return (b & start_2byte_mask) == 0 ? 1
+ : (b & start_3byte_mask) != start_3byte_mask ? 2
+ : (b & start_4byte_mask) != start_4byte_mask ? 3
+ : 4;
+ }
+
+ static constexpr char32_t decode(unsigned char b0, unsigned char b1) {
+ return ((b0 & 0x1F) << 6) | (b1 & 0x3F);
+ }
+ static constexpr char32_t decode(unsigned char b0, unsigned char b1, unsigned char b2) {
+ return ((b0 & 0x0F) << 12) | ((b1 & 0x3F) << 6) | (b2 & 0x3F);
+ }
+ static constexpr char32_t decode(unsigned char b0, unsigned char b1, unsigned char b2, unsigned char b3) {
+ return ((b0 & 0x07) << 18) | ((b1 & 0x3F) << 12) | ((b2 & 0x3F) << 6) | (b3 & 0x3F);
+ }
+
+ // utf16 related
+ static constexpr char32_t last_bmp_value = 0xFFFF;
+ static constexpr char32_t normalizing_value = 0x10000;
+ static constexpr int lead_surrogate_bitmask = 0xFFC00;
+ static constexpr int trail_surrogate_bitmask = 0x3FF;
+ static constexpr int lead_shifted_bits = 10;
+ static constexpr char32_t replacement = 0xFFFD;
+
+ static char32_t combine_surrogates(char16_t lead, char16_t trail) {
+ auto hi = lead - first_lead_surrogate;
+ auto lo = trail - first_trail_surrogate;
+ return normalizing_value + ((hi << lead_shifted_bits) | lo);
+ }
+ };
+
+ inline encoded_result<char> code_point_to_utf8(char32_t codepoint) {
+ encoded_result<char> er;
+ er.error = error_code::ok;
+ if (codepoint <= unicode_detail::last_1byte_value) {
+ er.code_units_size = 1;
+ er.code_units = std::array<char, 4>{ { static_cast<char>(codepoint) } };
+ }
+ else if (codepoint <= unicode_detail::last_2byte_value) {
+ er.code_units_size = 2;
+ er.code_units = std::array<char, 4>{{
+ static_cast<char>(0xC0 | ((codepoint & 0x7C0) >> 6)),
+ static_cast<char>(0x80 | (codepoint & 0x3F)),
+ }};
+ }
+ else if (codepoint <= unicode_detail::last_3byte_value) {
+ er.code_units_size = 3;
+ er.code_units = std::array<char, 4>{{
+ static_cast<char>(0xE0 | ((codepoint & 0xF000) >> 12)),
+ static_cast<char>(0x80 | ((codepoint & 0xFC0) >> 6)),
+ static_cast<char>(0x80 | (codepoint & 0x3F)),
+ }};
+ }
+ else {
+ er.code_units_size = 4;
+ er.code_units = std::array<char, 4>{ {
+ static_cast<char>(0xF0 | ((codepoint & 0x1C0000) >> 18)),
+ static_cast<char>(0x80 | ((codepoint & 0x3F000) >> 12)),
+ static_cast<char>(0x80 | ((codepoint & 0xFC0) >> 6)),
+ static_cast<char>(0x80 | (codepoint & 0x3F)),
+ } };
+ }
+ return er;
+ }
+
+ inline encoded_result<char16_t> code_point_to_utf16(char32_t codepoint) {
+ encoded_result<char16_t> er;
+
+ if (codepoint <= unicode_detail::last_bmp_value) {
+ er.code_units_size = 1;
+ er.code_units = std::array<char16_t, 4>{ { static_cast<char16_t>(codepoint) } };
+ er.error = error_code::ok;
+ }
+ else {
+ auto normal = codepoint - unicode_detail::normalizing_value;
+ auto lead = unicode_detail::first_lead_surrogate + ((normal & unicode_detail::lead_surrogate_bitmask) >> unicode_detail::lead_shifted_bits);
+ auto trail = unicode_detail::first_trail_surrogate + (normal & unicode_detail::trail_surrogate_bitmask);
+ er.code_units = std::array<char16_t, 4>{ {
+ static_cast<char16_t>(lead),
+ static_cast<char16_t>(trail)
+ } };
+ er.code_units_size = 2;
+ er.error = error_code::ok;
+ }
+ return er;
+ }
+
+ inline encoded_result<char32_t> code_point_to_utf32(char32_t codepoint) {
+ encoded_result<char32_t> er;
+ er.code_units_size = 1;
+ er.code_units[0] = codepoint;
+ er.error = error_code::ok;
+ return er;
+ }
+
+ template <typename It>
+ inline decoded_result<It> utf8_to_code_point(It it, It last) {
+ decoded_result<It> dr;
+ if (it == last) {
+ dr.next = it;
+ dr.error = error_code::sequence_too_short;
+ return dr;
+ }
+
+ unsigned char b0 = *it;
+ std::size_t length = unicode_detail::sequence_length(b0);
+
+ if (length == 1) {
+ dr.codepoint = static_cast<char32_t>(b0);
+ dr.error = error_code::ok;
+ ++it;
+ dr.next = it;
+ return dr;
+ }
+
+ if (unicode_detail::is_invalid(b0) || unicode_detail::is_continuation(b0)) {
+ dr.error = error_code::invalid_code_unit;
+ dr.next = it;
+ return dr;
+ }
+
+ ++it;
+ std::array<unsigned char, 4> b;
+ b[0] = b0;
+ for (std::size_t i = 1; i < length; ++i) {
+ b[i] = *it;
+ if (!unicode_detail::is_continuation(b[i])) {
+ dr.error = error_code::invalid_code_unit;
+ dr.next = it;
+ return dr;
+ }
+ ++it;
+ }
+
+ char32_t decoded;
+ switch (length) {
+ case 2:
+ decoded = unicode_detail::decode(b[0], b[1]);
+ break;
+ case 3:
+ decoded = unicode_detail::decode(b[0], b[1], b[2]);
+ break;
+ default:
+ decoded = unicode_detail::decode(b[0], b[1], b[2], b[3]);
+ break;
+ }
+
+ if (unicode_detail::is_overlong(decoded, length)) {
+ dr.error = error_code::overlong_sequence;
+ return dr;
+ }
+ if (unicode_detail::is_surrogate(decoded) || decoded > unicode_detail::last_code_point) {
+ dr.error = error_code::invalid_code_point;
+ return dr;
+ }
+
+ // then everything is fine
+ dr.codepoint = decoded;
+ dr.error = error_code::ok;
+ dr.next = it;
+ return dr;
+ }
+
+ template <typename It>
+ inline decoded_result<It> utf16_to_code_point(It it, It last) {
+ decoded_result<It> dr;
+ if (it == last) {
+ dr.next = it;
+ dr.error = error_code::sequence_too_short;
+ return dr;
+ }
+
+ char16_t lead = static_cast<char16_t>(*it);
+
+ if (!unicode_detail::is_surrogate(lead)) {
+ ++it;
+ dr.codepoint = static_cast<char32_t>(lead);
+ dr.next = it;
+ dr.error = error_code::ok;
+ return dr;
+ }
+ if (!unicode_detail::is_lead_surrogate(lead)) {
+ dr.error = error_code::invalid_leading_surrogate;
+ dr.next = it;
+ return dr;
+ }
+
+ ++it;
+ auto trail = *it;
+ if (!unicode_detail::is_trail_surrogate(trail)) {
+ dr.error = error_code::invalid_trailing_surrogate;
+ dr.next = it;
+ return dr;
+ }
+
+ dr.codepoint = unicode_detail::combine_surrogates(lead, trail);
+ dr.next = ++it;
+ dr.error = error_code::ok;
+ return dr;
+ }
+
+ template <typename It>
+ inline decoded_result<It> utf32_to_code_point(It it, It last) {
+ decoded_result<It> dr;
+ if (it == last) {
+ dr.next = it;
+ dr.error = error_code::sequence_too_short;
+ return dr;
+ }
+ dr.codepoint = static_cast<char32_t>(*it);
+ dr.next = ++it;
+ dr.error = error_code::ok;
+ return dr;
+ }
+ }
+}
+// end of sol/unicode.hpp
+
+#include <memory>
+#include <functional>
+#include <utility>
+#include <cstdlib>
+#include <cmath>
+#include <string_view>
+#if SOL_IS_ON(SOL_STD_VARIANT_I_)
+#include <variant>
+#endif // Apple clang screwed up
+
+namespace sol { namespace stack {
+
+ namespace stack_detail {
+ template <typename Ch>
+ struct count_code_units_utf {
+ std::size_t needed_size;
+
+ count_code_units_utf() : needed_size(0) {
+ }
+
+ void operator()(const unicode::encoded_result<Ch> er) {
+ needed_size += er.code_units_size;
+ }
+ };
+
+ template <typename Ch, typename ErCh>
+ struct copy_code_units_utf {
+ Ch* target_;
+
+ copy_code_units_utf(Ch* target) : target_(target) {
+ }
+
+ void operator()(const unicode::encoded_result<ErCh> er) {
+ std::memcpy(target_, er.code_units.data(), er.code_units_size * sizeof(ErCh));
+ target_ += er.code_units_size;
+ }
+ };
+
+ template <typename Ch, typename F>
+ inline void convert(const char* strb, const char* stre, F&& f) {
+ char32_t cp = 0;
+ for (const char* strtarget = strb; strtarget < stre;) {
+ auto dr = unicode::utf8_to_code_point(strtarget, stre);
+ if (dr.error != unicode::error_code::ok) {
+ cp = unicode::unicode_detail::replacement;
+ ++strtarget;
+ }
+ else {
+ cp = dr.codepoint;
+ strtarget = dr.next;
+ }
+ if constexpr (std::is_same_v<Ch, char32_t>) {
+ auto er = unicode::code_point_to_utf32(cp);
+ f(er);
+ }
+ else {
+ auto er = unicode::code_point_to_utf16(cp);
+ f(er);
+ }
+ }
+ }
+
+ template <typename BaseCh, typename S>
+ inline S get_into(lua_State* L, int index, record& tracking) {
+ using Ch = typename S::value_type;
+ tracking.use(1);
+ size_t len;
+ auto utf8p = lua_tolstring(L, index, &len);
+ if (len < 1)
+ return S();
+ const char* strb = utf8p;
+ const char* stre = utf8p + len;
+ stack_detail::count_code_units_utf<BaseCh> count_units;
+ convert<BaseCh>(strb, stre, count_units);
+ S r(count_units.needed_size, static_cast<Ch>(0));
+ r.resize(count_units.needed_size);
+ Ch* target = &r[0];
+ stack_detail::copy_code_units_utf<Ch, BaseCh> copy_units(target);
+ convert<BaseCh>(strb, stre, copy_units);
+ return r;
+ }
+ } // namespace stack_detail
+
+ template <typename T, typename>
+ struct unqualified_getter {
+ static decltype(auto) get(lua_State* L, int index, record& tracking) {
+ if constexpr (std::is_same_v<T, bool>) {
+ tracking.use(1);
+ return lua_toboolean(L, index) != 0;
+ }
+ else if constexpr (std::is_enum_v<T>) {
+ tracking.use(1);
+ return static_cast<T>(lua_tointegerx(L, index, nullptr));
+ }
+ else if constexpr (std::is_integral_v<T> || std::is_same_v<T, lua_Integer>) {
+ tracking.use(1);
+#if SOL_LUA_VESION_I_ >= 503
+ if (lua_isinteger(L, index) != 0) {
+ return static_cast<T>(lua_tointeger(L, index));
+ }
+#endif
+ return static_cast<T>(llround(lua_tonumber(L, index)));
+ }
+ else if constexpr (std::is_floating_point_v<T> || std::is_same_v<T, lua_Number>) {
+ tracking.use(1);
+ return static_cast<T>(lua_tonumber(L, index));
+ }
+ else if constexpr (is_lua_reference_v<T>) {
+ tracking.use(1);
+ return T(L, index);
+ }
+ else if constexpr (is_unique_usertype_v<T>) {
+ using Real = typename unique_usertype_traits<T>::actual_type;
+
+ tracking.use(1);
+ void* memory = lua_touserdata(L, index);
+ memory = detail::align_usertype_unique<Real>(memory);
+ Real* mem = static_cast<Real*>(memory);
+ return *mem;
+ }
+ else if constexpr (meta::is_optional_v<T>) {
+ using ValueType = typename T::value_type;
+ return unqualified_check_getter<ValueType>::template get_using<T>(L, index, no_panic, tracking);
+ }
+ else if constexpr (std::is_same_v<T, luaL_Stream*>) {
+ luaL_Stream* pstream = static_cast<luaL_Stream*>(lua_touserdata(L, index));
+ return pstream;
+ }
+ else if constexpr (std::is_same_v<T, luaL_Stream>) {
+ luaL_Stream* pstream = static_cast<luaL_Stream*>(lua_touserdata(L, index));
+ return *pstream;
+ }
+#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE_I_)
+ 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);
+ }
+#endif
+ else {
+ return stack_detail::unchecked_unqualified_get<detail::as_value_tag<T>>(L, index, tracking);
+ }
+ }
+ };
+
+ template <typename X, typename>
+ struct qualified_getter {
+ static decltype(auto) get(lua_State* L, int index, record& tracking) {
+ using Tu = meta::unqualified_t<X>;
+ static constexpr bool is_userdata_of_some_kind
+ = !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>;
+ if constexpr (is_userdata_of_some_kind) {
+ if (type_of(L, index) == type::userdata) {
+ return static_cast<Tu>(stack_detail::unchecked_unqualified_get<Tu>(L, index, tracking));
+ }
+ else {
+ return stack_detail::unchecked_unqualified_get<sol::nested<Tu>>(L, index, tracking);
+ }
+ }
+ else if constexpr (!std::is_reference_v<X> && is_unique_usertype_v<Tu> && !is_base_rebindable_non_void_v<unique_usertype_traits<Tu>>) {
+ using u_traits = unique_usertype_traits<Tu>;
+ using T = typename u_traits::type;
+ using Real = typename u_traits::actual_type;
+ tracking.use(1);
+ void* memory = lua_touserdata(L, index);
+ memory = detail::align_usertype_unique_destructor(memory);
+ detail::unique_destructor& pdx = *static_cast<detail::unique_destructor*>(memory);
+ if (&detail::usertype_unique_alloc_destroy<T, X> == pdx) {
+ memory = detail::align_usertype_unique_tag<true, false>(memory);
+ memory = detail::align_usertype_unique<Real, true, false>(memory);
+ Real* mem = static_cast<Real*>(memory);
+ return static_cast<Real>(*mem);
+ }
+ Real r(nullptr);
+ if constexpr (!derive<T>::value) {
+ // TODO: abort / terminate, maybe only in debug modes?
+ return static_cast<Real>(std::move(r));
+ }
+ else {
+ memory = detail::align_usertype_unique_tag<true, false>(memory);
+ detail::unique_tag& ic = *reinterpret_cast<detail::unique_tag*>(memory);
+ memory = detail::align_usertype_unique<Real, true, false>(memory);
+ string_view ti = usertype_traits<T>::qualified_name();
+ int cast_operation;
+ if constexpr (is_base_rebindable_v<u_traits>) {
+ using rebind_t = typename u_traits::template rebind_base<void>;
+ string_view rebind_ti = usertype_traits<rebind_t>::qualified_name();
+ cast_operation = ic(memory, &r, ti, rebind_ti);
+ }
+ else {
+ string_view rebind_ti("");
+ cast_operation = ic(memory, &r, ti, rebind_ti);
+ }
+ switch (cast_operation) {
+ case 1: {
+ // it's a perfect match,
+ // alias memory directly
+ Real* mem = static_cast<Real*>(memory);
+ return static_cast<Real>(*mem);
+ }
+ case 2:
+ // it's a base match, return the
+ // aliased creation
+ return static_cast<Real>(std::move(r));
+ default:
+ // uh oh..
+ break;
+ }
+ // TODO: abort / terminate, maybe only in debug modes?
+ return static_cast<Real>(r);
+ }
+ }
+ else {
+ return stack_detail::unchecked_unqualified_get<Tu>(L, index, tracking);
+ }
+ }
+ };
+
+ template <typename T>
+ struct unqualified_getter<as_table_t<T>> {
+ using Tu = meta::unqualified_t<T>;
+
+ template <typename V>
+ static void push_back_at_end(std::true_type, types<V>, lua_State* L, T& cont, std::size_t) {
+ cont.push_back(stack::get<V>(L, -lua_size<V>::value));
+ }
+
+ template <typename V>
+ static void push_back_at_end(std::false_type, types<V> t, lua_State* L, T& cont, std::size_t idx) {
+ insert_at_end(meta::has_insert<Tu>(), t, L, cont, idx);
+ }
+
+ template <typename V>
+ static void insert_at_end(std::true_type, types<V>, lua_State* L, T& cont, std::size_t) {
+ using std::cend;
+ cont.insert(cend(cont), stack::get<V>(L, -lua_size<V>::value));
+ }
+
+ template <typename V>
+ static void insert_at_end(std::false_type, types<V>, lua_State* L, T& cont, std::size_t idx) {
+ cont[idx] = stack::get<V>(L, -lua_size<V>::value);
+ }
+
+ static bool max_size_check(std::false_type, T&, std::size_t) {
+ return false;
+ }
+
+ static bool max_size_check(std::true_type, T& cont, std::size_t idx) {
+ return idx >= cont.max_size();
+ }
+
+ static T get(lua_State* L, int relindex, record& tracking) {
+ return get(meta::is_associative<Tu>(), L, relindex, tracking);
+ }
+
+ static T get(std::false_type, lua_State* L, int relindex, record& tracking) {
+ typedef typename Tu::value_type V;
+ return get(types<V>(), L, relindex, tracking);
+ }
+
+ template <typename V>
+ static T get(types<V> t, lua_State* L, int relindex, record& tracking) {
+ tracking.use(1);
+
+ // the W4 flag is really great,
+ // so great that it can tell my for loops (twice nested)
+ // below never actually terminate
+ // without hitting where the gotos have infested
+
+ // so now I would get the error W4XXX unreachable
+ // me that the return cont at the end of this function
+ // which is fair until other compilers complain
+ // that there isn't a return and that based on
+ // SOME MAGICAL FORCE
+ // control flow falls off the end of a non-void function
+ // so it needs to be there for the compilers that are
+ // too flimsy to analyze the basic blocks...
+ // (I'm sure I should file a bug but those compilers are already
+ // in the wild; it doesn't matter if I fix them,
+ // someone else is still going to get some old-ass compiler
+ // and then bother me about the unclean build for the 30th
+ // time)
+
+ // "Why not an IIFE?"
+ // Because additional lambdas / functions which serve as
+ // capture-all-and-then-invoke bloat binary sizes
+ // by an actually detectable amount
+ // (one user uses sol2 pretty heavily and 22 MB of binary size
+ // was saved by reducing reliance on lambdas in templates)
+
+ // This would really be solved by having break N;
+ // be a real, proper thing...
+ // but instead, we have to use labels and gotos
+ // and earn the universal vitriol of the dogmatic
+ // programming community
+
+ // all in all: W4 is great!~
+
+ int index = lua_absindex(L, relindex);
+ T cont;
+ std::size_t idx = 0;
+#if SOL_LUA_VESION_I_ >= 503
+ // This method is HIGHLY performant over regular table iteration
+ // thanks to the Lua API changes in 5.3
+ // Questionable in 5.4
+ for (lua_Integer i = 0;; i += lua_size<V>::value) {
+ if (max_size_check(meta::has_max_size<Tu>(), cont, idx)) {
+ // see above comment
+ goto done;
+ }
+ bool isnil = false;
+ for (int vi = 0; vi < lua_size<V>::value; ++vi) {
+#if defined(LUA_NILINTABLE) && LUA_NILINTABLE && SOL_LUA_VESION_I_ >= 600
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+ lua_pushinteger(L, static_cast<lua_Integer>(i + vi));
+ if (lua_keyin(L, index) == 0) {
+ // it's time to stop
+ isnil = true;
+ }
+ else {
+ // we have a key, have to get the value
+ lua_geti(L, index, i + vi);
+ }
+#else
+ type vt = static_cast<type>(lua_geti(L, index, i + vi));
+ isnil = vt == type::none || vt == type::lua_nil;
+#endif
+ if (isnil) {
+ if (i == 0) {
+ break;
+ }
+#if defined(LUA_NILINTABLE) && LUA_NILINTABLE && SOL_LUA_VESION_I_ >= 600
+ lua_pop(L, vi);
+#else
+ lua_pop(L, (vi + 1));
+#endif
+ // see above comment
+ goto done;
+ }
+ }
+ if (isnil) {
+#if defined(LUA_NILINTABLE) && LUA_NILINTABLE && SOL_LUA_VESION_I_ >= 600
+#else
+ lua_pop(L, lua_size<V>::value);
+#endif
+ continue;
+ }
+
+ push_back_at_end(meta::has_push_back<Tu>(), t, L, cont, idx);
+ ++idx;
+ lua_pop(L, lua_size<V>::value);
+ }
+#else
+ // Zzzz slower but necessary thanks to the lower version API and missing functions qq
+ for (lua_Integer i = 0;; i += lua_size<V>::value, lua_pop(L, lua_size<V>::value)) {
+ if (idx >= cont.max_size()) {
+ // see above comment
+ goto done;
+ }
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 2, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+ bool isnil = false;
+ for (int vi = 0; vi < lua_size<V>::value; ++vi) {
+ lua_pushinteger(L, i);
+ lua_gettable(L, index);
+ type vt = type_of(L, -1);
+ isnil = vt == type::lua_nil;
+ if (isnil) {
+ if (i == 0) {
+ break;
+ }
+ lua_pop(L, (vi + 1));
+ // see above comment
+ goto done;
+ }
+ }
+ if (isnil)
+ continue;
+ push_back_at_end(meta::has_push_back<Tu>(), t, L, cont, idx);
+ ++idx;
+ }
+#endif
+ done:
+ return cont;
+ }
+
+ static T get(std::true_type, lua_State* L, int index, record& tracking) {
+ typedef typename Tu::value_type P;
+ typedef typename P::first_type K;
+ typedef typename P::second_type V;
+ return get(types<K, V>(), L, index, tracking);
+ }
+
+ template <typename K, typename V>
+ static T get(types<K, V>, lua_State* L, int relindex, record& tracking) {
+ tracking.use(1);
+
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 3, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+
+ T associative;
+ int index = lua_absindex(L, relindex);
+ lua_pushnil(L);
+ while (lua_next(L, index) != 0) {
+ decltype(auto) key = stack::check_get<K>(L, -2);
+ if (!key) {
+ lua_pop(L, 1);
+ continue;
+ }
+ associative.emplace(std::forward<decltype(*key)>(*key), stack::get<V>(L, -1));
+ lua_pop(L, 1);
+ }
+ return associative;
+ }
+ };
+
+ template <typename T, typename Al>
+ struct unqualified_getter<as_table_t<std::forward_list<T, Al>>> {
+ typedef std::forward_list<T, Al> C;
+
+ static C get(lua_State* L, int relindex, record& tracking) {
+ return get(meta::has_key_value_pair<C>(), L, relindex, tracking);
+ }
+
+ static C get(std::true_type, lua_State* L, int index, record& tracking) {
+ typedef typename T::value_type P;
+ typedef typename P::first_type K;
+ typedef typename P::second_type V;
+ return get(types<K, V>(), L, index, tracking);
+ }
+
+ static C get(std::false_type, lua_State* L, int relindex, record& tracking) {
+ typedef typename C::value_type V;
+ return get(types<V>(), L, relindex, tracking);
+ }
+
+ template <typename V>
+ static C get(types<V>, lua_State* L, int relindex, record& tracking) {
+ tracking.use(1);
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 3, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+
+ int index = lua_absindex(L, relindex);
+ C cont;
+ auto at = cont.cbefore_begin();
+ std::size_t idx = 0;
+#if SOL_LUA_VESION_I_ >= 503
+ // This method is HIGHLY performant over regular table iteration thanks to the Lua API changes in 5.3
+ for (lua_Integer i = 0;; i += lua_size<V>::value, lua_pop(L, lua_size<V>::value)) {
+ if (idx >= cont.max_size()) {
+ goto done;
+ }
+ bool isnil = false;
+ for (int vi = 0; vi < lua_size<V>::value; ++vi) {
+ type t = static_cast<type>(lua_geti(L, index, i + vi));
+ isnil = t == type::lua_nil;
+ if (isnil) {
+ if (i == 0) {
+ break;
+ }
+ lua_pop(L, (vi + 1));
+ goto done;
+ }
+ }
+ if (isnil)
+ continue;
+ at = cont.insert_after(at, stack::get<V>(L, -lua_size<V>::value));
+ ++idx;
+ }
+#else
+ // Zzzz slower but necessary thanks to the lower version API and missing functions qq
+ for (lua_Integer i = 0;; i += lua_size<V>::value, lua_pop(L, lua_size<V>::value)) {
+ if (idx >= cont.max_size()) {
+ goto done;
+ }
+ bool isnil = false;
+ for (int vi = 0; vi < lua_size<V>::value; ++vi) {
+ lua_pushinteger(L, i);
+ lua_gettable(L, index);
+ type t = type_of(L, -1);
+ isnil = t == type::lua_nil;
+ if (isnil) {
+ if (i == 0) {
+ break;
+ }
+ lua_pop(L, (vi + 1));
+ goto done;
+ }
+ }
+ if (isnil)
+ continue;
+ at = cont.insert_after(at, stack::get<V>(L, -lua_size<V>::value));
+ ++idx;
+ }
+#endif
+ done:
+ return cont;
+ }
+
+ template <typename K, typename V>
+ static C get(types<K, V>, lua_State* L, int relindex, record& tracking) {
+ tracking.use(1);
+
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 3, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+
+ C associative;
+ auto at = associative.cbefore_begin();
+ int index = lua_absindex(L, relindex);
+ lua_pushnil(L);
+ while (lua_next(L, index) != 0) {
+ decltype(auto) key = stack::check_get<K>(L, -2);
+ if (!key) {
+ lua_pop(L, 1);
+ continue;
+ }
+ at = associative.emplace_after(at, std::forward<decltype(*key)>(*key), stack::get<V>(L, -1));
+ lua_pop(L, 1);
+ }
+ return associative;
+ }
+ };
+
+ template <typename T>
+ struct unqualified_getter<nested<T>> {
+ static T get(lua_State* L, int index, record& tracking) {
+ using Tu = meta::unqualified_t<T>;
+ if constexpr (is_container_v<Tu>) {
+ if constexpr (meta::is_associative<Tu>::value) {
+ typedef typename T::value_type P;
+ typedef typename P::first_type K;
+ typedef typename P::second_type V;
+ 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);
+ }
+ else {
+ typedef typename T::value_type V;
+ 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);
+ }
+ }
+ else {
+ unqualified_getter<Tu> g;
+ // VC++ has a bad warning here: shut it up
+ (void)g;
+ return g.get(L, index, tracking);
+ }
+ }
+ };
+
+ template <typename T>
+ struct unqualified_getter<as_container_t<T>> {
+ static decltype(auto) get(lua_State* L, int index, record& tracking) {
+ return stack::unqualified_get<T>(L, index, tracking);
+ }
+ };
+
+ template <typename T>
+ struct unqualified_getter<as_container_t<T>*> {
+ static decltype(auto) get(lua_State* L, int index, record& tracking) {
+ return stack::unqualified_get<T*>(L, index, tracking);
+ }
+ };
+
+ template <>
+ struct unqualified_getter<userdata_value> {
+ static userdata_value get(lua_State* L, int index, record& tracking) {
+ tracking.use(1);
+ return userdata_value(lua_touserdata(L, index));
+ }
+ };
+
+ template <>
+ struct unqualified_getter<lightuserdata_value> {
+ static lightuserdata_value get(lua_State* L, int index, record& tracking) {
+ tracking.use(1);
+ return lightuserdata_value(lua_touserdata(L, index));
+ }
+ };
+
+ template <typename T>
+ struct unqualified_getter<light<T>> {
+ static light<T> get(lua_State* L, int index, record& tracking) {
+ tracking.use(1);
+ void* memory = lua_touserdata(L, index);
+ return light<T>(static_cast<T*>(memory));
+ }
+ };
+
+ template <typename T>
+ struct unqualified_getter<user<T>> {
+ static std::add_lvalue_reference_t<T> get(lua_State* L, int index, record& tracking) {
+ tracking.use(1);
+ void* memory = lua_touserdata(L, index);
+ memory = detail::align_user<T>(memory);
+ return *static_cast<std::remove_reference_t<T>*>(memory);
+ }
+ };
+
+ template <typename T>
+ struct unqualified_getter<user<T*>> {
+ static T* get(lua_State* L, int index, record& tracking) {
+ tracking.use(1);
+ void* memory = lua_touserdata(L, index);
+ memory = detail::align_user<T*>(memory);
+ return static_cast<T*>(memory);
+ }
+ };
+
+ template <>
+ struct unqualified_getter<type> {
+ static type get(lua_State* L, int index, record& tracking) {
+ tracking.use(1);
+ return static_cast<type>(lua_type(L, index));
+ }
+ };
+
+ template <>
+ struct unqualified_getter<std::string> {
+ static std::string get(lua_State* L, int index, record& tracking) {
+ tracking.use(1);
+ std::size_t len;
+ auto str = lua_tolstring(L, index, &len);
+ return std::string(str, len);
+ }
+ };
+
+ template <>
+ struct unqualified_getter<const char*> {
+ static const char* get(lua_State* L, int index, record& tracking) {
+ tracking.use(1);
+ size_t sz;
+ return lua_tolstring(L, index, &sz);
+ }
+ };
+
+ template <>
+ struct unqualified_getter<char> {
+ static char get(lua_State* L, int index, record& tracking) {
+ tracking.use(1);
+ size_t len;
+ auto str = lua_tolstring(L, index, &len);
+ return len > 0 ? str[0] : '\0';
+ }
+ };
+
+ template <typename Traits>
+ struct unqualified_getter<basic_string_view<char, Traits>> {
+ static string_view get(lua_State* L, int index, record& tracking) {
+ tracking.use(1);
+ size_t sz;
+ const char* str = lua_tolstring(L, index, &sz);
+ return basic_string_view<char, Traits>(str, sz);
+ }
+ };
+
+ template <typename Traits, typename Al>
+ struct unqualified_getter<std::basic_string<wchar_t, Traits, Al>> {
+ using S = std::basic_string<wchar_t, Traits, Al>;
+ static S get(lua_State* L, int index, record& tracking) {
+ using Ch = meta::conditional_t<sizeof(wchar_t) == 2, char16_t, char32_t>;
+ return stack_detail::get_into<Ch, S>(L, index, tracking);
+ }
+ };
+
+ template <typename Traits, typename Al>
+ struct unqualified_getter<std::basic_string<char16_t, Traits, Al>> {
+ static std::basic_string<char16_t, Traits, Al> get(lua_State* L, int index, record& tracking) {
+ return stack_detail::get_into<char16_t, std::basic_string<char16_t, Traits, Al>>(L, index, tracking);
+ }
+ };
+
+ template <typename Traits, typename Al>
+ struct unqualified_getter<std::basic_string<char32_t, Traits, Al>> {
+ static std::basic_string<char32_t, Traits, Al> get(lua_State* L, int index, record& tracking) {
+ return stack_detail::get_into<char32_t, std::basic_string<char32_t, Traits, Al>>(L, index, tracking);
+ }
+ };
+
+ template <>
+ struct unqualified_getter<char16_t> {
+ static char16_t get(lua_State* L, int index, record& tracking) {
+ string_view utf8 = stack::get<string_view>(L, index, tracking);
+ const char* strb = utf8.data();
+ const char* stre = utf8.data() + utf8.size();
+ char32_t cp = 0;
+ auto dr = unicode::utf8_to_code_point(strb, stre);
+ if (dr.error != unicode::error_code::ok) {
+ cp = unicode::unicode_detail::replacement;
+ }
+ else {
+ cp = dr.codepoint;
+ }
+ auto er = unicode::code_point_to_utf16(cp);
+ return er.code_units[0];
+ }
+ };
+
+ template <>
+ struct unqualified_getter<char32_t> {
+ static char32_t get(lua_State* L, int index, record& tracking) {
+ string_view utf8 = stack::get<string_view>(L, index, tracking);
+ const char* strb = utf8.data();
+ const char* stre = utf8.data() + utf8.size();
+ char32_t cp = 0;
+ auto dr = unicode::utf8_to_code_point(strb, stre);
+ if (dr.error != unicode::error_code::ok) {
+ cp = unicode::unicode_detail::replacement;
+ }
+ else {
+ cp = dr.codepoint;
+ }
+ auto er = unicode::code_point_to_utf32(cp);
+ return er.code_units[0];
+ }
+ };
+
+ template <>
+ struct unqualified_getter<wchar_t> {
+ static wchar_t get(lua_State* L, int index, record& tracking) {
+ typedef meta::conditional_t<sizeof(wchar_t) == 2, char16_t, char32_t> Ch;
+ unqualified_getter<Ch> g;
+ (void)g;
+ auto c = g.get(L, index, tracking);
+ return static_cast<wchar_t>(c);
+ }
+ };
+
+ template <>
+ struct unqualified_getter<meta_function> {
+ static meta_function get(lua_State* L, int index, record& tracking) {
+ tracking.use(1);
+ const char* name = unqualified_getter<const char*> {}.get(L, index, tracking);
+ const auto& mfnames = meta_function_names();
+ for (std::size_t i = 0; i < mfnames.size(); ++i)
+ if (mfnames[i] == name)
+ return static_cast<meta_function>(i);
+ return meta_function::construct;
+ }
+ };
+
+ template <>
+ struct unqualified_getter<lua_nil_t> {
+ static lua_nil_t get(lua_State*, int, record& tracking) {
+ tracking.use(1);
+ return lua_nil;
+ }
+ };
+
+ template <>
+ struct unqualified_getter<std::nullptr_t> {
+ static std::nullptr_t get(lua_State*, int, record& tracking) {
+ tracking.use(1);
+ return nullptr;
+ }
+ };
+
+ template <>
+ struct unqualified_getter<nullopt_t> {
+ static nullopt_t get(lua_State*, int, record& tracking) {
+ tracking.use(1);
+ return nullopt;
+ }
+ };
+
+ template <>
+ struct unqualified_getter<this_state> {
+ static this_state get(lua_State* L, int, record& tracking) {
+ tracking.use(0);
+ return this_state(L);
+ }
+ };
+
+ template <>
+ struct unqualified_getter<this_main_state> {
+ static this_main_state get(lua_State* L, int, record& tracking) {
+ tracking.use(0);
+ return this_main_state(main_thread(L, L));
+ }
+ };
+
+ template <>
+ struct unqualified_getter<lua_CFunction> {
+ static lua_CFunction get(lua_State* L, int index, record& tracking) {
+ tracking.use(1);
+ return lua_tocfunction(L, index);
+ }
+ };
+
+ template <>
+ struct unqualified_getter<c_closure> {
+ static c_closure get(lua_State* L, int index, record& tracking) {
+ tracking.use(1);
+ return c_closure(lua_tocfunction(L, index), -1);
+ }
+ };
+
+ template <>
+ struct unqualified_getter<error> {
+ static error get(lua_State* L, int index, record& tracking) {
+ tracking.use(1);
+ size_t sz = 0;
+ const char* err = lua_tolstring(L, index, &sz);
+ if (err == nullptr) {
+ return error(detail::direct_error, "");
+ }
+ return error(detail::direct_error, std::string(err, sz));
+ }
+ };
+
+ template <>
+ struct unqualified_getter<void*> {
+ static void* get(lua_State* L, int index, record& tracking) {
+ tracking.use(1);
+ return lua_touserdata(L, index);
+ }
+ };
+
+ template <>
+ struct unqualified_getter<const void*> {
+ static const void* get(lua_State* L, int index, record& tracking) {
+ tracking.use(1);
+ return lua_touserdata(L, index);
+ }
+ };
+
+ template <typename T>
+ struct unqualified_getter<detail::as_value_tag<T>> {
+ static T* get_no_lua_nil(lua_State* L, int index, record& tracking) {
+ void* memory = lua_touserdata(L, index);
+#if SOL_IS_ON(SOL_USE_INTEROP_I_)
+ auto ugr = stack_detail::interop_get<T>(L, index, memory, tracking);
+ if (ugr.first) {
+ return ugr.second;
+ }
+#endif // interop extensibility
+ tracking.use(1);
+ void* rawdata = detail::align_usertype_pointer(memory);
+ void** pudata = static_cast<void**>(rawdata);
+ void* udata = *pudata;
+ return get_no_lua_nil_from(L, udata, index, tracking);
+ }
+
+ static T* get_no_lua_nil_from(lua_State* L, void* udata, int index, record&) {
+ bool has_derived = derive<T>::value || weak_derive<T>::value;
+ if (has_derived) {
+ if (lua_getmetatable(L, index) == 1) {
+ lua_getfield(L, -1, &detail::base_class_cast_key()[0]);
+ if (type_of(L, -1) != type::lua_nil) {
+ void* basecastdata = lua_touserdata(L, -1);
+ detail::inheritance_cast_function ic = reinterpret_cast<detail::inheritance_cast_function>(basecastdata);
+ // use the casting function to properly adjust the pointer for the desired T
+ udata = ic(udata, usertype_traits<T>::qualified_name());
+ }
+ lua_pop(L, 2);
+ }
+ }
+ T* obj = static_cast<T*>(udata);
+ return obj;
+ }
+
+ static T& get(lua_State* L, int index, record& tracking) {
+ return *get_no_lua_nil(L, index, tracking);
+ }
+ };
+
+ template <typename T>
+ struct unqualified_getter<detail::as_pointer_tag<T>> {
+ static T* get(lua_State* L, int index, record& tracking) {
+ type t = type_of(L, index);
+ if (t == type::lua_nil) {
+ tracking.use(1);
+ return nullptr;
+ }
+ unqualified_getter<detail::as_value_tag<T>> g;
+ // Avoid VC++ warning
+ (void)g;
+ return g.get_no_lua_nil(L, index, tracking);
+ }
+ };
+
+ template <typename T>
+ struct unqualified_getter<non_null<T*>> {
+ static T* get(lua_State* L, int index, record& tracking) {
+ unqualified_getter<detail::as_value_tag<T>> g;
+ // Avoid VC++ warning
+ (void)g;
+ return g.get_no_lua_nil(L, index, tracking);
+ }
+ };
+
+ template <typename T>
+ struct unqualified_getter<T&> {
+ static T& get(lua_State* L, int index, record& tracking) {
+ unqualified_getter<detail::as_value_tag<T>> g;
+ // Avoid VC++ warning
+ (void)g;
+ return g.get(L, index, tracking);
+ }
+ };
+
+ template <typename T>
+ struct unqualified_getter<std::reference_wrapper<T>> {
+ static T& get(lua_State* L, int index, record& tracking) {
+ unqualified_getter<T&> g;
+ // Avoid VC++ warning
+ (void)g;
+ return g.get(L, index, tracking);
+ }
+ };
+
+ template <typename T>
+ struct unqualified_getter<T*> {
+ static T* get(lua_State* L, int index, record& tracking) {
+#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE_I_)
+ if constexpr (std::is_function_v<T>) {
+ return stack_detail::get_function_pointer<T>(L, index, tracking);
+ }
+ else {
+ unqualified_getter<detail::as_pointer_tag<T>> g;
+ // Avoid VC++ warning
+ (void)g;
+ return g.get(L, index, tracking);
+ }
+#else
+ unqualified_getter<detail::as_pointer_tag<T>> g;
+ // Avoid VC++ warning
+ (void)g;
+ return g.get(L, index, tracking);
+#endif
+ }
+ };
+
+ template <typename... Tn>
+ struct unqualified_getter<std::tuple<Tn...>> {
+ typedef std::tuple<decltype(stack::get<Tn>(nullptr, 0))...> R;
+
+ template <typename... Args>
+ static R apply(std::index_sequence<>, lua_State*, int, record&, Args&&... args) {
+ // Fuck you too, VC++
+ return R { std::forward<Args>(args)... };
+ }
+
+ template <std::size_t I, std::size_t... Ix, typename... Args>
+ static R apply(std::index_sequence<I, Ix...>, lua_State* L, int index, record& tracking, Args&&... args) {
+ // Fuck you too, VC++
+ typedef std::tuple_element_t<I, std::tuple<Tn...>> T;
+ return apply(std::index_sequence<Ix...>(), L, index, tracking, std::forward<Args>(args)..., stack::get<T>(L, index + tracking.used, tracking));
+ }
+
+ static R get(lua_State* L, int index, record& tracking) {
+ return apply(std::make_index_sequence<sizeof...(Tn)>(), L, index, tracking);
+ }
+ };
+
+ template <typename A, typename B>
+ struct unqualified_getter<std::pair<A, B>> {
+ static decltype(auto) get(lua_State* L, int index, record& tracking) {
+ return std::pair<decltype(stack::get<A>(L, index)), decltype(stack::get<B>(L, index))> { stack::get<A>(L, index, tracking),
+ stack::get<B>(L, index + tracking.used, tracking) };
+ }
+ };
+
+#if SOL_IS_ON(SOL_STD_VARIANT_I_)
+
+ template <typename... Tn>
+ struct unqualified_getter<std::variant<Tn...>> {
+ using V = std::variant<Tn...>;
+
+ static V get_one(std::integral_constant<std::size_t, std::variant_size_v<V>>, lua_State* L, int index, record& tracking) {
+ (void)L;
+ (void)index;
+ (void)tracking;
+ if constexpr (std::variant_size_v<V> == 0) {
+ return V();
+ }
+ else {
+ // using T = std::variant_alternative_t<0, V>;
+ std::abort();
+ // return V(std::in_place_index<0>, stack::get<T>(L, index, tracking));
+ }
+ }
+
+ template <std::size_t I>
+ static V get_one(std::integral_constant<std::size_t, I>, lua_State* L, int index, record& tracking) {
+ typedef std::variant_alternative_t<I, V> T;
+ record temp_tracking = tracking;
+ if (stack::check<T>(L, index, no_panic, temp_tracking)) {
+ tracking = temp_tracking;
+ return V(std::in_place_index<I>, stack::get<T>(L, index));
+ }
+ return get_one(std::integral_constant<std::size_t, I + 1>(), L, index, tracking);
+ }
+
+ static V get(lua_State* L, int index, record& tracking) {
+ return get_one(std::integral_constant<std::size_t, 0>(), L, index, tracking);
+ }
+ };
+#endif // variant
+
+}} // namespace sol::stack
+
+// end of sol/stack_get_unqualified.hpp
+
+// beginning of sol/stack_get_qualified.hpp
+
+namespace sol {
+namespace stack {
+
+ // There are no more enable_ifs that can be used here,
+ // so this is just for posterity, I guess?
+ // maybe I'll fill this file in later.
+
+}
+} // namespace sol::stack
+
+// end of sol/stack_get_qualified.hpp
+
+// end of sol/stack_get.hpp
+
+// beginning of sol/stack_check_get.hpp
+
+// beginning of sol/stack_check_get_unqualified.hpp
+
+#include <cstdlib>
+#include <cmath>
+#include <optional>
+#if SOL_IS_ON(SOL_STD_VARIANT_I_)
+#include <variant>
+#endif // variant shenanigans (thanks, Mac OSX)
+
+namespace sol { namespace stack {
+ template <typename T, typename>
+ struct unqualified_check_getter {
+ typedef decltype(stack_detail::unchecked_unqualified_get<T>(nullptr, -1, std::declval<record&>())) R;
+
+ template <typename Optional, typename Handler>
+ static Optional get_using(lua_State* L, int index, Handler&& handler, record& tracking) {
+ if constexpr (!meta::meta_detail::is_adl_sol_lua_check_v<T> && !meta::meta_detail::is_adl_sol_lua_get_v<T>) {
+ if constexpr (is_lua_reference_v<T>) {
+ // actually check if it's none here, otherwise
+ // we'll have a none object inside an optional!
+ bool success = lua_isnoneornil(L, index) == 0 && stack::check<T>(L, index, no_panic);
+ if (!success) {
+ // expected type, actual type
+ tracking.use(static_cast<int>(success));
+ handler(L, index, type::poly, type_of(L, index), "");
+ return detail::associated_nullopt_v<Optional>;
+ }
+ return stack_detail::unchecked_get<T>(L, index, tracking);
+ }
+ else if constexpr ((std::is_integral_v<T> || std::is_same_v<T, lua_Integer>)&&!std::is_same_v<T, bool>) {
+#if SOL_LUA_VESION_I_ >= 503
+ if (lua_isinteger(L, index) != 0) {
+ tracking.use(1);
+ return static_cast<T>(lua_tointeger(L, index));
+ }
+#endif
+ int isnum = 0;
+ const lua_Number value = lua_tonumberx(L, index, &isnum);
+ if (isnum != 0) {
+#if SOL_IS_ON(SOL_NUMBER_PRECISION_CHECKS_I_)
+ const auto integer_value = llround(value);
+ if (static_cast<lua_Number>(integer_value) == value) {
+ tracking.use(1);
+ return static_cast<T>(integer_value);
+ }
+#else
+ tracking.use(1);
+ return static_cast<T>(value);
+#endif
+ }
+ const type t = type_of(L, index);
+ tracking.use(static_cast<int>(t != type::none));
+ handler(L, index, type::number, t, "not an integer");
+ return detail::associated_nullopt_v<Optional>;
+ }
+ else if constexpr (std::is_floating_point_v<T> || std::is_same_v<T, lua_Number>) {
+ int isnum = 0;
+ lua_Number value = lua_tonumberx(L, index, &isnum);
+ if (isnum == 0) {
+ type t = type_of(L, index);
+ tracking.use(static_cast<int>(t != type::none));
+ handler(L, index, type::number, t, "not a valid floating point number");
+ return detail::associated_nullopt_v<Optional>;
+ }
+ tracking.use(1);
+ return static_cast<T>(value);
+ }
+ else if constexpr (std::is_enum_v<T> && !meta::any_same_v<T, meta_function, type>) {
+ int isnum = 0;
+ lua_Integer value = lua_tointegerx(L, index, &isnum);
+ if (isnum == 0) {
+ type t = type_of(L, index);
+ tracking.use(static_cast<int>(t != type::none));
+ handler(L, index, type::number, t, "not a valid enumeration value");
+ return detail::associated_nullopt_v<Optional>;
+ }
+ tracking.use(1);
+ return static_cast<T>(value);
+ }
+ else {
+ if (!unqualified_check<T>(L, index, std::forward<Handler>(handler))) {
+ tracking.use(static_cast<int>(!lua_isnone(L, index)));
+ return detail::associated_nullopt_v<Optional>;
+ }
+ return stack_detail::unchecked_unqualified_get<T>(L, index, tracking);
+ }
+ }
+ else {
+ if (!unqualified_check<T>(L, index, std::forward<Handler>(handler))) {
+ tracking.use(static_cast<int>(!lua_isnone(L, index)));
+ return detail::associated_nullopt_v<Optional>;
+ }
+ return stack_detail::unchecked_unqualified_get<T>(L, index, tracking);
+ }
+ }
+
+ template <typename Handler>
+ static optional<R> get(lua_State* L, int index, Handler&& handler, record& tracking) {
+ return get_using<optional<R>>(L, index, std::forward<Handler>(handler), tracking);
+ }
+ };
+
+#if SOL_IS_ON(SOL_STD_VARIANT_I_)
+ template <typename... Tn, typename C>
+ struct unqualified_check_getter<std::variant<Tn...>, C> {
+ typedef std::variant<Tn...> V;
+ typedef std::variant_size<V> V_size;
+ typedef std::integral_constant<bool, V_size::value == 0> V_is_empty;
+
+ template <typename Handler>
+ static optional<V> get_empty(std::true_type, lua_State*, int, Handler&&, record&) {
+ return nullopt;
+ }
+
+ template <typename Handler>
+ static optional<V> get_empty(std::false_type, lua_State* L, int index, Handler&& handler, record&) {
+ // This should never be reached...
+ // please check your code and understand what you did to bring yourself here
+ // maybe file a bug report, or 5
+ handler(
+ L, index, type::poly, type_of(L, index), "this variant code should never be reached: if it has, you have done something so terribly wrong");
+ return nullopt;
+ }
+
+ template <typename Handler>
+ static optional<V> get_one(std::integral_constant<std::size_t, 0>, lua_State* L, int index, Handler&& handler, record& tracking) {
+ return get_empty(V_is_empty(), L, index, std::forward<Handler>(handler), tracking);
+ }
+
+ template <std::size_t I, typename Handler>
+ static optional<V> get_one(std::integral_constant<std::size_t, I>, lua_State* L, int index, Handler&& handler, record& tracking) {
+ typedef std::variant_alternative_t<I - 1, V> T;
+ if (stack::check<T>(L, index, no_panic, tracking)) {
+ return V(std::in_place_index<I - 1>, stack::get<T>(L, index));
+ }
+ return get_one(std::integral_constant<std::size_t, I - 1>(), L, index, std::forward<Handler>(handler), tracking);
+ }
+
+ template <typename Handler>
+ static optional<V> get(lua_State* L, int index, Handler&& handler, record& tracking) {
+ return get_one(std::integral_constant<std::size_t, V_size::value>(), L, index, std::forward<Handler>(handler), tracking);
+ }
+ };
+#endif // standard variant
+}} // namespace sol::stack
+
+// end of sol/stack_check_get_unqualified.hpp
+
+// beginning of sol/stack_check_get_qualified.hpp
+
+namespace sol { namespace stack {
+ template <typename T, typename C>
+ struct qualified_check_getter {
+ typedef decltype(stack_detail::unchecked_get<T>(nullptr, -1, std::declval<record&>())) R;
+
+ template <typename Handler>
+ static optional<R> get(lua_State* L, int index, Handler&& handler, record& tracking) {
+ if constexpr (is_lua_reference_v<T>) {
+ // actually check if it's none here, otherwise
+ // we'll have a none object inside an optional!
+ bool success = lua_isnoneornil(L, index) == 0 && stack::check<T>(L, index, no_panic);
+ if (!success) {
+ // expected type, actual type
+ tracking.use(static_cast<int>(success));
+ handler(L, index, type::poly, type_of(L, index), "");
+ return nullopt;
+ }
+ return stack_detail::unchecked_get<T>(L, index, tracking);
+ }
+ else {
+ if (!check<T>(L, index, std::forward<Handler>(handler))) {
+ tracking.use(static_cast<int>(!lua_isnone(L, index)));
+ return nullopt;
+ }
+ return stack_detail::unchecked_get<T>(L, index, tracking);
+ }
+ }
+ };
+
+ template <typename T>
+ struct qualified_getter<T, std::enable_if_t<meta::is_optional_v<T>>> {
+ static T get(lua_State* L, int index, record& tracking) {
+ using ValueType = typename meta::unqualified_t<T>::value_type;
+ if constexpr (is_lua_reference_v<ValueType>) {
+ // actually check if it's none here, otherwise
+ // we'll have a none object inside an optional!
+ bool success = lua_isnoneornil(L, index) == 0 && stack::check<ValueType>(L, index, no_panic);
+ if (!success) {
+ // expected type, actual type
+ tracking.use(static_cast<int>(success));
+ return {};
+ }
+ return stack_detail::unchecked_get<ValueType>(L, index, tracking);
+ }
+ else {
+ if (!check<ValueType>(L, index, &no_panic)) {
+ tracking.use(static_cast<int>(!lua_isnone(L, index)));
+ return {};
+ }
+ return stack_detail::unchecked_get<ValueType>(L, index, tracking);
+ }
+ }
+ };
+
+}} // namespace sol::stack
+
+// end of sol/stack_check_get_qualified.hpp
+
+// end of sol/stack_check_get.hpp
+
+// beginning of sol/stack_push.hpp
+
+#include <memory>
+#include <type_traits>
+#include <cassert>
+#include <limits>
+#include <cmath>
+#include <string_view>
+#if SOL_IS_ON(SOL_STD_VARIANT_I_)
+#include <variant>
+#endif // Can use variant
+
+namespace sol { namespace stack {
+ namespace stack_detail {
+ template <typename T>
+ inline bool integer_value_fits(const T& value) {
+ if constexpr (sizeof(T) < sizeof(lua_Integer) || (std::is_signed_v<T> && sizeof(T) == sizeof(lua_Integer))) {
+ (void)value;
+ return true;
+ }
+ else {
+ auto u_min = static_cast<std::intmax_t>((std::numeric_limits<lua_Integer>::min)());
+ auto u_max = static_cast<std::uintmax_t>((std::numeric_limits<lua_Integer>::max)());
+ auto t_min = static_cast<std::intmax_t>((std::numeric_limits<T>::min)());
+ auto t_max = static_cast<std::uintmax_t>((std::numeric_limits<T>::max)());
+ return (u_min <= t_min || value >= static_cast<T>(u_min)) && (u_max >= t_max || value <= static_cast<T>(u_max));
+ }
+ }
+
+ template <typename T>
+ 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>, char /*, char8_t*/, char16_t, char32_t>) {
+ if constexpr (std::is_signed_v<T>) {
+ return stack::push(L, static_cast<std::int_least32_t>(value));
+ }
+ else {
+ return stack::push(L, static_cast<std::uint_least32_t>(value));
+ }
+ }
+ else {
+ return stack::push(L, static_cast<std::underlying_type_t<T>>(value));
+ }
+ }
+
+ template <typename T>
+ int msvc_is_ass_with_if_constexpr_push_enum(std::false_type, lua_State*, const T&) {
+ return 0;
+ }
+ } // namespace stack_detail
+
+ inline int push_environment_of(lua_State* L, int index = -1) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_environment);
+#endif // make sure stack doesn't overflow
+#if SOL_LUA_VESION_I_ < 502
+ // Use lua_getfenv
+ lua_getfenv(L, index);
+#else
+ // Use upvalues as explained in Lua 5.2 and beyond's manual
+ if (lua_getupvalue(L, index, 1) == nullptr) {
+ push(L, lua_nil);
+ return 1;
+ }
+#endif
+ return 1;
+ }
+
+ template <typename T>
+ int push_environment_of(const T& target) {
+ target.push();
+ return push_environment_of(target.lua_state(), -1) + 1;
+ }
+
+ template <typename T>
+ struct unqualified_pusher<detail::as_value_tag<T>> {
+ template <typename F, typename... Args>
+ static int push_fx(lua_State* L, F&& f, Args&&... args) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_userdata);
+#endif // make sure stack doesn't overflow
+ // Basically, we store all user-data like this:
+ // If it's a movable/copyable value (no std::ref(x)), then we store the pointer to the new
+ // data in the first sizeof(T*) bytes, and then however many bytes it takes to
+ // do the actual object. Things that are std::ref or plain T* are stored as
+ // just the sizeof(T*), and nothing else.
+ T* obj = detail::usertype_allocate<T>(L);
+ f();
+ std::allocator<T> alloc {};
+ std::allocator_traits<std::allocator<T>>::construct(alloc, obj, std::forward<Args>(args)...);
+ return 1;
+ }
+
+ template <typename K, typename... Args>
+ static int push_keyed(lua_State* L, K&& k, Args&&... args) {
+ stack_detail::undefined_metatable fx(L, &k[0], &stack::stack_detail::set_undefined_methods_on<T>);
+ return push_fx(L, fx, std::forward<Args>(args)...);
+ }
+
+ template <typename Arg, typename... Args>
+ static int push(lua_State* L, Arg&& arg, Args&&... args) {
+ if constexpr (std::is_same_v<meta::unqualified_t<Arg>, detail::with_function_tag>) {
+ (void)arg;
+ return push_fx(L, std::forward<Args>(args)...);
+ }
+ else {
+ return push_keyed(L, usertype_traits<T>::metatable(), std::forward<Arg>(arg), std::forward<Args>(args)...);
+ }
+ }
+
+ static int push(lua_State* L) {
+ return push_keyed(L, usertype_traits<T>::metatable());
+ }
+ };
+
+ template <typename T>
+ struct unqualified_pusher<detail::as_pointer_tag<T>> {
+ typedef meta::unqualified_t<T> U;
+
+ template <typename F>
+ static int push_fx(lua_State* L, F&& f, T* obj) {
+ if (obj == nullptr)
+ return stack::push(L, lua_nil);
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_userdata);
+#endif // make sure stack doesn't overflow
+ T** pref = detail::usertype_allocate_pointer<T>(L);
+ f();
+ *pref = obj;
+ return 1;
+ }
+
+ template <typename K>
+ static int push_keyed(lua_State* L, K&& k, T* obj) {
+ stack_detail::undefined_metatable fx(L, &k[0], &stack::stack_detail::set_undefined_methods_on<U*>);
+ return push_fx(L, fx, obj);
+ }
+
+ template <typename Arg, typename... Args>
+ static int push(lua_State* L, Arg&& arg, Args&&... args) {
+ if constexpr (std::is_same_v<meta::unqualified_t<Arg>, detail::with_function_tag>) {
+ (void)arg;
+ return push_fx(L, std::forward<Args>(args)...);
+ }
+ else {
+ return push_keyed(L, usertype_traits<U*>::metatable(), std::forward<Arg>(arg), std::forward<Args>(args)...);
+ }
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<detail::as_reference_tag> {
+ template <typename T>
+ static int push(lua_State* L, T&& obj) {
+ return stack::push(L, detail::ptr(obj));
+ }
+ };
+
+ namespace stack_detail {
+ template <typename T>
+ struct uu_pusher {
+ using u_traits = unique_usertype_traits<T>;
+ using P = typename u_traits::type;
+ using Real = typename u_traits::actual_type;
+
+ template <typename Arg, typename... Args>
+ static int push(lua_State* L, Arg&& arg, Args&&... args) {
+ if constexpr (std::is_base_of_v<Real, meta::unqualified_t<Arg>>) {
+ if (u_traits::is_null(arg)) {
+ return stack::push(L, lua_nil);
+ }
+ return push_deep(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+ }
+ else {
+ return push_deep(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+ }
+ }
+
+ template <typename... Args>
+ static int push_deep(lua_State* L, Args&&... args) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_userdata);
+#endif // make sure stack doesn't overflow
+ P** pref = nullptr;
+ detail::unique_destructor* fx = nullptr;
+ detail::unique_tag* id = nullptr;
+ Real* mem = detail::usertype_unique_allocate<P, Real>(L, pref, fx, id);
+ if (luaL_newmetatable(L, &usertype_traits<detail::unique_usertype<std::remove_cv_t<P>>>::metatable()[0]) == 1) {
+ detail::lua_reg_table l {};
+ int index = 0;
+ detail::indexed_insert insert_fx(l, index);
+ detail::insert_default_registrations<P>(insert_fx, detail::property_always_true);
+ l[index] = { to_string(meta_function::garbage_collect).c_str(), detail::make_destructor<T>() };
+ luaL_setfuncs(L, l, 0);
+ }
+ lua_setmetatable(L, -2);
+ *fx = detail::usertype_unique_alloc_destroy<P, Real>;
+ *id = &detail::inheritance<P>::template type_unique_cast<Real>;
+ detail::default_construct::construct(mem, std::forward<Args>(args)...);
+ *pref = unique_usertype_traits<T>::get(*mem);
+ return 1;
+ }
+ };
+ } // namespace stack_detail
+
+ template <typename T>
+ struct unqualified_pusher<detail::as_unique_tag<T>> {
+ template <typename... Args>
+ static int push(lua_State* L, Args&&... args) {
+ stack_detail::uu_pusher<T> p;
+ (void)p;
+ return p.push(L, std::forward<Args>(args)...);
+ }
+ };
+
+ template <typename T, typename>
+ struct unqualified_pusher {
+ template <typename... Args>
+ static int push(lua_State* L, Args&&... args) {
+ using Tu = meta::unqualified_t<T>;
+ if constexpr (is_lua_reference_v<Tu>) {
+ using int_arr = int[];
+ int_arr p { (std::forward<Args>(args).push(L))... };
+ return p[0];
+ }
+ else if constexpr (std::is_same_v<Tu, bool>) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+ lua_pushboolean(L, std::forward<Args>(args)...);
+ return 1;
+ }
+ else if constexpr (std::is_integral_v<Tu> || std::is_same_v<Tu, lua_Integer>) {
+ const Tu& value(std::forward<Args>(args)...);
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_integral);
+#endif // make sure stack doesn't overflow
+#if SOL_LUA_VESION_I_ >= 503
+ if (stack_detail::integer_value_fits<Tu>(value)) {
+ lua_pushinteger(L, static_cast<lua_Integer>(value));
+ return 1;
+ }
+#endif // Lua 5.3 and above
+#if SOL_IS_ON(SOL_NUMBER_PRECISION_CHECKS_I_)
+ if (static_cast<T>(llround(static_cast<lua_Number>(value))) != value) {
+#if SOL_IS_OFF(SOL_EXCEPTIONS_I_)
+ // Is this really worth it?
+ assert(false && "integer value will be misrepresented in lua");
+ lua_pushinteger(L, static_cast<lua_Integer>(value));
+ return 1;
+#else
+ throw error(detail::direct_error, "integer value will be misrepresented in lua");
+#endif // No Exceptions
+ }
+#endif // Safe Numerics and Number Precision Check
+ lua_pushnumber(L, static_cast<lua_Number>(value));
+ return 1;
+ }
+ 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_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_floating);
+#endif // make sure stack doesn't overflow
+ lua_pushnumber(L, std::forward<Args>(args)...);
+ return 1;
+ }
+ else if constexpr (std::is_same_v<Tu, luaL_Stream*>) {
+ luaL_Stream* source { std::forward<Args>(args)... };
+ luaL_Stream* stream = static_cast<luaL_Stream*>(lua_newuserdata(L, sizeof(luaL_Stream)));
+ stream->f = source->f;
+#if SOL_IS_ON(SOL_LUAL_STREAM_USE_CLOSE_FUNCTION_I_)
+ stream->closef = source->closef;
+#endif // LuaJIT and Lua 5.1 and below do not have
+ return 1;
+ }
+ else if constexpr (std::is_same_v<Tu, luaL_Stream>) {
+ luaL_Stream& source(std::forward<Args>(args)...);
+ luaL_Stream* stream = static_cast<luaL_Stream*>(lua_newuserdata(L, sizeof(luaL_Stream)));
+ stream->f = source.f;
+#if SOL_IS_ON(SOL_LUAL_STREAM_USE_CLOSE_FUNCTION_I_)
+ stream->closef = source.closef;
+#endif // LuaJIT and Lua 5.1 and below do not have
+ return 1;
+ }
+ else if constexpr (std::is_enum_v<Tu>) {
+ return stack_detail::msvc_is_ass_with_if_constexpr_push_enum(std::true_type(), L, std::forward<Args>(args)...);
+ }
+ else if constexpr (std::is_pointer_v<Tu>) {
+ return stack::push<detail::as_pointer_tag<std::remove_pointer_t<T>>>(L, std::forward<Args>(args)...);
+ }
+ else if constexpr (is_unique_usertype_v<Tu>) {
+ return stack::push<detail::as_unique_tag<T>>(L, std::forward<Args>(args)...);
+ }
+ else {
+ return stack::push<detail::as_value_tag<T>>(L, std::forward<Args>(args)...);
+ }
+ }
+ };
+
+ template <typename T>
+ struct unqualified_pusher<std::reference_wrapper<T>> {
+ static int push(lua_State* L, const std::reference_wrapper<T>& t) {
+ return stack::push(L, std::addressof(detail::deref(t.get())));
+ }
+ };
+
+ template <typename T>
+ struct unqualified_pusher<detail::as_table_tag<T>> {
+ using has_kvp = meta::has_key_value_pair<meta::unqualified_t<std::remove_pointer_t<T>>>;
+
+ static int push(lua_State* L, const T& tablecont) {
+ return push(has_kvp(), std::false_type(), L, tablecont);
+ }
+
+ static int push(lua_State* L, const T& tablecont, nested_tag_t) {
+ return push(has_kvp(), std::true_type(), L, tablecont);
+ }
+
+ static int push(std::true_type, lua_State* L, const T& tablecont) {
+ return push(has_kvp(), std::true_type(), L, tablecont);
+ }
+
+ static int push(std::false_type, lua_State* L, const T& tablecont) {
+ return push(has_kvp(), std::false_type(), L, tablecont);
+ }
+
+ template <bool is_nested>
+ static int push(std::true_type, std::integral_constant<bool, is_nested>, lua_State* L, const T& tablecont) {
+ auto& cont = detail::deref(detail::unwrap(tablecont));
+ lua_createtable(L, static_cast<int>(cont.size()), 0);
+ int tableindex = lua_gettop(L);
+ for (const auto& pair : cont) {
+ if (is_nested) {
+ set_field(L, pair.first, as_nested_ref(pair.second), tableindex);
+ }
+ else {
+ set_field(L, pair.first, pair.second, tableindex);
+ }
+ }
+ return 1;
+ }
+
+ template <bool is_nested>
+ static int push(std::false_type, std::integral_constant<bool, is_nested>, lua_State* L, const T& tablecont) {
+ auto& cont = detail::deref(detail::unwrap(tablecont));
+ lua_createtable(L, stack_detail::get_size_hint(cont), 0);
+ int tableindex = lua_gettop(L);
+ std::size_t index = 1;
+ for (const auto& i : cont) {
+#if SOL_LUA_VESION_I_ >= 503
+ int p = is_nested ? stack::push(L, as_nested_ref(i)) : stack::push(L, i);
+ for (int pi = 0; pi < p; ++pi) {
+ lua_seti(L, tableindex, static_cast<lua_Integer>(index++));
+ }
+#else
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+ lua_pushinteger(L, static_cast<lua_Integer>(index));
+ int p = is_nested ? stack::push(L, as_nested_ref(i)) : stack::push(L, i);
+ if (p == 1) {
+ ++index;
+ lua_settable(L, tableindex);
+ }
+ else {
+ int firstindex = tableindex + 1 + 1;
+ for (int pi = 0; pi < p; ++pi) {
+ stack::push(L, index);
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+ lua_pushvalue(L, firstindex);
+ lua_settable(L, tableindex);
+ ++index;
+ ++firstindex;
+ }
+ lua_pop(L, 1 + p);
+ }
+#endif // Lua Version 5.3 and others
+ }
+ // TODO: figure out a better way to do this...?
+ // set_field(L, -1, cont.size());
+ return 1;
+ }
+ };
+
+ template <typename T>
+ struct unqualified_pusher<as_table_t<T>> {
+ static int push(lua_State* L, const T& v) {
+ using inner_t = std::remove_pointer_t<meta::unwrap_unqualified_t<T>>;
+ if constexpr (is_container_v<inner_t>) {
+ return stack::push<detail::as_table_tag<T>>(L, v);
+ }
+ else {
+ return stack::push(L, v);
+ }
+ }
+ };
+
+ template <typename T>
+ struct unqualified_pusher<nested<T>> {
+ static int push(lua_State* L, const T& tablecont) {
+ using Tu = meta::unwrap_unqualified_t<T>;
+ using inner_t = std::remove_pointer_t<Tu>;
+ if constexpr (is_container_v<inner_t>) {
+ return stack::push<detail::as_table_tag<T>>(L, tablecont, nested_tag);
+ }
+ else {
+ return stack::push<Tu>(L, tablecont);
+ }
+ }
+ };
+
+ template <typename T>
+ struct unqualified_pusher<std::initializer_list<T>> {
+ static int push(lua_State* L, const std::initializer_list<T>& il) {
+ unqualified_pusher<detail::as_table_tag<std::initializer_list<T>>> p {};
+ // silence annoying VC++ warning
+ (void)p;
+ return p.push(L, il);
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<lua_nil_t> {
+ static int push(lua_State* L, lua_nil_t) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+ lua_pushnil(L);
+ return 1;
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<stack_count> {
+ static int push(lua_State*, stack_count st) {
+ return st.count;
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<metatable_key_t> {
+ static int push(lua_State* L, metatable_key_t) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+ lua_pushlstring(L, to_string(meta_function::metatable).c_str(), 4);
+ return 1;
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<std::remove_pointer_t<lua_CFunction>> {
+ static int push(lua_State* L, lua_CFunction func, int n = 0) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+ lua_pushcclosure(L, func, n);
+ return 1;
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<lua_CFunction> {
+ static int push(lua_State* L, lua_CFunction func, int n = 0) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+ lua_pushcclosure(L, func, n);
+ return 1;
+ }
+ };
+
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_)
+ template <>
+ 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) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+ lua_pushcclosure(L, func, n);
+ return 1;
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<detail::lua_CFunction_noexcept> {
+ static int push(lua_State* L, detail::lua_CFunction_noexcept func, int n = 0) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+ lua_pushcclosure(L, func, n);
+ return 1;
+ }
+ };
+#endif // noexcept function type
+
+ template <>
+ struct unqualified_pusher<c_closure> {
+ static int push(lua_State* L, c_closure cc) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+ lua_pushcclosure(L, cc.c_function, cc.upvalues);
+ return 1;
+ }
+ };
+
+ template <typename Arg, typename... Args>
+ struct unqualified_pusher<closure<Arg, Args...>> {
+ template <std::size_t... I, typename T>
+ static int push(std::index_sequence<I...>, lua_State* L, T&& c) {
+ using f_tuple = decltype(std::forward<T>(c).upvalues);
+ int pushcount = multi_push(L, std::get<I>(std::forward<f_tuple>(std::forward<T>(c).upvalues))...);
+ return stack::push(L, c_closure(c.c_function, pushcount));
+ }
+
+ template <typename T>
+ static int push(lua_State* L, T&& c) {
+ return push(std::make_index_sequence<1 + sizeof...(Args)>(), L, std::forward<T>(c));
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<void*> {
+ static int push(lua_State* L, void* userdata) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+ lua_pushlightuserdata(L, userdata);
+ return 1;
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<const void*> {
+ static int push(lua_State* L, const void* userdata) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+ lua_pushlightuserdata(L, const_cast<void*>(userdata));
+ return 1;
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<lightuserdata_value> {
+ static int push(lua_State* L, lightuserdata_value userdata) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+ lua_pushlightuserdata(L, userdata);
+ return 1;
+ }
+ };
+
+ template <typename T>
+ struct unqualified_pusher<light<T>> {
+ static int push(lua_State* L, light<T> l) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+ lua_pushlightuserdata(L, static_cast<void*>(l.value));
+ return 1;
+ }
+ };
+
+ template <typename T>
+ struct unqualified_pusher<user<T>> {
+ template <bool with_meta = true, typename Key, typename... Args>
+ static int push_with(lua_State* L, Key&& name, Args&&... args) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_userdata);
+#endif // make sure stack doesn't overflow
+ // A dumb pusher
+ T* data = detail::user_allocate<T>(L);
+ if (with_meta) {
+ // Make sure we have a plain GC set for this data
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+ if (luaL_newmetatable(L, name) != 0) {
+ lua_CFunction cdel = detail::user_alloc_destruct<T>;
+ lua_pushcclosure(L, cdel, 0);
+ lua_setfield(L, -2, "__gc");
+ }
+ lua_setmetatable(L, -2);
+ }
+ std::allocator<T> alloc {};
+ std::allocator_traits<std::allocator<T>>::construct(alloc, data, std::forward<Args>(args)...);
+ return 1;
+ }
+
+ template <typename Arg, typename... Args>
+ static int push(lua_State* L, Arg&& arg, Args&&... args) {
+ if constexpr (std::is_same_v<meta::unqualified_t<Arg>, metatable_key_t>) {
+ const auto name = &arg[0];
+ return push_with<true>(L, name, std::forward<Args>(args)...);
+ }
+ else if constexpr (std::is_same_v<meta::unqualified_t<Arg>, no_metatable_t>) {
+ (void)arg;
+ const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
+ return push_with<false>(L, name, std::forward<Args>(args)...);
+ }
+ else {
+ const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
+ return push_with(L, name, std::forward<Arg>(arg), std::forward<Args>(args)...);
+ }
+ }
+
+ static int push(lua_State* L, const user<T>& u) {
+ const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
+ return push_with(L, name, u.value);
+ }
+
+ static int push(lua_State* L, user<T>&& u) {
+ const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
+ return push_with(L, name, std::move(u.value));
+ }
+
+ static int push(lua_State* L, no_metatable_t, const user<T>& u) {
+ const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
+ return push_with<false>(L, name, u.value);
+ }
+
+ static int push(lua_State* L, no_metatable_t, user<T>&& u) {
+ const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
+ return push_with<false>(L, name, std::move(u.value));
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<userdata_value> {
+ static int push(lua_State* L, userdata_value data) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_userdata);
+#endif // make sure stack doesn't overflow
+ void** ud = detail::usertype_allocate_pointer<void>(L);
+ *ud = data.value;
+ return 1;
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<const char*> {
+ static int push_sized(lua_State* L, const char* str, std::size_t len) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+ lua_pushlstring(L, str, len);
+ return 1;
+ }
+
+ static int push(lua_State* L, const char* str) {
+ if (str == nullptr)
+ return stack::push(L, lua_nil);
+ return push_sized(L, str, std::char_traits<char>::length(str));
+ }
+
+ static int push(lua_State* L, const char* strb, const char* stre) {
+ return push_sized(L, strb, stre - strb);
+ }
+
+ static int push(lua_State* L, const char* str, std::size_t len) {
+ return push_sized(L, str, len);
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<char*> {
+ static int push_sized(lua_State* L, const char* str, std::size_t len) {
+ unqualified_pusher<const char*> p {};
+ (void)p;
+ return p.push_sized(L, str, len);
+ }
+
+ static int push(lua_State* L, const char* str) {
+ unqualified_pusher<const char*> p {};
+ (void)p;
+ return p.push(L, str);
+ }
+
+ static int push(lua_State* L, const char* strb, const char* stre) {
+ unqualified_pusher<const char*> p {};
+ (void)p;
+ return p.push(L, strb, stre);
+ }
+
+ static int push(lua_State* L, const char* str, std::size_t len) {
+ unqualified_pusher<const char*> p {};
+ (void)p;
+ return p.push(L, str, len);
+ }
+ };
+
+ template <size_t N>
+ struct unqualified_pusher<char[N]> {
+ static int push(lua_State* L, const char (&str)[N]) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+ lua_pushlstring(L, str, std::char_traits<char>::length(str));
+ return 1;
+ }
+
+ static int push(lua_State* L, const char (&str)[N], std::size_t sz) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+ lua_pushlstring(L, str, sz);
+ return 1;
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<char> {
+ static int push(lua_State* L, char c) {
+ const char str[2] = { c, '\0' };
+ return stack::push(L, static_cast<const char*>(str), 1);
+ }
+ };
+
+ template <typename Ch, typename Traits, typename Al>
+ struct unqualified_pusher<std::basic_string<Ch, Traits, Al>> {
+ static int push(lua_State* L, const std::basic_string<Ch, Traits, Al>& str) {
+ if constexpr (!std::is_same_v<Ch, char>) {
+ return stack::push(L, str.data(), str.size());
+ }
+ else {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+ lua_pushlstring(L, str.c_str(), str.size());
+ return 1;
+ }
+ }
+
+ static int push(lua_State* L, const std::basic_string<Ch, Traits, Al>& str, std::size_t sz) {
+ if constexpr (!std::is_same_v<Ch, char>) {
+ return stack::push(L, str.data(), sz);
+ }
+ else {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+ lua_pushlstring(L, str.c_str(), sz);
+ return 1;
+ }
+ }
+ };
+
+ template <typename Ch, typename Traits>
+ struct unqualified_pusher<basic_string_view<Ch, Traits>> {
+ static int push(lua_State* L, const basic_string_view<Ch, Traits>& sv) {
+ return stack::push(L, sv.data(), sv.length());
+ }
+
+ static int push(lua_State* L, const basic_string_view<Ch, Traits>& sv, std::size_t n) {
+ return stack::push(L, sv.data(), n);
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<meta_function> {
+ static int push(lua_State* L, meta_function m) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_meta_function_name);
+#endif // make sure stack doesn't overflow
+ const std::string& str = to_string(m);
+ lua_pushlstring(L, str.c_str(), str.size());
+ return 1;
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<absolute_index> {
+ static int push(lua_State* L, absolute_index ai) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+ lua_pushvalue(L, ai);
+ return 1;
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<raw_index> {
+ static int push(lua_State* L, raw_index ri) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+ lua_pushvalue(L, ri);
+ return 1;
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<ref_index> {
+ static int push(lua_State* L, ref_index ri) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+ lua_rawgeti(L, LUA_REGISTRYINDEX, ri);
+ return 1;
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<const wchar_t*> {
+ static int push(lua_State* L, const wchar_t* wstr) {
+ return push(L, wstr, std::char_traits<wchar_t>::length(wstr));
+ }
+
+ static int push(lua_State* L, const wchar_t* wstr, std::size_t sz) {
+ return push(L, wstr, wstr + sz);
+ }
+
+ static int push(lua_State* L, const wchar_t* strb, const wchar_t* stre) {
+ if constexpr (sizeof(wchar_t) == 2) {
+ const char16_t* sb = reinterpret_cast<const char16_t*>(strb);
+ const char16_t* se = reinterpret_cast<const char16_t*>(stre);
+ return stack::push(L, sb, se);
+ }
+ else {
+ const char32_t* sb = reinterpret_cast<const char32_t*>(strb);
+ const char32_t* se = reinterpret_cast<const char32_t*>(stre);
+ return stack::push(L, sb, se);
+ }
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<wchar_t*> {
+ static int push(lua_State* L, const wchar_t* str) {
+ unqualified_pusher<const wchar_t*> p {};
+ (void)p;
+ return p.push(L, str);
+ }
+
+ static int push(lua_State* L, const wchar_t* strb, const wchar_t* stre) {
+ unqualified_pusher<const wchar_t*> p {};
+ (void)p;
+ return p.push(L, strb, stre);
+ }
+
+ static int push(lua_State* L, const wchar_t* str, std::size_t len) {
+ unqualified_pusher<const wchar_t*> p {};
+ (void)p;
+ return p.push(L, str, len);
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<const char16_t*> {
+ static int convert_into(lua_State* L, char* start, std::size_t, const char16_t* strb, const char16_t* stre) {
+ char* target = start;
+ char32_t cp = 0;
+ for (const char16_t* strtarget = strb; strtarget < stre;) {
+ auto dr = unicode::utf16_to_code_point(strtarget, stre);
+ if (dr.error != unicode::error_code::ok) {
+ cp = unicode::unicode_detail::replacement;
+ }
+ else {
+ cp = dr.codepoint;
+ }
+ auto er = unicode::code_point_to_utf8(cp);
+ const char* utf8data = er.code_units.data();
+ std::memcpy(target, utf8data, er.code_units_size);
+ target += er.code_units_size;
+ strtarget = dr.next;
+ }
+
+ return stack::push(L, start, target);
+ }
+
+ static int push(lua_State* L, const char16_t* u16str) {
+ return push(L, u16str, std::char_traits<char16_t>::length(u16str));
+ }
+
+ static int push(lua_State* L, const char16_t* u16str, std::size_t sz) {
+ return push(L, u16str, u16str + sz);
+ }
+
+ static int push(lua_State* L, const char16_t* strb, const char16_t* stre) {
+ char sbo[SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_];
+ // if our max string space is small enough, use SBO
+ // right off the bat
+ std::size_t max_possible_code_units = (stre - strb) * 4;
+ if (max_possible_code_units <= SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_) {
+ return convert_into(L, sbo, max_possible_code_units, strb, stre);
+ }
+ // otherwise, we must manually count/check size
+ std::size_t needed_size = 0;
+ for (const char16_t* strtarget = strb; strtarget < stre;) {
+ auto dr = unicode::utf16_to_code_point(strtarget, stre);
+ auto er = unicode::code_point_to_utf8(dr.codepoint);
+ needed_size += er.code_units_size;
+ strtarget = dr.next;
+ }
+ if (needed_size < SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_) {
+ return convert_into(L, sbo, needed_size, strb, stre);
+ }
+ std::string u8str("", 0);
+ u8str.resize(needed_size);
+ char* target = const_cast<char*>(u8str.data());
+ return convert_into(L, target, needed_size, strb, stre);
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<char16_t*> {
+ static int push(lua_State* L, const char16_t* str) {
+ unqualified_pusher<const char16_t*> p {};
+ (void)p;
+ return p.push(L, str);
+ }
+
+ static int push(lua_State* L, const char16_t* strb, const char16_t* stre) {
+ unqualified_pusher<const char16_t*> p {};
+ (void)p;
+ return p.push(L, strb, stre);
+ }
+
+ static int push(lua_State* L, const char16_t* str, std::size_t len) {
+ unqualified_pusher<const char16_t*> p {};
+ (void)p;
+ return p.push(L, str, len);
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<const char32_t*> {
+ static int convert_into(lua_State* L, char* start, std::size_t, const char32_t* strb, const char32_t* stre) {
+ char* target = start;
+ char32_t cp = 0;
+ for (const char32_t* strtarget = strb; strtarget < stre;) {
+ auto dr = unicode::utf32_to_code_point(strtarget, stre);
+ if (dr.error != unicode::error_code::ok) {
+ cp = unicode::unicode_detail::replacement;
+ }
+ else {
+ cp = dr.codepoint;
+ }
+ auto er = unicode::code_point_to_utf8(cp);
+ const char* data = er.code_units.data();
+ std::memcpy(target, data, er.code_units_size);
+ target += er.code_units_size;
+ strtarget = dr.next;
+ }
+ return stack::push(L, start, target);
+ }
+
+ static int push(lua_State* L, const char32_t* u32str) {
+ return push(L, u32str, u32str + std::char_traits<char32_t>::length(u32str));
+ }
+
+ static int push(lua_State* L, const char32_t* u32str, std::size_t sz) {
+ return push(L, u32str, u32str + sz);
+ }
+
+ static int push(lua_State* L, const char32_t* strb, const char32_t* stre) {
+ char sbo[SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_];
+ // if our max string space is small enough, use SBO
+ // right off the bat
+ std::size_t max_possible_code_units = (stre - strb) * 4;
+ if (max_possible_code_units <= SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_) {
+ return convert_into(L, sbo, max_possible_code_units, strb, stre);
+ }
+ // otherwise, we must manually count/check size
+ std::size_t needed_size = 0;
+ for (const char32_t* strtarget = strb; strtarget < stre;) {
+ auto dr = unicode::utf32_to_code_point(strtarget, stre);
+ auto er = unicode::code_point_to_utf8(dr.codepoint);
+ needed_size += er.code_units_size;
+ strtarget = dr.next;
+ }
+ if (needed_size < SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_) {
+ return convert_into(L, sbo, needed_size, strb, stre);
+ }
+ std::string u8str("", 0);
+ u8str.resize(needed_size);
+ char* target = const_cast<char*>(u8str.data());
+ return convert_into(L, target, needed_size, strb, stre);
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<char32_t*> {
+ static int push(lua_State* L, const char32_t* str) {
+ unqualified_pusher<const char32_t*> p {};
+ (void)p;
+ return p.push(L, str);
+ }
+
+ static int push(lua_State* L, const char32_t* strb, const char32_t* stre) {
+ unqualified_pusher<const char32_t*> p {};
+ (void)p;
+ return p.push(L, strb, stre);
+ }
+
+ static int push(lua_State* L, const char32_t* str, std::size_t len) {
+ unqualified_pusher<const char32_t*> p {};
+ (void)p;
+ return p.push(L, str, len);
+ }
+ };
+
+ template <size_t N>
+ struct unqualified_pusher<wchar_t[N]> {
+ static int push(lua_State* L, const wchar_t (&str)[N]) {
+ return push(L, str, std::char_traits<wchar_t>::length(str));
+ }
+
+ static int push(lua_State* L, const wchar_t (&str)[N], std::size_t sz) {
+ const wchar_t* str_ptr = static_cast<const wchar_t*>(str);
+ return stack::push<const wchar_t*>(L, str_ptr, str_ptr + sz);
+ }
+ };
+
+ template <size_t N>
+ struct unqualified_pusher<char16_t[N]> {
+ static int push(lua_State* L, const char16_t (&str)[N]) {
+ return push(L, str, std::char_traits<char16_t>::length(str));
+ }
+
+ static int push(lua_State* L, const char16_t (&str)[N], std::size_t sz) {
+ const char16_t* str_ptr = static_cast<const char16_t*>(str);
+ return stack::push<const char16_t*>(L, str_ptr, str_ptr + sz);
+ }
+ };
+
+ template <size_t N>
+ struct unqualified_pusher<char32_t[N]> {
+ static int push(lua_State* L, const char32_t (&str)[N]) {
+ return push(L, str, std::char_traits<char32_t>::length(str));
+ }
+
+ static int push(lua_State* L, const char32_t (&str)[N], std::size_t sz) {
+ const char32_t* str_ptr = static_cast<const char32_t*>(str);
+ return stack::push<const char32_t*>(L, str_ptr, str_ptr + sz);
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<wchar_t> {
+ static int push(lua_State* L, wchar_t c) {
+ const wchar_t str[2] = { c, '\0' };
+ return stack::push(L, static_cast<const wchar_t*>(str), 1);
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<char16_t> {
+ static int push(lua_State* L, char16_t c) {
+ const char16_t str[2] = { c, '\0' };
+ return stack::push(L, static_cast<const char16_t*>(str), 1);
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<char32_t> {
+ static int push(lua_State* L, char32_t c) {
+ const char32_t str[2] = { c, '\0' };
+ return stack::push(L, static_cast<const char32_t*>(str), 1);
+ }
+ };
+
+ template <typename... Args>
+ struct unqualified_pusher<std::tuple<Args...>> {
+ template <std::size_t... I, typename T>
+ static int push(std::index_sequence<I...>, lua_State* L, T&& t) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, static_cast<int>(sizeof...(I)), detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+ int pushcount = 0;
+ (void)detail::swallow { 0, (pushcount += stack::push(L, std::get<I>(std::forward<T>(t))), 0)... };
+ return pushcount;
+ }
+
+ template <typename T>
+ static int push(lua_State* L, T&& t) {
+ return push(std::index_sequence_for<Args...>(), L, std::forward<T>(t));
+ }
+ };
+
+ template <typename A, typename B>
+ struct unqualified_pusher<std::pair<A, B>> {
+ template <typename T>
+ static int push(lua_State* L, T&& t) {
+ int pushcount = stack::push(L, std::get<0>(std::forward<T>(t)));
+ pushcount += stack::push(L, std::get<1>(std::forward<T>(t)));
+ return pushcount;
+ }
+ };
+
+ template <typename T>
+ struct unqualified_pusher<T, std::enable_if_t<meta::is_optional_v<T>>> {
+ using ValueType = typename meta::unqualified_t<T>::value_type;
+
+ template <typename Optional>
+ static int push(lua_State* L, Optional&& op) {
+ using QualifiedValueType = meta::conditional_t<std::is_lvalue_reference_v<Optional>, ValueType&, ValueType&&>;
+ if (!op) {
+ return stack::push(L, nullopt);
+ }
+ return stack::push(L, static_cast<QualifiedValueType>(op.value()));
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<nullopt_t> {
+ static int push(lua_State* L, nullopt_t) {
+ return stack::push(L, lua_nil);
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<std::nullptr_t> {
+ static int push(lua_State* L, std::nullptr_t) {
+ return stack::push(L, lua_nil);
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<this_state> {
+ static int push(lua_State*, const this_state&) {
+ return 0;
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<this_main_state> {
+ static int push(lua_State*, const this_main_state&) {
+ return 0;
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<new_table> {
+ static int push(lua_State* L, const new_table& nt) {
+ lua_createtable(L, nt.sequence_hint, nt.map_hint);
+ return 1;
+ }
+ };
+
+ template <typename Allocator>
+ struct unqualified_pusher<basic_bytecode<Allocator>> {
+ template <typename T>
+ static int push(lua_State* L, T&& bc, const char* bytecode_name) {
+ const auto first = bc.data();
+ const auto bcsize = bc.size();
+ // pushes either the function, or an error
+ // if it errors, shit goes south, and people can test that upstream
+ (void)luaL_loadbuffer(
+ L, reinterpret_cast<const char*>(first), static_cast<std::size_t>(bcsize * (sizeof(*first) / sizeof(const char))), bytecode_name);
+ return 1;
+ }
+
+ template <typename T>
+ static int push(lua_State* L, T&& bc) {
+ return push(L, std::forward<bc>(bc), "bytecode");
+ }
+ };
+
+#if SOL_IS_ON(SOL_STD_VARIANT_I_)
+ namespace stack_detail {
+
+ struct push_function {
+ lua_State* L;
+
+ push_function(lua_State* L) : L(L) {
+ }
+
+ template <typename T>
+ int operator()(T&& value) const {
+ return stack::push<T>(L, std::forward<T>(value));
+ }
+ };
+
+ } // namespace stack_detail
+
+ template <typename... Tn>
+ struct unqualified_pusher<std::variant<Tn...>> {
+ static int push(lua_State* L, const std::variant<Tn...>& v) {
+ return std::visit(stack_detail::push_function(L), v);
+ }
+
+ static int push(lua_State* L, std::variant<Tn...>&& v) {
+ return std::visit(stack_detail::push_function(L), std::move(v));
+ }
+ };
+#endif // Variant because Clang is terrible
+
+}} // namespace sol::stack
+
+// end of sol/stack_push.hpp
+
+// beginning of sol/stack_pop.hpp
+
+#include <utility>
+#include <tuple>
+
+namespace sol {
+namespace stack {
+ template <typename T, typename>
+ struct popper {
+ inline static decltype(auto) pop(lua_State* L) {
+ if constexpr (is_stack_based_v<meta::unqualified_t<T>>) {
+ static_assert(!is_stack_based_v<meta::unqualified_t<T>>,
+ "You cannot pop something that lives solely on the stack: it will not remain on the stack when popped and thusly will go out of "
+ "scope!");
+ }
+ else {
+ record tracking{};
+ decltype(auto) r = get<T>(L, -lua_size<T>::value, tracking);
+ lua_pop(L, tracking.used);
+ return r;
+ }
+ }
+ };
+}
+} // namespace sol::stack
+
+// end of sol/stack_pop.hpp
+
+// beginning of sol/stack_field.hpp
+
+namespace sol { namespace stack {
+ template <typename T, bool global, bool raw, typename>
+ struct field_getter {
+ static constexpr int default_table_index = meta::conditional_t < meta::is_c_str_v<T>
+#if SOL_LUA_VESION_I_ >= 503
+ || (std::is_integral_v<T> && !std::is_same_v<T, bool>)
+#endif // integer global keys 5.3 or better
+ || (raw && std::is_void_v<std::remove_pointer_t<T>>),
+ std::integral_constant<int, -1>, std::integral_constant<int, -2> > ::value;
+
+ template <typename Key>
+ void get(lua_State* L, Key&& key, int tableindex = default_table_index) {
+ if constexpr (std::is_same_v<T, update_if_empty_t> || std::is_same_v<T, override_value_t> || std::is_same_v<T, create_if_nil_t>) {
+ (void)L;
+ (void)key;
+ (void)tableindex;
+ }
+ else if constexpr (std::is_same_v<T, env_key_t>) {
+ (void)key;
+#if SOL_LUA_VESION_I_ < 502
+ // Use lua_setfenv
+ lua_getfenv(L, tableindex);
+#else
+ // Use upvalues as explained in Lua 5.2 and beyond's manual
+ if (lua_getupvalue(L, tableindex, 1) == nullptr) {
+ push(L, lua_nil);
+ }
+#endif
+ }
+ else if constexpr (std::is_same_v<T, metatable_key_t>) {
+ (void)key;
+ if (lua_getmetatable(L, tableindex) == 0)
+ push(L, lua_nil);
+ }
+ else if constexpr (raw) {
+ if constexpr (std::is_integral_v<T> && !std::is_same_v<bool, T>) {
+ lua_rawgeti(L, tableindex, static_cast<lua_Integer>(key));
+ }
+#if SOL_LUA_VESION_I_ >= 502
+ else if constexpr (std::is_void_v<std::remove_pointer_t<T>>) {
+ lua_rawgetp(L, tableindex, key);
+ }
+#endif // Lua 5.2.x+
+ else {
+ push(L, std::forward<Key>(key));
+ lua_rawget(L, tableindex);
+ }
+ }
+ else {
+ if constexpr (meta::is_c_str_v<T>) {
+ if constexpr (global) {
+ (void)tableindex;
+ lua_getglobal(L, &key[0]);
+ }
+ else {
+ lua_getfield(L, tableindex, &key[0]);
+ }
+ }
+#if SOL_LUA_VESION_I_ >= 503
+ else if constexpr (std::is_integral_v<T> && !std::is_same_v<bool, T>) {
+ lua_geti(L, tableindex, static_cast<lua_Integer>(key));
+ }
+#endif // Lua 5.3.x+
+ else {
+ push(L, std::forward<Key>(key));
+ lua_gettable(L, tableindex);
+ }
+ }
+ }
+ };
+
+ template <typename... Args, bool b, bool raw, typename C>
+ struct field_getter<std::tuple<Args...>, b, raw, C> {
+ template <std::size_t... I, typename Keys>
+ void apply(std::index_sequence<0, I...>, lua_State* L, Keys&& keys, int tableindex) {
+ get_field<b, raw>(L, std::get<0>(std::forward<Keys>(keys)), tableindex);
+ void(detail::swallow { (get_field<false, raw>(L, std::get<I>(std::forward<Keys>(keys))), 0)... });
+ reference saved(L, -1);
+ lua_pop(L, static_cast<int>(sizeof...(I)));
+ saved.push();
+ }
+
+ template <typename Keys>
+ void get(lua_State* L, Keys&& keys) {
+ apply(std::make_index_sequence<sizeof...(Args)>(), L, std::forward<Keys>(keys), lua_absindex(L, -1));
+ }
+
+ template <typename Keys>
+ void get(lua_State* L, Keys&& keys, int tableindex) {
+ apply(std::make_index_sequence<sizeof...(Args)>(), L, std::forward<Keys>(keys), tableindex);
+ }
+ };
+
+ template <typename A, typename B, bool b, bool raw, typename C>
+ struct field_getter<std::pair<A, B>, b, raw, C> {
+ template <typename Keys>
+ void get(lua_State* L, Keys&& keys, int tableindex) {
+ get_field<b, raw>(L, std::get<0>(std::forward<Keys>(keys)), tableindex);
+ get_field<false, raw>(L, std::get<1>(std::forward<Keys>(keys)));
+ reference saved(L, -1);
+ lua_pop(L, static_cast<int>(2));
+ saved.push();
+ }
+
+ template <typename Keys>
+ void get(lua_State* L, Keys&& keys) {
+ get_field<b, raw>(L, std::get<0>(std::forward<Keys>(keys)));
+ get_field<false, raw>(L, std::get<1>(std::forward<Keys>(keys)));
+ reference saved(L, -1);
+ lua_pop(L, static_cast<int>(2));
+ saved.push();
+ }
+ };
+
+ template <typename T, bool global, bool raw, typename>
+ struct field_setter {
+ static constexpr int default_table_index
+ = meta::conditional_t < (meta::is_c_str_v<T> || meta::is_string_of_v<T, char>) || (std::is_integral_v<T> && !std::is_same_v<T, bool>)
+ || (std::is_integral_v<T> && !std::is_same_v<T, bool>) || (raw && std::is_void_v<std::remove_pointer_t<T>>),
+ std::integral_constant<int, -2>, std::integral_constant<int, -3> > ::value;
+
+ template <typename Key, typename Value>
+ void set(lua_State* L, Key&& key, Value&& value, int tableindex = default_table_index) {
+ if constexpr (std::is_same_v<T, update_if_empty_t> || std::is_same_v<T, override_value_t>) {
+ (void)L;
+ (void)key;
+ (void)value;
+ (void)tableindex;
+ }
+ else if constexpr (std::is_same_v<T, metatable_key_t>) {
+ (void)key;
+ push(L, std::forward<Value>(value));
+ lua_setmetatable(L, tableindex);
+ }
+ else if constexpr (raw) {
+ if constexpr (std::is_integral_v<T> && !std::is_same_v<bool, T>) {
+ push(L, std::forward<Value>(value));
+ lua_rawseti(L, tableindex, static_cast<lua_Integer>(key));
+ }
+#if SOL_LUA_VESION_I_ >= 502
+ else if constexpr (std::is_void_v<std::remove_pointer_t<T>>) {
+ push(L, std::forward<Value>(value));
+ lua_rawsetp(L, tableindex, std::forward<Key>(key));
+ }
+#endif // Lua 5.2.x
+ else {
+ push(L, std::forward<Key>(key));
+ push(L, std::forward<Value>(value));
+ lua_rawset(L, tableindex);
+ }
+ }
+ else {
+ if constexpr (meta::is_c_str_v<T> || meta::is_string_of_v<T, char>) {
+ if constexpr (global) {
+ push(L, std::forward<Value>(value));
+ lua_setglobal(L, &key[0]);
+ (void)tableindex;
+ }
+ else {
+ push(L, std::forward<Value>(value));
+ lua_setfield(L, tableindex, &key[0]);
+ }
+ }
+#if SOL_LUA_VESION_I_ >= 503
+ else if constexpr (std::is_integral_v<T> && !std::is_same_v<bool, T>) {
+ push(L, std::forward<Value>(value));
+ lua_seti(L, tableindex, static_cast<lua_Integer>(key));
+ }
+#endif // Lua 5.3.x
+ else {
+ push(L, std::forward<Key>(key));
+ push(L, std::forward<Value>(value));
+ lua_settable(L, tableindex);
+ }
+ }
+ }
+ };
+
+ template <typename... Args, bool b, bool raw, typename C>
+ struct field_setter<std::tuple<Args...>, b, raw, C> {
+ template <bool g, std::size_t I, typename Keys, typename Value>
+ void apply(std::index_sequence<I>, lua_State* L, Keys&& keys, Value&& value, int tableindex) {
+ I < 1 ? set_field<g, raw>(L, std::get<I>(std::forward<Keys>(keys)), std::forward<Value>(value), tableindex)
+ : set_field<g, raw>(L, std::get<I>(std::forward<Keys>(keys)), std::forward<Value>(value));
+ }
+
+ template <bool g, std::size_t I0, std::size_t I1, std::size_t... I, typename Keys, typename Value>
+ void apply(std::index_sequence<I0, I1, I...>, lua_State* L, Keys&& keys, Value&& value, int tableindex) {
+ I0 < 1 ? get_field<g, raw>(L, std::get<I0>(std::forward<Keys>(keys)), tableindex)
+ : get_field<g, raw>(L, std::get<I0>(std::forward<Keys>(keys)), -1);
+ apply<false>(std::index_sequence<I1, I...>(), L, std::forward<Keys>(keys), std::forward<Value>(value), -1);
+ }
+
+ template <bool g, std::size_t I0, std::size_t... I, typename Keys, typename Value>
+ void top_apply(std::index_sequence<I0, I...>, lua_State* L, Keys&& keys, Value&& value, int tableindex) {
+ apply<g>(std::index_sequence<I0, I...>(), L, std::forward<Keys>(keys), std::forward<Value>(value), tableindex);
+ lua_pop(L, static_cast<int>(sizeof...(I)));
+ }
+
+ template <typename Keys, typename Value>
+ void set(lua_State* L, Keys&& keys, Value&& value, int tableindex = -3) {
+ top_apply<b>(std::make_index_sequence<sizeof...(Args)>(), L, std::forward<Keys>(keys), std::forward<Value>(value), tableindex);
+ }
+ };
+
+ template <typename A, typename B, bool b, bool raw, typename C>
+ struct field_setter<std::pair<A, B>, b, raw, C> {
+ template <typename Keys, typename Value>
+ void set(lua_State* L, Keys&& keys, Value&& value, int tableindex = -1) {
+ get_field<b, raw>(L, std::get<0>(std::forward<Keys>(keys)), tableindex);
+ set_field<false, raw>(L, std::get<1>(std::forward<Keys>(keys)), std::forward<Value>(value), lua_gettop(L));
+ lua_pop(L, 1);
+ }
+ };
+}} // namespace sol::stack
+
+// end of sol/stack_field.hpp
+
+// beginning of sol/stack_probe.hpp
+
+namespace sol {
+namespace stack {
+ template <typename T, typename P, bool b, bool raw, typename>
+ struct probe_field_getter {
+ template <typename Key>
+ probe get(lua_State* L, Key&& key, int tableindex = -2) {
+ if constexpr(!b) {
+ if (!maybe_indexable(L, tableindex)) {
+ return probe(false, 0);
+ }
+ }
+ get_field<b, raw>(L, std::forward<Key>(key), tableindex);
+ return probe(check<P>(L), 1);
+ }
+ };
+
+ template <typename A, typename B, typename P, bool b, bool raw, typename C>
+ struct probe_field_getter<std::pair<A, B>, P, b, raw, C> {
+ template <typename Keys>
+ probe get(lua_State* L, Keys&& keys, int tableindex = -2) {
+ if (!b && !maybe_indexable(L, tableindex)) {
+ return probe(false, 0);
+ }
+ get_field<b, raw>(L, std::get<0>(keys), tableindex);
+ if (!maybe_indexable(L)) {
+ return probe(false, 1);
+ }
+ get_field<false, raw>(L, std::get<1>(keys), tableindex);
+ return probe(check<P>(L), 2);
+ }
+ };
+
+ template <typename... Args, typename P, bool b, bool raw, typename C>
+ struct probe_field_getter<std::tuple<Args...>, P, b, raw, C> {
+ template <std::size_t I, typename Keys>
+ probe apply(std::index_sequence<I>, int sofar, lua_State* L, Keys&& keys, int tableindex) {
+ get_field<(I<1) && b, raw>(L, std::get<I>(keys), tableindex);
+ return probe(check<P>(L), sofar);
+ }
+
+ template <std::size_t I, std::size_t I1, std::size_t... In, typename Keys>
+ probe apply(std::index_sequence<I, I1, In...>, int sofar, lua_State* L, Keys&& keys, int tableindex) {
+ get_field < I<1 && b, raw>(L, std::get<I>(keys), tableindex);
+ if (!maybe_indexable(L)) {
+ return probe(false, sofar);
+ }
+ return apply(std::index_sequence<I1, In...>(), sofar + 1, L, std::forward<Keys>(keys), -1);
+ }
+
+ template <typename Keys>
+ probe get(lua_State* L, Keys&& keys, int tableindex = -2) {
+ if constexpr (!b) {
+ if (!maybe_indexable(L, tableindex)) {
+ return probe(false, 0);
+ }
+ return apply(std::index_sequence_for<Args...>(), 1, L, std::forward<Keys>(keys), tableindex);
+ }
+ else {
+ return apply(std::index_sequence_for<Args...>(), 1, L, std::forward<Keys>(keys), tableindex);
+ }
+ }
+ };
+}
+} // namespace sol::stack
+
+// end of sol/stack_probe.hpp
+
+#include <cstring>
+#include <array>
+
+namespace sol {
+ namespace detail {
+ using typical_chunk_name_t = char[SOL_ID_SIZE_I_];
+ using typical_file_chunk_name_t = char[SOL_FILE_ID_SIZE_I_];
+
+ inline const std::string& default_chunk_name() {
+ static const std::string name = "";
+ return name;
+ }
+
+ template <std::size_t N>
+ const char* make_chunk_name(const string_view& code, const std::string& chunkname, char (&basechunkname)[N]) {
+ if (chunkname.empty()) {
+ auto it = code.cbegin();
+ auto e = code.cend();
+ std::size_t i = 0;
+ static const std::size_t n = N - 4;
+ for (i = 0; i < n && it != e; ++i, ++it) {
+ basechunkname[i] = *it;
+ }
+ if (it != e) {
+ for (std::size_t c = 0; c < 3; ++i, ++c) {
+ basechunkname[i] = '.';
+ }
+ }
+ basechunkname[i] = '\0';
+ return &basechunkname[0];
+ }
+ else {
+ return chunkname.c_str();
+ }
+ }
+
+ inline void clear_entries(stack_reference r) {
+ stack::push(r.lua_state(), lua_nil);
+ while (lua_next(r.lua_state(), -2)) {
+ absolute_index key(r.lua_state(), -2);
+ auto pn = stack::pop_n(r.lua_state(), 1);
+ stack::set_field<false, true>(r.lua_state(), key, lua_nil, r.stack_index());
+ }
+ }
+
+ inline void clear_entries(const reference& registry_reference) {
+ auto pp = stack::push_pop(registry_reference);
+ stack_reference ref(registry_reference.lua_state(), -1);
+ clear_entries(ref);
+ }
+ } // namespace detail
+
+ namespace stack {
+ namespace stack_detail {
+ template <typename T>
+ inline int push_as_upvalues(lua_State* L, T& item) {
+ typedef std::decay_t<T> TValue;
+ static const std::size_t itemsize = sizeof(TValue);
+ static const std::size_t voidsize = sizeof(void*);
+ static const std::size_t voidsizem1 = voidsize - 1;
+ static const std::size_t data_t_count = (sizeof(TValue) + voidsizem1) / voidsize;
+ typedef std::array<void*, data_t_count> data_t;
+
+ data_t data { {} };
+ std::memcpy(&data[0], std::addressof(item), itemsize);
+ int pushcount = 0;
+ for (const auto& v : data) {
+ lua_pushlightuserdata(L, v);
+ pushcount += 1;
+ }
+ return pushcount;
+ }
+
+ template <typename T>
+ inline std::pair<T, int> get_as_upvalues(lua_State* L, int index = 2) {
+ static const std::size_t data_t_count = (sizeof(T) + (sizeof(void*) - 1)) / sizeof(void*);
+ typedef std::array<void*, data_t_count> data_t;
+ data_t voiddata { {} };
+ for (std::size_t i = 0, d = 0; d < sizeof(T); ++i, d += sizeof(void*)) {
+ voiddata[i] = lua_touserdata(L, upvalue_index(index++));
+ }
+ return std::pair<T, int>(*reinterpret_cast<T*>(static_cast<void*>(voiddata.data())), index);
+ }
+
+ template <typename T>
+ inline std::pair<T, int> get_as_upvalues_using_function(lua_State* L, int function_index = -1) {
+ static const std::size_t data_t_count = (sizeof(T) + (sizeof(void*) - 1)) / sizeof(void*);
+ typedef std::array<void*, data_t_count> data_t;
+ function_index = lua_absindex(L, function_index);
+ int index = 0;
+ data_t voiddata { {} };
+ for (std::size_t d = 0; d < sizeof(T); d += sizeof(void*)) {
+ // first upvalue is nullptr to respect environment shenanigans
+ // So +2 instead of +1
+ const char* upvalue_name = lua_getupvalue(L, function_index, index + 2);
+ if (upvalue_name == nullptr) {
+ // We should freak out here...
+ break;
+ }
+ voiddata[index] = lua_touserdata(L, -1);
+ ++index;
+ }
+ lua_pop(L, index);
+ return std::pair<T, int>(*reinterpret_cast<T*>(static_cast<void*>(voiddata.data())), index);
+ }
+
+ template <typename Fx, typename... Args>
+ static decltype(auto) eval(types<>, std::index_sequence<>, lua_State*, int, record&, Fx&& fx, Args&&... args) {
+ return std::forward<Fx>(fx)(std::forward<Args>(args)...);
+ }
+
+ template <typename Fx, typename Arg, typename... Args, std::size_t I, std::size_t... Is, typename... FxArgs>
+ static decltype(auto) eval(
+ types<Arg, Args...>, std::index_sequence<I, Is...>, lua_State* L, int start, record& tracking, Fx&& fx, FxArgs&&... fxargs) {
+ return eval(types<Args...>(),
+ std::index_sequence<Is...>(),
+ L,
+ start,
+ tracking,
+ std::forward<Fx>(fx),
+ std::forward<FxArgs>(fxargs)...,
+ stack_detail::unchecked_get<Arg>(L, start + tracking.used, tracking));
+ }
+
+ template <bool checkargs = detail::default_safe_function_calls, std::size_t... I, typename R, typename... Args, typename Fx, typename... FxArgs>
+ inline decltype(auto) call(types<R>, types<Args...> ta, std::index_sequence<I...> tai, lua_State* L, int start, Fx&& fx, FxArgs&&... args) {
+ static_assert(meta::all<meta::is_not_move_only<Args>...>::value,
+ "One of the arguments being bound is a move-only type, and it is not being taken by reference: this will break your code. Please take "
+ "a reference and std::move it manually if this was your intention.");
+ if constexpr (checkargs) {
+ argument_handler<types<R, Args...>> handler {};
+ multi_check<Args...>(L, start, handler);
+ }
+ record tracking {};
+ if constexpr (std::is_void_v<R>) {
+ eval(ta, tai, L, start, tracking, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
+ }
+ else {
+ return eval(ta, tai, L, start, tracking, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
+ }
+ }
+ } // namespace stack_detail
+
+ template <typename T>
+ int set_ref(lua_State* L, T&& arg, int tableindex = -2) {
+ push(L, std::forward<T>(arg));
+ return luaL_ref(L, tableindex);
+ }
+
+ template <bool check_args = detail::default_safe_function_calls, typename R, typename... Args, typename Fx, typename... FxArgs>
+ inline decltype(auto) call(types<R> tr, types<Args...> ta, lua_State* L, int start, Fx&& fx, FxArgs&&... args) {
+ using args_indices = std::make_index_sequence<sizeof...(Args)>;
+ if constexpr (std::is_void_v<R>) {
+ stack_detail::call<check_args>(tr, ta, args_indices(), L, start, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
+ }
+ else {
+ return stack_detail::call<check_args>(tr, ta, args_indices(), L, start, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
+ }
+ }
+
+ template <bool check_args = detail::default_safe_function_calls, typename R, typename... Args, typename Fx, typename... FxArgs>
+ inline decltype(auto) call(types<R> tr, types<Args...> ta, lua_State* L, Fx&& fx, FxArgs&&... args) {
+ if constexpr (std::is_void_v<R>) {
+ call<check_args>(tr, ta, L, 1, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
+ }
+ else {
+ return call<check_args>(tr, ta, L, 1, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
+ }
+ }
+
+ template <bool check_args = detail::default_safe_function_calls, typename R, typename... Args, typename Fx, typename... FxArgs>
+ inline decltype(auto) call_from_top(types<R> tr, types<Args...> ta, lua_State* L, Fx&& fx, FxArgs&&... args) {
+ using expected_count_t = meta::count_for_pack<lua_size, Args...>;
+ if constexpr (std::is_void_v<R>) {
+ call<check_args>(tr,
+ ta,
+ L,
+ (std::max)(static_cast<int>(lua_gettop(L) - expected_count_t::value), static_cast<int>(0)),
+ std::forward<Fx>(fx),
+ std::forward<FxArgs>(args)...);
+ }
+ else {
+ return call<check_args>(tr,
+ ta,
+ L,
+ (std::max)(static_cast<int>(lua_gettop(L) - expected_count_t::value), static_cast<int>(0)),
+ std::forward<Fx>(fx),
+ std::forward<FxArgs>(args)...);
+ }
+ }
+
+ template <bool check_args = detail::default_safe_function_calls, bool clean_stack = true, typename Ret0, typename... Ret, typename... Args,
+ typename Fx, typename... FxArgs>
+ inline int call_into_lua(types<Ret0, Ret...> tr, types<Args...> ta, lua_State* L, int start, Fx&& fx, FxArgs&&... fxargs) {
+ if constexpr (std::is_void_v<Ret0>) {
+ call<check_args>(tr, ta, L, start, std::forward<Fx>(fx), std::forward<FxArgs>(fxargs)...);
+ if constexpr (clean_stack) {
+ lua_settop(L, 0);
+ }
+ return 0;
+ }
+ else {
+ (void)tr;
+ decltype(auto) r
+ = call<check_args>(types<meta::return_type_t<Ret0, Ret...>>(), ta, L, start, std::forward<Fx>(fx), std::forward<FxArgs>(fxargs)...);
+ using R = meta::unqualified_t<decltype(r)>;
+ using is_stack = meta::any<is_stack_based<R>, std::is_same<R, absolute_index>, std::is_same<R, ref_index>, std::is_same<R, raw_index>>;
+ if constexpr (clean_stack && !is_stack::value) {
+ lua_settop(L, 0);
+ }
+ return push_reference(L, std::forward<decltype(r)>(r));
+ }
+ }
+
+ template <bool check_args = detail::default_safe_function_calls, bool clean_stack = true, typename Fx, typename... FxArgs>
+ inline int call_lua(lua_State* L, int start, Fx&& fx, FxArgs&&... fxargs) {
+ using traits_type = lua_bind_traits<meta::unqualified_t<Fx>>;
+ using args_list = typename traits_type::args_list;
+ using returns_list = typename traits_type::returns_list;
+ return call_into_lua<check_args, clean_stack>(returns_list(), args_list(), L, start, std::forward<Fx>(fx), std::forward<FxArgs>(fxargs)...);
+ }
+
+ inline call_syntax get_call_syntax(lua_State* L, const string_view& key, int index) {
+ if (lua_gettop(L) < 1) {
+ return call_syntax::dot;
+ }
+ luaL_getmetatable(L, key.data());
+ auto pn = pop_n(L, 1);
+ if (lua_compare(L, -1, index, LUA_OPEQ) != 1) {
+ return call_syntax::dot;
+ }
+ return call_syntax::colon;
+ }
+
+ inline void script(
+ lua_State* L, lua_Reader reader, void* data, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+ detail::typical_chunk_name_t basechunkname = {};
+ const char* chunknametarget = detail::make_chunk_name("lua_Reader", chunkname, basechunkname);
+ if (lua_load(L, reader, data, chunknametarget, to_string(mode).c_str()) || lua_pcall(L, 0, LUA_MULTRET, 0)) {
+ lua_error(L);
+ }
+ }
+
+ inline void script(
+ lua_State* L, const string_view& code, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+
+ detail::typical_chunk_name_t basechunkname = {};
+ const char* chunknametarget = detail::make_chunk_name(code, chunkname, basechunkname);
+ if (luaL_loadbufferx(L, code.data(), code.size(), chunknametarget, to_string(mode).c_str()) || lua_pcall(L, 0, LUA_MULTRET, 0)) {
+ lua_error(L);
+ }
+ }
+
+ inline void script_file(lua_State* L, const std::string& filename, load_mode mode = load_mode::any) {
+ if (luaL_loadfilex(L, filename.c_str(), to_string(mode).c_str()) || lua_pcall(L, 0, LUA_MULTRET, 0)) {
+ lua_error(L);
+ }
+ }
+
+ 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 (L == nullptr) {
+ return;
+ }
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+ lua_pushlightuserdata(L, (void*)handler);
+ auto pn = pop_n(L, 1);
+ luaJIT_setmode(L, -1, LUAJIT_MODE_WRAPCFUNC | LUAJIT_MODE_ON);
+#else
+ (void)L;
+ (void)handler;
+#endif
+ }
+
+ inline void luajit_exception_off(lua_State* L) {
+#if SOL_IS_ON(SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE_I_)
+ if (L == nullptr) {
+ return;
+ }
+ luaJIT_setmode(L, -1, LUAJIT_MODE_WRAPCFUNC | LUAJIT_MODE_OFF);
+#else
+ (void)L;
+#endif
+ }
+ } // namespace stack
+} // namespace sol
+
+// end of sol/stack.hpp
+
+// beginning of sol/object.hpp
+
+// beginning of sol/make_reference.hpp
+
+namespace sol {
+
+ template <typename R = reference, bool should_pop = !is_stack_based_v<R>, typename T>
+ R make_reference(lua_State* L, T&& value) {
+ int backpedal = stack::push(L, std::forward<T>(value));
+ R r = stack::get<R>(L, -backpedal);
+ if (should_pop) {
+ lua_pop(L, backpedal);
+ }
+ return r;
+ }
+
+ template <typename T, typename R = reference, bool should_pop = !is_stack_based_v<R>, typename... Args>
+ R make_reference(lua_State* L, Args&&... args) {
+ int backpedal = stack::push<T>(L, std::forward<Args>(args)...);
+ R r = stack::get<R>(L, -backpedal);
+ if (should_pop) {
+ lua_pop(L, backpedal);
+ }
+ return r;
+ }
+
+ template <typename R = reference, bool should_pop = !is_stack_based_v<R>, typename T>
+ R make_reference_userdata(lua_State* L, T&& value) {
+ int backpedal = stack::push_userdata(L, std::forward<T>(value));
+ R r = stack::get<R>(L, -backpedal);
+ if (should_pop) {
+ lua_pop(L, backpedal);
+ }
+ return r;
+ }
+
+ template <typename T, typename R = reference, bool should_pop = !is_stack_based_v<R>, typename... Args>
+ R make_reference_userdata(lua_State* L, Args&&... args) {
+ int backpedal = stack::push_userdata<T>(L, std::forward<Args>(args)...);
+ R r = stack::get<R>(L, -backpedal);
+ if (should_pop) {
+ lua_pop(L, backpedal);
+ }
+ return r;
+ }
+
+} // namespace sol
+
+// end of sol/make_reference.hpp
+
+// beginning of sol/object_base.hpp
+
+namespace sol {
+
+ template <typename ref_t>
+ class basic_object_base : public ref_t {
+ private:
+ using base_t = ref_t;
+
+ template <typename T>
+ decltype(auto) as_stack(std::true_type) const {
+ return stack::get<T>(base_t::lua_state(), base_t::stack_index());
+ }
+
+ template <typename T>
+ decltype(auto) as_stack(std::false_type) const {
+ base_t::push();
+ return stack::pop<T>(base_t::lua_state());
+ }
+
+ template <typename T>
+ bool is_stack(std::true_type) const {
+ return stack::check<T>(base_t::lua_state(), base_t::stack_index(), no_panic);
+ }
+
+ template <typename T>
+ bool is_stack(std::false_type) const {
+ int r = base_t::registry_index();
+ if (r == LUA_REFNIL)
+ return meta::any_same<meta::unqualified_t<T>, lua_nil_t, nullopt_t, std::nullptr_t>::value ? true : false;
+ if (r == LUA_NOREF)
+ return false;
+ auto pp = stack::push_pop(*this);
+ return stack::check<T>(base_t::lua_state(), -1, no_panic);
+ }
+
+ public:
+ basic_object_base() noexcept = default;
+ basic_object_base(const basic_object_base&) = default;
+ basic_object_base(basic_object_base&&) = default;
+ basic_object_base& operator=(const basic_object_base&) = default;
+ basic_object_base& operator=(basic_object_base&&) = default;
+ template <typename T, typename... Args, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_object_base>>> = meta::enabler>
+ basic_object_base(T&& arg, Args&&... args)
+ : base_t(std::forward<T>(arg), std::forward<Args>(args)...) {
+ }
+
+ template <typename T>
+ decltype(auto) as() const {
+ return as_stack<T>(is_stack_based<base_t>());
+ }
+
+ template <typename T>
+ bool is() const {
+ return is_stack<T>(is_stack_based<base_t>());
+ }
+ };
+} // namespace sol
+
+// end of sol/object_base.hpp
+
+namespace sol {
+
+ template <typename base_type>
+ class basic_object : public basic_object_base<base_type> {
+ private:
+ typedef basic_object_base<base_type> base_t;
+
+ template <bool invert_and_pop = false>
+ basic_object(std::integral_constant<bool, invert_and_pop>, lua_State* L, int index = -1) noexcept
+ : base_t(L, index) {
+ if (invert_and_pop) {
+ lua_pop(L, -index);
+ }
+ }
+
+ protected:
+ basic_object(detail::no_safety_tag, lua_nil_t n) : base_t(n) {
+ }
+ basic_object(detail::no_safety_tag, lua_State* L, int index) : base_t(L, index) {
+ }
+ basic_object(lua_State* L, detail::global_tag t) : base_t(L, t) {
+ }
+ basic_object(detail::no_safety_tag, lua_State* L, ref_index index) : base_t(L, index) {
+ }
+ template <typename T,
+ meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_object>>, 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>
+ basic_object(detail::no_safety_tag, T&& r) noexcept : base_t(std::forward<T>(r)) {
+ }
+
+ template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+ basic_object(detail::no_safety_tag, lua_State* L, T&& r) noexcept : base_t(L, std::forward<T>(r)) {
+ }
+
+ public:
+ basic_object() noexcept = default;
+ template <typename T, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_object>>, meta::neg<std::is_same<base_type, stack_reference>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+ basic_object(T&& r)
+ : base_t(std::forward<T>(r)) {
+ }
+ template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+ basic_object(lua_State* L, T&& r)
+ : base_t(L, std::forward<T>(r)) {
+ }
+ basic_object(lua_nil_t r)
+ : base_t(r) {
+ }
+ basic_object(const basic_object&) = default;
+ basic_object(basic_object&&) = default;
+ basic_object(const stack_reference& r) noexcept
+ : basic_object(r.lua_state(), r.stack_index()) {
+ }
+ basic_object(stack_reference&& r) noexcept
+ : basic_object(r.lua_state(), r.stack_index()) {
+ }
+ template <typename Super>
+ basic_object(const proxy_base<Super>& r) noexcept
+ : basic_object(r.operator basic_object()) {
+ }
+ template <typename Super>
+ basic_object(proxy_base<Super>&& r) noexcept
+ : basic_object(r.operator basic_object()) {
+ }
+ basic_object(lua_State* L, lua_nil_t r) noexcept
+ : base_t(L, r) {
+ }
+ basic_object(lua_State* L, int index = -1) noexcept
+ : base_t(L, index) {
+ }
+ basic_object(lua_State* L, absolute_index index) noexcept
+ : base_t(L, index) {
+ }
+ basic_object(lua_State* L, raw_index index) noexcept
+ : base_t(L, index) {
+ }
+ basic_object(lua_State* L, ref_index index) noexcept
+ : base_t(L, index) {
+ }
+ template <typename T, typename... Args>
+ basic_object(lua_State* L, in_place_type_t<T>, Args&&... args) noexcept
+ : basic_object(std::integral_constant<bool, !is_stack_based<base_t>::value>(), L, -stack::push<T>(L, std::forward<Args>(args)...)) {
+ }
+ template <typename T, typename... Args>
+ basic_object(lua_State* L, in_place_t, T&& arg, Args&&... args) noexcept
+ : basic_object(L, in_place_type<T>, std::forward<T>(arg), std::forward<Args>(args)...) {
+ }
+ basic_object& operator=(const basic_object&) = default;
+ basic_object& operator=(basic_object&&) = default;
+ basic_object& operator=(const base_type& b) {
+ base_t::operator=(b);
+ return *this;
+ }
+ basic_object& operator=(base_type&& b) {
+ base_t::operator=(std::move(b));
+ return *this;
+ }
+ template <typename Super>
+ basic_object& operator=(const proxy_base<Super>& r) {
+ this->operator=(r.operator basic_object());
+ return *this;
+ }
+ template <typename Super>
+ basic_object& operator=(proxy_base<Super>&& r) {
+ this->operator=(r.operator basic_object());
+ return *this;
+ }
+ };
+
+ template <typename T>
+ object make_object(lua_State* L, T&& value) {
+ return make_reference<object, true>(L, std::forward<T>(value));
+ }
+
+ template <typename T, typename... Args>
+ object make_object(lua_State* L, Args&&... args) {
+ return make_reference<T, object, true>(L, std::forward<Args>(args)...);
+ }
+
+ template <typename T>
+ object make_object_userdata(lua_State* L, T&& value) {
+ return make_reference_userdata<object, true>(L, std::forward<T>(value));
+ }
+
+ template <typename T, typename... Args>
+ object make_object_userdata(lua_State* L, Args&&... args) {
+ return make_reference_userdata<T, object, true>(L, std::forward<Args>(args)...);
+ }
+} // namespace sol
+
+// end of sol/object.hpp
+
+// beginning of sol/function.hpp
+
+// beginning of sol/unsafe_function.hpp
+
+// beginning of sol/function_result.hpp
+
+// beginning of sol/protected_function_result.hpp
+
+// beginning of sol/proxy_base.hpp
+
+namespace sol {
+ struct proxy_base_tag {};
+
+ namespace detail {
+ template <typename T>
+ using proxy_key_t = meta::conditional_t<meta::is_specialization_of_v<meta::unqualified_t<T>, std::tuple>, T,
+ std::tuple<meta::conditional_t<std::is_array_v<meta::unqualified_t<T>>, std::remove_reference_t<T>&, meta::unqualified_t<T>>>>;
+ }
+
+ template <typename Super>
+ struct proxy_base : proxy_base_tag {
+ operator std::string() const {
+ const Super& super = *static_cast<const Super*>(static_cast<const void*>(this));
+ return super.template get<std::string>();
+ }
+
+ template <typename T, meta::enable<meta::neg<meta::is_string_constructible<T>>, is_proxy_primitive<meta::unqualified_t<T>>> = meta::enabler>
+ operator T() const {
+ const Super& super = *static_cast<const Super*>(static_cast<const void*>(this));
+ return super.template get<T>();
+ }
+
+ template <typename T, meta::enable<meta::neg<meta::is_string_constructible<T>>, meta::neg<is_proxy_primitive<meta::unqualified_t<T>>>> = meta::enabler>
+ operator T&() const {
+ const Super& super = *static_cast<const Super*>(static_cast<const void*>(this));
+ return super.template get<T&>();
+ }
+
+ lua_State* lua_state() const {
+ const Super& super = *static_cast<const Super*>(static_cast<const void*>(this));
+ return super.lua_state();
+ }
+ };
+} // namespace sol
+
+// end of sol/proxy_base.hpp
+
+// beginning of sol/stack_iterator.hpp
+
+#include <limits>
+#include <iterator>
+
+namespace sol {
+ template <typename proxy_t, bool is_const>
+ struct stack_iterator {
+ typedef meta::conditional_t<is_const, const proxy_t, proxy_t> reference;
+ typedef meta::conditional_t<is_const, const proxy_t*, proxy_t*> pointer;
+ typedef proxy_t value_type;
+ typedef std::ptrdiff_t difference_type;
+ typedef std::random_access_iterator_tag iterator_category;
+ lua_State* L;
+ int index;
+ int stacktop;
+ proxy_t sp;
+
+ stack_iterator()
+ : L(nullptr), index((std::numeric_limits<int>::max)()), stacktop((std::numeric_limits<int>::max)()), sp() {
+ }
+ stack_iterator(const stack_iterator<proxy_t, true>& r)
+ : L(r.L), index(r.index), stacktop(r.stacktop), sp(r.sp) {
+ }
+ stack_iterator(lua_State* luastate, int idx, int topidx)
+ : L(luastate), index(idx), stacktop(topidx), sp(luastate, idx) {
+ }
+
+ reference operator*() {
+ return proxy_t(L, index);
+ }
+
+ reference operator*() const {
+ return proxy_t(L, index);
+ }
+
+ pointer operator->() {
+ sp = proxy_t(L, index);
+ return &sp;
+ }
+
+ pointer operator->() const {
+ const_cast<proxy_t&>(sp) = proxy_t(L, index);
+ return &sp;
+ }
+
+ stack_iterator& operator++() {
+ ++index;
+ return *this;
+ }
+
+ stack_iterator operator++(int) {
+ auto r = *this;
+ this->operator++();
+ return r;
+ }
+
+ stack_iterator& operator--() {
+ --index;
+ return *this;
+ }
+
+ stack_iterator operator--(int) {
+ auto r = *this;
+ this->operator--();
+ return r;
+ }
+
+ stack_iterator& operator+=(difference_type idx) {
+ index += static_cast<int>(idx);
+ return *this;
+ }
+
+ stack_iterator& operator-=(difference_type idx) {
+ index -= static_cast<int>(idx);
+ return *this;
+ }
+
+ difference_type operator-(const stack_iterator& r) const {
+ return index - r.index;
+ }
+
+ stack_iterator operator+(difference_type idx) const {
+ stack_iterator r = *this;
+ r += idx;
+ return r;
+ }
+
+ reference operator[](difference_type idx) const {
+ return proxy_t(L, index + static_cast<int>(idx));
+ }
+
+ bool operator==(const stack_iterator& r) const {
+ if (stacktop == (std::numeric_limits<int>::max)()) {
+ return r.index == r.stacktop;
+ }
+ else if (r.stacktop == (std::numeric_limits<int>::max)()) {
+ return index == stacktop;
+ }
+ return index == r.index;
+ }
+
+ bool operator!=(const stack_iterator& r) const {
+ return !(this->operator==(r));
+ }
+
+ bool operator<(const stack_iterator& r) const {
+ return index < r.index;
+ }
+
+ bool operator>(const stack_iterator& r) const {
+ return index > r.index;
+ }
+
+ bool operator<=(const stack_iterator& r) const {
+ return index <= r.index;
+ }
+
+ bool operator>=(const stack_iterator& r) const {
+ return index >= r.index;
+ }
+ };
+
+ template <typename proxy_t, bool is_const>
+ inline stack_iterator<proxy_t, is_const> operator+(typename stack_iterator<proxy_t, is_const>::difference_type n, const stack_iterator<proxy_t, is_const>& r) {
+ return r + n;
+ }
+} // namespace sol
+
+// end of sol/stack_iterator.hpp
+
+// beginning of sol/stack_proxy.hpp
+
+// beginning of sol/stack_proxy_base.hpp
+
+namespace sol {
+ struct stack_proxy_base : public proxy_base<stack_proxy_base> {
+ private:
+ lua_State* L;
+ int index;
+
+ public:
+ stack_proxy_base()
+ : L(nullptr), index(0) {
+ }
+ stack_proxy_base(lua_State* L, int index)
+ : L(L), index(index) {
+ }
+
+ template <typename T>
+ decltype(auto) get() const {
+ return stack::get<T>(L, stack_index());
+ }
+
+ template <typename T>
+ bool is() const {
+ return stack::check<T>(L, stack_index());
+ }
+
+ template <typename T>
+ decltype(auto) as() const {
+ return get<T>();
+ }
+
+ type get_type() const noexcept {
+ return type_of(lua_state(), stack_index());
+ }
+
+ int push() const {
+ return push(L);
+ }
+
+ int push(lua_State* Ls) const {
+ lua_pushvalue(Ls, index);
+ return 1;
+ }
+
+ lua_State* lua_state() const {
+ return L;
+ }
+ int stack_index() const {
+ return index;
+ }
+ };
+
+ namespace stack {
+ template <>
+ struct unqualified_getter<stack_proxy_base> {
+ static stack_proxy_base get(lua_State* L, int index = -1) {
+ return stack_proxy_base(L, index);
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<stack_proxy_base> {
+ static int push(lua_State*, const stack_proxy_base& ref) {
+ return ref.push();
+ }
+ };
+ } // namespace stack
+
+} // namespace sol
+
+// end of sol/stack_proxy_base.hpp
+
+namespace sol {
+ struct stack_proxy : public stack_proxy_base {
+ public:
+ stack_proxy() : stack_proxy_base() {
+ }
+ stack_proxy(lua_State* L, int index) : stack_proxy_base(L, index) {
+ }
+
+ template <typename... Ret, typename... Args>
+ decltype(auto) call(Args&&... args);
+
+ template <typename... Args>
+ decltype(auto) operator()(Args&&... args) {
+ return call<>(std::forward<Args>(args)...);
+ }
+ };
+
+ namespace stack {
+ template <>
+ struct unqualified_getter<stack_proxy> {
+ static stack_proxy get(lua_State* L, int index, record& tracking) {
+ tracking.use(0);
+ return stack_proxy(L, index);
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<stack_proxy> {
+ static int push(lua_State*, const stack_proxy& ref) {
+ return ref.push();
+ }
+ };
+ } // namespace stack
+} // namespace sol
+
+// end of sol/stack_proxy.hpp
+
+#include <cstdint>
+
+namespace sol {
+ struct protected_function_result : public proxy_base<protected_function_result> {
+ private:
+ lua_State* L;
+ int index;
+ int returncount;
+ int popcount;
+ call_status err;
+
+ public:
+ typedef stack_proxy reference_type;
+ typedef stack_proxy value_type;
+ typedef stack_proxy* pointer;
+ typedef std::ptrdiff_t difference_type;
+ typedef std::size_t size_type;
+ typedef stack_iterator<stack_proxy, false> iterator;
+ typedef stack_iterator<stack_proxy, true> const_iterator;
+ typedef std::reverse_iterator<iterator> reverse_iterator;
+ typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+ protected_function_result() noexcept = default;
+ 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) {
+ }
+
+ // We do not want anyone to copy these around willy-nilly
+ // Will likely break people, but also will probably get rid of quiet bugs that have
+ // been lurking. (E.g., Vanilla Lua will just quietly discard over-pops and under-pops:
+ // LuaJIT and other Lua engines will implode and segfault at random later times.)
+ protected_function_result(const protected_function_result&) = delete;
+ protected_function_result& operator=(const protected_function_result&) = delete;
+
+ protected_function_result(protected_function_result&& o) noexcept
+ : L(o.L), index(o.index), returncount(o.returncount), popcount(o.popcount), err(o.err) {
+ // Must be manual, otherwise destructor will screw us
+ // return count being 0 is enough to keep things clean
+ // but we will be thorough
+ o.abandon();
+ }
+ protected_function_result& operator=(protected_function_result&& o) noexcept {
+ L = o.L;
+ index = o.index;
+ returncount = o.returncount;
+ popcount = o.popcount;
+ err = o.err;
+ // Must be manual, otherwise destructor will screw us
+ // return count being 0 is enough to keep things clean
+ // but we will be thorough
+ o.abandon();
+ return *this;
+ }
+
+ protected_function_result(const unsafe_function_result& o) = delete;
+ protected_function_result& operator=(const unsafe_function_result& o) = delete;
+ protected_function_result(unsafe_function_result&& o) noexcept;
+ protected_function_result& operator=(unsafe_function_result&& o) noexcept;
+
+ call_status status() const noexcept {
+ return err;
+ }
+
+ bool valid() const noexcept {
+ return status() == call_status::ok || status() == call_status::yielded;
+ }
+
+ template <typename T>
+ decltype(auto) get(int index_offset = 0) const {
+ using UT = meta::unqualified_t<T>;
+ int target = index + index_offset;
+ if constexpr (meta::is_optional_v<UT>) {
+ using ValueType = typename UT::value_type;
+ if constexpr (std::is_same_v<ValueType, error>) {
+ if (valid()) {
+ return UT();
+ }
+ return UT(error(detail::direct_error, stack::get<std::string>(L, target)));
+ }
+ else {
+ if (!valid()) {
+ return UT();
+ }
+ return stack::get<UT>(L, target);
+ }
+ }
+ else {
+ if constexpr (std::is_same_v<T, error>) {
+#if SOL_IS_ON(SOL_SAFE_PROXIES_I_)
+ if (valid()) {
+ type t = type_of(L, target);
+ type_panic_c_str(L, target, t, type::none, "bad get from protected_function_result (is an error)");
+ }
+#endif // Check Argument Safety
+ return error(detail::direct_error, stack::get<std::string>(L, target));
+ }
+ else {
+#if SOL_IS_ON(SOL_SAFE_PROXIES_I_)
+ if (!valid()) {
+ 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)");
+ }
+#endif // Check Argument Safety
+ return stack::get<T>(L, target);
+ }
+ }
+ }
+
+ type get_type(int index_offset = 0) const noexcept {
+ return type_of(L, index + static_cast<int>(index_offset));
+ }
+
+ stack_proxy operator[](difference_type index_offset) const {
+ return stack_proxy(L, index + static_cast<int>(index_offset));
+ }
+
+ iterator begin() {
+ return iterator(L, index, stack_index() + return_count());
+ }
+ iterator end() {
+ return iterator(L, stack_index() + return_count(), stack_index() + return_count());
+ }
+ const_iterator begin() const {
+ return const_iterator(L, index, stack_index() + return_count());
+ }
+ const_iterator end() const {
+ return const_iterator(L, stack_index() + return_count(), stack_index() + return_count());
+ }
+ const_iterator cbegin() const {
+ return begin();
+ }
+ const_iterator cend() const {
+ return end();
+ }
+
+ reverse_iterator rbegin() {
+ return std::reverse_iterator<iterator>(begin());
+ }
+ reverse_iterator rend() {
+ return std::reverse_iterator<iterator>(end());
+ }
+ const_reverse_iterator rbegin() const {
+ return std::reverse_iterator<const_iterator>(begin());
+ }
+ const_reverse_iterator rend() const {
+ return std::reverse_iterator<const_iterator>(end());
+ }
+ const_reverse_iterator crbegin() const {
+ return std::reverse_iterator<const_iterator>(cbegin());
+ }
+ const_reverse_iterator crend() const {
+ return std::reverse_iterator<const_iterator>(cend());
+ }
+
+ lua_State* lua_state() const noexcept {
+ return L;
+ };
+ int stack_index() const noexcept {
+ return index;
+ };
+ int return_count() const noexcept {
+ return returncount;
+ };
+ int pop_count() const noexcept {
+ return popcount;
+ };
+ void abandon() noexcept {
+ // L = nullptr;
+ index = 0;
+ returncount = 0;
+ popcount = 0;
+ err = call_status::runtime;
+ }
+ ~protected_function_result() {
+ stack::remove(L, index, popcount);
+ }
+ };
+
+ namespace stack {
+ template <>
+ struct unqualified_pusher<protected_function_result> {
+ static int push(lua_State* L, const protected_function_result& pfr) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, static_cast<int>(pfr.pop_count()), detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+ int p = 0;
+ for (int i = 0; i < pfr.pop_count(); ++i) {
+ lua_pushvalue(L, i + pfr.stack_index());
+ ++p;
+ }
+ return p;
+ }
+ };
+ } // namespace stack
+} // namespace sol
+
+// end of sol/protected_function_result.hpp
+
+// beginning of sol/unsafe_function_result.hpp
+
+#include <cstdint>
+
+namespace sol {
+ struct unsafe_function_result : public proxy_base<unsafe_function_result> {
+ private:
+ lua_State* L;
+ int index;
+ int returncount;
+
+ public:
+ typedef stack_proxy reference_type;
+ typedef stack_proxy value_type;
+ typedef stack_proxy* pointer;
+ typedef std::ptrdiff_t difference_type;
+ typedef std::size_t size_type;
+ typedef stack_iterator<stack_proxy, false> iterator;
+ typedef stack_iterator<stack_proxy, true> const_iterator;
+ typedef std::reverse_iterator<iterator> reverse_iterator;
+ typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+ unsafe_function_result() noexcept = default;
+ unsafe_function_result(lua_State* Ls, int idx = -1, int retnum = 0) noexcept : L(Ls), index(idx), returncount(retnum) {
+ }
+
+ // We do not want anyone to copy these around willy-nilly
+ // Will likely break people, but also will probably get rid of quiet bugs that have
+ // been lurking. (E.g., Vanilla Lua will just quietly discard over-pops and under-pops:
+ // LuaJIT and other Lua engines will implode and segfault at random later times.)
+ unsafe_function_result(const unsafe_function_result&) = delete;
+ unsafe_function_result& operator=(const unsafe_function_result&) = delete;
+
+ unsafe_function_result(unsafe_function_result&& o) noexcept : L(o.L), index(o.index), returncount(o.returncount) {
+ // Must be manual, otherwise destructor will screw us
+ // return count being 0 is enough to keep things clean
+ // but will be thorough
+ o.abandon();
+ }
+ unsafe_function_result& operator=(unsafe_function_result&& o) noexcept {
+ L = o.L;
+ index = o.index;
+ returncount = o.returncount;
+ // Must be manual, otherwise destructor will screw us
+ // return count being 0 is enough to keep things clean
+ // but will be thorough
+ o.abandon();
+ return *this;
+ }
+
+ unsafe_function_result(const protected_function_result& o) = delete;
+ unsafe_function_result& operator=(const protected_function_result& o) = delete;
+ unsafe_function_result(protected_function_result&& o) noexcept;
+ unsafe_function_result& operator=(protected_function_result&& o) noexcept;
+
+ template <typename T>
+ decltype(auto) get(difference_type index_offset = 0) const {
+ return stack::get<T>(L, index + static_cast<int>(index_offset));
+ }
+
+ type get_type(difference_type index_offset = 0) const noexcept {
+ return type_of(L, index + static_cast<int>(index_offset));
+ }
+
+ stack_proxy operator[](difference_type index_offset) const {
+ return stack_proxy(L, index + static_cast<int>(index_offset));
+ }
+
+ iterator begin() {
+ return iterator(L, index, stack_index() + return_count());
+ }
+ iterator end() {
+ return iterator(L, stack_index() + return_count(), stack_index() + return_count());
+ }
+ const_iterator begin() const {
+ return const_iterator(L, index, stack_index() + return_count());
+ }
+ const_iterator end() const {
+ return const_iterator(L, stack_index() + return_count(), stack_index() + return_count());
+ }
+ const_iterator cbegin() const {
+ return begin();
+ }
+ const_iterator cend() const {
+ return end();
+ }
+
+ reverse_iterator rbegin() {
+ return std::reverse_iterator<iterator>(begin());
+ }
+ reverse_iterator rend() {
+ return std::reverse_iterator<iterator>(end());
+ }
+ const_reverse_iterator rbegin() const {
+ return std::reverse_iterator<const_iterator>(begin());
+ }
+ const_reverse_iterator rend() const {
+ return std::reverse_iterator<const_iterator>(end());
+ }
+ const_reverse_iterator crbegin() const {
+ return std::reverse_iterator<const_iterator>(cbegin());
+ }
+ const_reverse_iterator crend() const {
+ return std::reverse_iterator<const_iterator>(cend());
+ }
+
+ call_status status() const noexcept {
+ return call_status::ok;
+ }
+
+ bool valid() const noexcept {
+ return status() == call_status::ok || status() == call_status::yielded;
+ }
+
+ lua_State* lua_state() const {
+ return L;
+ };
+ int stack_index() const {
+ return index;
+ };
+ int return_count() const {
+ return returncount;
+ };
+ void abandon() noexcept {
+ // L = nullptr;
+ index = 0;
+ returncount = 0;
+ }
+ ~unsafe_function_result() {
+ lua_pop(L, returncount);
+ }
+ };
+
+ namespace stack {
+ template <>
+ struct unqualified_pusher<unsafe_function_result> {
+ static int push(lua_State* L, const unsafe_function_result& fr) {
+ int p = 0;
+ for (int i = 0; i < fr.return_count(); ++i) {
+ lua_pushvalue(L, i + fr.stack_index());
+ ++p;
+ }
+ return p;
+ }
+ };
+ } // namespace stack
+} // namespace sol
+
+// end of sol/unsafe_function_result.hpp
+
+#include <cstdint>
+
+namespace sol {
+
+ namespace detail {
+ template <>
+ struct is_speshul<unsafe_function_result> : std::true_type {};
+ template <>
+ struct is_speshul<protected_function_result> : std::true_type {};
+
+ template <std::size_t I, typename... Args, typename T>
+ stack_proxy get(types<Args...>, meta::index_value<0>, meta::index_value<I>, const T& fr) {
+ return stack_proxy(fr.lua_state(), static_cast<int>(fr.stack_index() + I));
+ }
+
+ template <std::size_t I, std::size_t N, typename Arg, typename... Args, typename T, meta::enable<meta::boolean<(N > 0)>> = meta::enabler>
+ stack_proxy get(types<Arg, Args...>, meta::index_value<N>, meta::index_value<I>, const T& fr) {
+ return get(types<Args...>(), meta::index_value<N - 1>(), meta::index_value<I + lua_size<Arg>::value>(), fr);
+ }
+ } // namespace detail
+
+ template <>
+ struct tie_size<unsafe_function_result> : std::integral_constant<std::size_t, SIZE_MAX> {};
+
+ template <>
+ struct tie_size<protected_function_result> : std::integral_constant<std::size_t, SIZE_MAX> {};
+
+ template <std::size_t I>
+ stack_proxy get(const unsafe_function_result& fr) {
+ return stack_proxy(fr.lua_state(), static_cast<int>(fr.stack_index() + I));
+ }
+
+ template <std::size_t I, typename... Args>
+ stack_proxy get(types<Args...> t, const unsafe_function_result& fr) {
+ return detail::get(t, meta::index_value<I>(), meta::index_value<0>(), fr);
+ }
+
+ template <std::size_t I>
+ stack_proxy get(const protected_function_result& fr) {
+ return stack_proxy(fr.lua_state(), static_cast<int>(fr.stack_index() + I));
+ }
+
+ template <std::size_t I, typename... Args>
+ stack_proxy get(types<Args...> t, const protected_function_result& fr) {
+ return detail::get(t, meta::index_value<I>(), meta::index_value<0>(), fr);
+ }
+} // namespace sol
+
+// end of sol/function_result.hpp
+
+// beginning of sol/function_types.hpp
+
+// beginning of sol/function_types_core.hpp
+
+// beginning of sol/wrapper.hpp
+
+namespace sol {
+
+ namespace detail {
+ template <typename T>
+ using array_return_type = meta::conditional_t<std::is_array<T>::value, std::add_lvalue_reference_t<T>, T>;
+ }
+
+ template <typename F, typename = void>
+ struct wrapper {
+ typedef lua_bind_traits<meta::unqualified_t<F>> traits_type;
+ typedef typename traits_type::args_list args_list;
+ typedef typename traits_type::args_list free_args_list;
+ typedef typename traits_type::returns_list returns_list;
+
+ template <typename... Args>
+ static decltype(auto) call(F& f, Args&&... args) {
+ return f(std::forward<Args>(args)...);
+ }
+
+ struct caller {
+ template <typename... Args>
+ decltype(auto) operator()(F& fx, Args&&... args) const {
+ return call(fx, std::forward<Args>(args)...);
+ }
+ };
+ };
+
+ template <typename F>
+ struct wrapper<F, std::enable_if_t<std::is_function<std::remove_pointer_t<meta::unqualified_t<F>>>::value>> {
+ typedef lua_bind_traits<std::remove_pointer_t<meta::unqualified_t<F>>> traits_type;
+ typedef typename traits_type::args_list args_list;
+ typedef typename traits_type::args_list free_args_list;
+ typedef typename traits_type::returns_list returns_list;
+
+ template <F fx, typename... Args>
+ static decltype(auto) invoke(Args&&... args) {
+ return fx(std::forward<Args>(args)...);
+ }
+
+ template <typename... Args>
+ static decltype(auto) call(F& fx, Args&&... args) {
+ return fx(std::forward<Args>(args)...);
+ }
+
+ struct caller {
+ template <typename... Args>
+ decltype(auto) operator()(F& fx, Args&&... args) const {
+ return call(fx, std::forward<Args>(args)...);
+ }
+ };
+
+ template <F fx>
+ struct invoker {
+ template <typename... Args>
+ decltype(auto) operator()(Args&&... args) const {
+ return invoke<fx>(std::forward<Args>(args)...);
+ }
+ };
+ };
+
+ template <typename F>
+ struct wrapper<F, std::enable_if_t<std::is_member_object_pointer<meta::unqualified_t<F>>::value>> {
+ typedef lua_bind_traits<meta::unqualified_t<F>> traits_type;
+ typedef typename traits_type::object_type object_type;
+ typedef typename traits_type::return_type return_type;
+ typedef typename traits_type::args_list args_list;
+ typedef types<object_type&, return_type> free_args_list;
+ typedef typename traits_type::returns_list returns_list;
+
+ template <F fx>
+ static auto call(object_type& mem) -> detail::array_return_type<decltype(mem.*fx)> {
+ return mem.*fx;
+ }
+
+ template <F fx, typename Arg, typename... Args>
+ static decltype(auto) invoke(object_type& mem, Arg&& arg, Args&&...) {
+ return mem.*fx = std::forward<Arg>(arg);
+ }
+
+ template <typename Fx>
+ static auto call(Fx&& fx, object_type& mem) -> detail::array_return_type<decltype(mem.*fx)> {
+ return mem.*fx;
+ }
+
+ template <typename Fx, typename Arg, typename... Args>
+ static void call(Fx&& fx, object_type& mem, Arg&& arg, Args&&...) {
+ using actual_type = meta::unqualified_t<detail::array_return_type<decltype(mem.*fx)>>;
+ if constexpr (std::is_array_v<actual_type>) {
+ using std::cbegin;
+ using std::cend;
+ auto first = cbegin(arg);
+ auto last = cend(arg);
+ for (std::size_t i = 0; first != last; ++i, ++first) {
+ (mem.*fx)[i] = *first;
+ }
+ }
+ else {
+ (mem.*fx) = std::forward<Arg>(arg);
+ }
+ }
+
+ struct caller {
+ template <typename Fx, typename... Args>
+ decltype(auto) operator()(Fx&& fx, object_type& mem, Args&&... args) const {
+ return call(std::forward<Fx>(fx), mem, std::forward<Args>(args)...);
+ }
+ };
+
+ template <F fx>
+ struct invoker {
+ template <typename... Args>
+ decltype(auto) operator()(Args&&... args) const {
+ return invoke<fx>(std::forward<Args>(args)...);
+ }
+ };
+ };
+
+ template <typename F, typename R, typename O, typename... FArgs>
+ struct member_function_wrapper {
+ typedef O object_type;
+ typedef lua_bind_traits<F> traits_type;
+ typedef typename traits_type::args_list args_list;
+ typedef types<object_type&, FArgs...> free_args_list;
+ typedef meta::tuple_types<R> returns_list;
+
+ template <F fx, typename... Args>
+ static R invoke(O& mem, Args&&... args) {
+ return (mem.*fx)(std::forward<Args>(args)...);
+ }
+
+ template <typename Fx, typename... Args>
+ static R call(Fx&& fx, O& mem, Args&&... args) {
+ return (mem.*fx)(std::forward<Args>(args)...);
+ }
+
+ struct caller {
+ template <typename Fx, typename... Args>
+ decltype(auto) operator()(Fx&& fx, O& mem, Args&&... args) const {
+ return call(std::forward<Fx>(fx), mem, std::forward<Args>(args)...);
+ }
+ };
+
+ template <F fx>
+ struct invoker {
+ template <typename... Args>
+ decltype(auto) operator()(O& mem, Args&&... args) const {
+ return invoke<fx>(mem, std::forward<Args>(args)...);
+ }
+ };
+ };
+
+ template <typename R, typename O, typename... Args>
+ struct wrapper<R (O::*)(Args...)> : public member_function_wrapper<R (O::*)(Args...), R, O, Args...> {};
+
+ template <typename R, typename O, typename... Args>
+ struct wrapper<R (O::*)(Args...) const> : public member_function_wrapper<R (O::*)(Args...) const, R, O, Args...> {};
+
+ template <typename R, typename O, typename... Args>
+ struct wrapper<R (O::*)(Args...) const volatile> : public member_function_wrapper<R (O::*)(Args...) const volatile, R, O, Args...> {};
+
+ template <typename R, typename O, typename... Args>
+ struct wrapper<R (O::*)(Args...)&> : public member_function_wrapper<R (O::*)(Args...)&, R, O, Args...> {};
+
+ template <typename R, typename O, typename... Args>
+ struct wrapper<R (O::*)(Args...) const&> : public member_function_wrapper<R (O::*)(Args...) const&, R, O, Args...> {};
+
+ template <typename R, typename O, typename... Args>
+ struct wrapper<R (O::*)(Args...) const volatile&> : public member_function_wrapper<R (O::*)(Args...) const volatile&, R, O, Args...> {};
+
+ template <typename R, typename O, typename... Args>
+ struct wrapper<R (O::*)(Args..., ...)&> : public member_function_wrapper<R (O::*)(Args..., ...)&, R, O, Args...> {};
+
+ template <typename R, typename O, typename... Args>
+ struct wrapper<R (O::*)(Args..., ...) const&> : public member_function_wrapper<R (O::*)(Args..., ...) const&, R, O, Args...> {};
+
+ template <typename R, typename O, typename... Args>
+ struct wrapper<R (O::*)(Args..., ...) const volatile&> : public member_function_wrapper<R (O::*)(Args..., ...) const volatile&, R, O, Args...> {};
+
+ template <typename R, typename O, typename... Args>
+ struct wrapper<R (O::*)(Args...) &&> : public member_function_wrapper<R (O::*)(Args...)&, R, O, Args...> {};
+
+ template <typename R, typename O, typename... Args>
+ struct wrapper<R (O::*)(Args...) const&&> : public member_function_wrapper<R (O::*)(Args...) const&, R, O, Args...> {};
+
+ template <typename R, typename O, typename... Args>
+ struct wrapper<R (O::*)(Args...) const volatile&&> : public member_function_wrapper<R (O::*)(Args...) const volatile&, R, O, Args...> {};
+
+ template <typename R, typename O, typename... Args>
+ struct wrapper<R (O::*)(Args..., ...) &&> : public member_function_wrapper<R (O::*)(Args..., ...)&, R, O, Args...> {};
+
+ template <typename R, typename O, typename... Args>
+ struct wrapper<R (O::*)(Args..., ...) const&&> : public member_function_wrapper<R (O::*)(Args..., ...) const&, R, O, Args...> {};
+
+ template <typename R, typename O, typename... Args>
+ struct wrapper<R (O::*)(Args..., ...) const volatile&&> : public member_function_wrapper<R (O::*)(Args..., ...) const volatile&, R, O, Args...> {};
+
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_)
+ // noexcept has become a part of a function's type
+
+ template <typename R, typename O, typename... Args>
+ struct wrapper<R (O::*)(Args...) noexcept> : public member_function_wrapper<R (O::*)(Args...) noexcept, R, O, Args...> {};
+
+ template <typename R, typename O, typename... Args>
+ struct wrapper<R (O::*)(Args...) const noexcept> : public member_function_wrapper<R (O::*)(Args...) const noexcept, R, O, Args...> {};
+
+ template <typename R, typename O, typename... Args>
+ struct wrapper<R (O::*)(Args...) const volatile noexcept> : public member_function_wrapper<R (O::*)(Args...) const volatile noexcept, R, O, Args...> {};
+
+ template <typename R, typename O, typename... Args>
+ struct wrapper<R (O::*)(Args...) & noexcept> : public member_function_wrapper<R (O::*)(Args...) & noexcept, R, O, Args...> {};
+
+ template <typename R, typename O, typename... Args>
+ struct wrapper<R (O::*)(Args...) const& noexcept> : public member_function_wrapper<R (O::*)(Args...) const& noexcept, R, O, Args...> {};
+
+ template <typename R, typename O, typename... Args>
+ struct wrapper<R (O::*)(Args...) const volatile& noexcept> : public member_function_wrapper<R (O::*)(Args...) const volatile& noexcept, R, O, Args...> {};
+
+ template <typename R, typename O, typename... Args>
+ struct wrapper<R (O::*)(Args..., ...) & noexcept> : public member_function_wrapper<R (O::*)(Args..., ...) & noexcept, R, O, Args...> {};
+
+ template <typename R, typename O, typename... Args>
+ struct wrapper<R (O::*)(Args..., ...) const& noexcept> : public member_function_wrapper<R (O::*)(Args..., ...) const& noexcept, R, O, Args...> {};
+
+ template <typename R, typename O, typename... Args>
+ struct wrapper<R (O::*)(Args..., ...) const volatile& noexcept>
+ : public member_function_wrapper<R (O::*)(Args..., ...) const volatile& noexcept, R, O, Args...> {};
+
+ template <typename R, typename O, typename... Args>
+ struct wrapper<R (O::*)(Args...) && noexcept> : public member_function_wrapper<R (O::*)(Args...) & noexcept, R, O, Args...> {};
+
+ template <typename R, typename O, typename... Args>
+ struct wrapper<R (O::*)(Args...) const&& noexcept> : public member_function_wrapper<R (O::*)(Args...) const& noexcept, R, O, Args...> {};
+
+ template <typename R, typename O, typename... Args>
+ struct wrapper<R (O::*)(Args...) const volatile&& noexcept> : public member_function_wrapper<R (O::*)(Args...) const volatile& noexcept, R, O, Args...> {};
+
+ template <typename R, typename O, typename... Args>
+ struct wrapper<R (O::*)(Args..., ...) && noexcept> : public member_function_wrapper<R (O::*)(Args..., ...) & noexcept, R, O, Args...> {};
+
+ template <typename R, typename O, typename... Args>
+ struct wrapper<R (O::*)(Args..., ...) const&& noexcept> : public member_function_wrapper<R (O::*)(Args..., ...) const& noexcept, R, O, Args...> {};
+
+ template <typename R, typename O, typename... Args>
+ struct wrapper<R (O::*)(Args..., ...) const volatile&& noexcept>
+ : public member_function_wrapper<R (O::*)(Args..., ...) const volatile& noexcept, R, O, Args...> {};
+
+#endif // noexcept is part of a function's type
+
+} // namespace sol
+
+// end of sol/wrapper.hpp
+
+#include <memory>
+
+namespace sol {
+namespace function_detail {
+ template <typename Fx, int start = 1, bool is_yielding = false>
+ int call(lua_State* L) {
+ Fx& fx = stack::get<user<Fx>>(L, upvalue_index(start));
+ int nr = fx(L);
+ if (is_yielding) {
+ return lua_yield(L, nr);
+ }
+ else {
+ return nr;
+ }
+ }
+}
+} // namespace sol::function_detail
+
+// end of sol/function_types_core.hpp
+
+// beginning of sol/function_types_templated.hpp
+
+// beginning of sol/call.hpp
+
+// beginning of sol/property.hpp
+
+#include <type_traits>
+#include <utility>
+
+namespace sol {
+ namespace detail {
+ struct no_prop {};
+ }
+
+ template <typename R, typename W>
+ struct property_wrapper : detail::ebco<R, 0>, detail::ebco<W, 1> {
+ private:
+ using read_base_t = detail::ebco<R, 0>;
+ using write_base_t = detail::ebco<W, 1>;
+
+ public:
+ template <typename Rx, typename Wx>
+ property_wrapper(Rx&& r, Wx&& w)
+ : read_base_t(std::forward<Rx>(r)), write_base_t(std::forward<Wx>(w)) {
+ }
+
+ W& write() {
+ return write_base_t::value();
+ }
+
+ const W& write() const {
+ return write_base_t::value();
+ }
+
+ R& read() {
+ return read_base_t::value();
+ }
+
+ const R& read() const {
+ return read_base_t::value();
+ }
+ };
+
+ template <typename F, typename G>
+ inline decltype(auto) property(F&& f, G&& g) {
+ typedef lua_bind_traits<meta::unqualified_t<F>> left_traits;
+ typedef lua_bind_traits<meta::unqualified_t<G>> right_traits;
+ if constexpr (left_traits::free_arity < right_traits::free_arity) {
+ return property_wrapper<std::decay_t<F>, std::decay_t<G>>(std::forward<F>(f), std::forward<G>(g));
+ }
+ else {
+ return property_wrapper<std::decay_t<G>, std::decay_t<F>>(std::forward<G>(g), std::forward<F>(f));
+ }
+ }
+
+ template <typename F>
+ inline decltype(auto) property(F&& f) {
+ typedef lua_bind_traits<meta::unqualified_t<F>> left_traits;
+ if constexpr (left_traits::free_arity < 2) {
+ return property_wrapper<std::decay_t<F>, detail::no_prop>(std::forward<F>(f), detail::no_prop());
+ }
+ else {
+ return property_wrapper<detail::no_prop, std::decay_t<F>>(detail::no_prop(), std::forward<F>(f));
+ }
+ }
+
+ template <typename F>
+ inline decltype(auto) readonly_property(F&& f) {
+ return property_wrapper<std::decay_t<F>, detail::no_prop>(std::forward<F>(f), detail::no_prop());
+ }
+
+ template <typename F>
+ inline decltype(auto) writeonly_property(F&& f) {
+ return property_wrapper<detail::no_prop, std::decay_t<F>>(detail::no_prop(), std::forward<F>(f));
+ }
+
+ template <typename T>
+ struct readonly_wrapper : detail::ebco<T> {
+ private:
+ using base_t = detail::ebco<T>;
+
+ public:
+ using base_t::base_t;
+
+ operator T&() {
+ return base_t::value();
+ }
+ operator const T&() const {
+ return base_t::value();
+ }
+ };
+
+ // Allow someone to make a member variable readonly (const)
+ template <typename R, typename T>
+ inline auto readonly(R T::*v) {
+ return readonly_wrapper<meta::unqualified_t<decltype(v)>>(v);
+ }
+
+ template <typename T>
+ struct var_wrapper : detail::ebco<T> {
+ private:
+ using base_t = detail::ebco<T>;
+
+ public:
+ using base_t::base_t;
+ };
+
+ template <typename V>
+ inline auto var(V&& v) {
+ typedef std::decay_t<V> T;
+ return var_wrapper<T>(std::forward<V>(v));
+ }
+
+ namespace meta {
+ template <typename T>
+ struct is_member_object : std::is_member_object_pointer<T> {};
+
+ template <typename T>
+ struct is_member_object<readonly_wrapper<T>> : std::true_type {};
+
+ template <typename T>
+ inline constexpr bool is_member_object_v = is_member_object<T>::value;
+ } // namespace meta
+
+} // namespace sol
+
+// end of sol/property.hpp
+
+// beginning of sol/protect.hpp
+
+#include <utility>
+
+namespace sol {
+
+ template <typename T>
+ struct protect_t {
+ T value;
+
+ template <typename Arg, typename... Args, meta::disable<std::is_same<protect_t, meta::unqualified_t<Arg>>> = meta::enabler>
+ protect_t(Arg&& arg, Args&&... args)
+ : value(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+ }
+
+ protect_t(const protect_t&) = default;
+ protect_t(protect_t&&) = default;
+ protect_t& operator=(const protect_t&) = default;
+ protect_t& operator=(protect_t&&) = default;
+ };
+
+ template <typename T>
+ auto protect(T&& value) {
+ return protect_t<std::decay_t<T>>(std::forward<T>(value));
+ }
+
+} // namespace sol
+
+// end of sol/protect.hpp
+
+namespace sol {
+ namespace u_detail {
+
+ } // namespace u_detail
+
+ namespace policy_detail {
+ template <int I, int... In>
+ inline void handle_policy(static_stack_dependencies<I, In...>, lua_State* L, int&) {
+ if constexpr (sizeof...(In) == 0) {
+ (void)L;
+ return;
+ }
+ else {
+ absolute_index ai(L, I);
+ if (type_of(L, ai) != type::userdata) {
+ return;
+ }
+ lua_createtable(L, static_cast<int>(sizeof...(In)), 0);
+ stack_reference deps(L, -1);
+ auto per_dep = [&L, &deps](int i) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+ lua_pushvalue(L, i);
+ luaL_ref(L, deps.stack_index());
+ };
+ (void)per_dep;
+ (void)detail::swallow{ int(), (per_dep(In), int())... };
+ lua_setuservalue(L, ai);
+ }
+ }
+
+ template <int... In>
+ inline void handle_policy(returns_self_with<In...>, lua_State* L, int& pushed) {
+ pushed = stack::push(L, raw_index(1));
+ handle_policy(static_stack_dependencies<-1, In...>(), L, pushed);
+ }
+
+ inline void handle_policy(const stack_dependencies& sdeps, lua_State* L, int&) {
+ absolute_index ai(L, sdeps.target);
+ if (type_of(L, ai) != type::userdata) {
+ return;
+ }
+ lua_createtable(L, static_cast<int>(sdeps.size()), 0);
+ stack_reference deps(L, -1);
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, static_cast<int>(sdeps.size()), detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+ for (std::size_t i = 0; i < sdeps.size(); ++i) {
+ lua_pushvalue(L, sdeps.stack_indices[i]);
+ luaL_ref(L, deps.stack_index());
+ }
+ lua_setuservalue(L, ai);
+ }
+
+ template <typename P, meta::disable<std::is_base_of<detail::policy_base_tag, meta::unqualified_t<P>>> = meta::enabler>
+ inline void handle_policy(P&& p, lua_State* L, int& pushed) {
+ pushed = std::forward<P>(p)(L, pushed);
+ }
+ } // namespace policy_detail
+
+ namespace function_detail {
+ inline int no_construction_error(lua_State* L) {
+ return luaL_error(L, "sol: cannot call this constructor (tagged as non-constructible)");
+ }
+ } // namespace function_detail
+
+ namespace call_detail {
+
+ template <typename R, typename W>
+ inline auto& pick(std::true_type, property_wrapper<R, W>& f) {
+ return f.read();
+ }
+
+ template <typename R, typename W>
+ inline auto& pick(std::false_type, property_wrapper<R, W>& f) {
+ return f.write();
+ }
+
+ template <typename T, typename List>
+ struct void_call : void_call<T, meta::function_args_t<List>> {};
+
+ template <typename T, typename... Args>
+ struct void_call<T, types<Args...>> {
+ static void call(Args...) {
+ }
+ };
+
+ template <typename T, bool checked, bool clean_stack>
+ struct constructor_match {
+ T* obj_;
+
+ constructor_match(T* o) : obj_(o) {
+ }
+
+ template <typename Fx, std::size_t I, typename... R, typename... Args>
+ int operator()(types<Fx>, meta::index_value<I>, types<R...> r, types<Args...> a, lua_State* L, int, int start) const {
+ detail::default_construct func{};
+ return stack::call_into_lua<checked, clean_stack>(r, a, L, start, func, obj_);
+ }
+ };
+
+ namespace overload_detail {
+ template <std::size_t... M, typename Match, typename... Args>
+ inline int overload_match_arity(types<>, std::index_sequence<>, std::index_sequence<M...>, Match&&, lua_State* L, int, int, Args&&...) {
+ return luaL_error(L, "sol: no matching function call takes this number of arguments and the specified types");
+ }
+
+ template <typename Fx, typename... Fxs, std::size_t I, std::size_t... In, std::size_t... M, typename Match, typename... Args>
+ inline int overload_match_arity(types<Fx, Fxs...>, std::index_sequence<I, In...>, std::index_sequence<M...>, Match&& matchfx, lua_State* L,
+ int fxarity, int start, Args&&... args) {
+ typedef lua_bind_traits<meta::unwrap_unqualified_t<Fx>> traits;
+ typedef meta::tuple_types<typename traits::return_type> return_types;
+ typedef typename traits::free_args_list args_list;
+ // compile-time eliminate any functions that we know ahead of time are of improper arity
+ if constexpr (!traits::runtime_variadics_t::value
+ && meta::find_in_pack_v<meta::index_value<traits::free_arity>, meta::index_value<M>...>::value) {
+ return overload_match_arity(types<Fxs...>(),
+ std::index_sequence<In...>(),
+ std::index_sequence<M...>(),
+ std::forward<Match>(matchfx),
+ L,
+ fxarity,
+ start,
+ std::forward<Args>(args)...);
+ }
+ else {
+ if constexpr (!traits::runtime_variadics_t::value) {
+ if (traits::free_arity != fxarity) {
+ return overload_match_arity(types<Fxs...>(),
+ std::index_sequence<In...>(),
+ std::index_sequence<traits::free_arity, M...>(),
+ std::forward<Match>(matchfx),
+ L,
+ fxarity,
+ start,
+ std::forward<Args>(args)...);
+ }
+ }
+ stack::record tracking{};
+ if (!stack::stack_detail::check_types(args_list(), L, start, no_panic, tracking)) {
+ return overload_match_arity(types<Fxs...>(),
+ std::index_sequence<In...>(),
+ std::index_sequence<M...>(),
+ std::forward<Match>(matchfx),
+ L,
+ fxarity,
+ start,
+ std::forward<Args>(args)...);
+ }
+ return matchfx(types<Fx>(), meta::index_value<I>(), return_types(), args_list(), L, fxarity, start, std::forward<Args>(args)...);
+ }
+ }
+
+ template <std::size_t... M, typename Match, typename... Args>
+ inline int overload_match_arity_single(
+ types<>, std::index_sequence<>, std::index_sequence<M...>, Match&& matchfx, lua_State* L, int fxarity, int start, Args&&... args) {
+ return overload_match_arity(types<>(),
+ std::index_sequence<>(),
+ std::index_sequence<M...>(),
+ std::forward<Match>(matchfx),
+ L,
+ fxarity,
+ start,
+ std::forward<Args>(args)...);
+ }
+
+ template <typename Fx, std::size_t I, std::size_t... M, typename Match, typename... Args>
+ inline int overload_match_arity_single(
+ types<Fx>, std::index_sequence<I>, std::index_sequence<M...>, Match&& matchfx, lua_State* L, int fxarity, int start, Args&&... args) {
+ typedef lua_bind_traits<meta::unwrap_unqualified_t<Fx>> traits;
+ typedef meta::tuple_types<typename traits::return_type> return_types;
+ typedef typename traits::free_args_list args_list;
+ // compile-time eliminate any functions that we know ahead of time are of improper arity
+ if constexpr (!traits::runtime_variadics_t::value
+ && meta::find_in_pack_v<meta::index_value<traits::free_arity>, meta::index_value<M>...>::value) {
+ return overload_match_arity(types<>(),
+ std::index_sequence<>(),
+ std::index_sequence<M...>(),
+ std::forward<Match>(matchfx),
+ L,
+ fxarity,
+ start,
+ std::forward<Args>(args)...);
+ }
+ if constexpr (!traits::runtime_variadics_t::value) {
+ if (traits::free_arity != fxarity) {
+ return overload_match_arity(types<>(),
+ std::index_sequence<>(),
+ std::index_sequence<traits::free_arity, M...>(),
+ std::forward<Match>(matchfx),
+ L,
+ fxarity,
+ start,
+ std::forward<Args>(args)...);
+ }
+ }
+ return matchfx(types<Fx>(), meta::index_value<I>(), return_types(), args_list(), L, fxarity, start, std::forward<Args>(args)...);
+ }
+
+ template <typename Fx, typename Fx1, typename... Fxs, std::size_t I, std::size_t I1, std::size_t... In, std::size_t... M, typename Match,
+ typename... Args>
+ inline int overload_match_arity_single(types<Fx, Fx1, Fxs...>, std::index_sequence<I, I1, In...>, std::index_sequence<M...>, Match&& matchfx,
+ lua_State* L, int fxarity, int start, Args&&... args) {
+ typedef lua_bind_traits<meta::unwrap_unqualified_t<Fx>> traits;
+ typedef meta::tuple_types<typename traits::return_type> return_types;
+ typedef typename traits::free_args_list args_list;
+ // compile-time eliminate any functions that we know ahead of time are of improper arity
+ if constexpr (!traits::runtime_variadics_t::value
+ && meta::find_in_pack_v<meta::index_value<traits::free_arity>, meta::index_value<M>...>::value) {
+ return overload_match_arity(types<Fx1, Fxs...>(),
+ std::index_sequence<I1, In...>(),
+ std::index_sequence<M...>(),
+ std::forward<Match>(matchfx),
+ L,
+ fxarity,
+ start,
+ std::forward<Args>(args)...);
+ }
+ else {
+ if constexpr (!traits::runtime_variadics_t::value) {
+ if (traits::free_arity != fxarity) {
+ return overload_match_arity(types<Fx1, Fxs...>(),
+ std::index_sequence<I1, In...>(),
+ std::index_sequence<traits::free_arity, M...>(),
+ std::forward<Match>(matchfx),
+ L,
+ fxarity,
+ start,
+ std::forward<Args>(args)...);
+ }
+ }
+ stack::record tracking{};
+ if (!stack::stack_detail::check_types(args_list(), L, start, no_panic, tracking)) {
+ return overload_match_arity(types<Fx1, Fxs...>(),
+ std::index_sequence<I1, In...>(),
+ std::index_sequence<M...>(),
+ std::forward<Match>(matchfx),
+ L,
+ fxarity,
+ start,
+ std::forward<Args>(args)...);
+ }
+ return matchfx(types<Fx>(), meta::index_value<I>(), return_types(), args_list(), L, fxarity, start, std::forward<Args>(args)...);
+ }
+ }
+ } // namespace overload_detail
+
+ template <typename... Functions, typename Match, typename... Args>
+ inline int overload_match_arity(Match&& matchfx, lua_State* L, int fxarity, int start, Args&&... args) {
+ return overload_detail::overload_match_arity_single(types<Functions...>(),
+ std::make_index_sequence<sizeof...(Functions)>(),
+ std::index_sequence<>(),
+ std::forward<Match>(matchfx),
+ L,
+ fxarity,
+ start,
+ std::forward<Args>(args)...);
+ }
+
+ template <typename... Functions, typename Match, typename... Args>
+ inline int overload_match(Match&& matchfx, lua_State* L, int start, Args&&... args) {
+ int fxarity = lua_gettop(L) - (start - 1);
+ return overload_match_arity<Functions...>(std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
+ }
+
+ template <typename T, typename... TypeLists, typename Match, typename... Args>
+ inline int construct_match(Match&& matchfx, lua_State* L, int fxarity, int start, Args&&... args) {
+ // use same overload resolution matching as all other parts of the framework
+ return overload_match_arity<decltype(void_call<T, TypeLists>::call)...>(
+ std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
+ }
+
+ template <typename T, bool checked, bool clean_stack, typename... TypeLists>
+ inline int construct_trampolined(lua_State* L) {
+ static const auto& meta = usertype_traits<T>::metatable();
+ int argcount = lua_gettop(L);
+ call_syntax syntax = argcount > 0 ? stack::get_call_syntax(L, usertype_traits<T>::user_metatable(), 1) : call_syntax::dot;
+ argcount -= static_cast<int>(syntax);
+
+ T* obj = detail::usertype_allocate<T>(L);
+ reference userdataref(L, -1);
+ stack::stack_detail::undefined_metatable umf(L, &meta[0], &stack::stack_detail::set_undefined_methods_on<T>);
+ umf();
+
+ // put userdata at the first index
+ lua_insert(L, 1);
+ construct_match<T, TypeLists...>(constructor_match<T, checked, clean_stack>(obj), L, argcount, 1 + static_cast<int>(syntax));
+
+ userdataref.push();
+ return 1;
+ }
+
+ template <typename T, bool checked, bool clean_stack, typename... TypeLists>
+ inline int construct(lua_State* L) {
+ return detail::static_trampoline<&construct_trampolined<T, checked, clean_stack, TypeLists...>>(L);
+ }
+
+ template <typename F, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename = void>
+ struct agnostic_lua_call_wrapper {
+ template <typename Fx, typename... Args>
+ static int call(lua_State* L, Fx&& f, Args&&... args) {
+ using uFx = meta::unqualified_t<Fx>;
+ static constexpr bool is_ref = is_lua_reference_v<uFx>;
+ if constexpr (is_ref) {
+ if constexpr (is_index) {
+ return stack::push(L, std::forward<Fx>(f), std::forward<Args>(args)...);
+ }
+ else {
+ std::forward<Fx>(f) = stack::unqualified_get<F>(L, boost + (is_variable ? 3 : 1));
+ return 0;
+ }
+ }
+ else {
+ using wrap = wrapper<uFx>;
+ using traits_type = typename wrap::traits_type;
+ using fp_t = typename traits_type::function_pointer_type;
+ constexpr bool is_function_pointer_convertible
+ = std::is_class_v<uFx> && std::is_convertible_v<std::decay_t<Fx>, fp_t>;
+ if constexpr (is_function_pointer_convertible) {
+ fp_t fx = f;
+ return agnostic_lua_call_wrapper<fp_t, is_index, is_variable, checked, boost, clean_stack>{}.call(
+ L, fx, std::forward<Args>(args)...);
+ }
+ else {
+ using returns_list = typename wrap::returns_list;
+ using args_list = typename wrap::free_args_list;
+ using caller = typename wrap::caller;
+ return stack::call_into_lua<checked, clean_stack>(
+ returns_list(), args_list(), L, boost + 1, caller(), std::forward<Fx>(f), std::forward<Args>(args)...);
+ }
+ }
+ }
+ };
+
+ template <typename T, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+ struct agnostic_lua_call_wrapper<var_wrapper<T>, is_index, is_variable, checked, boost, clean_stack, C> {
+ template <typename F>
+ static int call(lua_State* L, F&& f) {
+ if constexpr (is_index) {
+ constexpr bool is_stack = is_stack_based_v<meta::unqualified_t<decltype(detail::unwrap(f.value()))>>;
+ if constexpr (clean_stack && !is_stack) {
+ lua_settop(L, 0);
+ }
+ return stack::push_reference(L, detail::unwrap(f.value()));
+ }
+ else {
+ if constexpr (std::is_const_v<meta::unwrapped_t<T>>) {
+ (void)f;
+ return luaL_error(L, "sol: cannot write to a readonly (const) variable");
+ }
+ else {
+ using R = meta::unwrapped_t<T>;
+ if constexpr (std::is_assignable_v<std::add_lvalue_reference_t<meta::unqualified_t<R>>, R>) {
+ detail::unwrap(f.value()) = stack::unqualified_get<meta::unwrapped_t<T>>(L, boost + (is_variable ? 3 : 1));
+ if (clean_stack) {
+ lua_settop(L, 0);
+ }
+ return 0;
+ }
+ else {
+ return luaL_error(L, "sol: cannot write to this variable: copy assignment/constructor not available");
+ }
+ }
+ }
+ }
+ };
+
+ template <bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+ struct agnostic_lua_call_wrapper<lua_CFunction_ref, is_index, is_variable, checked, boost, clean_stack, C> {
+ static int call(lua_State* L, lua_CFunction_ref f) {
+ return f(L);
+ }
+ };
+
+ template <bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+ struct agnostic_lua_call_wrapper<lua_CFunction, is_index, is_variable, checked, boost, clean_stack, C> {
+ static int call(lua_State* L, lua_CFunction f) {
+ return f(L);
+ }
+ };
+
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_)
+ 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> {
+ static int call(lua_State* L, detail::lua_CFunction_noexcept f) {
+ return f(L);
+ }
+ };
+#endif // noexcept function types
+
+ template <bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+ struct agnostic_lua_call_wrapper<detail::no_prop, is_index, is_variable, checked, boost, clean_stack, C> {
+ static int call(lua_State* L, const detail::no_prop&) {
+ return luaL_error(L, is_index ? "sol: cannot read from a writeonly property" : "sol: cannot write to a readonly property");
+ }
+ };
+
+ template <bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+ struct agnostic_lua_call_wrapper<no_construction, is_index, is_variable, checked, boost, clean_stack, C> {
+ static int call(lua_State* L, const no_construction&) {
+ return function_detail::no_construction_error(L);
+ }
+ };
+
+ template <typename... Args, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+ struct agnostic_lua_call_wrapper<bases<Args...>, is_index, is_variable, checked, boost, clean_stack, C> {
+ static int call(lua_State*, const bases<Args...>&) {
+ // Uh. How did you even call this, lul
+ return 0;
+ }
+ };
+
+ template <typename T, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+ struct agnostic_lua_call_wrapper<std::reference_wrapper<T>, is_index, is_variable, checked, boost, clean_stack, C> {
+ static int call(lua_State* L, std::reference_wrapper<T> f) {
+ agnostic_lua_call_wrapper<T, is_index, is_variable, checked, boost, clean_stack> alcw{};
+ return alcw.call(L, f.get());
+ }
+ };
+
+ template <typename T, typename F, bool is_index, bool is_variable, bool checked = detail::default_safe_function_calls, int boost = 0,
+ bool clean_stack = true, typename = void>
+ struct lua_call_wrapper {
+ template <typename Fx, typename... Args>
+ static int call(lua_State* L, Fx&& fx, Args&&... args) {
+ if constexpr (std::is_member_function_pointer_v<F>) {
+ using wrap = wrapper<F>;
+ using object_type = typename wrap::object_type;
+ if constexpr (sizeof...(Args) < 1) {
+ using Ta = meta::conditional_t<std::is_void_v<T>, object_type, T>;
+ static_assert(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 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!");
+#if SOL_IS_ON(SOL_SAFE_USERTYPE_I_)
+ auto maybeo = stack::check_get<Ta*>(L, 1);
+ if (!maybeo || maybeo.value() == nullptr) {
+ return luaL_error(L,
+ "sol: received nil for 'self' argument (use ':' for accessing member functions, make sure member variables are "
+ "preceeded by the "
+ "actual object with '.' syntax)");
+ }
+ object_type* o = static_cast<object_type*>(maybeo.value());
+ return call(L, std::forward<Fx>(fx), *o);
+#else
+ object_type& o = static_cast<object_type&>(*stack::unqualified_get<non_null<Ta*>>(L, 1));
+ return call(L, std::forward<Fx>(fx), o);
+#endif // Safety
+ }
+ else {
+ using returns_list = typename wrap::returns_list;
+ using args_list = typename wrap::args_list;
+ using caller = typename wrap::caller;
+ return stack::call_into_lua<checked, clean_stack>(
+ returns_list(), args_list(), L, boost + (is_variable ? 3 : 2), caller(), std::forward<Fx>(fx), std::forward<Args>(args)...);
+ }
+ }
+ else if constexpr (std::is_member_object_pointer_v<F>) {
+ using wrap = wrapper<F>;
+ using object_type = typename wrap::object_type;
+ if constexpr (is_index) {
+ if constexpr (sizeof...(Args) < 1) {
+ using Ta = meta::conditional_t<std::is_void_v<T>, object_type, T>;
+ static_assert(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 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!");
+#if SOL_IS_ON(SOL_SAFE_USERTYPE_I_)
+ auto maybeo = stack::check_get<Ta*>(L, 1);
+ if (!maybeo || maybeo.value() == nullptr) {
+ 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 (pass 'self' as first argument)");
+ }
+ object_type* o = static_cast<object_type*>(maybeo.value());
+ return call(L, std::forward<Fx>(fx), *o);
+#else
+ object_type& o = static_cast<object_type&>(*stack::get<non_null<Ta*>>(L, 1));
+ return call(L, std::forward<Fx>(fx), o);
+#endif // Safety
+ }
+ else {
+ using returns_list = typename wrap::returns_list;
+ using caller = typename wrap::caller;
+ return stack::call_into_lua<checked, clean_stack>(returns_list(),
+ types<>(),
+ L,
+ boost + (is_variable ? 3 : 2),
+ caller(),
+ std::forward<Fx>(fx),
+ std::forward<Args>(args)...);
+ }
+ }
+ else {
+ using traits_type = lua_bind_traits<F>;
+ using return_type = typename traits_type::return_type;
+ constexpr bool ret_is_const = std::is_const_v<std::remove_reference_t<return_type>>;
+ if constexpr (ret_is_const) {
+ (void)fx;
+ (void)detail::swallow{ 0, (static_cast<void>(args), 0)... };
+ return luaL_error(L, "sol: cannot write to a readonly (const) variable");
+ }
+ else {
+ using u_return_type = meta::unqualified_t<return_type>;
+ constexpr bool is_assignable = std::is_copy_assignable_v<u_return_type> || std::is_array_v<u_return_type>;
+ if constexpr (!is_assignable) {
+ (void)fx;
+ (void)detail::swallow{ 0, ((void)args, 0)... };
+ return luaL_error(L, "sol: cannot write to this variable: copy assignment/constructor not available");
+ }
+ else {
+ using args_list = typename wrap::args_list;
+ using caller = typename wrap::caller;
+ if constexpr (sizeof...(Args) > 0) {
+ return stack::call_into_lua<checked, clean_stack>(types<void>(),
+ args_list(),
+ L,
+ boost + (is_variable ? 3 : 2),
+ caller(),
+ std::forward<Fx>(fx),
+ std::forward<Args>(args)...);
+ }
+ else {
+ using Ta = meta::conditional_t<std::is_void_v<T>, object_type, T>;
+#if SOL_IS_ON(SOL_SAFE_USERTYPE_I_)
+ auto maybeo = stack::check_get<Ta*>(L, 1);
+ if (!maybeo || maybeo.value() == nullptr) {
+ 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 (pass 'self' as first argument)");
+ }
+ object_type* po = static_cast<object_type*>(maybeo.value());
+ object_type& o = *po;
+#else
+ object_type& o = static_cast<object_type&>(*stack::get<non_null<Ta*>>(L, 1));
+#endif // Safety
+
+ return stack::call_into_lua<checked, clean_stack>(
+ types<void>(), args_list(), L, boost + (is_variable ? 3 : 2), caller(), std::forward<Fx>(fx), o);
+ }
+ }
+ }
+ }
+ }
+ else {
+ agnostic_lua_call_wrapper<F, is_index, is_variable, checked, boost, clean_stack> alcw{};
+ return alcw.call(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+ }
+ }
+ };
+
+ template <typename T, typename F, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+ struct lua_call_wrapper<T, readonly_wrapper<F>, is_index, is_variable, checked, boost, clean_stack, C> {
+ using traits_type = lua_bind_traits<F>;
+ using wrap = wrapper<F>;
+ using object_type = typename wrap::object_type;
+
+ static int call(lua_State* L, readonly_wrapper<F>&& rw) {
+ if constexpr (!is_index) {
+ (void)rw;
+ return luaL_error(L, "sol: cannot write to a sol::readonly variable");
+ }
+ else {
+ lua_call_wrapper<T, F, true, is_variable, checked, boost, clean_stack, C> lcw;
+ return lcw.call(L, std::move(rw.value()));
+ }
+ }
+
+ static int call(lua_State* L, readonly_wrapper<F>&& rw, object_type& o) {
+ if constexpr (!is_index) {
+ (void)o;
+ return call(L, std::move(rw));
+ }
+ else {
+ lua_call_wrapper<T, F, true, is_variable, checked, boost, clean_stack, C> lcw;
+ return lcw.call(L, rw.value(), o);
+ }
+ }
+
+ static int call(lua_State* L, const readonly_wrapper<F>& rw) {
+ if constexpr (!is_index) {
+ (void)rw;
+ return luaL_error(L, "sol: cannot write to a sol::readonly variable");
+ }
+ else {
+ lua_call_wrapper<T, F, true, is_variable, checked, boost, clean_stack, C> lcw;
+ return lcw.call(L, rw.value());
+ }
+ }
+
+ static int call(lua_State* L, const readonly_wrapper<F>& rw, object_type& o) {
+ if constexpr (!is_index) {
+ (void)o;
+ return call(L, rw);
+ }
+ else {
+ lua_call_wrapper<T, F, true, is_variable, checked, boost, clean_stack, C> lcw;
+ return lcw.call(L, rw.value(), o);
+ }
+ }
+ };
+
+ template <typename T, typename... Args, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+ struct lua_call_wrapper<T, constructor_list<Args...>, is_index, is_variable, checked, boost, clean_stack, C> {
+ typedef constructor_list<Args...> F;
+
+ static int call(lua_State* L, F&) {
+ const auto& meta = usertype_traits<T>::metatable();
+ int argcount = lua_gettop(L);
+ call_syntax syntax = argcount > 0 ? stack::get_call_syntax(L, usertype_traits<T>::user_metatable(), 1) : call_syntax::dot;
+ argcount -= static_cast<int>(syntax);
+
+ T* obj = detail::usertype_allocate<T>(L);
+ reference userdataref(L, -1);
+ stack::stack_detail::undefined_metatable umf(L, &meta[0], &stack::stack_detail::set_undefined_methods_on<T>);
+ umf();
+
+ // put userdata at the first index
+ lua_insert(L, 1);
+ construct_match<T, Args...>(constructor_match<T, checked, clean_stack>(obj), L, argcount, boost + 1 + 1 + static_cast<int>(syntax));
+
+ userdataref.push();
+ return 1;
+ }
+ };
+
+ template <typename T, typename... Cxs, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+ struct lua_call_wrapper<T, constructor_wrapper<Cxs...>, is_index, is_variable, checked, boost, clean_stack, C> {
+ typedef constructor_wrapper<Cxs...> F;
+
+ struct onmatch {
+ template <typename Fx, std::size_t I, typename... R, typename... Args>
+ int operator()(types<Fx>, meta::index_value<I>, types<R...> r, types<Args...> a, lua_State* L, int, int start, F& f) {
+ const auto& meta = usertype_traits<T>::metatable();
+ T* obj = detail::usertype_allocate<T>(L);
+ reference userdataref(L, -1);
+ stack::stack_detail::undefined_metatable umf(L, &meta[0], &stack::stack_detail::set_undefined_methods_on<T>);
+ umf();
+
+ auto& func = std::get<I>(f.functions);
+ // put userdata at the first index
+ lua_insert(L, 1);
+ stack::call_into_lua<checked, clean_stack>(r, a, L, boost + 1 + start, func, detail::implicit_wrapper<T>(obj));
+
+ userdataref.push();
+ return 1;
+ }
+ };
+
+ static int call(lua_State* L, F& f) {
+ call_syntax syntax = stack::get_call_syntax(L, usertype_traits<T>::user_metatable(), 1);
+ int syntaxval = static_cast<int>(syntax);
+ int argcount = lua_gettop(L) - syntaxval;
+ return construct_match<T, meta::pop_front_type_t<meta::function_args_t<Cxs>>...>(onmatch(), L, argcount, 1 + syntaxval, f);
+ }
+ };
+
+ template <typename T, typename Fx, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+ struct lua_call_wrapper<T, destructor_wrapper<Fx>, is_index, is_variable, checked, boost, clean_stack, C> {
+
+ template <typename F>
+ static int call(lua_State* L, F&& f) {
+ if constexpr (std::is_void_v<Fx>) {
+ return detail::usertype_alloc_destruct<T>(L);
+ }
+ else {
+ using uFx = meta::unqualified_t<Fx>;
+ lua_call_wrapper<T, uFx, is_index, is_variable, checked, boost, clean_stack> lcw{};
+ return lcw.call(L, std::forward<F>(f).fx);
+ }
+ }
+ };
+
+ template <typename T, typename... Fs, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+ struct lua_call_wrapper<T, overload_set<Fs...>, is_index, is_variable, checked, boost, clean_stack, C> {
+ typedef overload_set<Fs...> F;
+
+ struct on_match {
+ template <typename Fx, std::size_t I, typename... R, typename... Args>
+ int operator()(types<Fx>, meta::index_value<I>, types<R...>, types<Args...>, lua_State* L, int, int, F& fx) {
+ auto& f = std::get<I>(fx.functions);
+ return lua_call_wrapper<T, Fx, is_index, is_variable, checked, boost>{}.call(L, f);
+ }
+ };
+
+ static int call(lua_State* L, F& fx) {
+ return overload_match_arity<Fs...>(on_match(), L, lua_gettop(L), 1, fx);
+ }
+ };
+
+ template <typename T, typename... Fs, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+ struct lua_call_wrapper<T, factory_wrapper<Fs...>, is_index, is_variable, checked, boost, clean_stack, C> {
+ typedef factory_wrapper<Fs...> F;
+
+ struct on_match {
+ template <typename Fx, std::size_t I, typename... R, typename... Args>
+ int operator()(types<Fx>, meta::index_value<I>, types<R...>, types<Args...>, lua_State* L, int, int, F& fx) {
+ auto& f = std::get<I>(fx.functions);
+ return lua_call_wrapper<T, Fx, is_index, is_variable, checked, boost, clean_stack>{}.call(L, f);
+ }
+ };
+
+ static int call(lua_State* L, F& fx) {
+ return overload_match_arity<Fs...>(on_match(), L, lua_gettop(L) - boost, 1 + boost, fx);
+ }
+ };
+
+ template <typename T, typename R, typename W, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+ struct lua_call_wrapper<T, property_wrapper<R, W>, is_index, is_variable, checked, boost, clean_stack, C> {
+ typedef meta::conditional_t<is_index, R, W> P;
+ typedef meta::unqualified_t<P> U;
+ typedef wrapper<U> wrap;
+ typedef lua_bind_traits<U> traits_type;
+ typedef meta::unqualified_t<typename traits_type::template arg_at<0>> object_type;
+
+ template <typename F, typename... Args>
+ static int call(lua_State* L, F&& f, Args&&... args) {
+ constexpr bool is_specialized = meta::any<std::is_same<U, detail::no_prop>,
+ meta::is_specialization_of<U, var_wrapper>,
+ meta::is_specialization_of<U, constructor_wrapper>,
+ meta::is_specialization_of<U, constructor_list>,
+ std::is_member_pointer<U>>::value;
+ if constexpr (is_specialized) {
+ if constexpr (is_index) {
+ decltype(auto) p = f.read();
+ lua_call_wrapper<T, meta::unqualified_t<decltype(p)>, is_index, is_variable, checked, boost, clean_stack> lcw{};
+ return lcw.call(L, p, std::forward<Args>(args)...);
+ }
+ else {
+ decltype(auto) p = f.write();
+ lua_call_wrapper<T, meta::unqualified_t<decltype(p)>, is_index, is_variable, checked, boost, clean_stack> lcw{};
+ return lcw.call(L, p, std::forward<Args>(args)...);
+ }
+ }
+ else {
+ constexpr bool non_class_object_type = meta::any<std::is_void<object_type>,
+ meta::boolean<lua_type_of<meta::unwrap_unqualified_t<object_type>>::value != type::userdata>>::value;
+ if constexpr (non_class_object_type) {
+ // The type being void means we don't have any arguments, so it might be a free functions?
+ using args_list = typename traits_type::free_args_list;
+ using returns_list = typename wrap::returns_list;
+ using caller = typename wrap::caller;
+ if constexpr (is_index) {
+ decltype(auto) pf = f.read();
+ return stack::call_into_lua<checked, clean_stack>(
+ returns_list(), args_list(), L, boost + (is_variable ? 3 : 2), caller(), pf);
+ }
+ else {
+ decltype(auto) pf = f.write();
+ return stack::call_into_lua<checked, clean_stack>(
+ returns_list(), args_list(), L, boost + (is_variable ? 3 : 2), caller(), pf);
+ }
+ }
+ else {
+ using args_list = meta::pop_front_type_t<typename traits_type::free_args_list>;
+ using Ta = T;
+ using Oa = std::remove_pointer_t<object_type>;
+#if SOL_IS_ON(SOL_SAFE_USERTYPE_I_)
+ auto maybeo = stack::check_get<Ta*>(L, 1);
+ if (!maybeo || maybeo.value() == nullptr) {
+ 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 (pass 'self' as first argument)");
+ }
+ Oa* o = static_cast<Oa*>(maybeo.value());
+#else
+ Oa* o = static_cast<Oa*>(stack::get<non_null<Ta*>>(L, 1));
+#endif // Safety
+ using returns_list = typename wrap::returns_list;
+ using caller = typename wrap::caller;
+ if constexpr (is_index) {
+ decltype(auto) pf = f.read();
+ return stack::call_into_lua<checked, clean_stack>(
+ returns_list(), args_list(), L, boost + (is_variable ? 3 : 2), caller(), pf, detail::implicit_wrapper<Oa>(*o));
+ }
+ else {
+ decltype(auto) pf = f.write();
+ return stack::call_into_lua<checked, clean_stack>(
+ returns_list(), args_list(), L, boost + (is_variable ? 3 : 2), caller(), pf, detail::implicit_wrapper<Oa>(*o));
+ }
+ }
+ }
+ }
+ };
+
+ template <typename T, typename V, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+ struct lua_call_wrapper<T, protect_t<V>, is_index, is_variable, checked, boost, clean_stack, C> {
+ typedef protect_t<V> F;
+
+ template <typename... Args>
+ static int call(lua_State* L, F& fx, Args&&... args) {
+ return lua_call_wrapper<T, V, is_index, is_variable, true, boost, clean_stack>{}.call(L, fx.value, std::forward<Args>(args)...);
+ }
+ };
+
+ template <typename T, typename F, typename... Policies, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+ struct lua_call_wrapper<T, policy_wrapper<F, Policies...>, is_index, is_variable, checked, boost, clean_stack, C> {
+ typedef policy_wrapper<F, Policies...> P;
+
+ template <std::size_t... In>
+ static int call(std::index_sequence<In...>, lua_State* L, P& fx) {
+ int pushed = lua_call_wrapper<T, F, is_index, is_variable, checked, boost, false, C>{}.call(L, fx.value);
+ (void)detail::swallow{ int(), (policy_detail::handle_policy(std::get<In>(fx.policies), L, pushed), int())... };
+ return pushed;
+ }
+
+ static int call(lua_State* L, P& fx) {
+ typedef typename P::indices indices;
+ return call(indices(), L, fx);
+ }
+ };
+
+ template <typename T, typename Y, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+ struct lua_call_wrapper<T, yielding_t<Y>, is_index, is_variable, checked, boost, clean_stack, C> {
+ template <typename F>
+ static int call(lua_State* L, F&& f) {
+ return lua_call_wrapper<T, meta::unqualified_t<Y>, is_index, is_variable, checked, boost, clean_stack>{}.call(L, f.func);
+ }
+ };
+
+ template <typename T, typename Sig, typename P, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+ struct lua_call_wrapper<T, function_arguments<Sig, P>, is_index, is_variable, checked, boost, clean_stack, C> {
+ static int call(lua_State* L, const function_arguments<Sig, P>& f) {
+ lua_call_wrapper<T, meta::unqualified_t<P>, is_index, is_variable, checked, boost, clean_stack> lcw{};
+ return lcw.call(L, std::get<0>(f.arguments));
+ }
+
+ static int call(lua_State* L, function_arguments<Sig, P>&& f) {
+ lua_call_wrapper<T, meta::unqualified_t<P>, is_index, is_variable, checked, boost, clean_stack> lcw{};
+ return lcw.call(L, std::get<0>(std::move(f.arguments)));
+ }
+ };
+
+ template <typename T, bool is_index, bool is_variable, int boost = 0, bool checked = detail::default_safe_function_calls, bool clean_stack = true,
+ typename Fx, typename... Args>
+ inline int call_wrapped(lua_State* L, Fx&& fx, Args&&... args) {
+ using uFx = meta::unqualified_t<Fx>;
+ if constexpr (meta::is_specialization_of_v<uFx, yielding_t>) {
+ using real_fx = meta::unqualified_t<decltype(std::forward<Fx>(fx).func)>;
+ lua_call_wrapper<T, real_fx, is_index, is_variable, checked, boost, clean_stack> lcw{};
+ return lcw.call(L, std::forward<Fx>(fx).func, std::forward<Args>(args)...);
+ }
+ else {
+ lua_call_wrapper<T, uFx, is_index, is_variable, checked, boost, clean_stack> lcw{};
+ return lcw.call(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+ }
+ }
+
+ template <typename T, bool is_index, bool is_variable, typename F, int start = 1, bool checked = detail::default_safe_function_calls,
+ bool clean_stack = true>
+ inline int call_user(lua_State* L) {
+ auto& fx = stack::unqualified_get<user<F>>(L, upvalue_index(start));
+ using uFx = meta::unqualified_t<F>;
+ int nr = call_wrapped<T, is_index, is_variable, 0, checked, clean_stack>(L, fx);
+ if constexpr (meta::is_specialization_of_v<uFx, yielding_t>) {
+ return lua_yield(L, nr);
+ }
+ else {
+ return nr;
+ }
+ }
+
+ template <typename T, typename = void>
+ struct is_var_bind : std::false_type {};
+
+ template <typename T>
+ struct is_var_bind<T, std::enable_if_t<std::is_member_object_pointer<T>::value>> : std::true_type {};
+
+ template <typename T>
+ struct is_var_bind<T, std::enable_if_t<is_lua_reference_or_proxy<T>::value>> : std::true_type {};
+
+ template <>
+ struct is_var_bind<detail::no_prop> : std::true_type {};
+
+ template <typename R, typename W>
+ struct is_var_bind<property_wrapper<R, W>> : std::true_type {};
+
+ template <typename T>
+ struct is_var_bind<var_wrapper<T>> : std::true_type {};
+
+ template <typename T>
+ struct is_var_bind<readonly_wrapper<T>> : is_var_bind<meta::unqualified_t<T>> {};
+
+ template <typename F, typename... Policies>
+ struct is_var_bind<policy_wrapper<F, Policies...>> : is_var_bind<meta::unqualified_t<F>> {};
+ } // namespace call_detail
+
+ template <typename T>
+ struct is_variable_binding : call_detail::is_var_bind<meta::unqualified_t<T>> {};
+
+ template <typename T>
+ using is_var_wrapper = meta::is_specialization_of<T, var_wrapper>;
+
+ template <typename T>
+ struct is_function_binding : meta::neg<is_variable_binding<T>> {};
+
+} // namespace sol
+
+// end of sol/call.hpp
+
+namespace sol {
+ namespace function_detail {
+ template <typename F, F fx>
+ inline int call_wrapper_variable(std::false_type, lua_State* L) {
+ typedef meta::bind_traits<meta::unqualified_t<F>> traits_type;
+ typedef typename traits_type::args_list args_list;
+ typedef meta::tuple_types<typename traits_type::return_type> return_type;
+ return stack::call_into_lua(return_type(), args_list(), L, 1, fx);
+ }
+
+ template <typename R, typename V, V, typename T>
+ inline int call_set_assignable(std::false_type, T&&, lua_State* L) {
+ return luaL_error(L, "cannot write to this type: copy assignment/constructor not available");
+ }
+
+ template <typename R, typename V, V variable, typename T>
+ inline int call_set_assignable(std::true_type, lua_State* L, T&& mem) {
+ (mem.*variable) = stack::get<R>(L, 2);
+ return 0;
+ }
+
+ template <typename R, typename V, V, typename T>
+ inline int call_set_variable(std::false_type, lua_State* L, T&&) {
+ return luaL_error(L, "cannot write to a const variable");
+ }
+
+ template <typename R, typename V, V variable, typename T>
+ inline int call_set_variable(std::true_type, lua_State* L, T&& mem) {
+ return call_set_assignable<R, V, variable>(std::is_assignable<std::add_lvalue_reference_t<R>, R>(), L, std::forward<T>(mem));
+ }
+
+ template <typename V, V variable>
+ inline int call_wrapper_variable(std::true_type, lua_State* L) {
+ typedef meta::bind_traits<meta::unqualified_t<V>> traits_type;
+ typedef typename traits_type::object_type T;
+ typedef typename traits_type::return_type R;
+ auto& mem = stack::get<T>(L, 1);
+ switch (lua_gettop(L)) {
+ case 1: {
+ decltype(auto) r = (mem.*variable);
+ stack::push_reference(L, std::forward<decltype(r)>(r));
+ return 1;
+ }
+ case 2:
+ return call_set_variable<R, V, variable>(meta::neg<std::is_const<R>>(), L, mem);
+ default:
+ return luaL_error(L, "incorrect number of arguments to member variable function call");
+ }
+ }
+
+ template <typename F, F fx>
+ inline int call_wrapper_function(std::false_type, lua_State* L) {
+ return call_wrapper_variable<F, fx>(std::is_member_object_pointer<F>(), L);
+ }
+
+ template <typename F, F fx>
+ inline int call_wrapper_function(std::true_type, lua_State* L) {
+ return call_detail::call_wrapped<void, false, false>(L, fx);
+ }
+
+ template <typename F, F fx>
+ int call_wrapper_entry(lua_State* L) noexcept(meta::bind_traits<F>::is_noexcept) {
+ return call_wrapper_function<F, fx>(std::is_member_function_pointer<meta::unqualified_t<F>>(), L);
+ }
+
+ template <typename... Fxs>
+ struct c_call_matcher {
+ template <typename Fx, std::size_t I, typename R, typename... Args>
+ int operator()(types<Fx>, meta::index_value<I>, types<R>, types<Args...>, lua_State* L, int, int) const {
+ typedef meta::at_in_pack_t<I, Fxs...> target;
+ return target::call(L);
+ }
+ };
+
+ template <typename F, F fx>
+ inline int c_call_raw(std::true_type, lua_State* L) {
+ return fx(L);
+ }
+
+ template <typename F, F fx>
+ inline int c_call_raw(std::false_type, lua_State* L) {
+#ifdef __clang__
+ return detail::trampoline(L, function_detail::call_wrapper_entry<F, fx>);
+#else
+ return detail::typed_static_trampoline<decltype(&function_detail::call_wrapper_entry<F, fx>), (&function_detail::call_wrapper_entry<F, fx>)>(L);
+#endif // fuck you clang :c
+ }
+
+ } // namespace function_detail
+
+ template <typename F, F fx>
+ inline int c_call(lua_State* L) {
+ typedef meta::unqualified_t<F> Fu;
+ typedef std::integral_constant<bool,
+ std::is_same<Fu, lua_CFunction>::value
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_)
+ || std::is_same<Fu, detail::lua_CFunction_noexcept>::value
+#endif
+ >
+ is_raw;
+ return function_detail::c_call_raw<F, fx>(is_raw(), L);
+ }
+
+ template <typename F, F f>
+ struct wrap {
+ typedef F type;
+
+ static int call(lua_State* L) {
+ return c_call<type, f>(L);
+ }
+ };
+
+ template <typename... Fxs>
+ inline int c_call(lua_State* L) {
+ if constexpr (sizeof...(Fxs) < 2) {
+ using target = meta::at_in_pack_t<0, Fxs...>;
+ return target::call(L);
+ }
+ else {
+ return call_detail::overload_match_arity<typename Fxs::type...>(function_detail::c_call_matcher<Fxs...>(), L, lua_gettop(L), 1);
+ }
+ }
+
+} // namespace sol
+
+// end of sol/function_types_templated.hpp
+
+// beginning of sol/function_types_stateless.hpp
+
+namespace sol { namespace function_detail {
+ template <typename Function, bool is_yielding>
+ struct upvalue_free_function {
+ using function_type = std::remove_pointer_t<std::decay_t<Function>>;
+ using traits_type = meta::bind_traits<function_type>;
+
+ static int real_call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX_I_)
+ // MSVC is broken, what a surprise...
+#else
+ noexcept(traits_type::is_noexcept)
+#endif
+ {
+ auto udata = stack::stack_detail::get_as_upvalues<function_type*>(L);
+ function_type* fx = udata.first;
+ return call_detail::call_wrapped<void, true, false>(L, fx);
+ }
+
+ static int call(lua_State* L) {
+ int nr = detail::typed_static_trampoline<decltype(&real_call), (&real_call)>(L);
+ if (is_yielding) {
+ return lua_yield(L, nr);
+ }
+ else {
+ return nr;
+ }
+ }
+
+ int operator()(lua_State* L) {
+ return call(L);
+ }
+ };
+
+ template <typename T, typename Function, bool is_yielding>
+ struct upvalue_member_function {
+ typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+ typedef lua_bind_traits<function_type> traits_type;
+
+ static int real_call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX_I_)
+ // MSVC is broken, what a surprise...
+#else
+ noexcept(traits_type::is_noexcept)
+#endif
+ {
+ // Layout:
+ // idx 1...n: verbatim data of member function pointer
+ // idx n + 1: is the object's void pointer
+ // We don't need to store the size, because the other side is templated
+ // with the same member function pointer type
+ function_type& memfx = stack::get<user<function_type>>(L, upvalue_index(2));
+ auto& item = *static_cast<T*>(stack::get<void*>(L, upvalue_index(3)));
+ return call_detail::call_wrapped<T, true, false, -1>(L, memfx, item);
+ }
+
+ static int call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX_I_)
+ // MSVC is broken, what a surprise...
+#else
+ noexcept(traits_type::is_noexcept)
+#endif
+ {
+ int nr = detail::typed_static_trampoline<decltype(&real_call), (&real_call)>(L);
+ if (is_yielding) {
+ return lua_yield(L, nr);
+ }
+ else {
+ return nr;
+ }
+ }
+
+ int operator()(lua_State* L) {
+ return call(L);
+ }
+ };
+
+ template <typename T, typename Function, bool is_yielding>
+ struct upvalue_member_variable {
+ typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+ typedef lua_bind_traits<function_type> traits_type;
+
+ static int real_call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX_I_)
+ // MSVC is broken, what a surprise...
+#else
+ noexcept(traits_type::is_noexcept)
+#endif
+ {
+ // Layout:
+ // idx 1...n: verbatim data of member variable pointer
+ // idx n + 1: is the object's void pointer
+ // We don't need to store the size, because the other side is templated
+ // with the same member function pointer type
+ auto memberdata = stack::stack_detail::get_as_upvalues<function_type>(L);
+ auto objdata = stack::stack_detail::get_as_upvalues<T*>(L, memberdata.second);
+ auto& mem = *objdata.first;
+ function_type& var = memberdata.first;
+ switch (lua_gettop(L)) {
+ case 0:
+ return call_detail::call_wrapped<T, true, false, -1>(L, var, mem);
+ case 1:
+ return call_detail::call_wrapped<T, false, false, -1>(L, var, mem);
+ default:
+ return luaL_error(L, "sol: incorrect number of arguments to member variable function");
+ }
+ }
+
+ static int call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX_I_)
+ // MSVC is broken, what a surprise...
+#else
+ noexcept(traits_type::is_noexcept)
+#endif
+ {
+ int nr = detail::typed_static_trampoline<decltype(&real_call), (&real_call)>(L);
+ if (is_yielding) {
+ return lua_yield(L, nr);
+ }
+ else {
+ return nr;
+ }
+ }
+
+ int operator()(lua_State* L) {
+ return call(L);
+ }
+ };
+
+ template <typename T, typename Function, bool is_yielding>
+ struct upvalue_member_variable<T, readonly_wrapper<Function>, is_yielding> {
+ typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+ typedef lua_bind_traits<function_type> traits_type;
+
+ static int real_call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX_I_)
+ // MSVC is broken, what a surprise...
+#else
+ noexcept(traits_type::is_noexcept)
+#endif
+ {
+ // Layout:
+ // idx 1...n: verbatim data of member variable pointer
+ // idx n + 1: is the object's void pointer
+ // We don't need to store the size, because the other side is templated
+ // with the same member function pointer type
+ auto memberdata = stack::stack_detail::get_as_upvalues<function_type>(L);
+ auto objdata = stack::stack_detail::get_as_upvalues<T*>(L, memberdata.second);
+ auto& mem = *objdata.first;
+ function_type& var = memberdata.first;
+ switch (lua_gettop(L)) {
+ case 0:
+ return call_detail::call_wrapped<T, true, false, -1>(L, var, mem);
+ default:
+ return luaL_error(L, "sol: incorrect number of arguments to member variable function");
+ }
+ }
+
+ static int call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX_I_)
+ // MSVC is broken, what a surprise...
+#else
+ noexcept(traits_type::is_noexcept)
+#endif
+ {
+ int nr = detail::typed_static_trampoline<decltype(&real_call), (&real_call)>(L);
+ if (is_yielding) {
+ return lua_yield(L, nr);
+ }
+ else {
+ return nr;
+ }
+ }
+
+ int operator()(lua_State* L) {
+ return call(L);
+ }
+ };
+
+ template <typename T, typename Function, bool is_yielding>
+ struct upvalue_this_member_function {
+ typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+ typedef lua_bind_traits<function_type> traits_type;
+
+ static int real_call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX_I_)
+ // MSVC is broken, what a surprise...
+#else
+ noexcept(traits_type::is_noexcept)
+#endif
+ {
+ // Layout:
+ // idx 1...n: verbatim data of member variable pointer
+ function_type& memfx = stack::get<user<function_type>>(L, upvalue_index(2));
+ return call_detail::call_wrapped<T, false, false>(L, memfx);
+ }
+
+ static int call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX_I_)
+ // MSVC is broken, what a surprise...
+#else
+ noexcept(traits_type::is_noexcept)
+#endif
+ {
+ int nr = detail::typed_static_trampoline<decltype(&real_call), (&real_call)>(L);
+ if (is_yielding) {
+ return lua_yield(L, nr);
+ }
+ else {
+ return nr;
+ }
+ }
+
+ int operator()(lua_State* L) {
+ return call(L);
+ }
+ };
+
+ template <typename T, typename Function, bool is_yielding>
+ struct upvalue_this_member_variable {
+ typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+
+ static int real_call(lua_State* L) noexcept(false) {
+ // Layout:
+ // idx 1...n: verbatim data of member variable pointer
+ auto memberdata = stack::stack_detail::get_as_upvalues<function_type>(L);
+ function_type& var = memberdata.first;
+ switch (lua_gettop(L)) {
+ case 1:
+ return call_detail::call_wrapped<T, true, false>(L, var);
+ case 2:
+ return call_detail::call_wrapped<T, false, false>(L, var);
+ default:
+ return luaL_error(L, "sol: incorrect number of arguments to member variable function");
+ }
+ }
+
+ static int call(lua_State* L) {
+ int nr = detail::typed_static_trampoline<decltype(&real_call), (&real_call)>(L);
+ if (is_yielding) {
+ return lua_yield(L, nr);
+ }
+ else {
+ return nr;
+ }
+ }
+
+ int operator()(lua_State* L) {
+ return call(L);
+ }
+ };
+
+ template <typename T, typename Function, bool is_yielding>
+ struct upvalue_this_member_variable<T, readonly_wrapper<Function>, is_yielding> {
+ typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+ typedef lua_bind_traits<function_type> traits_type;
+
+ static int real_call(lua_State* L) noexcept(false) {
+ // Layout:
+ // idx 1...n: verbatim data of member variable pointer
+ auto memberdata = stack::stack_detail::get_as_upvalues<function_type>(L);
+ function_type& var = memberdata.first;
+ switch (lua_gettop(L)) {
+ case 1:
+ return call_detail::call_wrapped<T, true, false>(L, var);
+ default:
+ return luaL_error(L, "sol: incorrect number of arguments to member variable function");
+ }
+ }
+
+ static int call(lua_State* L) {
+ int nr = detail::typed_static_trampoline<decltype(&real_call), (&real_call)>(L);
+ if (is_yielding) {
+ return lua_yield(L, nr);
+ }
+ else {
+ return nr;
+ }
+ }
+
+ int operator()(lua_State* L) {
+ return call(L);
+ }
+ };
+}} // namespace sol::function_detail
+
+// end of sol/function_types_stateless.hpp
+
+// beginning of sol/function_types_stateful.hpp
+
+namespace sol {
+namespace function_detail {
+ template <typename Func, bool is_yielding, bool no_trampoline>
+ struct functor_function {
+ typedef std::decay_t<meta::unwrap_unqualified_t<Func>> function_type;
+ function_type fx;
+
+ template <typename... Args>
+ functor_function(function_type f, Args&&... args)
+ : fx(std::move(f), std::forward<Args>(args)...) {
+ }
+
+ int call(lua_State* L) {
+ int nr = call_detail::call_wrapped<void, true, false>(L, fx);
+ if (is_yielding) {
+ return lua_yield(L, nr);
+ }
+ else {
+ return nr;
+ }
+ }
+
+ int operator()(lua_State* L) {
+ if (!no_trampoline) {
+ auto f = [&](lua_State*) -> int { return this->call(L); };
+ return detail::trampoline(L, f);
+ }
+ else {
+ return call(L);
+ }
+ }
+ };
+
+ template <typename T, typename Function, bool is_yielding>
+ struct member_function {
+ typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+ typedef meta::function_return_t<function_type> return_type;
+ typedef meta::function_args_t<function_type> args_lists;
+ function_type invocation;
+ T member;
+
+ template <typename... Args>
+ member_function(function_type f, Args&&... args)
+ : invocation(std::move(f)), member(std::forward<Args>(args)...) {
+ }
+
+ int call(lua_State* L) {
+ int nr = call_detail::call_wrapped<T, true, false, -1>(L, invocation, detail::unwrap(detail::deref(member)));
+ if (is_yielding) {
+ return lua_yield(L, nr);
+ }
+ else {
+ return nr;
+ }
+ }
+
+ int operator()(lua_State* L) {
+ auto f = [&](lua_State*) -> int { return this->call(L); };
+ return detail::trampoline(L, f);
+ }
+ };
+
+ template <typename T, typename Function, bool is_yielding>
+ struct member_variable {
+ typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+ typedef typename meta::bind_traits<function_type>::return_type return_type;
+ typedef typename meta::bind_traits<function_type>::args_list args_lists;
+ function_type var;
+ T member;
+ typedef std::add_lvalue_reference_t<meta::unwrapped_t<std::remove_reference_t<decltype(detail::deref(member))>>> M;
+
+ template <typename... Args>
+ member_variable(function_type v, Args&&... args)
+ : var(std::move(v)), member(std::forward<Args>(args)...) {
+ }
+
+ int call(lua_State* L) {
+ int nr;
+ {
+ M mem = detail::unwrap(detail::deref(member));
+ switch (lua_gettop(L)) {
+ case 0:
+ nr = call_detail::call_wrapped<T, true, false, -1>(L, var, mem);
+ break;
+ case 1:
+ nr = call_detail::call_wrapped<T, false, false, -1>(L, var, mem);
+ break;
+ default:
+ nr = luaL_error(L, "sol: incorrect number of arguments to member variable function");
+ break;
+ }
+ }
+ if (is_yielding) {
+ return lua_yield(L, nr);
+ }
+ else {
+ return nr;
+ }
+ }
+
+ int operator()(lua_State* L) {
+ auto f = [&](lua_State*) -> int { return this->call(L); };
+ return detail::trampoline(L, f);
+ }
+ };
+}
+} // namespace sol::function_detail
+
+// end of sol/function_types_stateful.hpp
+
+// beginning of sol/function_types_overloaded.hpp
+
+namespace sol {
+namespace function_detail {
+ template <int start_skew, typename... Functions>
+ struct overloaded_function {
+ typedef std::tuple<Functions...> overload_list;
+ typedef std::make_index_sequence<sizeof...(Functions)> indices;
+ overload_list overloads;
+
+ overloaded_function(overload_list set)
+ : overloads(std::move(set)) {
+ }
+
+ overloaded_function(Functions... fxs)
+ : overloads(fxs...) {
+ }
+
+ template <typename Fx, std::size_t I, typename... R, typename... Args>
+ static int call(types<Fx>, meta::index_value<I>, types<R...>, types<Args...>, lua_State* L, int, int, overload_list& ol) {
+ auto& func = std::get<I>(ol);
+ int nr = call_detail::call_wrapped<void, true, false, start_skew>(L, func);
+ return nr;
+ }
+
+ int operator()(lua_State* L) {
+ auto mfx = [](auto&&... args) { return call(std::forward<decltype(args)>(args)...); };
+ return call_detail::overload_match<Functions...>(mfx, L, 1 + start_skew, overloads);
+ }
+ };
+}
+} // namespace sol::function_detail
+
+// end of sol/function_types_overloaded.hpp
+
+// beginning of sol/resolve.hpp
+
+namespace sol {
+
+#ifndef __clang__
+ // constexpr is fine for not-clang
+
+ namespace detail {
+ template <typename R, typename... Args, typename F, typename = std::invoke_result_t<meta::unqualified_t<F>, Args...>>
+ inline constexpr auto resolve_i(types<R(Args...)>, F &&) -> R (meta::unqualified_t<F>::*)(Args...) {
+ using Sig = R(Args...);
+ typedef meta::unqualified_t<F> Fu;
+ return static_cast<Sig Fu::*>(&Fu::operator());
+ }
+
+ template <typename F, typename U = meta::unqualified_t<F>>
+ inline constexpr auto resolve_f(std::true_type, F&& f)
+ -> decltype(resolve_i(types<meta::function_signature_t<decltype(&U::operator())>>(), std::forward<F>(f))) {
+ return resolve_i(types<meta::function_signature_t<decltype(&U::operator())>>(), std::forward<F>(f));
+ }
+
+ template <typename F>
+ inline constexpr void resolve_f(std::false_type, F&&) {
+ static_assert(
+ meta::has_deducible_signature<F>::value, "Cannot use no-template-parameter call with an overloaded functor: specify the signature");
+ }
+
+ template <typename F, typename U = meta::unqualified_t<F>>
+ inline constexpr auto resolve_i(types<>, F&& f) -> decltype(resolve_f(meta::has_deducible_signature<U>(), std::forward<F>(f))) {
+ return resolve_f(meta::has_deducible_signature<U> {}, std::forward<F>(f));
+ }
+
+ template <typename... Args, typename F, typename R = std::invoke_result_t<F&, Args...>>
+ inline constexpr auto resolve_i(types<Args...>, F&& f) -> decltype(resolve_i(types<R(Args...)>(), std::forward<F>(f))) {
+ return resolve_i(types<R(Args...)>(), std::forward<F>(f));
+ }
+
+ template <typename Sig, typename C>
+ inline constexpr Sig C::*resolve_v(std::false_type, Sig C::*mem_func_ptr) {
+ return mem_func_ptr;
+ }
+
+ template <typename Sig, typename C>
+ inline constexpr Sig C::*resolve_v(std::true_type, Sig C::*mem_variable_ptr) {
+ return mem_variable_ptr;
+ }
+ } // namespace detail
+
+ template <typename... Args, typename R>
+ inline constexpr auto resolve(R fun_ptr(Args...)) -> R (*)(Args...) {
+ return fun_ptr;
+ }
+
+ template <typename Sig>
+ inline constexpr Sig* resolve(Sig* fun_ptr) {
+ return fun_ptr;
+ }
+
+ template <typename... Args, typename R, typename C>
+ inline constexpr auto resolve(R (C::*mem_ptr)(Args...)) -> R (C::*)(Args...) {
+ return mem_ptr;
+ }
+
+ template <typename Sig, typename C>
+ inline constexpr Sig C::*resolve(Sig C::*mem_ptr) {
+ return detail::resolve_v(std::is_member_object_pointer<Sig C::*>(), mem_ptr);
+ }
+
+ template <typename... Sig, typename F, meta::disable<std::is_function<meta::unqualified_t<F>>> = meta::enabler>
+ inline constexpr auto resolve(F&& f) -> decltype(detail::resolve_i(types<Sig...>(), std::forward<F>(f))) {
+ return detail::resolve_i(types<Sig...>(), std::forward<F>(f));
+ }
+#else
+
+ // Clang has distinct problems with constexpr arguments,
+ // so don't use the constexpr versions inside of clang.
+
+ namespace detail {
+ template <typename R, typename... Args, typename F, typename = std::invoke_result_t<meta::unqualified_t<F>, Args...>>
+ inline auto resolve_i(types<R(Args...)>, F &&) -> R (meta::unqualified_t<F>::*)(Args...) {
+ using Sig = R(Args...);
+ typedef meta::unqualified_t<F> Fu;
+ return static_cast<Sig Fu::*>(&Fu::operator());
+ }
+
+ template <typename F, typename U = meta::unqualified_t<F>>
+ inline auto resolve_f(std::true_type, F&& f)
+ -> decltype(resolve_i(types<meta::function_signature_t<decltype(&U::operator())>>(), std::forward<F>(f))) {
+ return resolve_i(types<meta::function_signature_t<decltype(&U::operator())>>(), std::forward<F>(f));
+ }
+
+ template <typename F>
+ inline void resolve_f(std::false_type, F&&) {
+ static_assert(
+ meta::has_deducible_signature<F>::value, "Cannot use no-template-parameter call with an overloaded functor: specify the signature");
+ }
+
+ template <typename F, typename U = meta::unqualified_t<F>>
+ inline auto resolve_i(types<>, F&& f) -> decltype(resolve_f(meta::has_deducible_signature<U>(), std::forward<F>(f))) {
+ return resolve_f(meta::has_deducible_signature<U> {}, std::forward<F>(f));
+ }
+
+ template <typename... Args, typename F, typename R = std::invoke_result_t<F&, Args...>>
+ inline auto resolve_i(types<Args...>, F&& f) -> decltype(resolve_i(types<R(Args...)>(), std::forward<F>(f))) {
+ return resolve_i(types<R(Args...)>(), std::forward<F>(f));
+ }
+
+ template <typename Sig, typename C>
+ inline Sig C::*resolve_v(std::false_type, Sig C::*mem_func_ptr) {
+ return mem_func_ptr;
+ }
+
+ template <typename Sig, typename C>
+ inline Sig C::*resolve_v(std::true_type, Sig C::*mem_variable_ptr) {
+ return mem_variable_ptr;
+ }
+ } // namespace detail
+
+ template <typename... Args, typename R>
+ inline auto resolve(R fun_ptr(Args...)) -> R (*)(Args...) {
+ return fun_ptr;
+ }
+
+ template <typename Sig>
+ inline Sig* resolve(Sig* fun_ptr) {
+ return fun_ptr;
+ }
+
+ template <typename... Args, typename R, typename C>
+ inline auto resolve(R (C::*mem_ptr)(Args...)) -> R (C::*)(Args...) {
+ return mem_ptr;
+ }
+
+ template <typename Sig, typename C>
+ inline Sig C::*resolve(Sig C::*mem_ptr) {
+ return detail::resolve_v(std::is_member_object_pointer<Sig C::*>(), mem_ptr);
+ }
+
+ template <typename... Sig, typename F>
+ inline auto resolve(F&& f) -> decltype(detail::resolve_i(types<Sig...>(), std::forward<F>(f))) {
+ return detail::resolve_i(types<Sig...>(), std::forward<F>(f));
+ }
+
+#endif
+
+} // namespace sol
+
+// end of sol/resolve.hpp
+
+namespace sol {
+ namespace function_detail {
+ template <typename T>
+ struct class_indicator {
+ using type = T;
+ };
+
+ struct call_indicator { };
+
+ template <bool yielding>
+ int lua_c_wrapper(lua_State* L) {
+ lua_CFunction cf = lua_tocfunction(L, lua_upvalueindex(2));
+ int nr = cf(L);
+ if constexpr (yielding) {
+ return lua_yield(L, nr);
+ }
+ else {
+ return nr;
+ }
+ }
+
+ template <bool yielding>
+ int lua_c_noexcept_wrapper(lua_State* L) noexcept {
+ detail::lua_CFunction_noexcept cf = reinterpret_cast<detail::lua_CFunction_noexcept>(lua_tocfunction(L, lua_upvalueindex(2)));
+ int nr = cf(L);
+ if constexpr (yielding) {
+ return lua_yield(L, nr);
+ }
+ else {
+ return nr;
+ }
+ }
+
+ struct c_function_invocation { };
+
+ template <bool is_yielding, typename Fx, typename... Args>
+ void select(lua_State* L, Fx&& fx, Args&&... args);
+
+ template <bool is_yielding, bool no_trampoline, typename Fx, typename... Args>
+ void select_set_fx(lua_State* L, Args&&... args) {
+ lua_CFunction freefunc = no_trampoline ? detail::static_trampoline<function_detail::call<meta::unqualified_t<Fx>, 2, is_yielding>>
+ : function_detail::call<meta::unqualified_t<Fx>, 2, is_yielding>;
+
+ int upvalues = 0;
+ upvalues += stack::push(L, nullptr);
+ upvalues += stack::push<user<Fx>>(L, std::forward<Args>(args)...);
+ stack::push(L, c_closure(freefunc, upvalues));
+ }
+
+ template <bool is_yielding, typename R, typename... A, typename Fx, typename... Args>
+ void select_convertible(types<R(A...)>, lua_State* L, Fx&& fx, Args&&... args) {
+ using dFx = std::decay_t<meta::unwrap_unqualified_t<Fx>>;
+ using fx_ptr_t = R (*)(A...);
+ constexpr bool is_convertible = std::is_convertible_v<dFx, fx_ptr_t>;
+ if constexpr (is_convertible) {
+ fx_ptr_t fxptr = detail::unwrap(std::forward<Fx>(fx));
+ select<is_yielding>(L, std::move(fxptr), std::forward<Args>(args)...);
+ }
+ else {
+ using F = function_detail::functor_function<dFx, false, true>;
+ select_set_fx<is_yielding, false, F>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+ }
+ }
+
+ template <bool is_yielding, typename Fx, typename... Args>
+ void select_convertible(types<>, lua_State* L, Fx&& fx, Args&&... args) {
+ typedef meta::function_signature_t<meta::unwrap_unqualified_t<Fx>> Sig;
+ select_convertible<is_yielding>(types<Sig>(), L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+ }
+
+ template <bool is_yielding, typename Fx, typename... Args>
+ void select_member_variable(lua_State* L, Fx&& fx, Args&&... args) {
+ using uFx = meta::unqualified_t<Fx>;
+ if constexpr (sizeof...(Args) < 1) {
+ using C = typename meta::bind_traits<uFx>::object_type;
+ lua_CFunction freefunc = &function_detail::upvalue_this_member_variable<C, Fx, is_yielding>::call;
+
+ int upvalues = 0;
+ upvalues += stack::push(L, nullptr);
+ upvalues += stack::stack_detail::push_as_upvalues(L, fx);
+ stack::push(L, c_closure(freefunc, upvalues));
+ }
+ else if constexpr (sizeof...(Args) < 2) {
+ using Tu = typename meta::meta_detail::unqualified_non_alias<Args...>::type;
+ constexpr bool is_reference = meta::is_specialization_of_v<Tu, std::reference_wrapper> || std::is_pointer_v<Tu>;
+ if constexpr (meta::is_specialization_of_v<Tu, function_detail::class_indicator>) {
+ lua_CFunction freefunc = &function_detail::upvalue_this_member_variable<typename Tu::type, Fx, is_yielding>::call;
+
+ int upvalues = 0;
+ upvalues += stack::push(L, nullptr);
+ upvalues += stack::stack_detail::push_as_upvalues(L, fx);
+ stack::push(L, c_closure(freefunc, upvalues));
+ }
+ else if constexpr (is_reference) {
+ typedef std::decay_t<Fx> dFx;
+ dFx memfxptr(std::forward<Fx>(fx));
+ auto userptr = detail::ptr(std::forward<Args>(args)...);
+ lua_CFunction freefunc
+ = &function_detail::upvalue_member_variable<std::decay_t<decltype(*userptr)>, meta::unqualified_t<Fx>, is_yielding>::call;
+
+ int upvalues = 0;
+ upvalues += stack::push(L, nullptr);
+ upvalues += stack::stack_detail::push_as_upvalues(L, memfxptr);
+ upvalues += stack::push(L, static_cast<void const*>(userptr));
+ stack::push(L, c_closure(freefunc, upvalues));
+ }
+ else {
+ using clean_fx = std::remove_pointer_t<std::decay_t<Fx>>;
+ using F = function_detail::member_variable<Tu, clean_fx, is_yielding>;
+ select_set_fx<false, false, F>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+ }
+ }
+ else {
+ using C = typename meta::bind_traits<uFx>::object_type;
+ using clean_fx = std::remove_pointer_t<std::decay_t<Fx>>;
+ using F = function_detail::member_variable<C, clean_fx, is_yielding>;
+ select_set_fx<false, false, F>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+ }
+ }
+
+ template <bool is_yielding, typename Fx, typename T, typename... Args>
+ void select_member_function_with(lua_State* L, Fx&& fx, T&& obj, Args&&... args) {
+ using dFx = std::decay_t<Fx>;
+ using Tu = meta::unqualified_t<T>;
+ if constexpr (meta::is_specialization_of_v<Tu, function_detail::class_indicator>) {
+ (void)obj;
+ using C = typename Tu::type;
+ lua_CFunction freefunc = &function_detail::upvalue_this_member_function<C, dFx, is_yielding>::call;
+
+ int upvalues = 0;
+ upvalues += stack::push(L, nullptr);
+ upvalues += stack::push<user<dFx>>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+ stack::push(L, c_closure(freefunc, upvalues));
+ }
+ else {
+ constexpr bool is_reference = meta::is_specialization_of_v<Tu, std::reference_wrapper> || std::is_pointer_v<Tu>;
+ if constexpr (is_reference) {
+ auto userptr = detail::ptr(std::forward<T>(obj));
+ lua_CFunction freefunc = &function_detail::upvalue_member_function<std::decay_t<decltype(*userptr)>, dFx, is_yielding>::call;
+
+ int upvalues = 0;
+ upvalues += stack::push(L, nullptr);
+ upvalues += stack::push<user<dFx>>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+ upvalues += stack::push(L, lightuserdata_value(static_cast<void*>(userptr)));
+ stack::push(L, c_closure(freefunc, upvalues));
+ }
+ else {
+ using F = function_detail::member_function<Tu, dFx, is_yielding>;
+ select_set_fx<false, false, F>(L, std::forward<Fx>(fx), std::forward<T>(obj), std::forward<Args>(args)...);
+ }
+ }
+ }
+
+ template <bool is_yielding, typename Fx, typename... Args>
+ void select_member_function(lua_State* L, Fx&& fx, Args&&... args) {
+ using dFx = std::decay_t<Fx>;
+ if constexpr (sizeof...(Args) < 1) {
+ using C = typename meta::bind_traits<meta::unqualified_t<Fx>>::object_type;
+ lua_CFunction freefunc = &function_detail::upvalue_this_member_function<C, dFx, is_yielding>::call;
+
+ int upvalues = 0;
+ upvalues += stack::push(L, nullptr);
+ upvalues += stack::push<user<dFx>>(L, std::forward<Fx>(fx));
+ stack::push(L, c_closure(freefunc, upvalues));
+ }
+ else {
+ select_member_function_with<is_yielding>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+ }
+ }
+
+ template <bool is_yielding, typename Fx, typename... Args>
+ void select(lua_State* L, Fx&& fx, Args&&... args) {
+ using uFx = meta::unqualified_t<Fx>;
+ if constexpr (is_lua_reference_v<uFx>) {
+ // TODO: hoist into lambda in this case for yielding???
+ stack::push(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+ }
+ else if constexpr (is_lua_c_function_v<uFx>) {
+ int upvalues = 0;
+ upvalues += stack::push(L, nullptr);
+ upvalues += stack::push(L, std::forward<Fx>(fx));
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_)
+ if constexpr (std::is_nothrow_invocable_r_v<int, uFx, lua_State*>) {
+ detail::lua_CFunction_noexcept cf = &lua_c_noexcept_wrapper<is_yielding>;
+ lua_pushcclosure(L, reinterpret_cast<lua_CFunction>(cf), 2);
+ }
+ else {
+ lua_CFunction cf = &lua_c_wrapper<is_yielding>;
+ lua_pushcclosure(L, cf, 2);
+ }
+#else
+ lua_CFunction cf = &function_detail::lua_c_wrapper<is_yielding>;
+ lua_pushcclosure(L, cf, 2);
+#endif
+ }
+ else if constexpr (std::is_function_v<std::remove_pointer_t<uFx>>) {
+ std::decay_t<Fx> target(std::forward<Fx>(fx), std::forward<Args>(args)...);
+ lua_CFunction freefunc = &function_detail::upvalue_free_function<Fx, is_yielding>::call;
+
+ int upvalues = 0;
+ upvalues += stack::push(L, nullptr);
+ upvalues += stack::stack_detail::push_as_upvalues(L, target);
+ stack::push(L, c_closure(freefunc, upvalues));
+ }
+ else if constexpr (std::is_member_function_pointer_v<uFx>) {
+ select_member_function<is_yielding>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+ }
+ else if constexpr (meta::is_member_object_v<uFx>) {
+ select_member_variable<is_yielding>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+ }
+ else {
+ select_convertible<is_yielding>(types<>(), L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+ }
+ }
+ } // namespace function_detail
+
+ namespace stack {
+ template <typename... Sigs>
+ struct unqualified_pusher<function_sig<Sigs...>> {
+ template <bool is_yielding, typename Arg0, typename... Args>
+ static int push(lua_State* L, Arg0&& arg0, Args&&... args) {
+ if constexpr (meta::is_specialization_of_v<meta::unqualified_t<Arg0>, std::function>) {
+ if constexpr (is_yielding) {
+ return stack::push<meta::unqualified_t<Arg0>>(L, detail::yield_tag, std::forward<Arg0>(arg0), std::forward<Args>(args)...);
+ }
+ else {
+ return stack::push(L, std::forward<Arg0>(arg0), std::forward<Args>(args)...);
+ }
+ }
+ else {
+ function_detail::select<is_yielding>(L, std::forward<Arg0>(arg0), std::forward<Args>(args)...);
+ return 1;
+ }
+ }
+
+ template <typename Arg0, typename... Args>
+ static int push(lua_State* L, Arg0&& arg0, Args&&... args) {
+ if constexpr (std::is_same_v<meta::unqualified_t<Arg0>, detail::yield_tag_t>) {
+ push<true>(L, std::forward<Args>(args)...);
+ }
+ else if constexpr (meta::is_specialization_of_v<meta::unqualified_t<Arg0>, yielding_t>) {
+ push<true>(L, std::forward<Arg0>(arg0).func, std::forward<Args>(args)...);
+ }
+ else {
+ push<false>(L, std::forward<Arg0>(arg0), std::forward<Args>(args)...);
+ }
+ return 1;
+ }
+ };
+
+ template <typename T>
+ struct unqualified_pusher<yielding_t<T>> {
+ template <typename... Args>
+ static int push(lua_State* L, const yielding_t<T>& f, Args&&... args) {
+ if constexpr (meta::is_specialization_of_v<meta::unqualified_t<T>, std::function>) {
+ return stack::push<T>(L, detail::yield_tag, f.func, std::forward<Args>(args)...);
+ }
+ else {
+ function_detail::select<true>(L, f.func, std::forward<Args>(args)...);
+ return 1;
+ }
+ }
+
+ template <typename... Args>
+ static int push(lua_State* L, yielding_t<T>&& f, Args&&... args) {
+ if constexpr (meta::is_specialization_of_v<meta::unqualified_t<T>, std::function>) {
+ return stack::push<T>(L, detail::yield_tag, std::move(f.func), std::forward<Args>(args)...);
+ }
+ else {
+ function_detail::select<true>(L, std::move(f.func), std::forward<Args>(args)...);
+ return 1;
+ }
+ }
+ };
+
+ template <typename T, typename... Args>
+ struct unqualified_pusher<function_arguments<T, Args...>> {
+ template <std::size_t... I, typename FP>
+ static int push_func(std::index_sequence<I...>, lua_State* L, FP&& fp) {
+ return stack::push<T>(L, std::get<I>(std::forward<FP>(fp).arguments)...);
+ }
+
+ static int push(lua_State* L, const function_arguments<T, Args...>& fp) {
+ return push_func(std::make_index_sequence<sizeof...(Args)>(), L, fp);
+ }
+
+ static int push(lua_State* L, function_arguments<T, Args...>&& fp) {
+ return push_func(std::make_index_sequence<sizeof...(Args)>(), L, std::move(fp));
+ }
+ };
+
+ template <typename Signature>
+ struct unqualified_pusher<std::function<Signature>> {
+ static int push(lua_State* L, detail::yield_tag_t, const std::function<Signature>& fx) {
+ if (fx) {
+ function_detail::select<true>(L, fx);
+ return 1;
+ }
+ return stack::push(L, lua_nil);
+ }
+
+ static int push(lua_State* L, detail::yield_tag_t, std::function<Signature>&& fx) {
+ if (fx) {
+ function_detail::select<true>(L, std::move(fx));
+ return 1;
+ }
+ return stack::push(L, lua_nil);
+ }
+
+ static int push(lua_State* L, const std::function<Signature>& fx) {
+ if (fx) {
+ function_detail::select<false>(L, fx);
+ return 1;
+ }
+ return stack::push(L, lua_nil);
+ }
+
+ static int push(lua_State* L, std::function<Signature>&& fx) {
+ if (fx) {
+ function_detail::select<false>(L, std::move(fx));
+ return 1;
+ }
+ return stack::push(L, lua_nil);
+ }
+ };
+
+ template <typename Signature>
+ struct unqualified_pusher<Signature, std::enable_if_t<std::is_member_pointer<Signature>::value>> {
+ template <typename... Args>
+ static int push(lua_State* L, Args&&... args) {
+ function_detail::select<false>(L, std::forward<Args>(args)...);
+ return 1;
+ }
+ };
+
+ template <typename 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>>,
+ meta::neg<std::is_same<Signature, std::remove_pointer_t<lua_CFunction>>>
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_)
+ ,
+ meta::neg<std::is_same<Signature, detail::lua_CFunction_noexcept>>,
+ meta::neg<std::is_same<Signature, std::remove_pointer_t<detail::lua_CFunction_noexcept>>>
+#endif // noexcept function types
+ >::value>> {
+ template <typename F>
+ static int push(lua_State* L, F&& f) {
+ function_detail::select<false>(L, std::forward<F>(f));
+ return 1;
+ }
+ };
+
+ template <typename... Functions>
+ struct unqualified_pusher<overload_set<Functions...>> {
+ static int push(lua_State* L, overload_set<Functions...>&& set) {
+ using F = function_detail::overloaded_function<0, Functions...>;
+ function_detail::select_set_fx<false, false, F>(L, std::move(set.functions));
+ return 1;
+ }
+
+ static int push(lua_State* L, const overload_set<Functions...>& set) {
+ using F = function_detail::overloaded_function<0, Functions...>;
+ function_detail::select_set_fx<false, false, F>(L, set.functions);
+ return 1;
+ }
+ };
+
+ template <typename T>
+ struct unqualified_pusher<protect_t<T>> {
+ static int push(lua_State* L, protect_t<T>&& pw) {
+ lua_CFunction cf = call_detail::call_user<void, false, false, protect_t<T>, 2>;
+ int upvalues = 0;
+ upvalues += stack::push(L, nullptr);
+ upvalues += stack::push<user<protect_t<T>>>(L, std::move(pw.value));
+ return stack::push(L, c_closure(cf, upvalues));
+ }
+
+ static int push(lua_State* L, const protect_t<T>& pw) {
+ lua_CFunction cf = call_detail::call_user<void, false, false, protect_t<T>, 2>;
+ int upvalues = 0;
+ upvalues += stack::push(L, nullptr);
+ upvalues += stack::push<user<protect_t<T>>>(L, pw.value);
+ return stack::push(L, c_closure(cf, upvalues));
+ }
+ };
+
+ template <typename F, typename G>
+ struct unqualified_pusher<property_wrapper<F, G>> {
+ static int push(lua_State* L, property_wrapper<F, G>&& pw) {
+ if constexpr (std::is_void_v<F>) {
+ return stack::push(L, std::move(pw.write()));
+ }
+ else if constexpr (std::is_void_v<G>) {
+ return stack::push(L, std::move(pw.read()));
+ }
+ else {
+ return stack::push(L, overload(std::move(pw.read()), std::move(pw.write())));
+ }
+ }
+
+ static int push(lua_State* L, const property_wrapper<F, G>& pw) {
+ if constexpr (std::is_void_v<F>) {
+ return stack::push(L, pw.write);
+ }
+ else if constexpr (std::is_void_v<G>) {
+ return stack::push(L, pw.read);
+ }
+ else {
+ return stack::push(L, overload(pw.read, pw.write));
+ }
+ }
+ };
+
+ template <typename T>
+ struct unqualified_pusher<var_wrapper<T>> {
+ static int push(lua_State* L, var_wrapper<T>&& vw) {
+ return stack::push(L, std::move(vw.value()));
+ }
+ static int push(lua_State* L, const var_wrapper<T>& vw) {
+ return stack::push(L, vw.value());
+ }
+ };
+
+ template <typename... Functions>
+ struct unqualified_pusher<factory_wrapper<Functions...>> {
+ static int push(lua_State* L, const factory_wrapper<Functions...>& fw) {
+ using F = function_detail::overloaded_function<0, Functions...>;
+ function_detail::select_set_fx<false, false, F>(L, fw.functions);
+ return 1;
+ }
+
+ static int push(lua_State* L, factory_wrapper<Functions...>&& fw) {
+ using F = function_detail::overloaded_function<0, Functions...>;
+ function_detail::select_set_fx<false, false, F>(L, std::move(fw.functions));
+ return 1;
+ }
+
+ static int push(lua_State* L, const factory_wrapper<Functions...>& fw, function_detail::call_indicator) {
+ using F = function_detail::overloaded_function<1, Functions...>;
+ function_detail::select_set_fx<false, false, F>(L, fw.functions);
+ return 1;
+ }
+
+ static int push(lua_State* L, factory_wrapper<Functions...>&& fw, function_detail::call_indicator) {
+ using F = function_detail::overloaded_function<1, Functions...>;
+ function_detail::select_set_fx<false, false, F>(L, std::move(fw.functions));
+ return 1;
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<no_construction> {
+ static int push(lua_State* L, no_construction) {
+ lua_CFunction cf = &function_detail::no_construction_error;
+ return stack::push(L, cf);
+ }
+
+ static int push(lua_State* L, no_construction c, function_detail::call_indicator) {
+ return push(L, c);
+ }
+ };
+
+ template <typename T>
+ struct unqualified_pusher<detail::tagged<T, no_construction>> {
+ static int push(lua_State* L, detail::tagged<T, no_construction>) {
+ lua_CFunction cf = &function_detail::no_construction_error;
+ return stack::push(L, cf);
+ }
+
+ static int push(lua_State* L, no_construction c, function_detail::call_indicator) {
+ return push(L, c);
+ }
+ };
+
+ template <typename T, typename... Lists>
+ struct unqualified_pusher<detail::tagged<T, constructor_list<Lists...>>> {
+ static int push(lua_State* L, detail::tagged<T, constructor_list<Lists...>>) {
+ lua_CFunction cf = call_detail::construct<T, detail::default_safe_function_calls, true, Lists...>;
+ return stack::push(L, cf);
+ }
+
+ static int push(lua_State* L, constructor_list<Lists...>) {
+ lua_CFunction cf = call_detail::construct<T, detail::default_safe_function_calls, true, Lists...>;
+ return stack::push(L, cf);
+ }
+ };
+
+ template <typename L0, typename... Lists>
+ struct unqualified_pusher<constructor_list<L0, Lists...>> {
+ typedef constructor_list<L0, Lists...> cl_t;
+ static int push(lua_State* L, cl_t cl) {
+ typedef typename meta::bind_traits<L0>::return_type T;
+ return stack::push<detail::tagged<T, cl_t>>(L, cl);
+ }
+ };
+
+ template <typename T, typename... Fxs>
+ struct unqualified_pusher<detail::tagged<T, constructor_wrapper<Fxs...>>> {
+ static int push(lua_State* L, detail::tagged<T, constructor_wrapper<Fxs...>>&& c) {
+ return push(L, std::move(c.value()));
+ }
+
+ static int push(lua_State* L, const detail::tagged<T, const constructor_wrapper<Fxs...>>& c) {
+ return push(L, c.value());
+ }
+
+ static int push(lua_State* L, constructor_wrapper<Fxs...>&& c) {
+ lua_CFunction cf = call_detail::call_user<T, false, false, constructor_wrapper<Fxs...>, 2>;
+ int upvalues = 0;
+ upvalues += stack::push(L, nullptr);
+ upvalues += stack::push<user<constructor_wrapper<Fxs...>>>(L, std::move(c));
+ return stack::push(L, c_closure(cf, upvalues));
+ }
+
+ static int push(lua_State* L, const constructor_wrapper<Fxs...>& c) {
+ lua_CFunction cf = call_detail::call_user<T, false, false, constructor_wrapper<Fxs...>, 2>;
+ int upvalues = 0;
+ upvalues += stack::push(L, nullptr);
+ upvalues += stack::push<user<constructor_wrapper<Fxs...>>>(L, c);
+ return stack::push(L, c_closure(cf, upvalues));
+ }
+ };
+
+ template <typename F, typename... Fxs>
+ struct unqualified_pusher<constructor_wrapper<F, Fxs...>> {
+ static int push(lua_State* L, const constructor_wrapper<F, Fxs...>& c) {
+ typedef typename meta::bind_traits<F>::template arg_at<0> arg0;
+ typedef meta::unqualified_t<std::remove_pointer_t<arg0>> T;
+ return stack::push<detail::tagged<T, constructor_wrapper<F, Fxs...>>>(L, c);
+ }
+
+ static int push(lua_State* L, constructor_wrapper<F, Fxs...>&& c) {
+ typedef typename meta::bind_traits<F>::template arg_at<0> arg0;
+ typedef meta::unqualified_t<std::remove_pointer_t<arg0>> T;
+ return stack::push<detail::tagged<T, constructor_wrapper<F, Fxs...>>>(L, std::move(c));
+ }
+ };
+
+ template <typename T>
+ struct unqualified_pusher<detail::tagged<T, destructor_wrapper<void>>> {
+ static int push(lua_State* L, destructor_wrapper<void>) {
+ lua_CFunction cf = detail::usertype_alloc_destruct<T>;
+ return stack::push(L, cf);
+ }
+ };
+
+ template <typename T, typename Fx>
+ struct unqualified_pusher<detail::tagged<T, destructor_wrapper<Fx>>> {
+ static int push(lua_State* L, destructor_wrapper<Fx>&& c) {
+ lua_CFunction cf = call_detail::call_user<T, false, false, destructor_wrapper<Fx>, 2>;
+ int upvalues = 0;
+ upvalues += stack::push(L, nullptr);
+ upvalues += stack::push<user<destructor_wrapper<Fx>>>(L, std::move(c));
+ return stack::push(L, c_closure(cf, upvalues));
+ }
+
+ static int push(lua_State* L, const destructor_wrapper<Fx>& c) {
+ lua_CFunction cf = call_detail::call_user<T, false, false, destructor_wrapper<Fx>, 2>;
+ int upvalues = 0;
+ upvalues += stack::push(L, nullptr);
+ upvalues += stack::push<user<destructor_wrapper<Fx>>>(L, c);
+ return stack::push(L, c_closure(cf, upvalues));
+ }
+ };
+
+ template <typename Fx>
+ struct unqualified_pusher<destructor_wrapper<Fx>> {
+ static int push(lua_State* L, destructor_wrapper<Fx>&& c) {
+ lua_CFunction cf = call_detail::call_user<void, false, false, destructor_wrapper<Fx>, 2>;
+ int upvalues = 0;
+ upvalues += stack::push(L, nullptr);
+ upvalues += stack::push<user<destructor_wrapper<Fx>>>(L, std::move(c));
+ return stack::push(L, c_closure(cf, upvalues));
+ }
+
+ static int push(lua_State* L, const destructor_wrapper<Fx>& c) {
+ lua_CFunction cf = call_detail::call_user<void, false, false, destructor_wrapper<Fx>, 2>;
+ int upvalues = 0;
+ upvalues += stack::push(L, nullptr);
+ upvalues += stack::push<user<destructor_wrapper<Fx>>>(L, c);
+ return stack::push(L, c_closure(cf, upvalues));
+ }
+ };
+
+ template <typename F, typename... Policies>
+ struct unqualified_pusher<policy_wrapper<F, Policies...>> {
+ using P = policy_wrapper<F, Policies...>;
+
+ static int push(lua_State* L, const P& p) {
+ lua_CFunction cf = call_detail::call_user<void, false, false, P, 2>;
+ int upvalues = 0;
+ upvalues += stack::push(L, nullptr);
+ upvalues += stack::push<user<P>>(L, p);
+ return stack::push(L, c_closure(cf, upvalues));
+ }
+
+ static int push(lua_State* L, P&& p) {
+ lua_CFunction cf = call_detail::call_user<void, false, false, P, 2>;
+ int upvalues = 0;
+ upvalues += stack::push(L, nullptr);
+ upvalues += stack::push<user<P>>(L, std::move(p));
+ return stack::push(L, c_closure(cf, upvalues));
+ }
+ };
+
+ template <typename T, typename F, typename... Policies>
+ struct unqualified_pusher<detail::tagged<T, policy_wrapper<F, Policies...>>> {
+ using P = policy_wrapper<F, Policies...>;
+ using Tagged = detail::tagged<T, P>;
+
+ static int push(lua_State* L, const Tagged& p) {
+ lua_CFunction cf = call_detail::call_user<T, false, false, P, 2>;
+ int upvalues = 0;
+ upvalues += stack::push(L, nullptr);
+ upvalues += stack::push<user<P>>(L, p.value());
+ return stack::push(L, c_closure(cf, upvalues));
+ }
+
+ static int push(lua_State* L, Tagged&& p) {
+ lua_CFunction cf = call_detail::call_user<T, false, false, P, 2>;
+ int upvalues = 0;
+ upvalues += stack::push(L, nullptr);
+ upvalues += stack::push<user<P>>(L, std::move(p.value()));
+ return stack::push(L, c_closure(cf, upvalues));
+ }
+ };
+
+ template <typename T>
+ struct unqualified_pusher<push_invoke_t<T>> {
+ static int push(lua_State* L, push_invoke_t<T>&& pi) {
+ if constexpr (std::is_invocable_v<std::add_rvalue_reference_t<T>, lua_State*>) {
+ return stack::push(L, std::move(pi.value())(L));
+ }
+ else {
+ return stack::push(L, std::move(pi.value())());
+ }
+ }
+
+ static int push(lua_State* L, const push_invoke_t<T>& pi) {
+ if constexpr (std::is_invocable_v<const T, lua_State*>) {
+ return stack::push(L, pi.value()(L));
+ }
+ else {
+ return stack::push(L, pi.value()());
+ }
+ }
+ };
+
+ namespace stack_detail {
+ template <typename Function, typename Handler>
+ bool check_function_pointer(lua_State* L, int index, Handler&& handler, record& tracking) noexcept {
+#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE_I_)
+ tracking.use(1);
+ bool success = lua_iscfunction(L, index) == 1;
+ if (success) {
+ // there must be at LEAST 2 upvalues; otherwise, we didn't serialize it.
+ const char* upvalue_name = lua_getupvalue(L, index, 2);
+ lua_pop(L, 1);
+ success = upvalue_name != nullptr;
+ }
+ if (!success) {
+ // expected type, actual type
+ handler(
+ L, index, type::function, type_of(L, index), "type must be a Lua C Function gotten from a function pointer serialized by sol2");
+ }
+ return success;
+#else
+ return false;
+#endif
+ }
+
+ template <typename Function>
+ Function* get_function_pointer(lua_State* L, int index, record& tracking) noexcept {
+#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE_I_)
+ tracking.use(1);
+ auto udata = stack::stack_detail::get_as_upvalues_using_function<Function*>(L, index);
+ Function* fx = udata.first;
+ return fx;
+#else
+ static_assert(meta::meta_detail::always_true<Function>::value,
+#if SOL_IS_DEFAULT_OFF(SOL_GET_FUNCTION_POINTER_UNSAFE_I_)
+ "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 "
+ "SOL_GET_FUNCTION_POINTER_UNSAFE configuration macro, as detailed in the documentation. "
+ "Please be careful!"
+#else
+ "You are attempting to retrieve a function pointer type. "
+ "You explicitly turned off the ability to do this by defining "
+ "SOL_GET_FUNCTION_POINTER_UNSAFE or similar to be off. "
+ "Please reconsider this!"
+#endif
+ );
+ return nullptr;
+#endif
+ }
+ } // namespace stack_detail
+ } // namespace stack
+} // namespace sol
+
+// end of sol/function_types.hpp
+
+// beginning of sol/dump_handler.hpp
+
+#include <cstdint>
+#include <exception>
+
+namespace sol {
+
+ class dump_error : public error {
+ private:
+ int ec_;
+
+ public:
+ dump_error(int error_code_) : error("dump returned non-zero error of " + std::to_string(error_code_)), ec_(error_code_) {
+ }
+
+ int error_code() const {
+ return ec_;
+ }
+ };
+
+ inline int dump_pass_on_error(lua_State* L, int result_code, lua_Writer writer_function, void* userdata, bool strip) {
+ (void)L;
+ (void)writer_function;
+ (void)userdata;
+ (void)strip;
+ return result_code;
+ }
+
+ inline int dump_panic_on_error(lua_State* L, int result_code, lua_Writer writer_function, void* userdata, bool strip) {
+ (void)L;
+ (void)writer_function;
+ (void)userdata;
+ (void)strip;
+ return luaL_error(L, "a non-zero error code (%d) was returned by the lua_Writer for the dump function", result_code);
+ }
+
+ inline int dump_throw_on_error(lua_State* L, int result_code, lua_Writer writer_function, void* userdata, bool strip) {
+#if SOL_IS_OFF(SOL_EXCEPTIONS_I_)
+ return dump_panic_on_error(L, result_code, writer_function, userdata, strip);
+#else
+ (void)L;
+ (void)writer_function;
+ (void)userdata;
+ (void)strip;
+ throw dump_error(result_code);
+#endif // no exceptions stuff
+ }
+
+} // namespace sol
+
+// end of sol/dump_handler.hpp
+
+#include <cstdint>
+
+namespace sol {
+ template <typename ref_t, bool aligned = false>
+ class basic_function : public basic_object<ref_t> {
+ private:
+ using base_t = basic_object<ref_t>;
+
+ void luacall(std::ptrdiff_t argcount, std::ptrdiff_t resultcount) const {
+ lua_call(lua_state(), static_cast<int>(argcount), static_cast<int>(resultcount));
+ }
+
+ template <std::size_t... I, typename... Ret>
+ auto invoke(types<Ret...>, std::index_sequence<I...>, std::ptrdiff_t n) const {
+ luacall(n, lua_size<std::tuple<Ret...>>::value);
+ return stack::pop<std::tuple<Ret...>>(lua_state());
+ }
+
+ template <std::size_t I, typename Ret, meta::enable<meta::neg<std::is_void<Ret>>> = meta::enabler>
+ Ret invoke(types<Ret>, std::index_sequence<I>, std::ptrdiff_t n) const {
+ luacall(n, lua_size<Ret>::value);
+ return stack::pop<Ret>(lua_state());
+ }
+
+ template <std::size_t I>
+ void invoke(types<void>, std::index_sequence<I>, std::ptrdiff_t n) const {
+ luacall(n, 0);
+ }
+
+ unsafe_function_result invoke(types<>, std::index_sequence<>, std::ptrdiff_t n) const {
+ int stacksize = lua_gettop(lua_state());
+ int firstreturn = (std::max)(1, stacksize - static_cast<int>(n));
+ luacall(n, LUA_MULTRET);
+ int poststacksize = lua_gettop(lua_state());
+ int returncount = poststacksize - (firstreturn - 1);
+ return unsafe_function_result(lua_state(), firstreturn, returncount);
+ }
+
+ public:
+ using base_t::lua_state;
+
+ basic_function() = default;
+ template <typename T, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_function>>, 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>
+ basic_function(T&& r) noexcept
+ : base_t(std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ if (!is_function<meta::unqualified_t<T>>::value) {
+ auto pp = stack::push_pop(*this);
+ constructor_handler handler{};
+ stack::check<basic_function>(lua_state(), -1, handler);
+ }
+#endif // Safety
+ }
+ basic_function(const basic_function&) = default;
+ basic_function& operator=(const basic_function&) = default;
+ basic_function(basic_function&&) = default;
+ basic_function& operator=(basic_function&&) = default;
+ basic_function(const stack_reference& r)
+ : basic_function(r.lua_state(), r.stack_index()) {
+ }
+ basic_function(stack_reference&& r)
+ : basic_function(r.lua_state(), r.stack_index()) {
+ }
+ basic_function(lua_nil_t n)
+ : base_t(n) {
+ }
+ template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+ basic_function(lua_State* L, T&& r)
+ : base_t(L, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ auto pp = stack::push_pop(*this);
+ constructor_handler handler{};
+ stack::check<basic_function>(lua_state(), -1, handler);
+#endif // Safety
+ }
+ basic_function(lua_State* L, int index = -1)
+ : base_t(L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ constructor_handler handler{};
+ stack::check<basic_function>(L, index, handler);
+#endif // Safety
+ }
+ basic_function(lua_State* L, ref_index index)
+ : base_t(L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ auto pp = stack::push_pop(*this);
+ constructor_handler handler{};
+ stack::check<basic_function>(lua_state(), -1, handler);
+#endif // Safety
+ }
+
+ template <typename Fx>
+ int dump(lua_Writer writer, void* userdata, bool strip, Fx&& on_error) const {
+ this->push();
+ auto ppn = stack::push_popper_n<false>(this->lua_state(), 1);
+ int r = lua_dump(this->lua_state(), writer, userdata, strip ? 1 : 0);
+ if (r != 0) {
+ return on_error(this->lua_state(), r, writer, userdata, strip);
+ }
+ return r;
+ }
+
+ int dump(lua_Writer writer, void* userdata, bool strip = false) const {
+ return dump(writer, userdata, strip, &dump_throw_on_error);
+ }
+
+ template <typename Container = bytecode>
+ Container dump() const {
+ Container bc;
+ (void)dump(static_cast<lua_Writer>(&basic_insert_dump_writer<Container>), static_cast<void*>(&bc), false, &dump_panic_on_error);
+ return bc;
+ }
+
+ template <typename Container = bytecode, typename Fx>
+ Container dump(Fx&& on_error) const {
+ Container bc;
+ (void)dump(static_cast<lua_Writer>(&basic_insert_dump_writer<Container>), static_cast<void*>(&bc), false, std::forward<Fx>(on_error));
+ return bc;
+ }
+
+ template <typename... Args>
+ unsafe_function_result operator()(Args&&... args) const {
+ return call<>(std::forward<Args>(args)...);
+ }
+
+ template <typename... Ret, typename... Args>
+ decltype(auto) operator()(types<Ret...>, Args&&... args) const {
+ return call<Ret...>(std::forward<Args>(args)...);
+ }
+
+ template <typename... Ret, typename... Args>
+ decltype(auto) call(Args&&... args) const {
+ if (!aligned) {
+ base_t::push();
+ }
+ int pushcount = stack::multi_push_reference(lua_state(), std::forward<Args>(args)...);
+ return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), static_cast<std::ptrdiff_t>(pushcount));
+ }
+ };
+} // namespace sol
+
+// end of sol/unsafe_function.hpp
+
+// beginning of sol/protected_function.hpp
+
+// beginning of sol/protected_handler.hpp
+
+#include <cstdint>
+
+namespace sol {
+ namespace detail {
+ inline const char(&default_handler_name())[9]{
+ static const char name[9] = "sol.\xF0\x9F\x94\xA9";
+ return name;
+ }
+
+ template <bool b, typename target_t = reference>
+ struct protected_handler {
+ typedef is_stack_based<target_t> is_stack;
+ const target_t& target;
+ int stackindex;
+
+ protected_handler(std::false_type, const target_t& target)
+ : target(target), stackindex(0) {
+ if (b) {
+ stackindex = lua_gettop(target.lua_state()) + 1;
+ target.push();
+ }
+ }
+
+ protected_handler(std::true_type, const target_t& target)
+ : target(target), stackindex(0) {
+ if (b) {
+ stackindex = target.stack_index();
+ }
+ }
+
+ protected_handler(const target_t& target)
+ : protected_handler(is_stack(), target) {
+ }
+
+ bool valid() const noexcept {
+ return b;
+ }
+
+ ~protected_handler() {
+ if constexpr (!is_stack::value) {
+ if (stackindex != 0) {
+ lua_remove(target.lua_state(), stackindex);
+ }
+ }
+ }
+ };
+
+ template <typename base_t, typename T>
+ basic_function<base_t> force_cast(T& p) {
+ return p;
+ }
+
+ template <typename Reference, bool is_main_ref = false>
+ static Reference get_default_handler(lua_State* L) {
+ if (is_stack_based<Reference>::value || L == nullptr)
+ return Reference(L, lua_nil);
+ L = is_main_ref ? main_thread(L, L) : L;
+ lua_getglobal(L, default_handler_name());
+ auto pp = stack::pop_n(L, 1);
+ return Reference(L, -1);
+ }
+
+ template <typename T>
+ static void set_default_handler(lua_State* L, const T& ref) {
+ if (L == nullptr) {
+ return;
+ }
+ if (!ref.valid()) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK_I_)
+ luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+ lua_pushnil(L);
+ lua_setglobal(L, default_handler_name());
+ }
+ else {
+ ref.push(L);
+ lua_setglobal(L, default_handler_name());
+ }
+ }
+ } // namespace detail
+} // namespace sol
+
+// end of sol/protected_handler.hpp
+
+#include <cstdint>
+#include <algorithm>
+
+namespace sol {
+
+ namespace detail {
+ template <bool b, typename handler_t>
+ inline void handle_protected_exception(lua_State* L, optional<const std::exception&> maybe_ex, const char* error, detail::protected_handler<b, handler_t>& h) {
+ h.stackindex = 0;
+ if (b) {
+ h.target.push();
+ detail::call_exception_handler(L, maybe_ex, error);
+ lua_call(L, 1, 1);
+ }
+ else {
+ detail::call_exception_handler(L, maybe_ex, error);
+ }
+ }
+ }
+
+ template <typename ref_t, bool aligned = false, typename handler_t = reference>
+ class basic_protected_function : public basic_object<ref_t> {
+ private:
+ using base_t = basic_object<ref_t>;
+
+ public:
+ using is_stack_handler = is_stack_based<handler_t>;
+
+ static handler_t get_default_handler(lua_State* L) {
+ return detail::get_default_handler<handler_t, is_main_threaded<base_t>::value>(L);
+ }
+
+ template <typename T>
+ static void set_default_handler(const T& ref) {
+ detail::set_default_handler(ref.lua_state(), ref);
+ }
+
+ private:
+ template <bool b>
+ call_status luacall(std::ptrdiff_t argcount, std::ptrdiff_t resultcount, detail::protected_handler<b, handler_t>& h) const {
+ return static_cast<call_status>(lua_pcall(lua_state(), static_cast<int>(argcount), static_cast<int>(resultcount), h.stackindex));
+ }
+
+ template <std::size_t... I, bool b, typename... Ret>
+ auto invoke(types<Ret...>, std::index_sequence<I...>, std::ptrdiff_t n, detail::protected_handler<b, handler_t>& h) const {
+ luacall(n, sizeof...(Ret), h);
+ return stack::pop<std::tuple<Ret...>>(lua_state());
+ }
+
+ template <std::size_t I, bool b, typename Ret>
+ Ret invoke(types<Ret>, std::index_sequence<I>, std::ptrdiff_t n, detail::protected_handler<b, handler_t>& h) const {
+ luacall(n, 1, h);
+ return stack::pop<Ret>(lua_state());
+ }
+
+ template <std::size_t I, bool b>
+ void invoke(types<void>, std::index_sequence<I>, std::ptrdiff_t n, detail::protected_handler<b, handler_t>& h) const {
+ luacall(n, 0, h);
+ }
+
+ template <bool b>
+ protected_function_result invoke(types<>, std::index_sequence<>, std::ptrdiff_t n, detail::protected_handler<b, handler_t>& h) const {
+ int stacksize = lua_gettop(lua_state());
+ int poststacksize = stacksize;
+ int firstreturn = 1;
+ int returncount = 0;
+ call_status code = call_status::ok;
+#if !defined(SOL_NO_EXCEPTIONS) || !SOL_NO_EXCEPTIONS
+#if (!defined(SOL_EXCEPTIONS_SAFE_PROPAGATION) || !SOL_NO_EXCEPTIONS_SAFE_PROPAGATION) || (defined(SOL_LUAJIT) && SOL_LUAJIT)
+ try {
+#endif // Safe Exception Propagation
+#endif // No Exceptions
+ firstreturn = (std::max)(1, static_cast<int>(stacksize - n - static_cast<int>(h.valid() && !is_stack_handler::value)));
+ code = luacall(n, LUA_MULTRET, h);
+ poststacksize = lua_gettop(lua_state()) - static_cast<int>(h.valid() && !is_stack_handler::value);
+ returncount = poststacksize - (firstreturn - 1);
+#ifndef SOL_NO_EXCEPTIONS
+#if (!defined(SOL_EXCEPTIONS_SAFE_PROPAGATION) || !SOL_NO_EXCEPTIONS_SAFE_PROPAGATION) || (defined(SOL_LUAJIT) && SOL_LUAJIT)
+ }
+ // Handle C++ errors thrown from C++ functions bound inside of lua
+ catch (const char* error) {
+ detail::handle_protected_exception(lua_state(), optional<const std::exception&>(nullopt), error, h);
+ firstreturn = lua_gettop(lua_state());
+ return protected_function_result(lua_state(), firstreturn, 0, 1, call_status::runtime);
+ }
+ catch (const std::string& error) {
+ detail::handle_protected_exception(lua_state(), optional<const std::exception&>(nullopt), error.c_str(), h);
+ firstreturn = lua_gettop(lua_state());
+ return protected_function_result(lua_state(), firstreturn, 0, 1, call_status::runtime);
+ }
+ catch (const std::exception& error) {
+ detail::handle_protected_exception(lua_state(), optional<const std::exception&>(error), error.what(), h);
+ firstreturn = lua_gettop(lua_state());
+ return protected_function_result(lua_state(), firstreturn, 0, 1, call_status::runtime);
+ }
+#if (!defined(SOL_EXCEPTIONS_SAFE_PROPAGATION) || !SOL_NO_EXCEPTIONS_SAFE_PROPAGATION)
+ // LuaJIT cannot have the catchall when the safe propagation is on
+ // but LuaJIT will swallow all C++ errors
+ // if we don't at least catch std::exception ones
+ catch (...) {
+ detail::handle_protected_exception(lua_state(), optional<const std::exception&>(nullopt), detail::protected_function_error, h);
+ firstreturn = lua_gettop(lua_state());
+ return protected_function_result(lua_state(), firstreturn, 0, 1, call_status::runtime);
+ }
+#endif // LuaJIT
+#else
+ // do not handle exceptions: they can be propogated into C++ and keep all type information / rich information
+#endif // Safe Exception Propagation
+#endif // Exceptions vs. No Exceptions
+ return protected_function_result(lua_state(), firstreturn, returncount, returncount, code);
+ }
+
+ public:
+ using base_t::lua_state;
+
+ handler_t error_handler;
+
+ basic_protected_function() = default;
+ template <typename T, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_protected_function>>, 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>
+ basic_protected_function(T&& r) noexcept
+ : base_t(std::forward<T>(r)), error_handler(get_default_handler(r.lua_state())) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ if (!is_function<meta::unqualified_t<T>>::value) {
+ auto pp = stack::push_pop(*this);
+ constructor_handler handler{};
+ stack::check<basic_protected_function>(lua_state(), -1, handler);
+ }
+#endif // Safety
+ }
+ basic_protected_function(const basic_protected_function&) = default;
+ basic_protected_function& operator=(const basic_protected_function&) = default;
+ basic_protected_function(basic_protected_function&&) = default;
+ basic_protected_function& operator=(basic_protected_function&&) = default;
+ basic_protected_function(const basic_function<base_t>& b)
+ : basic_protected_function(b, get_default_handler(b.lua_state())) {
+ }
+ basic_protected_function(basic_function<base_t>&& b)
+ : basic_protected_function(std::move(b), get_default_handler(b.lua_state())) {
+ }
+ basic_protected_function(const basic_function<base_t>& b, handler_t eh)
+ : base_t(b), error_handler(std::move(eh)) {
+ }
+ basic_protected_function(basic_function<base_t>&& b, handler_t eh)
+ : base_t(std::move(b)), error_handler(std::move(eh)) {
+ }
+ basic_protected_function(const stack_reference& r)
+ : basic_protected_function(r.lua_state(), r.stack_index(), get_default_handler(r.lua_state())) {
+ }
+ basic_protected_function(stack_reference&& r)
+ : basic_protected_function(r.lua_state(), r.stack_index(), get_default_handler(r.lua_state())) {
+ }
+ basic_protected_function(const stack_reference& r, handler_t eh)
+ : basic_protected_function(r.lua_state(), r.stack_index(), std::move(eh)) {
+ }
+ basic_protected_function(stack_reference&& r, handler_t eh)
+ : basic_protected_function(r.lua_state(), r.stack_index(), std::move(eh)) {
+ }
+
+ template <typename Super>
+ basic_protected_function(const proxy_base<Super>& p)
+ : basic_protected_function(p, get_default_handler(p.lua_state())) {
+ }
+ template <typename Super>
+ basic_protected_function(proxy_base<Super>&& p)
+ : basic_protected_function(std::move(p), get_default_handler(p.lua_state())) {
+ }
+ template <typename Proxy, typename Handler, meta::enable<std::is_base_of<proxy_base_tag, meta::unqualified_t<Proxy>>, meta::neg<is_lua_index<meta::unqualified_t<Handler>>>> = meta::enabler>
+ basic_protected_function(Proxy&& p, Handler&& eh)
+ : basic_protected_function(detail::force_cast<base_t>(p), std::forward<Handler>(eh)) {
+ }
+
+ template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+ basic_protected_function(lua_State* L, T&& r)
+ : basic_protected_function(L, std::forward<T>(r), get_default_handler(L)) {
+ }
+ 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)), error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ auto pp = stack::push_pop(*this);
+ constructor_handler handler{};
+ stack::check<basic_protected_function>(lua_state(), -1, handler);
+#endif // Safety
+ }
+
+ basic_protected_function(lua_nil_t n)
+ : base_t(n), error_handler(n) {
+ }
+
+ 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), error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ constructor_handler handler{};
+ stack::check<basic_protected_function>(L, index, handler);
+#endif // Safety
+ }
+ 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), error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ constructor_handler handler{};
+ stack::check<basic_protected_function>(L, index, handler);
+#endif // Safety
+ }
+ 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), error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ constructor_handler handler{};
+ stack::check<basic_protected_function>(L, index, handler);
+#endif // Safety
+ }
+ 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), error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ auto pp = stack::push_pop(*this);
+ constructor_handler handler{};
+ stack::check<basic_protected_function>(lua_state(), -1, handler);
+#endif // Safety
+ }
+
+ template <typename Fx>
+ int dump(lua_Writer writer, void* userdata, bool strip, Fx&& on_error) const {
+ this->push();
+ auto ppn = stack::push_popper_n<false>(this->lua_state(), 1);
+ int r = lua_dump(this->lua_state(), writer, userdata, strip ? 1 : 0);
+ if (r != 0) {
+ return on_error(this->lua_state(), r, writer, userdata, strip);
+ }
+ return r;
+ }
+
+ int dump(lua_Writer writer, void* userdata, bool strip = false) const {
+ return dump(writer, userdata, strip, &dump_pass_on_error);
+ }
+
+ template <typename Container = bytecode>
+ Container dump() const {
+ Container bc;
+ (void)dump(static_cast<lua_Writer>(&basic_insert_dump_writer<Container>), static_cast<void*>(&bc), false, &dump_throw_on_error);
+ return bc;
+ }
+
+ template <typename Container = bytecode, typename Fx>
+ Container dump(Fx&& on_error) const {
+ Container bc;
+ (void)dump(static_cast<lua_Writer>(&basic_insert_dump_writer<Container>), static_cast<void*>(&bc), false, std::forward<Fx>(on_error));
+ return bc;
+ }
+
+ template <typename... Args>
+ protected_function_result operator()(Args&&... args) const {
+ return call<>(std::forward<Args>(args)...);
+ }
+
+ template <typename... Ret, typename... Args>
+ decltype(auto) operator()(types<Ret...>, Args&&... args) const {
+ return call<Ret...>(std::forward<Args>(args)...);
+ }
+
+ template <typename... Ret, typename... Args>
+ decltype(auto) call(Args&&... args) const {
+ if constexpr (!aligned) {
+ // we do not expect the function to already be on the stack: push it
+ if (error_handler.valid()) {
+ detail::protected_handler<true, handler_t> h(error_handler);
+ base_t::push();
+ int pushcount = stack::multi_push_reference(lua_state(), std::forward<Args>(args)...);
+ return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), pushcount, h);
+ }
+ else {
+ detail::protected_handler<false, handler_t> h(error_handler);
+ base_t::push();
+ int pushcount = stack::multi_push_reference(lua_state(), std::forward<Args>(args)...);
+ return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), pushcount, h);
+ }
+ }
+ else {
+ // the function is already on the stack at the right location
+ if (error_handler.valid()) {
+ // the handler will be pushed onto the stack manually,
+ // since it's not already on the stack this means we need to push our own
+ // function on the stack too and swap things to be in-place
+ if constexpr (!is_stack_handler::value) {
+ // so, we need to remove the function at the top and then dump the handler out ourselves
+ base_t::push();
+ }
+ detail::protected_handler<true, handler_t> h(error_handler);
+ if constexpr (!is_stack_handler::value) {
+ lua_replace(lua_state(), -3);
+ h.stackindex = lua_absindex(lua_state(), -2);
+ }
+ int pushcount = stack::multi_push_reference(lua_state(), std::forward<Args>(args)...);
+ return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), pushcount, h);
+ }
+ else {
+ detail::protected_handler<false, handler_t> h(error_handler);
+ int pushcount = stack::multi_push_reference(lua_state(), std::forward<Args>(args)...);
+ return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), pushcount, h);
+ }
+ }
+ }
+ };
+} // namespace sol
+
+// end of sol/protected_function.hpp
+
+#include <functional>
+
+namespace sol {
+ template <typename... Ret, typename... Args>
+ decltype(auto) stack_proxy::call(Args&&... args) {
+ stack_function sf(this->lua_state(), this->stack_index());
+ return sf.template call<Ret...>(std::forward<Args>(args)...);
+ }
+
+ inline protected_function_result::protected_function_result(unsafe_function_result&& o) noexcept
+ : L(o.lua_state()), index(o.stack_index()), returncount(o.return_count()), popcount(o.return_count()), err(o.status()) {
+ // Must be manual, otherwise destructor will screw us
+ // return count being 0 is enough to keep things clean
+ // but we will be thorough
+ o.abandon();
+ }
+
+ inline protected_function_result& protected_function_result::operator=(unsafe_function_result&& o) noexcept {
+ L = o.lua_state();
+ index = o.stack_index();
+ returncount = o.return_count();
+ popcount = o.return_count();
+ err = o.status();
+ // Must be manual, otherwise destructor will screw us
+ // return count being 0 is enough to keep things clean
+ // but we will be thorough
+ o.abandon();
+ return *this;
+ }
+
+ inline unsafe_function_result::unsafe_function_result(protected_function_result&& o) noexcept
+ : L(o.lua_state()), index(o.stack_index()), returncount(o.return_count()) {
+ // Must be manual, otherwise destructor will screw us
+ // return count being 0 is enough to keep things clean
+ // but we will be thorough
+ o.abandon();
+ }
+ inline unsafe_function_result& unsafe_function_result::operator=(protected_function_result&& o) noexcept {
+ L = o.lua_state();
+ index = o.stack_index();
+ returncount = o.return_count();
+ // Must be manual, otherwise destructor will screw us
+ // return count being 0 is enough to keep things clean
+ // but we will be thorough
+ o.abandon();
+ return *this;
+ }
+
+ namespace detail {
+ template <typename... R>
+ struct std_shim {
+ unsafe_function lua_func_;
+
+ std_shim(unsafe_function lua_func) : lua_func_(std::move(lua_func)) {
+ }
+
+ template <typename... Args>
+ meta::return_type_t<R...> operator()(Args&&... args) {
+ return lua_func_.call<R...>(std::forward<Args>(args)...);
+ }
+ };
+
+ template <>
+ struct std_shim<void> {
+ unsafe_function lua_func_;
+
+ std_shim(unsafe_function lua_func) : lua_func_(std::move(lua_func)) {
+ }
+
+ template <typename... Args>
+ void operator()(Args&&... args) {
+ lua_func_.call<void>(std::forward<Args>(args)...);
+ }
+ };
+ } // namespace detail
+
+ namespace stack {
+ template <typename Signature>
+ struct unqualified_getter<std::function<Signature>> {
+ typedef meta::bind_traits<Signature> fx_t;
+ typedef typename fx_t::args_list args_lists;
+ typedef meta::tuple_types<typename fx_t::return_type> return_types;
+
+ template <typename... R>
+ static std::function<Signature> get_std_func(types<R...>, lua_State* L, int index) {
+ detail::std_shim<R...> fx(unsafe_function(L, index));
+ return fx;
+ }
+
+ static std::function<Signature> get(lua_State* L, int index, record& tracking) {
+ tracking.use(1);
+ type t = type_of(L, index);
+ if (t == type::none || t == type::lua_nil) {
+ return nullptr;
+ }
+ return get_std_func(return_types(), L, index);
+ }
+ };
+
+ template <typename Allocator>
+ struct unqualified_getter<basic_bytecode<Allocator>> {
+ static basic_bytecode<Allocator> get(lua_State* L, int index, record& tracking) {
+ tracking.use(1);
+ stack_function sf(L, index);
+ return sf.dump(&dump_panic_on_error);
+ }
+ };
+ } // namespace stack
+
+} // namespace sol
+
+// end of sol/function.hpp
+
+// beginning of sol/usertype.hpp
+
+// beginning of sol/usertype_core.hpp
+
+// beginning of sol/deprecate.hpp
+
+#ifndef SOL_DEPRECATED
+#ifdef _MSC_VER
+#define SOL_DEPRECATED __declspec(deprecated)
+#elif __GNUC__
+#define SOL_DEPRECATED __attribute__((deprecated))
+#else
+#define SOL_DEPRECATED [[deprecated]]
+#endif // compilers
+#endif // SOL_DEPRECATED
+
+namespace sol {
+namespace detail {
+ template <typename T>
+ struct SOL_DEPRECATED deprecate_type {
+ using type = T;
+ };
+}
+} // namespace sol::detail
+
+// end of sol/deprecate.hpp
+
+// beginning of sol/usertype_container_launch.hpp
+
+// beginning of sol/usertype_container.hpp
+
+namespace sol {
+
+ template <typename T>
+ struct usertype_container;
+
+ namespace container_detail {
+
+ template <typename T>
+ struct has_clear_test {
+ private:
+ template <typename C>
+ static meta::sfinae_yes_t test(decltype(&C::clear));
+ template <typename C>
+ static meta::sfinae_no_t test(...);
+
+ public:
+ static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+ };
+
+ template <typename T>
+ struct has_empty_test {
+ private:
+ template <typename C>
+ static meta::sfinae_yes_t test(decltype(&C::empty));
+ template <typename C>
+ static meta::sfinae_no_t test(...);
+
+ public:
+ static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+ };
+
+ template <typename T>
+ struct has_erase_after_test {
+ private:
+ template <typename C>
+ static meta::sfinae_yes_t test(
+ decltype(std::declval<C>().erase_after(std::declval<std::add_rvalue_reference_t<typename C::const_iterator>>()))*);
+ template <typename C>
+ static meta::sfinae_no_t test(...);
+
+ public:
+ static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+ };
+
+ template <typename T, typename = void>
+ struct has_find_test {
+ private:
+ template <typename C>
+ static meta::sfinae_yes_t test(decltype(std::declval<C>().find(std::declval<std::add_rvalue_reference_t<typename C::value_type>>()))*);
+ template <typename C>
+ static meta::sfinae_no_t test(...);
+
+ public:
+ static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+ };
+
+ template <typename T>
+ struct has_find_test<T, std::enable_if_t<meta::is_lookup<T>::value>> {
+ private:
+ template <typename C>
+ static meta::sfinae_yes_t test(decltype(std::declval<C>().find(std::declval<std::add_rvalue_reference_t<typename C::key_type>>()))*);
+ template <typename C>
+ static meta::sfinae_no_t test(...);
+
+ public:
+ static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+ };
+
+ template <typename T>
+ struct has_erase_test {
+ private:
+ template <typename C>
+ static meta::sfinae_yes_t test(decltype(std::declval<C>().erase(std::declval<typename C::iterator>()))*);
+ template <typename C>
+ static meta::sfinae_no_t test(...);
+
+ public:
+ static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+ };
+
+ template <typename T>
+ struct has_erase_key_test {
+ private:
+ template <typename C>
+ static meta::sfinae_yes_t test(decltype(std::declval<C>().erase(std::declval<typename C::key_type>()))*);
+ template <typename C>
+ static meta::sfinae_no_t test(...);
+
+ public:
+ static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+ };
+
+ template <typename T>
+ struct has_traits_find_test {
+ private:
+ template <typename C>
+ static meta::sfinae_yes_t test(decltype(&C::find));
+ template <typename C>
+ static meta::sfinae_no_t test(...);
+
+ public:
+ static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+ };
+
+ template <typename T>
+ struct has_traits_index_of_test {
+ private:
+ template <typename C>
+ static meta::sfinae_yes_t test(decltype(&C::index_of));
+ template <typename C>
+ static meta::sfinae_no_t test(...);
+
+ public:
+ static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+ };
+
+ template <typename T>
+ struct has_traits_insert_test {
+ private:
+ template <typename C>
+ static meta::sfinae_yes_t test(decltype(&C::insert));
+ template <typename C>
+ static meta::sfinae_no_t test(...);
+
+ public:
+ static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+ };
+
+ template <typename T>
+ struct has_traits_erase_test {
+ private:
+ template <typename C>
+ static meta::sfinae_yes_t test(decltype(&C::erase));
+ template <typename C>
+ static meta::sfinae_no_t test(...);
+
+ public:
+ static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+ };
+
+ template <typename T>
+ struct has_traits_index_set_test {
+ private:
+ template <typename C>
+ static meta::sfinae_yes_t test(decltype(&C::index_set));
+ template <typename C>
+ static meta::sfinae_no_t test(...);
+
+ public:
+ static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+ };
+
+ template <typename T>
+ struct has_traits_index_get_test {
+ private:
+ template <typename C>
+ static meta::sfinae_yes_t test(decltype(&C::index_get));
+ template <typename C>
+ static meta::sfinae_no_t test(...);
+
+ public:
+ static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+ };
+
+ template <typename T>
+ struct has_traits_set_test {
+ private:
+ template <typename C>
+ static meta::sfinae_yes_t test(decltype(&C::set));
+ template <typename C>
+ static meta::sfinae_no_t test(...);
+
+ public:
+ static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+ };
+
+ template <typename T>
+ struct has_traits_get_test {
+ private:
+ template <typename C>
+ static meta::sfinae_yes_t test(decltype(&C::get));
+ template <typename C>
+ static meta::sfinae_no_t test(...);
+
+ public:
+ static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+ };
+
+ template <typename T>
+ struct has_traits_at_test {
+ private:
+ template <typename C>
+ static meta::sfinae_yes_t test(decltype(&C::at));
+ template <typename C>
+ static meta::sfinae_no_t test(...);
+
+ public:
+ static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+ };
+
+ template <typename T>
+ struct has_traits_pairs_test {
+ private:
+ template <typename C>
+ static meta::sfinae_yes_t test(decltype(&C::pairs));
+ template <typename C>
+ static meta::sfinae_no_t test(...);
+
+ public:
+ static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+ };
+
+ template <typename T>
+ struct has_traits_ipairs_test {
+ private:
+ template <typename C>
+ static meta::sfinae_yes_t test(decltype(&C::ipairs));
+ template <typename C>
+ static meta::sfinae_no_t test(...);
+
+ public:
+ static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+ };
+
+ template <typename T>
+ struct has_traits_next_test {
+ private:
+ template <typename C>
+ static meta::sfinae_yes_t test(decltype(&C::next));
+ template <typename C>
+ static meta::sfinae_no_t test(...);
+
+ public:
+ static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+ };
+
+ template <typename T>
+ struct has_traits_add_test {
+ private:
+ template <typename C>
+ static meta::sfinae_yes_t test(decltype(&C::add));
+ template <typename C>
+ static meta::sfinae_no_t test(...);
+
+ public:
+ static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+ };
+
+ template <typename T>
+ struct has_traits_size_test {
+ private:
+ template <typename C>
+ static meta::sfinae_yes_t test(decltype(&C::size));
+ template <typename C>
+ static meta::sfinae_no_t test(...);
+
+ public:
+ static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+ };
+
+ template <typename T>
+ using has_clear = meta::boolean<has_clear_test<T>::value>;
+
+ template <typename T>
+ using has_empty = meta::boolean<has_empty_test<T>::value>;
+
+ template <typename T>
+ using has_find = meta::boolean<has_find_test<T>::value>;
+
+ template <typename T>
+ using has_erase = meta::boolean<has_erase_test<T>::value>;
+
+ template <typename T>
+ using has_erase_key = meta::boolean<has_erase_key_test<T>::value>;
+
+ template <typename T>
+ using has_erase_after = meta::boolean<has_erase_after_test<T>::value>;
+
+ template <typename T>
+ using has_traits_get = meta::boolean<has_traits_get_test<T>::value>;
+
+ template <typename T>
+ using has_traits_at = meta::boolean<has_traits_at_test<T>::value>;
+
+ template <typename T>
+ using has_traits_set = meta::boolean<has_traits_set_test<T>::value>;
+
+ template <typename T>
+ using has_traits_index_get = meta::boolean<has_traits_index_get_test<T>::value>;
+
+ template <typename T>
+ using has_traits_index_set = meta::boolean<has_traits_index_set_test<T>::value>;
+
+ template <typename T>
+ using has_traits_pairs = meta::boolean<has_traits_pairs_test<T>::value>;
+
+ template <typename T>
+ using has_traits_ipairs = meta::boolean<has_traits_ipairs_test<T>::value>;
+
+ template <typename T>
+ using has_traits_next = meta::boolean<has_traits_next_test<T>::value>;
+
+ template <typename T>
+ using has_traits_add = meta::boolean<has_traits_add_test<T>::value>;
+
+ template <typename T>
+ using has_traits_size = meta::boolean<has_traits_size_test<T>::value>;
+
+ template <typename T>
+ using has_traits_clear = has_clear<T>;
+
+ template <typename T>
+ using has_traits_empty = has_empty<T>;
+
+ template <typename T>
+ using has_traits_find = meta::boolean<has_traits_find_test<T>::value>;
+
+ template <typename T>
+ using has_traits_index_of = meta::boolean<has_traits_index_of_test<T>::value>;
+
+ template <typename T>
+ using has_traits_insert = meta::boolean<has_traits_insert_test<T>::value>;
+
+ template <typename T>
+ using has_traits_erase = meta::boolean<has_traits_erase_test<T>::value>;
+
+ template <typename T>
+ struct is_forced_container : is_container<T> {};
+
+ template <typename T>
+ struct is_forced_container<as_container_t<T>> : std::true_type {};
+
+ template <typename T>
+ struct container_decay {
+ typedef T type;
+ };
+
+ template <typename T>
+ struct container_decay<as_container_t<T>> {
+ typedef T type;
+ };
+
+ template <typename T>
+ using container_decay_t = typename container_decay<meta::unqualified_t<T>>::type;
+
+ template <typename T>
+ decltype(auto) get_key(std::false_type, T&& t) {
+ return std::forward<T>(t);
+ }
+
+ template <typename T>
+ decltype(auto) get_key(std::true_type, T&& t) {
+ return t.first;
+ }
+
+ template <typename T>
+ decltype(auto) get_value(std::false_type, T&& t) {
+ return std::forward<T>(t);
+ }
+
+ template <typename T>
+ decltype(auto) get_value(std::true_type, T&& t) {
+ return t.second;
+ }
+
+ template <typename X, typename = void>
+ struct usertype_container_default {
+ private:
+ typedef std::remove_pointer_t<meta::unwrap_unqualified_t<X>> T;
+
+ public:
+ typedef lua_nil_t iterator;
+ typedef lua_nil_t value_type;
+
+ static int at(lua_State* L) {
+ return luaL_error(L, "sol: cannot call 'at(index)' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+ }
+
+ static int get(lua_State* L) {
+ return luaL_error(L, "sol: cannot call 'get(key)' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+ }
+
+ static int index_get(lua_State* L) {
+ return luaL_error(L, "sol: cannot call 'container[key]' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+ }
+
+ static int set(lua_State* L) {
+ return luaL_error(L, "sol: cannot call 'set(key, value)' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+ }
+
+ static int index_set(lua_State* L) {
+ return luaL_error(
+ L, "sol: cannot call 'container[key] = value' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+ }
+
+ static int add(lua_State* L) {
+ return luaL_error(L, "sol: cannot call 'add' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+ }
+
+ static int insert(lua_State* L) {
+ return luaL_error(L, "sol: cannot call 'insert' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+ }
+
+ static int find(lua_State* L) {
+ return luaL_error(L, "sol: cannot call 'find' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+ }
+
+ static int index_of(lua_State* L) {
+ return luaL_error(L, "sol: cannot call 'index_of' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+ }
+
+ static int size(lua_State* L) {
+ return luaL_error(L, "sol: cannot call 'end' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+ }
+
+ static int clear(lua_State* L) {
+ return luaL_error(L, "sol: cannot call 'clear' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+ }
+
+ static int empty(lua_State* L) {
+ return luaL_error(L, "sol: cannot call 'empty' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+ }
+
+ static int erase(lua_State* L) {
+ return luaL_error(L, "sol: cannot call 'erase' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+ }
+
+ static int next(lua_State* L) {
+ return luaL_error(L, "sol: cannot call 'next' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+ }
+
+ static int pairs(lua_State* L) {
+ return luaL_error(L, "sol: cannot call '__pairs/pairs' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+ }
+
+ static int ipairs(lua_State* L) {
+ return luaL_error(L, "sol: cannot call '__ipairs' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+ }
+
+ static iterator begin(lua_State* L, T&) {
+ luaL_error(L, "sol: cannot call 'being' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+ return lua_nil;
+ }
+
+ static iterator end(lua_State* L, T&) {
+ luaL_error(L, "sol: cannot call 'end' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+ return lua_nil;
+ }
+ };
+
+ template <typename X>
+ struct usertype_container_default<X,
+ std::enable_if_t<meta::all<is_forced_container<meta::unqualified_t<X>>, meta::has_value_type<meta::unqualified_t<container_decay_t<X>>>,
+ meta::has_iterator<meta::unqualified_t<container_decay_t<X>>>>::value>> {
+ private:
+ using T = std::remove_pointer_t<meta::unwrap_unqualified_t<container_decay_t<X>>>;
+
+ private:
+ using deferred_uc = usertype_container<X>;
+ using is_associative = meta::is_associative<T>;
+ using is_lookup = meta::is_lookup<T>;
+ using is_ordered = meta::is_ordered<T>;
+ using is_matched_lookup = meta::is_matched_lookup<T>;
+ using iterator = typename T::iterator;
+ using value_type = typename T::value_type;
+ typedef meta::conditional_t<is_matched_lookup::value, std::pair<value_type, value_type>,
+ meta::conditional_t<is_associative::value || is_lookup::value, value_type, std::pair<std::ptrdiff_t, value_type>>>
+ KV;
+ typedef typename KV::first_type K;
+ typedef typename KV::second_type V;
+ typedef meta::conditional_t<is_matched_lookup::value, std::ptrdiff_t, K> next_K;
+ typedef decltype(*std::declval<iterator&>()) iterator_return;
+ typedef meta::conditional_t<is_associative::value || is_matched_lookup::value, std::add_lvalue_reference_t<V>,
+ meta::conditional_t<is_lookup::value, V, iterator_return>>
+ captured_type;
+ typedef typename meta::iterator_tag<iterator>::type iterator_category;
+ typedef std::is_same<iterator_category, std::input_iterator_tag> is_input_iterator;
+ typedef meta::conditional_t<is_input_iterator::value, V, decltype(detail::deref_move_only(std::declval<captured_type>()))> push_type;
+ typedef std::is_copy_assignable<V> is_copyable;
+ typedef meta::neg<meta::any<std::is_const<V>, std::is_const<std::remove_reference_t<iterator_return>>, meta::neg<is_copyable>>> is_writable;
+ typedef meta::unqualified_t<decltype(get_key(is_associative(), std::declval<std::add_lvalue_reference_t<value_type>>()))> key_type;
+ typedef meta::all<std::is_integral<K>, meta::neg<meta::any<is_associative, is_lookup>>> is_linear_integral;
+
+ struct iter {
+ T& source;
+ iterator it;
+ std::size_t i;
+
+ iter(T& source, iterator it) : source(source), it(std::move(it)), i(0) {
+ }
+
+ ~iter() {
+ }
+ };
+
+ static auto& get_src(lua_State* L) {
+#if SOL_IS_ON(SOL_SAFE_USERTYPE_I_)
+ auto p = stack::unqualified_check_get<T*>(L, 1);
+ if (!p) {
+ luaL_error(L,
+ "sol: 'self' is not of type '%s' (pass 'self' as first argument with ':' or call on proper type)",
+ detail::demangle<T>().c_str());
+ }
+ if (p.value() == nullptr) {
+ luaL_error(
+ L, "sol: 'self' argument is nil (pass 'self' as first argument with ':' or call on a '%s' type)", detail::demangle<T>().c_str());
+ }
+ return *p.value();
+#else
+ return stack::unqualified_get<T>(L, 1);
+#endif // Safe getting with error
+ }
+
+ static detail::error_result at_category(std::input_iterator_tag, lua_State* L, T& self, std::ptrdiff_t pos) {
+ pos += deferred_uc::index_adjustment(L, self);
+ if (pos < 0) {
+ return stack::push(L, lua_nil);
+ }
+ auto it = deferred_uc::begin(L, self);
+ auto e = deferred_uc::end(L, self);
+ if (it == e) {
+ return stack::push(L, lua_nil);
+ }
+ while (pos > 0) {
+ --pos;
+ ++it;
+ if (it == e) {
+ return stack::push(L, lua_nil);
+ }
+ }
+ return get_associative(is_associative(), L, it);
+ }
+
+ static detail::error_result at_category(std::random_access_iterator_tag, lua_State* L, T& self, std::ptrdiff_t pos) {
+ std::ptrdiff_t len = static_cast<std::ptrdiff_t>(size_start(L, self));
+ pos += deferred_uc::index_adjustment(L, self);
+ if (pos < 0 || pos >= len) {
+ return stack::push(L, lua_nil);
+ }
+ auto it = std::next(deferred_uc::begin(L, self), pos);
+ return get_associative(is_associative(), L, it);
+ }
+
+ static detail::error_result at_start(lua_State* L, T& self, std::ptrdiff_t pos) {
+ return at_category(iterator_category(), L, self, pos);
+ }
+
+ template <typename Iter>
+ static detail::error_result get_associative(std::true_type, lua_State* L, Iter& it) {
+ decltype(auto) v = *it;
+ return stack::stack_detail::push_reference<push_type>(L, detail::deref_move_only(v.second));
+ }
+
+ template <typename Iter>
+ static detail::error_result get_associative(std::false_type, lua_State* L, Iter& it) {
+ return stack::stack_detail::push_reference<push_type>(L, detail::deref_move_only(*it));
+ }
+
+ static detail::error_result get_category(std::input_iterator_tag, lua_State* L, T& self, K& key) {
+ key += deferred_uc::index_adjustment(L, self);
+ if (key < 0) {
+ return stack::push(L, lua_nil);
+ }
+ auto it = deferred_uc::begin(L, self);
+ auto e = deferred_uc::end(L, self);
+ if (it == e) {
+ return stack::push(L, lua_nil);
+ }
+ while (key > 0) {
+ --key;
+ ++it;
+ if (it == e) {
+ return stack::push(L, lua_nil);
+ }
+ }
+ return get_associative(is_associative(), L, it);
+ }
+
+ static detail::error_result get_category(std::random_access_iterator_tag, lua_State* L, T& self, K& key) {
+ std::ptrdiff_t len = static_cast<std::ptrdiff_t>(size_start(L, self));
+ key += deferred_uc::index_adjustment(L, self);
+ if (key < 0 || key >= len) {
+ return stack::push(L, lua_nil);
+ }
+ auto it = std::next(deferred_uc::begin(L, self), key);
+ return get_associative(is_associative(), L, it);
+ }
+
+ static detail::error_result get_it(std::true_type, lua_State* L, T& self, K& key) {
+ return get_category(iterator_category(), L, self, key);
+ }
+
+ static detail::error_result get_comparative(std::true_type, lua_State* L, T& self, K& key) {
+ auto fx = [&](const value_type& r) -> bool { return key == get_key(is_associative(), r); };
+ auto e = deferred_uc::end(L, self);
+ auto it = std::find_if(deferred_uc::begin(L, self), e, std::ref(fx));
+ if (it == e) {
+ return stack::push(L, lua_nil);
+ }
+ return get_associative(is_associative(), L, it);
+ }
+
+ static detail::error_result get_comparative(std::false_type, lua_State*, T&, K&) {
+ return detail::error_result("cannot get this key on '%s': no suitable way to increment iterator and compare to key value '%s'",
+ detail::demangle<T>().data(),
+ detail::demangle<K>().data());
+ }
+
+ static detail::error_result get_it(std::false_type, lua_State* L, T& self, K& key) {
+ return get_comparative(meta::supports_op_equal<K, key_type>(), L, self, key);
+ }
+
+ static detail::error_result set_associative(std::true_type, iterator& it, stack_object value) {
+ decltype(auto) v = *it;
+ v.second = value.as<V>();
+ return {};
+ }
+
+ static detail::error_result set_associative(std::false_type, iterator& it, stack_object value) {
+ decltype(auto) v = *it;
+ v = value.as<V>();
+ return {};
+ }
+
+ static detail::error_result set_writable(std::true_type, lua_State*, T&, iterator& it, stack_object value) {
+ return set_associative(is_associative(), it, std::move(value));
+ }
+
+ static detail::error_result set_writable(std::false_type, lua_State*, T&, iterator&, stack_object) {
+ return detail::error_result(
+ "cannot perform a 'set': '%s's iterator reference is not writable (non-copy-assignable or const)", detail::demangle<T>().data());
+ }
+
+ static detail::error_result set_category(std::input_iterator_tag, lua_State* L, T& self, stack_object okey, stack_object value) {
+ decltype(auto) key = okey.as<K>();
+ key += deferred_uc::index_adjustment(L, self);
+ auto e = deferred_uc::end(L, self);
+ auto it = deferred_uc::begin(L, self);
+ auto backit = it;
+ for (; key > 0 && it != e; --key, ++it) {
+ backit = it;
+ }
+ if (it == e) {
+ if (key == 0) {
+ return add_copyable(is_copyable(), L, self, std::move(value), meta::has_insert_after<T>::value ? backit : it);
+ }
+ return detail::error_result("out of bounds (too big) for set on '%s'", detail::demangle<T>().c_str());
+ }
+ return set_writable(is_writable(), L, self, it, std::move(value));
+ }
+
+ static detail::error_result set_category(std::random_access_iterator_tag, lua_State* L, T& self, stack_object okey, stack_object value) {
+ decltype(auto) key = okey.as<K>();
+ key += deferred_uc::index_adjustment(L, self);
+ if (key < 0) {
+ return detail::error_result("sol: out of bounds (too small) for set on '%s'", detail::demangle<T>().c_str());
+ }
+ std::ptrdiff_t len = static_cast<std::ptrdiff_t>(size_start(L, self));
+ if (key == len) {
+ return add_copyable(is_copyable(), L, self, std::move(value));
+ }
+ else if (key >= len) {
+ return detail::error_result("sol: out of bounds (too big) for set on '%s'", detail::demangle<T>().c_str());
+ }
+ auto it = std::next(deferred_uc::begin(L, self), key);
+ return set_writable(is_writable(), L, self, it, std::move(value));
+ }
+
+ static detail::error_result set_comparative(std::true_type, lua_State* L, T& self, stack_object okey, stack_object value) {
+ decltype(auto) key = okey.as<K>();
+ if (!is_writable::value) {
+ return detail::error_result(
+ "cannot perform a 'set': '%s's iterator reference is not writable (non-copy-assignable or const)", detail::demangle<T>().data());
+ }
+ auto fx = [&](const value_type& r) -> bool { return key == get_key(is_associative(), r); };
+ auto e = deferred_uc::end(L, self);
+ auto it = std::find_if(deferred_uc::begin(L, self), e, std::ref(fx));
+ if (it == e) {
+ return {};
+ }
+ return set_writable(is_writable(), L, self, it, std::move(value));
+ }
+
+ static detail::error_result set_comparative(std::false_type, lua_State*, T&, stack_object, stack_object) {
+ return detail::error_result("cannot set this value on '%s': no suitable way to increment iterator or compare to '%s' key",
+ detail::demangle<T>().data(),
+ detail::demangle<K>().data());
+ }
+
+ template <typename Iter>
+ static detail::error_result set_associative_insert(std::true_type, lua_State*, T& self, Iter& it, K& key, stack_object value) {
+ if constexpr (meta::has_insert<T>::value) {
+ self.insert(it, value_type(key, value.as<V>()));
+ return {};
+ }
+ else {
+ (void)self;
+ (void)it;
+ (void)key;
+ return detail::error_result(
+ "cannot call 'set' on '%s': there is no 'insert' function on this associative type", detail::demangle<T>().c_str());
+ }
+ }
+
+ template <typename Iter>
+ static detail::error_result set_associative_insert(std::false_type, lua_State*, T& self, Iter& it, K& key, stack_object) {
+ if constexpr (meta::has_insert<T>::value) {
+ self.insert(it, key);
+ return {};
+ }
+ else {
+ (void)self;
+ (void)it;
+ (void)key;
+ return detail::error_result(
+ "cannot call 'set' on '%s': there is no 'insert' function on this non-associative type", detail::demangle<T>().c_str());
+ }
+ }
+
+ static detail::error_result set_associative_find(std::true_type, lua_State* L, T& self, stack_object okey, stack_object value) {
+ decltype(auto) key = okey.as<K>();
+ auto it = self.find(key);
+ if (it == deferred_uc::end(L, self)) {
+ return set_associative_insert(is_associative(), L, self, it, key, std::move(value));
+ }
+ return set_writable(is_writable(), L, self, it, std::move(value));
+ }
+
+ static detail::error_result set_associative_find(std::false_type, lua_State* L, T& self, stack_object key, stack_object value) {
+ return set_comparative(meta::supports_op_equal<K, key_type>(), L, self, std::move(key), std::move(value));
+ }
+
+ static detail::error_result set_it(std::true_type, lua_State* L, T& self, stack_object key, stack_object value) {
+ return set_category(iterator_category(), L, self, std::move(key), std::move(value));
+ }
+
+ static detail::error_result set_it(std::false_type, lua_State* L, T& self, stack_object key, stack_object value) {
+ return set_associative_find(meta::all<has_find<T>, meta::any<is_associative, is_lookup>>(), L, self, std::move(key), std::move(value));
+ }
+
+ template <bool idx_of = false>
+ static detail::error_result find_has_associative_lookup(std::true_type, lua_State* L, T& self) {
+ if constexpr (!is_ordered::value && idx_of) {
+ (void)L;
+ (void)self;
+ return detail::error_result("cannot perform an 'index_of': '%s's is not an ordered container", detail::demangle<T>().data());
+ }
+ else {
+ decltype(auto) key = stack::unqualified_get<K>(L, 2);
+ auto it = self.find(key);
+ if (it == deferred_uc::end(L, self)) {
+ return stack::push(L, lua_nil);
+ }
+ if constexpr (idx_of) {
+ auto dist = std::distance(deferred_uc::begin(L, self), it);
+ dist -= deferred_uc::index_adjustment(L, self);
+ return stack::push(L, dist);
+ }
+ else {
+ return get_associative(is_associative(), L, it);
+ }
+ }
+ }
+
+ template <bool idx_of = false>
+ static detail::error_result find_has_associative_lookup(std::false_type, lua_State* L, T& self) {
+ if constexpr (!is_ordered::value && idx_of) {
+ (void)L;
+ (void)self;
+ return detail::error_result("cannot perform an 'index_of': '%s's is not an ordered container", detail::demangle<T>().data());
+ }
+ else {
+ decltype(auto) value = stack::unqualified_get<V>(L, 2);
+ auto it = self.find(value);
+ if (it == deferred_uc::end(L, self)) {
+ return stack::push(L, lua_nil);
+ }
+ if constexpr (idx_of) {
+ auto dist = std::distance(deferred_uc::begin(L, self), it);
+ dist -= deferred_uc::index_adjustment(L, self);
+ return stack::push(L, dist);
+ }
+ else {
+ return get_associative(is_associative(), L, it);
+ }
+ }
+ }
+
+ template <bool idx_of = false>
+ static detail::error_result find_has(std::true_type, lua_State* L, T& self) {
+ return find_has_associative_lookup<idx_of>(meta::any<is_lookup, is_associative>(), L, self);
+ }
+
+ template <typename Iter>
+ static detail::error_result find_associative_lookup(std::true_type, lua_State* L, T&, Iter& it, std::size_t) {
+ return get_associative(is_associative(), L, it);
+ }
+
+ template <typename Iter>
+ static detail::error_result find_associative_lookup(std::false_type, lua_State* L, T& self, Iter&, std::size_t idx) {
+ idx -= deferred_uc::index_adjustment(L, self);
+ return stack::push(L, idx);
+ }
+
+ template <bool = false>
+ static detail::error_result find_comparative(std::false_type, lua_State*, T&) {
+ return detail::error_result("cannot call 'find' on '%s': there is no 'find' function and the value_type is not equality comparable",
+ detail::demangle<T>().c_str());
+ }
+
+ template <bool idx_of = false>
+ static detail::error_result find_comparative(std::true_type, lua_State* L, T& self) {
+ decltype(auto) value = stack::unqualified_get<V>(L, 2);
+ auto it = deferred_uc::begin(L, self);
+ auto e = deferred_uc::end(L, self);
+ std::size_t idx = 0;
+ for (;; ++it, ++idx) {
+ if (it == e) {
+ return stack::push(L, lua_nil);
+ }
+ if (value == get_value(is_associative(), *it)) {
+ break;
+ }
+ }
+ return find_associative_lookup(meta::all<meta::boolean<!idx_of>, meta::any<is_lookup, is_associative>>(), L, self, it, idx);
+ }
+
+ template <bool idx_of = false>
+ static detail::error_result find_has(std::false_type, lua_State* L, T& self) {
+ return find_comparative<idx_of>(meta::supports_op_equal<V>(), L, self);
+ }
+
+ template <typename Iter>
+ static detail::error_result add_insert_after(std::false_type, lua_State* L, T& self, stack_object value, Iter&) {
+ return add_insert_after(std::false_type(), L, self, value);
+ }
+
+ static detail::error_result add_insert_after(std::false_type, lua_State*, T&, stack_object) {
+ return detail::error_result("cannot call 'add' on type '%s': no suitable insert/push_back C++ functions", detail::demangle<T>().data());
+ }
+
+ template <typename Iter>
+ static detail::error_result add_insert_after(std::true_type, lua_State*, T& self, stack_object value, Iter& pos) {
+ self.insert_after(pos, value.as<V>());
+ return {};
+ }
+
+ static detail::error_result add_insert_after(std::true_type, lua_State* L, T& self, stack_object value) {
+ auto backit = self.before_begin();
+ {
+ auto e = deferred_uc::end(L, self);
+ for (auto it = deferred_uc::begin(L, self); it != e; ++backit, ++it) {
+ }
+ }
+ return add_insert_after(std::true_type(), L, self, value, backit);
+ }
+
+ template <typename Iter>
+ static detail::error_result add_insert(std::true_type, lua_State*, T& self, stack_object value, Iter& pos) {
+ self.insert(pos, value.as<V>());
+ return {};
+ }
+
+ static detail::error_result add_insert(std::true_type, lua_State* L, T& self, stack_object value) {
+ auto pos = deferred_uc::end(L, self);
+ return add_insert(std::true_type(), L, self, value, pos);
+ }
+
+ template <typename Iter>
+ static detail::error_result add_insert(std::false_type, lua_State* L, T& self, stack_object value, Iter& pos) {
+ return add_insert_after(meta::has_insert_after<T>(), L, self, std::move(value), pos);
+ }
+
+ static detail::error_result add_insert(std::false_type, lua_State* L, T& self, stack_object value) {
+ return add_insert_after(meta::has_insert_after<T>(), L, self, std::move(value));
+ }
+
+ template <typename Iter>
+ static detail::error_result add_push_back(std::true_type, lua_State*, T& self, stack_object value, Iter&) {
+ self.push_back(value.as<V>());
+ return {};
+ }
+
+ static detail::error_result add_push_back(std::true_type, lua_State*, T& self, stack_object value) {
+ self.push_back(value.as<V>());
+ return {};
+ }
+
+ template <typename Iter>
+ static detail::error_result add_push_back(std::false_type, lua_State* L, T& self, stack_object value, Iter& pos) {
+ return add_insert(meta::has_insert<T>(), L, self, value, pos);
+ }
+
+ static detail::error_result add_push_back(std::false_type, lua_State* L, T& self, stack_object value) {
+ return add_insert(meta::has_insert<T>(), L, self, value);
+ }
+
+ template <typename Iter>
+ static detail::error_result add_associative(std::true_type, lua_State* L, T& self, stack_object key, Iter& pos) {
+ if constexpr (meta::has_insert<T>::value) {
+ self.insert(pos, value_type(key.as<K>(), stack::unqualified_get<V>(L, 3)));
+ return {};
+ }
+ else {
+ (void)L;
+ (void)self;
+ (void)key;
+ (void)pos;
+ return detail::error_result(
+ "cannot call 'insert' on '%s': there is no 'insert' function on this associative type", detail::demangle<T>().c_str());
+ }
+ }
+
+ static detail::error_result add_associative(std::true_type, lua_State* L, T& self, stack_object key) {
+ auto pos = deferred_uc::end(L, self);
+ return add_associative(std::true_type(), L, self, std::move(key), pos);
+ }
+
+ template <typename Iter>
+ static detail::error_result add_associative(std::false_type, lua_State* L, T& self, stack_object value, Iter& pos) {
+ return add_push_back(meta::has_push_back<T>(), L, self, value, pos);
+ }
+
+ static detail::error_result add_associative(std::false_type, lua_State* L, T& self, stack_object value) {
+ return add_push_back(meta::has_push_back<T>(), L, self, value);
+ }
+
+ template <typename Iter>
+ static detail::error_result add_copyable(std::true_type, lua_State* L, T& self, stack_object value, Iter& pos) {
+ return add_associative(is_associative(), L, self, std::move(value), pos);
+ }
+
+ static detail::error_result add_copyable(std::true_type, lua_State* L, T& self, stack_object value) {
+ return add_associative(is_associative(), L, self, value);
+ }
+
+ template <typename Iter>
+ static detail::error_result add_copyable(std::false_type, lua_State* L, T& self, stack_object value, Iter&) {
+ return add_copyable(std::false_type(), L, self, std::move(value));
+ }
+
+ static detail::error_result add_copyable(std::false_type, lua_State*, T&, stack_object) {
+ return detail::error_result("cannot call 'add' on '%s': value_type is non-copyable", detail::demangle<T>().data());
+ }
+
+ static detail::error_result insert_lookup(std::true_type, lua_State* L, T& self, stack_object, stack_object value) {
+ // TODO: should we warn or error about someone calling insert on an ordered / lookup container with no associativity?
+ return add_copyable(std::true_type(), L, self, std::move(value));
+ }
+
+ static detail::error_result insert_lookup(std::false_type, lua_State* L, T& self, stack_object where, stack_object value) {
+ auto it = deferred_uc::begin(L, self);
+ auto key = where.as<K>();
+ key += deferred_uc::index_adjustment(L, self);
+ std::advance(it, key);
+ self.insert(it, value.as<V>());
+ return {};
+ }
+
+ static detail::error_result insert_after_has(std::true_type, lua_State* L, T& self, stack_object where, stack_object value) {
+ auto key = where.as<K>();
+ auto backit = self.before_begin();
+ {
+ key += deferred_uc::index_adjustment(L, self);
+ auto e = deferred_uc::end(L, self);
+ for (auto it = deferred_uc::begin(L, self); key > 0; ++backit, ++it, --key) {
+ if (backit == e) {
+ return detail::error_result("sol: out of bounds (too big) for set on '%s'", detail::demangle<T>().c_str());
+ }
+ }
+ }
+ self.insert_after(backit, value.as<V>());
+ return {};
+ }
+
+ static detail::error_result insert_after_has(std::false_type, lua_State*, T&, stack_object, stack_object) {
+ return detail::error_result(
+ "cannot call 'insert' on '%s': no suitable or similar functionality detected on this container", detail::demangle<T>().data());
+ }
+
+ static detail::error_result insert_has(std::true_type, lua_State* L, T& self, stack_object key, stack_object value) {
+ return insert_lookup(meta::any<is_associative, is_lookup>(), L, self, std::move(key), std::move(value));
+ }
+
+ static detail::error_result insert_has(std::false_type, lua_State* L, T& self, stack_object where, stack_object value) {
+ return insert_after_has(meta::has_insert_after<T>(), L, self, where, value);
+ }
+
+ static detail::error_result insert_copyable(std::true_type, lua_State* L, T& self, stack_object key, stack_object value) {
+ return insert_has(meta::has_insert<T>(), L, self, std::move(key), std::move(value));
+ }
+
+ static detail::error_result insert_copyable(std::false_type, lua_State*, T&, stack_object, stack_object) {
+ return detail::error_result("cannot call 'insert' on '%s': value_type is non-copyable", detail::demangle<T>().data());
+ }
+
+ static detail::error_result erase_integral(std::true_type, lua_State* L, T& self, K& key) {
+ auto it = deferred_uc::begin(L, self);
+ key += deferred_uc::index_adjustment(L, self);
+ std::advance(it, key);
+ self.erase(it);
+
+ return {};
+ }
+
+ static detail::error_result erase_integral(std::false_type, lua_State* L, T& self, const K& key) {
+ auto fx = [&](const value_type& r) -> bool { return key == r; };
+ auto e = deferred_uc::end(L, self);
+ auto it = std::find_if(deferred_uc::begin(L, self), e, std::ref(fx));
+ if (it == e) {
+ return {};
+ }
+ self.erase(it);
+
+ return {};
+ }
+
+ static detail::error_result erase_associative_lookup(std::true_type, lua_State*, T& self, const K& key) {
+ self.erase(key);
+ return {};
+ }
+
+ static detail::error_result erase_associative_lookup(std::false_type, lua_State* L, T& self, K& key) {
+ return erase_integral(std::is_integral<K>(), L, self, key);
+ }
+
+ static detail::error_result erase_after_has(std::true_type, lua_State* L, T& self, K& key) {
+ auto backit = self.before_begin();
+ {
+ key += deferred_uc::index_adjustment(L, self);
+ auto e = deferred_uc::end(L, self);
+ for (auto it = deferred_uc::begin(L, self); key > 0; ++backit, ++it, --key) {
+ if (backit == e) {
+ return detail::error_result("sol: out of bounds for erase on '%s'", detail::demangle<T>().c_str());
+ }
+ }
+ }
+ self.erase_after(backit);
+ return {};
+ }
+
+ static detail::error_result erase_after_has(std::false_type, lua_State*, T&, const K&) {
+ return detail::error_result("sol: cannot call erase on '%s'", detail::demangle<T>().c_str());
+ }
+
+ static detail::error_result erase_key_has(std::true_type, lua_State* L, T& self, K& key) {
+ return erase_associative_lookup(meta::any<is_associative, is_lookup>(), L, self, key);
+ }
+
+ static detail::error_result erase_key_has(std::false_type, lua_State* L, T& self, K& key) {
+ return erase_after_has(has_erase_after<T>(), L, self, key);
+ }
+
+ static detail::error_result erase_has(std::true_type, lua_State* L, T& self, K& key) {
+ return erase_associative_lookup(meta::any<is_associative, is_lookup>(), L, self, key);
+ }
+
+ static detail::error_result erase_has(std::false_type, lua_State* L, T& self, K& key) {
+ return erase_key_has(has_erase_key<T>(), L, self, key);
+ }
+
+ static auto size_has(std::false_type, lua_State* L, T& self) {
+ return std::distance(deferred_uc::begin(L, self), deferred_uc::end(L, self));
+ }
+
+ static auto size_has(std::true_type, lua_State*, T& self) {
+ return self.size();
+ }
+
+ static void clear_has(std::true_type, lua_State*, T& self) {
+ self.clear();
+ }
+
+ static void clear_has(std::false_type, lua_State* L, T&) {
+ luaL_error(L, "sol: cannot call clear on '%s'", detail::demangle<T>().c_str());
+ }
+
+ static bool empty_has(std::true_type, lua_State*, T& self) {
+ return self.empty();
+ }
+
+ static bool empty_has(std::false_type, lua_State* L, T& self) {
+ return deferred_uc::begin(L, self) == deferred_uc::end(L, self);
+ }
+
+ static detail::error_result get_associative_find(std::true_type, lua_State* L, T& self, K& key) {
+ auto it = self.find(key);
+ if (it == deferred_uc::end(L, self)) {
+ stack::push(L, lua_nil);
+ return {};
+ }
+ return get_associative(std::true_type(), L, it);
+ }
+
+ static detail::error_result get_associative_find(std::false_type, lua_State* L, T& self, K& key) {
+ return get_it(is_linear_integral(), L, self, key);
+ }
+
+ static detail::error_result get_start(lua_State* L, T& self, K& key) {
+ return get_associative_find(std::integral_constant < bool, is_associative::value&& has_find<T>::value > (), L, self, key);
+ }
+
+ static detail::error_result set_start(lua_State* L, T& self, stack_object key, stack_object value) {
+ return set_it(is_linear_integral(), L, self, std::move(key), std::move(value));
+ }
+
+ static std::size_t size_start(lua_State* L, T& self) {
+ return size_has(meta::has_size<T>(), L, self);
+ }
+
+ static void clear_start(lua_State* L, T& self) {
+ clear_has(has_clear<T>(), L, self);
+ }
+
+ static bool empty_start(lua_State* L, T& self) {
+ return empty_has(has_empty<T>(), L, self);
+ }
+
+ static detail::error_result erase_start(lua_State* L, T& self, K& key) {
+ return erase_has(has_erase<T>(), L, self, key);
+ }
+
+ template <bool ip>
+ static int next_associative(std::true_type, lua_State* L) {
+ iter& i = stack::unqualified_get<user<iter>>(L, 1);
+ auto& source = i.source;
+ auto& it = i.it;
+ if (it == deferred_uc::end(L, source)) {
+ return stack::push(L, lua_nil);
+ }
+ int p;
+ if constexpr (ip) {
+ ++i.i;
+ p = stack::push_reference(L, i.i);
+ }
+ else {
+ p = stack::push_reference(L, it->first);
+ }
+ p += stack::stack_detail::push_reference<push_type>(L, detail::deref_move_only(it->second));
+ std::advance(it, 1);
+ return p;
+ }
+
+ template <bool>
+ static int next_associative(std::false_type, lua_State* L) {
+ iter& i = stack::unqualified_get<user<iter>>(L, 1);
+ auto& source = i.source;
+ auto& it = i.it;
+ next_K k = stack::unqualified_get<next_K>(L, 2);
+ if (it == deferred_uc::end(L, source)) {
+ return stack::push(L, lua_nil);
+ }
+ int p;
+ if constexpr (std::is_integral_v<next_K>) {
+ p = stack::push_reference(L, k + 1);
+ }
+ else {
+ p = stack::stack_detail::push_reference(L, k + 1);
+ }
+ p += stack::stack_detail::push_reference<push_type>(L, detail::deref_move_only(*it));
+ std::advance(it, 1);
+ return p;
+ }
+
+ template <bool ip>
+ static int next_iter(lua_State* L) {
+ typedef meta::any<is_associative, meta::all<is_lookup, meta::neg<is_matched_lookup>>> is_assoc;
+ return next_associative<ip>(is_assoc(), L);
+ }
+
+ template <bool ip>
+ static int pairs_associative(std::true_type, lua_State* L) {
+ auto& src = get_src(L);
+ stack::push(L, next_iter<ip>);
+ stack::push<user<iter>>(L, src, deferred_uc::begin(L, src));
+ stack::push(L, lua_nil);
+ return 3;
+ }
+
+ template <bool ip>
+ static int pairs_associative(std::false_type, lua_State* L) {
+ auto& src = get_src(L);
+ stack::push(L, next_iter<ip>);
+ stack::push<user<iter>>(L, src, deferred_uc::begin(L, src));
+ stack::push(L, 0);
+ return 3;
+ }
+
+ public:
+ static int at(lua_State* L) {
+ auto& self = get_src(L);
+ detail::error_result er;
+ {
+ std::ptrdiff_t pos = stack::unqualified_get<std::ptrdiff_t>(L, 2);
+ er = at_start(L, self, pos);
+ }
+ return handle_errors(L, er);
+ }
+
+ static int get(lua_State* L) {
+ auto& self = get_src(L);
+ detail::error_result er;
+ {
+ decltype(auto) key = stack::unqualified_get<K>(L);
+ er = get_start(L, self, key);
+ }
+ return handle_errors(L, er);
+ }
+
+ static int index_get(lua_State* L) {
+ return get(L);
+ }
+
+ static int set(lua_State* L) {
+ stack_object value = stack_object(L, raw_index(3));
+ if constexpr (is_linear_integral::value) {
+ // for non-associative containers,
+ // erasure only happens if it is the
+ // last index in the container
+ auto key = stack::get<K>(L, 2);
+ auto self_size = deferred_uc::size(L);
+ if (key == static_cast<K>(self_size)) {
+ if (type_of(L, 3) == type::lua_nil) {
+ return erase(L);
+ }
+ }
+ }
+ else {
+ if (type_of(L, 3) == type::lua_nil) {
+ return erase(L);
+ }
+ }
+ auto& self = get_src(L);
+ detail::error_result er = set_start(L, self, stack_object(L, raw_index(2)), std::move(value));
+ return handle_errors(L, er);
+ }
+
+ static int index_set(lua_State* L) {
+ return set(L);
+ }
+
+ static int add(lua_State* L) {
+ auto& self = get_src(L);
+ detail::error_result er = add_copyable(is_copyable(), L, self, stack_object(L, raw_index(2)));
+ return handle_errors(L, er);
+ }
+
+ static int insert(lua_State* L) {
+ auto& self = get_src(L);
+ detail::error_result er = insert_copyable(is_copyable(), L, self, stack_object(L, raw_index(2)), stack_object(L, raw_index(3)));
+ return handle_errors(L, er);
+ }
+
+ static int find(lua_State* L) {
+ auto& self = get_src(L);
+ detail::error_result er = find_has(has_find<T>(), L, self);
+ return handle_errors(L, er);
+ }
+
+ static int index_of(lua_State* L) {
+ auto& self = get_src(L);
+ detail::error_result er = find_has<true>(has_find<T>(), L, self);
+ return handle_errors(L, er);
+ }
+
+ static iterator begin(lua_State*, T& self) {
+ if constexpr (meta::has_begin_end_v<T>) {
+ return self.begin();
+ }
+ else {
+ using std::begin;
+ return begin(self);
+ }
+ }
+
+ static iterator end(lua_State*, T& self) {
+ if constexpr (meta::has_begin_end_v<T>) {
+ return self.end();
+ }
+ else {
+ using std::end;
+ return end(self);
+ }
+ }
+
+ static int size(lua_State* L) {
+ auto& self = get_src(L);
+ std::size_t r = size_start(L, self);
+ return stack::push(L, r);
+ }
+
+ static int clear(lua_State* L) {
+ auto& self = get_src(L);
+ clear_start(L, self);
+ return 0;
+ }
+
+ static int erase(lua_State* L) {
+ auto& self = get_src(L);
+ detail::error_result er;
+ {
+ decltype(auto) key = stack::unqualified_get<K>(L, 2);
+ er = erase_start(L, self, key);
+ }
+ return handle_errors(L, er);
+ }
+
+ static int empty(lua_State* L) {
+ auto& self = get_src(L);
+ return stack::push(L, empty_start(L, self));
+ }
+
+ static std::ptrdiff_t index_adjustment(lua_State*, T&) {
+ return static_cast<std::ptrdiff_t>((SOL_CONTAINER_START_INDEX_I_) == 0 ? 0 : -(SOL_CONTAINER_START_INDEX_I_));
+ }
+
+ static int pairs(lua_State* L) {
+ typedef meta::any<is_associative, meta::all<is_lookup, meta::neg<is_matched_lookup>>> is_assoc;
+ return pairs_associative<false>(is_assoc(), L);
+ }
+
+ static int ipairs(lua_State* L) {
+ typedef meta::any<is_associative, meta::all<is_lookup, meta::neg<is_matched_lookup>>> is_assoc;
+ return pairs_associative<true>(is_assoc(), L);
+ }
+
+ static int next(lua_State* L) {
+ return stack::push(L, next_iter<false>);
+ }
+ };
+
+ template <typename X>
+ struct usertype_container_default<X, std::enable_if_t<std::is_array<std::remove_pointer_t<meta::unwrap_unqualified_t<X>>>::value>> {
+ private:
+ typedef std::remove_pointer_t<meta::unwrap_unqualified_t<X>> T;
+ typedef usertype_container<X> deferred_uc;
+
+ public:
+ typedef std::remove_extent_t<T> value_type;
+ typedef value_type* iterator;
+
+ private:
+ struct iter {
+ T& source;
+ iterator it;
+
+ iter(T& source, iterator it) : source(source), it(std::move(it)) {
+ }
+ };
+
+ static auto& get_src(lua_State* L) {
+ auto p = stack::unqualified_check_get<T*>(L, 1);
+#if SOL_IS_ON(SOL_SAFE_USERTYPE_I_)
+ if (!p) {
+ luaL_error(L,
+ "sol: 'self' is not of type '%s' (pass 'self' as first argument with ':' or call on proper type)",
+ detail::demangle<T>().c_str());
+ }
+ if (p.value() == nullptr) {
+ luaL_error(
+ L, "sol: 'self' argument is nil (pass 'self' as first argument with ':' or call on a '%s' type)", detail::demangle<T>().c_str());
+ }
+#endif // Safe getting with error
+ return *p.value();
+ }
+
+ static int find(std::true_type, lua_State* L) {
+ T& self = get_src(L);
+ decltype(auto) value = stack::unqualified_get<value_type>(L, 2);
+ std::size_t N = std::extent<T>::value;
+ for (std::size_t idx = 0; idx < N; ++idx) {
+ using v_t = std::add_const_t<decltype(self[idx])>;
+ v_t v = self[idx];
+ if (v == value) {
+ idx -= deferred_uc::index_adjustment(L, self);
+ return stack::push(L, idx);
+ }
+ }
+ return stack::push(L, lua_nil);
+ }
+
+ static int find(std::false_type, lua_State* L) {
+ return luaL_error(L, "sol: cannot call 'find' on '%s': no supported comparison operator for the value type", detail::demangle<T>().c_str());
+ }
+
+ static int next_iter(lua_State* L) {
+ iter& i = stack::unqualified_get<user<iter>>(L, 1);
+ auto& source = i.source;
+ auto& it = i.it;
+ std::size_t k = stack::unqualified_get<std::size_t>(L, 2);
+ if (it == deferred_uc::end(L, source)) {
+ return 0;
+ }
+ int p;
+ p = stack::push(L, k + 1);
+ p += stack::push_reference(L, detail::deref_move_only(*it));
+ std::advance(it, 1);
+ return p;
+ }
+
+ public:
+ static int clear(lua_State* L) {
+ return luaL_error(L, "sol: cannot call 'clear' on type '%s': cannot remove all items from a fixed array", detail::demangle<T>().c_str());
+ }
+
+ static int erase(lua_State* L) {
+ return luaL_error(L, "sol: cannot call 'erase' on type '%s': cannot remove an item from fixed arrays", detail::demangle<T>().c_str());
+ }
+
+ static int add(lua_State* L) {
+ return luaL_error(L, "sol: cannot call 'add' on type '%s': cannot add to fixed arrays", detail::demangle<T>().c_str());
+ }
+
+ static int insert(lua_State* L) {
+ return luaL_error(L, "sol: cannot call 'insert' on type '%s': cannot insert new entries into fixed arrays", detail::demangle<T>().c_str());
+ }
+
+ static int at(lua_State* L) {
+ return get(L);
+ }
+
+ static int get(lua_State* L) {
+ T& self = get_src(L);
+ std::ptrdiff_t idx = stack::unqualified_get<std::ptrdiff_t>(L, 2);
+ idx += deferred_uc::index_adjustment(L, self);
+ if (idx >= static_cast<std::ptrdiff_t>(std::extent<T>::value) || idx < 0) {
+ return stack::push(L, lua_nil);
+ }
+ return stack::push_reference(L, detail::deref_move_only(self[idx]));
+ }
+
+ static int index_get(lua_State* L) {
+ return get(L);
+ }
+
+ static int set(lua_State* L) {
+ T& self = get_src(L);
+ std::ptrdiff_t idx = stack::unqualified_get<std::ptrdiff_t>(L, 2);
+ idx += deferred_uc::index_adjustment(L, self);
+ if (idx >= static_cast<std::ptrdiff_t>(std::extent<T>::value)) {
+ return luaL_error(L, "sol: index out of bounds (too big) for set on '%s'", detail::demangle<T>().c_str());
+ }
+ if (idx < 0) {
+ return luaL_error(L, "sol: index out of bounds (too small) for set on '%s'", detail::demangle<T>().c_str());
+ }
+ self[idx] = stack::unqualified_get<value_type>(L, 3);
+ return 0;
+ }
+
+ static int index_set(lua_State* L) {
+ return set(L);
+ }
+
+ static int index_of(lua_State* L) {
+ return find(L);
+ }
+
+ static int find(lua_State* L) {
+ return find(meta::supports_op_equal<value_type, value_type>(), L);
+ }
+
+ static int size(lua_State* L) {
+ return stack::push(L, std::extent<T>::value);
+ }
+
+ static int empty(lua_State* L) {
+ return stack::push(L, std::extent<T>::value > 0);
+ }
+
+ static int pairs(lua_State* L) {
+ auto& src = get_src(L);
+ stack::push(L, next_iter);
+ stack::push<user<iter>>(L, src, deferred_uc::begin(L, src));
+ stack::push(L, 0);
+ return 3;
+ }
+
+ static int ipairs(lua_State* L) {
+ return pairs(L);
+ }
+
+ static int next(lua_State* L) {
+ return stack::push(L, next_iter);
+ }
+
+ static std::ptrdiff_t index_adjustment(lua_State*, T&) {
+ return (SOL_CONTAINER_START_INDEX_I_) == 0 ? 0 : -(SOL_CONTAINER_START_INDEX_I_);
+ }
+
+ static iterator begin(lua_State*, T& self) {
+ return std::addressof(self[0]);
+ }
+
+ static iterator end(lua_State*, T& self) {
+ return std::addressof(self[0]) + std::extent<T>::value;
+ }
+ };
+
+ template <typename X>
+ struct usertype_container_default<usertype_container<X>> : usertype_container_default<X> {};
+ } // namespace container_detail
+
+ template <typename T>
+ struct usertype_container : container_detail::usertype_container_default<T> {};
+
+} // namespace sol
+
+// end of sol/usertype_container.hpp
+
+#include <unordered_map>
+
+namespace sol {
+
+ namespace container_detail {
+ template <typename X>
+ struct u_c_launch {
+ using T = std::remove_pointer_t<meta::unqualified_t<X>>;
+ using uc = usertype_container<T>;
+ using default_uc = usertype_container_default<T>;
+
+ static inline int real_index_get_traits(std::true_type, lua_State* L) {
+ return uc::index_get(L);
+ }
+
+ static inline int real_index_get_traits(std::false_type, lua_State* L) {
+ return default_uc::index_get(L);
+ }
+
+ static inline int real_index_call(lua_State* L) {
+ static const std::unordered_map<string_view, lua_CFunction> calls {
+ { "at", &real_at_call },
+ { "get", &real_get_call },
+ { "set", &real_set_call },
+ { "size", &real_length_call },
+ { "add", &real_add_call },
+ { "empty", &real_empty_call },
+ { "insert", &real_insert_call },
+ { "clear", &real_clear_call },
+ { "find", &real_find_call },
+ { "index_of", &real_index_of_call },
+ { "erase", &real_erase_call },
+ { "pairs", &pairs_call },
+ { "next", &next_call },
+ };
+ auto maybenameview = stack::unqualified_check_get<string_view>(L, 2);
+ if (maybenameview) {
+ const string_view& name = *maybenameview;
+ auto it = calls.find(name);
+ if (it != calls.cend()) {
+ return stack::push(L, it->second);
+ }
+ }
+ return real_index_get_traits(container_detail::has_traits_index_get<uc>(), L);
+ }
+
+ static inline int real_at_traits(std::true_type, lua_State* L) {
+ return uc::at(L);
+ }
+
+ static inline int real_at_traits(std::false_type, lua_State* L) {
+ return default_uc::at(L);
+ }
+
+ static inline int real_at_call(lua_State* L) {
+ return real_at_traits(container_detail::has_traits_at<uc>(), L);
+ }
+
+ static inline int real_get_traits(std::true_type, lua_State* L) {
+ return uc::get(L);
+ }
+
+ static inline int real_get_traits(std::false_type, lua_State* L) {
+ return default_uc::get(L);
+ }
+
+ static inline int real_get_call(lua_State* L) {
+ return real_get_traits(container_detail::has_traits_get<uc>(), L);
+ }
+
+ static inline int real_set_traits(std::true_type, lua_State* L) {
+ return uc::set(L);
+ }
+
+ static inline int real_set_traits(std::false_type, lua_State* L) {
+ return default_uc::set(L);
+ }
+
+ static inline int real_set_call(lua_State* L) {
+ return real_set_traits(container_detail::has_traits_set<uc>(), L);
+ }
+
+ static inline int real_index_set_traits(std::true_type, lua_State* L) {
+ return uc::index_set(L);
+ }
+
+ static inline int real_index_set_traits(std::false_type, lua_State* L) {
+ return default_uc::index_set(L);
+ }
+
+ static inline int real_new_index_call(lua_State* L) {
+ return real_index_set_traits(container_detail::has_traits_index_set<uc>(), L);
+ }
+
+ static inline int real_pairs_traits(std::true_type, lua_State* L) {
+ return uc::pairs(L);
+ }
+
+ static inline int real_pairs_traits(std::false_type, lua_State* L) {
+ return default_uc::pairs(L);
+ }
+
+ static inline int real_pairs_call(lua_State* L) {
+ return real_pairs_traits(container_detail::has_traits_pairs<uc>(), L);
+ }
+
+ static inline int real_ipairs_traits(std::true_type, lua_State* L) {
+ return uc::ipairs(L);
+ }
+
+ static inline int real_ipairs_traits(std::false_type, lua_State* L) {
+ return default_uc::ipairs(L);
+ }
+
+ static inline int real_ipairs_call(lua_State* L) {
+ return real_ipairs_traits(container_detail::has_traits_ipairs<uc>(), L);
+ }
+
+ static inline int real_next_traits(std::true_type, lua_State* L) {
+ return uc::next(L);
+ }
+
+ static inline int real_next_traits(std::false_type, lua_State* L) {
+ return default_uc::next(L);
+ }
+
+ static inline int real_next_call(lua_State* L) {
+ return real_next_traits(container_detail::has_traits_next<uc>(), L);
+ }
+
+ static inline int real_size_traits(std::true_type, lua_State* L) {
+ return uc::size(L);
+ }
+
+ static inline int real_size_traits(std::false_type, lua_State* L) {
+ return default_uc::size(L);
+ }
+
+ static inline int real_length_call(lua_State* L) {
+ return real_size_traits(container_detail::has_traits_size<uc>(), L);
+ }
+
+ static inline int real_add_traits(std::true_type, lua_State* L) {
+ return uc::add(L);
+ }
+
+ static inline int real_add_traits(std::false_type, lua_State* L) {
+ return default_uc::add(L);
+ }
+
+ static inline int real_add_call(lua_State* L) {
+ return real_add_traits(container_detail::has_traits_add<uc>(), L);
+ }
+
+ static inline int real_insert_traits(std::true_type, lua_State* L) {
+ return uc::insert(L);
+ }
+
+ static inline int real_insert_traits(std::false_type, lua_State* L) {
+ return default_uc::insert(L);
+ }
+
+ static inline int real_insert_call(lua_State* L) {
+ return real_insert_traits(container_detail::has_traits_insert<uc>(), L);
+ }
+
+ static inline int real_clear_traits(std::true_type, lua_State* L) {
+ return uc::clear(L);
+ }
+
+ static inline int real_clear_traits(std::false_type, lua_State* L) {
+ return default_uc::clear(L);
+ }
+
+ static inline int real_clear_call(lua_State* L) {
+ return real_clear_traits(container_detail::has_traits_clear<uc>(), L);
+ }
+
+ static inline int real_empty_traits(std::true_type, lua_State* L) {
+ return uc::empty(L);
+ }
+
+ static inline int real_empty_traits(std::false_type, lua_State* L) {
+ return default_uc::empty(L);
+ }
+
+ static inline int real_empty_call(lua_State* L) {
+ return real_empty_traits(container_detail::has_traits_empty<uc>(), L);
+ }
+
+ static inline int real_erase_traits(std::true_type, lua_State* L) {
+ return uc::erase(L);
+ }
+
+ static inline int real_erase_traits(std::false_type, lua_State* L) {
+ return default_uc::erase(L);
+ }
+
+ static inline int real_erase_call(lua_State* L) {
+ return real_erase_traits(container_detail::has_traits_erase<uc>(), L);
+ }
+
+ static inline int real_find_traits(std::true_type, lua_State* L) {
+ return uc::find(L);
+ }
+
+ static inline int real_find_traits(std::false_type, lua_State* L) {
+ return default_uc::find(L);
+ }
+
+ static inline int real_find_call(lua_State* L) {
+ return real_find_traits(container_detail::has_traits_find<uc>(), L);
+ }
+
+ static inline int real_index_of_call(lua_State* L) {
+ if constexpr (container_detail::has_traits_index_of<uc>()) {
+ return uc::index_of(L);
+ }
+ else {
+ return default_uc::index_of(L);
+ }
+ }
+
+ static inline int add_call(lua_State* L) {
+ return detail::typed_static_trampoline<decltype(&real_add_call), (&real_add_call)>(L);
+ }
+
+ static inline int erase_call(lua_State* L) {
+ return detail::typed_static_trampoline<decltype(&real_erase_call), (&real_erase_call)>(L);
+ }
+
+ static inline int insert_call(lua_State* L) {
+ return detail::typed_static_trampoline<decltype(&real_insert_call), (&real_insert_call)>(L);
+ }
+
+ static inline int clear_call(lua_State* L) {
+ return detail::typed_static_trampoline<decltype(&real_clear_call), (&real_clear_call)>(L);
+ }
+
+ static inline int empty_call(lua_State* L) {
+ return detail::typed_static_trampoline<decltype(&real_empty_call), (&real_empty_call)>(L);
+ }
+
+ static inline int find_call(lua_State* L) {
+ return detail::typed_static_trampoline<decltype(&real_find_call), (&real_find_call)>(L);
+ }
+
+ static inline int index_of_call(lua_State* L) {
+ return detail::typed_static_trampoline<decltype(&real_index_of_call), (&real_index_of_call)>(L);
+ }
+
+ static inline int length_call(lua_State* L) {
+ return detail::typed_static_trampoline<decltype(&real_length_call), (&real_length_call)>(L);
+ }
+
+ static inline int pairs_call(lua_State* L) {
+ return detail::typed_static_trampoline<decltype(&real_pairs_call), (&real_pairs_call)>(L);
+ }
+
+ static inline int ipairs_call(lua_State* L) {
+ return detail::typed_static_trampoline<decltype(&real_ipairs_call), (&real_ipairs_call)>(L);
+ }
+
+ static inline int next_call(lua_State* L) {
+ return detail::typed_static_trampoline<decltype(&real_next_call), (&real_next_call)>(L);
+ }
+
+ static inline int at_call(lua_State* L) {
+ return detail::typed_static_trampoline<decltype(&real_at_call), (&real_at_call)>(L);
+ }
+
+ static inline int get_call(lua_State* L) {
+ return detail::typed_static_trampoline<decltype(&real_get_call), (&real_get_call)>(L);
+ }
+
+ static inline int set_call(lua_State* L) {
+ return detail::typed_static_trampoline<decltype(&real_set_call), (&real_set_call)>(L);
+ }
+
+ static inline int index_call(lua_State* L) {
+ return detail::typed_static_trampoline<decltype(&real_index_call), (&real_index_call)>(L);
+ }
+
+ static inline int new_index_call(lua_State* L) {
+ return detail::typed_static_trampoline<decltype(&real_new_index_call), (&real_new_index_call)>(L);
+ }
+ };
+ } // namespace container_detail
+
+ namespace stack {
+ namespace stack_detail {
+ template <typename T, bool is_shim = false>
+ struct metatable_setup {
+ lua_State* L;
+
+ metatable_setup(lua_State* L) : L(L) {
+ }
+
+ void operator()() {
+ using meta_usertype_container
+ = container_detail::u_c_launch<meta::conditional_t<is_shim, as_container_t<std::remove_pointer_t<T>>, std::remove_pointer_t<T>>>;
+ static const char* metakey
+ = is_shim ? &usertype_traits<as_container_t<std::remove_pointer_t<T>>>::metatable()[0] : &usertype_traits<T>::metatable()[0];
+ static const std::array<luaL_Reg, 20> reg = { {
+ // clang-format off
+ { "__pairs", &meta_usertype_container::pairs_call },
+ { "__ipairs", &meta_usertype_container::ipairs_call },
+ { "__len", &meta_usertype_container::length_call },
+ { "__index", &meta_usertype_container::index_call },
+ { "__newindex", &meta_usertype_container::new_index_call },
+ { "pairs", &meta_usertype_container::pairs_call },
+ { "next", &meta_usertype_container::next_call },
+ { "at", &meta_usertype_container::at_call },
+ { "get", &meta_usertype_container::get_call },
+ { "set", &meta_usertype_container::set_call },
+ { "size", &meta_usertype_container::length_call },
+ { "empty", &meta_usertype_container::empty_call },
+ { "clear", &meta_usertype_container::clear_call },
+ { "insert", &meta_usertype_container::insert_call },
+ { "add", &meta_usertype_container::add_call },
+ { "find", &meta_usertype_container::find_call },
+ { "index_of", &meta_usertype_container::index_of_call },
+ { "erase", &meta_usertype_container::erase_call },
+ std::is_pointer<T>::value ? luaL_Reg{ nullptr, nullptr } : luaL_Reg{ "__gc", &detail::usertype_alloc_destruct<T> },
+ { nullptr, nullptr }
+ // clang-format on
+ } };
+
+ if (luaL_newmetatable(L, metakey) == 1) {
+ luaL_setfuncs(L, reg.data(), 0);
+ }
+ lua_setmetatable(L, -2);
+ }
+ };
+ } // namespace stack_detail
+
+ template <typename T>
+ struct unqualified_pusher<as_container_t<T>> {
+ using C = meta::unqualified_t<T>;
+
+ static int push_lvalue(std::true_type, lua_State* L, const C& cont) {
+ stack_detail::metatable_setup<C*, true> fx(L);
+ return stack::push<detail::as_pointer_tag<const C>>(L, detail::with_function_tag(), fx, detail::ptr(cont));
+ }
+
+ static int push_lvalue(std::false_type, lua_State* L, const C& cont) {
+ stack_detail::metatable_setup<C, true> fx(L);
+ return stack::push<detail::as_value_tag<C>>(L, detail::with_function_tag(), fx, cont);
+ }
+
+ static int push_rvalue(std::true_type, lua_State* L, C&& cont) {
+ stack_detail::metatable_setup<C, true> fx(L);
+ return stack::push<detail::as_value_tag<C>>(L, detail::with_function_tag(), fx, std::move(cont));
+ }
+
+ static int push_rvalue(std::false_type, lua_State* L, const C& cont) {
+ return push_lvalue(std::is_lvalue_reference<T>(), L, cont);
+ }
+
+ static int push(lua_State* L, const as_container_t<T>& as_cont) {
+ return push_lvalue(std::is_lvalue_reference<T>(), L, as_cont.value());
+ }
+
+ static int push(lua_State* L, as_container_t<T>&& as_cont) {
+ return push_rvalue(meta::all<std::is_rvalue_reference<T>, meta::neg<std::is_lvalue_reference<T>>>(), L, std::forward<T>(as_cont.value()));
+ }
+ };
+
+ template <typename T>
+ struct unqualified_pusher<as_container_t<T*>> {
+ using C = std::add_pointer_t<meta::unqualified_t<std::remove_pointer_t<T>>>;
+
+ static int push(lua_State* L, T* cont) {
+ stack_detail::metatable_setup<C> fx(L);
+ return stack::push<detail::as_pointer_tag<T>>(L, detail::with_function_tag(), fx, cont);
+ }
+ };
+
+ template <typename T>
+ struct unqualified_pusher<T, std::enable_if_t<is_container_v<T>>> {
+ using C = T;
+
+ template <typename... Args>
+ static int push(lua_State* L, Args&&... args) {
+ stack_detail::metatable_setup<C> fx(L);
+ return stack::push<detail::as_value_tag<T>>(L, detail::with_function_tag(), fx, std::forward<Args>(args)...);
+ }
+ };
+
+ template <typename T>
+ struct unqualified_pusher<T*, std::enable_if_t<is_container_v<T>>> {
+ using C = std::add_pointer_t<meta::unqualified_t<std::remove_pointer_t<T>>>;
+
+ static int push(lua_State* L, T* cont) {
+ stack_detail::metatable_setup<C> fx(L);
+ return stack::push<detail::as_pointer_tag<T>>(L, detail::with_function_tag(), fx, cont);
+ }
+ };
+ } // namespace stack
+
+} // namespace sol
+
+// end of sol/usertype_container_launch.hpp
+
+#include <sstream>
+#include <type_traits>
+
+namespace sol {
+ namespace u_detail {
+ constexpr const lua_Integer toplevel_magic = static_cast<lua_Integer>(0xCCC2CCC1);
+
+ constexpr const int environment_index = 1;
+ constexpr const int usertype_storage_index = 2;
+ constexpr const int usertype_storage_base_index = 3;
+ constexpr const int exact_function_index = 4;
+ constexpr const int magic_index = 5;
+
+ constexpr const int simple_usertype_storage_index = 2;
+ constexpr const int index_function_index = 3;
+ constexpr const int new_index_function_index = 4;
+
+ constexpr const int base_walking_failed_index = -32467;
+ constexpr const int lookup_failed_index = -42469;
+
+ enum class submetatable_type {
+ // must be sequential
+ value,
+ reference,
+ unique,
+ const_reference,
+ const_value,
+ // must be LAST!
+ named
+ };
+
+ inline auto make_string_view(string_view s) {
+ return s;
+ }
+
+ inline auto make_string_view(call_construction) {
+ return string_view(to_string(meta_function::call_function));
+ }
+
+ inline auto make_string_view(meta_function mf) {
+ return string_view(to_string(mf));
+ }
+
+ inline auto make_string_view(base_classes_tag) {
+ return string_view(detail::base_class_cast_key());
+ }
+
+ template <typename Arg>
+ inline std::string make_string(Arg&& arg) {
+ string_view s = make_string_view(arg);
+ return std::string(s.data(), s.size());
+ }
+
+ inline int is_indexer(string_view s) {
+ if (s == to_string(meta_function::index)) {
+ return 1;
+ }
+ else if (s == to_string(meta_function::new_index)) {
+ return 2;
+ }
+ return 0;
+ }
+
+ inline int is_indexer(meta_function mf) {
+ if (mf == meta_function::index) {
+ return 1;
+ }
+ else if (mf == meta_function::new_index) {
+ return 2;
+ }
+ return 0;
+ }
+
+ inline int is_indexer(call_construction) {
+ return 0;
+ }
+ } // namespace u_detail
+
+ namespace detail {
+
+ template <typename T, typename IFx, typename Fx>
+ inline void insert_default_registrations(IFx&& ifx, Fx&& fx) {
+ (void)ifx;
+ (void)fx;
+ if constexpr (is_automagical<T>::value) {
+ if (fx(meta_function::less_than)) {
+ if constexpr (meta::supports_op_less<T>::value) {
+ lua_CFunction f = &comparsion_operator_wrap<T, std::less<>>;
+ ifx(meta_function::less_than, f);
+ }
+ }
+ if (fx(meta_function::less_than_or_equal_to)) {
+ if constexpr (meta::supports_op_less_equal<T>::value) {
+ lua_CFunction f = &comparsion_operator_wrap<T, std::less_equal<>>;
+ ifx(meta_function::less_than_or_equal_to, f);
+ }
+ }
+ if (fx(meta_function::equal_to)) {
+ if constexpr (meta::supports_op_equal<T>::value) {
+ lua_CFunction f = &comparsion_operator_wrap<T, std::equal_to<>>;
+ ifx(meta_function::equal_to, f);
+ }
+ else {
+ lua_CFunction f = &comparsion_operator_wrap<T, no_comp>;
+ ifx(meta_function::equal_to, f);
+ }
+ }
+ if (fx(meta_function::pairs)) {
+ ifx(meta_function::pairs, &container_detail::u_c_launch<as_container_t<T>>::pairs_call);
+ }
+ if (fx(meta_function::length)) {
+ if constexpr (meta::has_size<const T>::value || meta::has_size<T>::value) {
+ auto f = &default_size<T>;
+ ifx(meta_function::length, f);
+ }
+ }
+ if (fx(meta_function::to_string)) {
+ if constexpr (is_to_stringable<T>::value) {
+ auto f = &detail::static_trampoline<&default_to_string<T>>;
+ ifx(meta_function::to_string, f);
+ }
+ }
+ if (fx(meta_function::call_function)) {
+ if constexpr (meta::has_deducible_signature<T>::value) {
+ auto f = &c_call<decltype(&T::operator()), &T::operator()>;
+ ifx(meta_function::call_function, f);
+ }
+ }
+ }
+ }
+ } // namespace detail
+
+ namespace stack { namespace stack_detail {
+ template <typename X>
+ void set_undefined_methods_on(stack_reference t) {
+ using T = std::remove_pointer_t<X>;
+
+ lua_State* L = t.lua_state();
+
+ t.push();
+
+ detail::lua_reg_table l{};
+ int index = 0;
+ detail::indexed_insert insert_fx(l, index);
+ detail::insert_default_registrations<T>(insert_fx, detail::property_always_true);
+ if constexpr (!std::is_pointer_v<X>) {
+ l[index] = luaL_Reg{ to_string(meta_function::garbage_collect).c_str(), detail::make_destructor<T>() };
+ }
+ luaL_setfuncs(L, l, 0);
+
+ // __type table
+ lua_createtable(L, 0, 2);
+ const std::string& name = detail::demangle<T>();
+ lua_pushlstring(L, name.c_str(), name.size());
+ lua_setfield(L, -2, "name");
+ lua_CFunction is_func = &detail::is_check<T>;
+ lua_pushcclosure(L, is_func, 0);
+ lua_setfield(L, -2, "is");
+ lua_setfield(L, t.stack_index(), to_string(meta_function::type).c_str());
+
+ t.pop();
+ }
+ }} // namespace stack::stack_detail
+} // namespace sol
+
+// end of sol/usertype_core.hpp
+
+// beginning of sol/usertype_storage.hpp
+
+#include <bitset>
+#include <unordered_map>
+
+namespace sol { namespace u_detail {
+
+ struct usertype_storage_base;
+ template <typename T>
+ struct usertype_storage;
+
+ optional<usertype_storage_base&> maybe_get_usertype_storage_base(lua_State* L, int index);
+ usertype_storage_base& get_usertype_storage_base(lua_State* L, const char* gcmetakey);
+ template <typename T>
+ optional<usertype_storage<T>&> maybe_get_usertype_storage(lua_State* L);
+ template <typename T>
+ usertype_storage<T>& get_usertype_storage(lua_State* L);
+
+ using index_call_function = int(lua_State*, void*);
+ using change_indexing_mem_func
+ = void (usertype_storage_base::*)(lua_State*, submetatable_type, void*, stack_reference&, lua_CFunction, lua_CFunction, lua_CFunction, lua_CFunction);
+
+ struct index_call_storage {
+ index_call_function* index;
+ index_call_function* new_index;
+ void* binding_data;
+ };
+
+ struct new_index_call_storage : index_call_storage {
+ void* new_binding_data;
+ };
+
+ struct binding_base {
+ virtual void* data() = 0;
+ virtual ~binding_base() {
+ }
+ };
+
+ template <typename K, typename Fq, typename T = void>
+ struct binding : binding_base {
+ using uF = meta::unqualified_t<Fq>;
+ using F = meta::conditional_t<meta::is_c_str_of_v<uF, char>
+#ifdef __cpp_char8_t
+ || meta::is_c_str_of_v<uF, char8_t>
+#endif
+ || meta::is_c_str_of_v<uF, char16_t> || meta::is_c_str_of_v<uF, char32_t> || meta::is_c_str_of_v<uF, wchar_t>,
+ std::add_pointer_t<std::add_const_t<std::remove_all_extents_t<Fq>>>, std::decay_t<Fq>>;
+ F data_;
+
+ template <typename... Args>
+ binding(Args&&... args) : data_(std::forward<Args>(args)...) {
+ }
+
+ virtual void* data() override {
+ return static_cast<void*>(std::addressof(data_));
+ }
+
+ template <bool is_index = true, bool is_variable = false>
+ static inline int call_with_(lua_State* L, void* target) {
+ constexpr int boost = !detail::is_non_factory_constructor<F>::value && std::is_same<K, call_construction>::value ? 1 : 0;
+ auto& f = *static_cast<F*>(target);
+ return call_detail::call_wrapped<T, is_index, is_variable, boost>(L, f);
+ }
+
+ template <bool is_index = true, bool is_variable = false>
+ static inline int call_(lua_State* L) {
+ void* f = stack::get<void*>(L, upvalue_index(usertype_storage_index));
+ return call_with_<is_index, is_variable>(L, f);
+ }
+
+ template <bool is_index = true, bool is_variable = false>
+ static inline int call(lua_State* L) {
+ int r = detail::typed_static_trampoline<decltype(&call_<is_index, is_variable>), (&call_<is_index, is_variable>)>(L);
+ if constexpr (meta::is_specialization_of_v<uF, yielding_t>) {
+ return lua_yield(L, r);
+ }
+ else {
+ return r;
+ }
+ }
+
+ template <bool is_index = true, bool is_variable = false>
+ static inline int index_call_with_(lua_State* L, void* target) {
+ if constexpr (!is_variable) {
+ if constexpr (is_lua_c_function_v<std::decay_t<F>>) {
+ auto& f = *static_cast<std::decay_t<F>*>(target);
+ return stack::push(L, f);
+ }
+ else {
+ // set up upvalues
+ // for a chained call
+ int upvalues = 0;
+ upvalues += stack::push(L, nullptr);
+ upvalues += stack::push(L, target);
+ auto cfunc = &call<is_index, is_variable>;
+ return stack::push(L, c_closure(cfunc, upvalues));
+ }
+ }
+ else {
+ constexpr int boost = !detail::is_non_factory_constructor<F>::value && std::is_same<K, call_construction>::value ? 1 : 0;
+ auto& f = *static_cast<F*>(target);
+ return call_detail::call_wrapped<T, is_index, is_variable, boost>(L, f);
+ }
+ }
+
+ template <bool is_index = true, bool is_variable = false>
+ static inline int index_call_(lua_State* L) {
+ void* f = stack::get<void*>(L, upvalue_index(usertype_storage_index));
+ return index_call_with_<is_index, is_variable>(L, f);
+ }
+
+ template <bool is_index = true, bool is_variable = false>
+ static inline int index_call(lua_State* L) {
+ int r = detail::typed_static_trampoline<decltype(&index_call_<is_index, is_variable>), (&index_call_<is_index, is_variable>)>(L);
+ if constexpr (meta::is_specialization_of_v<uF, yielding_t>) {
+ return lua_yield(L, r);
+ }
+ else {
+ return r;
+ }
+ }
+ };
+
+ inline int index_fail(lua_State* L) {
+ if (lua_getmetatable(L, 1) == 1) {
+ int metatarget = lua_gettop(L);
+ stack::get_field<false, true>(L, stack_reference(L, raw_index(2)), metatarget);
+ return 1;
+ }
+ // With runtime extensibility, we can't
+ // hard-error things. They have to
+ // return nil, like regular table types
+ return stack::push(L, lua_nil);
+ }
+
+ inline int index_target_fail(lua_State* L, void*) {
+ return index_fail(L);
+ }
+
+ inline int new_index_fail(lua_State* L) {
+ return luaL_error(L, "sol: cannot set (new_index) into this object: no defined new_index operation on usertype");
+ }
+
+ inline int new_index_target_fail(lua_State* L, void*) {
+ return new_index_fail(L);
+ }
+
+ struct string_for_each_metatable_func {
+ bool is_destruction = false;
+ bool is_index = false;
+ bool is_new_index = false;
+ bool is_static_index = false;
+ bool is_static_new_index = false;
+ bool poison_indexing = false;
+ bool is_unqualified_lua_CFunction = false;
+ bool is_unqualified_lua_reference = false;
+ std::string* p_key = nullptr;
+ reference* p_binding_ref = nullptr;
+ lua_CFunction call_func = nullptr;
+ index_call_storage* p_ics = nullptr;
+ usertype_storage_base* p_usb = nullptr;
+ void* p_derived_usb = nullptr;
+ lua_CFunction idx_call = nullptr, new_idx_call = nullptr, meta_idx_call = nullptr, meta_new_idx_call = nullptr;
+ change_indexing_mem_func change_indexing;
+
+ void operator()(lua_State* L, submetatable_type smt, reference& fast_index_table) {
+ std::string& key = *p_key;
+ usertype_storage_base& usb = *p_usb;
+ index_call_storage& ics = *p_ics;
+
+ if (smt == submetatable_type::named) {
+ // do not override __call or
+ // other specific meta functions on named metatable:
+ // we need that for call construction
+ // and other amenities
+ return;
+ }
+ int fast_index_table_push = fast_index_table.push();
+ stack_reference t(L, -fast_index_table_push);
+ if (poison_indexing) {
+ (usb.*change_indexing)(L, smt, p_derived_usb, t, idx_call, new_idx_call, meta_idx_call, meta_new_idx_call);
+ }
+ if (is_destruction
+ && (smt == submetatable_type::reference || smt == submetatable_type::const_reference || smt == submetatable_type::named
+ || smt == submetatable_type::unique)) {
+ // gc does not apply to us here
+ // for reference types (raw T*, std::ref)
+ // for the named metatable itself,
+ // or for unique_usertypes, which do their own custom destruction
+ t.pop();
+ return;
+ }
+ if (is_index || is_new_index || is_static_index || is_static_new_index) {
+ // do not serialize the new_index and index functions here directly
+ // we control those...
+ t.pop();
+ return;
+ }
+ if (is_unqualified_lua_CFunction) {
+ stack::set_field<false, true>(L, key, call_func, t.stack_index());
+ }
+ else if (is_unqualified_lua_reference) {
+ reference& binding_ref = *p_binding_ref;
+ stack::set_field<false, true>(L, key, binding_ref, t.stack_index());
+ }
+ else {
+ stack::set_field<false, true>(L, key, make_closure(call_func, nullptr, ics.binding_data), t.stack_index());
+ }
+ t.pop();
+ }
+ };
+
+ struct lua_reference_func {
+ reference key;
+ reference value;
+
+ void operator()(lua_State* L, submetatable_type smt, reference& fast_index_table) {
+ if (smt == submetatable_type::named) {
+ return;
+ }
+ int fast_index_table_push = fast_index_table.push();
+ stack_reference t(L, -fast_index_table_push);
+ stack::set_field<false, true>(L, key, value, t.stack_index());
+ t.pop();
+ }
+ };
+
+ struct update_bases_func {
+ detail::inheritance_check_function base_class_check_func;
+ detail::inheritance_cast_function base_class_cast_func;
+ lua_CFunction idx_call, new_idx_call, meta_idx_call, meta_new_idx_call;
+ usertype_storage_base* p_usb;
+ void* p_derived_usb;
+ change_indexing_mem_func change_indexing;
+
+ void operator()(lua_State* L, submetatable_type smt, reference& fast_index_table) {
+ int fast_index_table_push = fast_index_table.push();
+ stack_reference t(L, -fast_index_table_push);
+ stack::set_field(L, detail::base_class_check_key(), reinterpret_cast<void*>(base_class_check_func), t.stack_index());
+ stack::set_field(L, detail::base_class_cast_key(), reinterpret_cast<void*>(base_class_cast_func), t.stack_index());
+ // change indexing, forcefully
+ (p_usb->*change_indexing)(L, smt, p_derived_usb, t, idx_call, new_idx_call, meta_idx_call, meta_new_idx_call);
+ t.pop();
+ }
+ };
+
+ struct binding_data_equals {
+ void* binding_data;
+
+ binding_data_equals(void* b) : binding_data(b) {
+ }
+
+ bool operator()(const std::unique_ptr<binding_base>& ptr) const {
+ return binding_data == ptr->data();
+ }
+ };
+
+ struct usertype_storage_base {
+ public:
+ std::vector<std::unique_ptr<binding_base>> storage;
+ std::vector<std::unique_ptr<char[]>> string_keys_storage;
+ std::unordered_map<string_view, index_call_storage> string_keys;
+ std::unordered_map<reference, reference, reference_hash, reference_equals> auxiliary_keys;
+ reference value_index_table;
+ reference reference_index_table;
+ reference unique_index_table;
+ reference const_reference_index_table;
+ reference const_value_index_table;
+ reference named_index_table;
+ reference type_table;
+ reference gc_names_table;
+ reference named_metatable;
+ new_index_call_storage base_index;
+ new_index_call_storage static_base_index;
+ bool is_using_index;
+ bool is_using_new_index;
+ std::bitset<64> properties;
+
+ usertype_storage_base(lua_State* L)
+ : storage()
+ , string_keys()
+ , auxiliary_keys()
+ , value_index_table()
+ , reference_index_table()
+ , unique_index_table()
+ , const_reference_index_table()
+ , type_table(make_reference(L, create))
+ , gc_names_table(make_reference(L, create))
+ , named_metatable(make_reference(L, create))
+ , base_index()
+ , static_base_index()
+ , is_using_index(false)
+ , is_using_new_index(false)
+ , properties() {
+ base_index.binding_data = nullptr;
+ base_index.index = index_target_fail;
+ base_index.new_index = new_index_target_fail;
+ base_index.new_binding_data = nullptr;
+ static_base_index.binding_data = nullptr;
+ static_base_index.index = index_target_fail;
+ static_base_index.new_binding_data = this;
+ static_base_index.new_index = new_index_target_set;
+ }
+
+ template <typename Fx>
+ void for_each_table(lua_State* L, Fx&& fx) {
+ for (int i = 0; i < 6; ++i) {
+ submetatable_type smt = static_cast<submetatable_type>(i);
+ reference* p_fast_index_table = nullptr;
+ switch (smt) {
+ case submetatable_type::const_value:
+ p_fast_index_table = &this->const_value_index_table;
+ break;
+ case submetatable_type::reference:
+ p_fast_index_table = &this->reference_index_table;
+ break;
+ case submetatable_type::unique:
+ p_fast_index_table = &this->unique_index_table;
+ break;
+ case submetatable_type::const_reference:
+ p_fast_index_table = &this->const_reference_index_table;
+ break;
+ case submetatable_type::named:
+ p_fast_index_table = &this->named_index_table;
+ break;
+ case submetatable_type::value:
+ default:
+ p_fast_index_table = &this->value_index_table;
+ break;
+ }
+ fx(L, smt, *p_fast_index_table);
+ }
+ }
+
+ void add_entry(string_view sv, index_call_storage ics) {
+ string_keys_storage.emplace_back(new char[sv.size()]);
+ std::unique_ptr<char[]>& sv_storage = string_keys_storage.back();
+ std::memcpy(sv_storage.get(), sv.data(), sv.size());
+ string_view stored_sv(sv_storage.get(), sv.size());
+ string_keys.insert_or_assign(std::move(stored_sv), std::move(ics));
+ }
+
+ template <typename T, typename... Bases>
+ void update_bases(lua_State* L, bases<Bases...>) {
+ static_assert(sizeof(void*) <= sizeof(detail::inheritance_check_function),
+ "The size of this data pointer is too small to fit the inheritance checking function: Please file "
+ "a bug report.");
+ static_assert(sizeof(void*) <= sizeof(detail::inheritance_cast_function),
+ "The size of this data pointer is too small to fit the inheritance checking function: Please file "
+ "a bug report.");
+ static_assert(!meta::any_same<T, Bases...>::value, "base classes cannot list the original class as part of the bases");
+ if constexpr (sizeof...(Bases) < 1) {
+ return;
+ }
+
+ (void)detail::swallow { 0, ((weak_derive<Bases>::value = true), 0)... };
+
+ void* derived_this = static_cast<void*>(static_cast<usertype_storage<T>*>(this));
+
+ update_bases_func for_each_fx;
+ for_each_fx.base_class_check_func = &detail::inheritance<T>::template type_check_with<Bases...>;
+ for_each_fx.base_class_cast_func = &detail::inheritance<T>::template type_cast_with<Bases...>;
+ for_each_fx.idx_call = &usertype_storage<T>::template index_call_with_bases<false, Bases...>;
+ for_each_fx.new_idx_call = &usertype_storage<T>::template index_call_with_bases<true, Bases...>;
+ for_each_fx.meta_idx_call = &usertype_storage<T>::template meta_index_call_with_bases<false, Bases...>;
+ for_each_fx.meta_new_idx_call = &usertype_storage<T>::template meta_index_call_with_bases<true, Bases...>;
+ for_each_fx.p_usb = this;
+ for_each_fx.p_derived_usb = derived_this;
+ for_each_fx.change_indexing = &usertype_storage_base::change_indexing;
+ for_each_fx.p_derived_usb = derived_this;
+ this->for_each_table(L, for_each_fx);
+ }
+
+ void clear() {
+ if (value_index_table.valid()) {
+ stack::clear(value_index_table);
+ }
+ if (reference_index_table.valid()) {
+ stack::clear(reference_index_table);
+ }
+ if (unique_index_table.valid()) {
+ stack::clear(unique_index_table);
+ }
+ if (const_reference_index_table.valid()) {
+ stack::clear(const_reference_index_table);
+ }
+ if (const_value_index_table.valid()) {
+ stack::clear(const_value_index_table);
+ }
+ if (named_index_table.valid()) {
+ stack::clear(named_index_table);
+ }
+ if (type_table.valid()) {
+ stack::clear(type_table);
+ }
+ if (gc_names_table.valid()) {
+ stack::clear(gc_names_table);
+ }
+ if (named_metatable.valid()) {
+ lua_State* L = named_metatable.lua_state();
+ auto pp = stack::push_pop(named_metatable);
+ int named_metatable_index = pp.index_of(named_metatable);
+ if (lua_getmetatable(L, named_metatable_index) == 1) {
+ stack::clear(L, absolute_index(L, -1));
+ }
+ stack::clear(named_metatable);
+ }
+
+ value_index_table = lua_nil;
+ reference_index_table = lua_nil;
+ unique_index_table = lua_nil;
+ const_reference_index_table = lua_nil;
+ const_value_index_table = lua_nil;
+ named_index_table = lua_nil;
+ type_table = lua_nil;
+ gc_names_table = lua_nil;
+ named_metatable = lua_nil;
+
+ storage.clear();
+ string_keys.clear();
+ auxiliary_keys.clear();
+ }
+
+ template <bool is_new_index, typename Base>
+ static void base_walk_index(lua_State* L, usertype_storage_base& self, bool& keep_going, int& base_result) {
+ using bases = typename base<Base>::type;
+ if (!keep_going) {
+ return;
+ }
+ (void)L;
+ (void)self;
+#if SOL_IS_ON(SOL_USE_UNSAFE_BASE_LOOKUP_I_)
+ usertype_storage_base& base_storage = get_usertype_storage<Base>(L);
+ base_result = self_index_call<is_new_index, true>(bases(), L, base_storage);
+#else
+ optional<usertype_storage<Base>&> maybe_base_storage = maybe_get_usertype_storage<Base>(L);
+ if (static_cast<bool>(maybe_base_storage)) {
+ base_result = self_index_call<is_new_index, true>(bases(), L, *maybe_base_storage);
+ keep_going = base_result == base_walking_failed_index;
+ }
+#endif // Fast versus slow, safe base lookup
+ }
+
+ template <bool is_new_index = false, bool base_walking = false, bool from_named_metatable = false, typename... Bases>
+ static inline int self_index_call(types<Bases...>, lua_State* L, usertype_storage_base& self) {
+ type k_type = stack::get<type>(L, 2);
+ if (k_type == type::string) {
+ index_call_storage* target = nullptr;
+ {
+ string_view k = stack::get<string_view>(L, 2);
+ auto it = self.string_keys.find(k);
+ if (it != self.string_keys.cend()) {
+ target = &it->second;
+ }
+ }
+ if (target != nullptr) {
+ // let the target decide what to do
+ if constexpr (is_new_index) {
+ return (target->new_index)(L, target->binding_data);
+ }
+ else {
+ return (target->index)(L, target->binding_data);
+ }
+ }
+ }
+ else if (k_type != type::lua_nil && k_type != type::none) {
+ reference* target = nullptr;
+ {
+ stack_reference k = stack::get<stack_reference>(L, 2);
+ auto it = self.auxiliary_keys.find(k);
+ if (it != self.auxiliary_keys.cend()) {
+ target = &it->second;
+ }
+ }
+ if (target != nullptr) {
+ if constexpr (is_new_index) {
+ // set value and return
+ *target = reference(L, 3);
+ return 0;
+ }
+ else {
+ // push target to return
+ // what we found
+ return stack::push(L, *target);
+ }
+ }
+ }
+
+ // retrieve bases and walk through them.
+ bool keep_going = true;
+ int base_result;
+ (void)keep_going;
+ (void)base_result;
+ (void)detail::swallow { 1, (base_walk_index<is_new_index, Bases>(L, self, keep_going, base_result), 1)... };
+ if constexpr (sizeof...(Bases) > 0) {
+ if (!keep_going) {
+ return base_result;
+ }
+ }
+ if constexpr (base_walking) {
+ // if we're JUST base-walking then don't index-fail, just
+ // return the false bits
+ return base_walking_failed_index;
+ }
+ else if constexpr (from_named_metatable) {
+ if constexpr (is_new_index) {
+ return self.static_base_index.new_index(L, self.static_base_index.new_binding_data);
+ }
+ else {
+ return self.static_base_index.index(L, self.static_base_index.binding_data);
+ }
+ }
+ else {
+ if constexpr (is_new_index) {
+ return self.base_index.new_index(L, self.base_index.new_binding_data);
+ }
+ else {
+ return self.base_index.index(L, self.base_index.binding_data);
+ }
+ }
+ }
+
+ void change_indexing(lua_State* L, submetatable_type submetatable, void* derived_this, stack_reference& t, lua_CFunction index,
+ lua_CFunction new_index, lua_CFunction meta_index, lua_CFunction meta_new_index) {
+ usertype_storage_base& this_base = *this;
+ void* base_this = static_cast<void*>(&this_base);
+
+ this->is_using_index |= true;
+ this->is_using_new_index |= true;
+ if (submetatable == submetatable_type::named) {
+ stack::set_field(L, metatable_key, named_index_table, t.stack_index());
+ stack_reference stack_metametatable(L, -named_metatable.push());
+ stack::set_field<false, true>(L,
+ meta_function::index,
+ make_closure(meta_index, nullptr, derived_this, base_this, nullptr, toplevel_magic),
+ stack_metametatable.stack_index());
+ stack::set_field<false, true>(L,
+ meta_function::new_index,
+ make_closure(meta_new_index, nullptr, derived_this, base_this, nullptr, toplevel_magic),
+ stack_metametatable.stack_index());
+ stack_metametatable.pop();
+ }
+ else {
+ stack::set_field<false, true>(
+ L, meta_function::index, make_closure(index, nullptr, derived_this, base_this, nullptr, toplevel_magic), t.stack_index());
+ stack::set_field<false, true>(
+ L, meta_function::new_index, make_closure(new_index, nullptr, derived_this, base_this, nullptr, toplevel_magic), t.stack_index());
+ }
+ }
+
+ template <typename T = void, typename Key, typename Value>
+ void set(lua_State* L, Key&& key, Value&& value);
+
+ static int new_index_target_set(lua_State* L, void* target) {
+ usertype_storage_base& self = *static_cast<usertype_storage_base*>(target);
+ self.set(L, reference(L, raw_index(2)), reference(L, raw_index(3)));
+ return 0;
+ }
+ };
+
+ template <typename T>
+ struct usertype_storage : usertype_storage_base {
+
+ using usertype_storage_base::usertype_storage_base;
+
+ template <bool is_new_index, bool from_named_metatable>
+ static inline int index_call_(lua_State* L) {
+ using bases = typename base<T>::type;
+ usertype_storage_base& self = stack::get<light<usertype_storage_base>>(L, upvalue_index(usertype_storage_index));
+ return self_index_call<is_new_index, false, from_named_metatable>(bases(), L, self);
+ }
+
+ template <bool is_new_index, bool from_named_metatable, typename... Bases>
+ static inline int index_call_with_bases_(lua_State* L) {
+ using bases = types<Bases...>;
+ usertype_storage_base& self = stack::get<light<usertype_storage_base>>(L, upvalue_index(usertype_storage_index));
+ return self_index_call<is_new_index, false, from_named_metatable>(bases(), L, self);
+ }
+
+ template <bool is_new_index>
+ static inline int index_call(lua_State* L) {
+ return detail::static_trampoline<&index_call_<is_new_index, false>>(L);
+ }
+
+ template <bool is_new_index, typename... Bases>
+ static inline int index_call_with_bases(lua_State* L) {
+ return detail::static_trampoline<&index_call_with_bases_<is_new_index, false, Bases...>>(L);
+ }
+
+ template <bool is_new_index>
+ static inline int meta_index_call(lua_State* L) {
+ return detail::static_trampoline<&index_call_<is_new_index, true>>(L);
+ }
+
+ template <bool is_new_index, typename... Bases>
+ static inline int meta_index_call_with_bases(lua_State* L) {
+ return detail::static_trampoline<&index_call_with_bases_<is_new_index, true, Bases...>>(L);
+ }
+
+ template <typename Key, typename Value>
+ inline void set(lua_State* L, Key&& key, Value&& value);
+ };
+
+ template <typename T>
+ inline int destruct_usertype_storage(lua_State* L) {
+ return detail::user_alloc_destruct<usertype_storage<T>>(L);
+ }
+
+ template <typename T, typename Key, typename Value>
+ void usertype_storage_base::set(lua_State* L, Key&& key, Value&& value) {
+ using ValueU = meta::unwrap_unqualified_t<Value>;
+ using KeyU = meta::unwrap_unqualified_t<Key>;
+ using Binding = binding<KeyU, ValueU, T>;
+ using is_var_bind = is_variable_binding<ValueU>;
+ if constexpr (std::is_same_v<KeyU, call_construction>) {
+ (void)key;
+ std::unique_ptr<Binding> p_binding = std::make_unique<Binding>(std::forward<Value>(value));
+ Binding& b = *p_binding;
+ this->storage.push_back(std::move(p_binding));
+
+ this->named_index_table.push();
+ absolute_index metametatable_index(L, -1);
+ stack::push(L, nullptr);
+ stack::push(L, b.data());
+ lua_CFunction target_func = &b.template call<false, false>;
+ lua_pushcclosure(L, target_func, 2);
+ lua_setfield(L, metametatable_index, to_string(meta_function::call).c_str());
+ this->named_index_table.pop();
+ }
+ else if constexpr (std::is_same_v<KeyU, base_classes_tag>) {
+ (void)key;
+ this->update_bases<T>(L, std::forward<Value>(value));
+ }
+ else if constexpr ((meta::is_string_like_or_constructible<KeyU>::value || std::is_same_v<KeyU, meta_function>)) {
+ std::string s = u_detail::make_string(std::forward<Key>(key));
+ auto storage_it = this->storage.end();
+ auto string_it = this->string_keys.find(s);
+ if (string_it != this->string_keys.cend()) {
+ const auto& binding_data = string_it->second.binding_data;
+ storage_it = std::find_if(this->storage.begin(), this->storage.end(), binding_data_equals(binding_data));
+ this->string_keys.erase(string_it);
+ }
+
+ std::unique_ptr<Binding> p_binding = std::make_unique<Binding>(std::forward<Value>(value));
+ Binding& b = *p_binding;
+ if (storage_it != this->storage.cend()) {
+ *storage_it = std::move(p_binding);
+ }
+ else {
+ this->storage.push_back(std::move(p_binding));
+ }
+
+ bool is_index = (s == to_string(meta_function::index));
+ bool is_new_index = (s == to_string(meta_function::new_index));
+ bool is_static_index = (s == to_string(meta_function::static_index));
+ bool is_static_new_index = (s == to_string(meta_function::static_new_index));
+ bool is_destruction = s == to_string(meta_function::garbage_collect);
+ bool poison_indexing = (!is_using_index || !is_using_new_index) && (is_var_bind::value || is_index || is_new_index);
+ void* derived_this = static_cast<void*>(static_cast<usertype_storage<T>*>(this));
+ index_call_storage ics;
+ ics.binding_data = b.data();
+ ics.index = is_index || is_static_index ? &Binding::template call_with_<true, is_var_bind::value>
+ : &Binding::template index_call_with_<true, is_var_bind::value>;
+ ics.new_index = is_new_index || is_static_new_index ? &Binding::template call_with_<false, is_var_bind::value>
+ : &Binding::template index_call_with_<false, is_var_bind::value>;
+
+ string_for_each_metatable_func for_each_fx;
+ for_each_fx.is_destruction = is_destruction;
+ for_each_fx.is_index = is_index;
+ for_each_fx.is_new_index = is_new_index;
+ for_each_fx.is_static_index = is_static_index;
+ for_each_fx.is_static_new_index = is_static_new_index;
+ for_each_fx.poison_indexing = poison_indexing;
+ for_each_fx.p_key = &s;
+ for_each_fx.p_ics = &ics;
+ if constexpr (is_lua_c_function_v<ValueU>) {
+ for_each_fx.is_unqualified_lua_CFunction = true;
+ for_each_fx.call_func = *static_cast<lua_CFunction*>(ics.binding_data);
+ }
+ else if constexpr (is_lua_reference_or_proxy_v<ValueU>) {
+ for_each_fx.is_unqualified_lua_reference = true;
+ for_each_fx.p_binding_ref = static_cast<reference*>(ics.binding_data);
+ }
+ else {
+ for_each_fx.call_func = &b.template call<false, is_var_bind::value>;
+ }
+ for_each_fx.p_usb = this;
+ for_each_fx.p_derived_usb = derived_this;
+ for_each_fx.idx_call = &usertype_storage<T>::template index_call<false>;
+ for_each_fx.new_idx_call = &usertype_storage<T>::template index_call<true>;
+ for_each_fx.meta_idx_call = &usertype_storage<T>::template meta_index_call<false>;
+ for_each_fx.meta_new_idx_call = &usertype_storage<T>::template meta_index_call<true>;
+ for_each_fx.change_indexing = &usertype_storage_base::change_indexing;
+ // set base index and base new_index
+ // functions here
+ if (is_index) {
+ this->base_index.index = ics.index;
+ this->base_index.binding_data = ics.binding_data;
+ }
+ if (is_new_index) {
+ this->base_index.new_index = ics.new_index;
+ this->base_index.new_binding_data = ics.binding_data;
+ }
+ if (is_static_index) {
+ this->static_base_index.index = ics.index;
+ this->static_base_index.binding_data = ics.binding_data;
+ }
+ if (is_static_new_index) {
+ this->static_base_index.new_index = ics.new_index;
+ this->static_base_index.new_binding_data = ics.binding_data;
+ }
+ this->for_each_table(L, for_each_fx);
+ this->add_entry(s, std::move(ics));
+ }
+ else {
+ // the reference-based implementation might compare poorly and hash
+ // poorly in some cases...
+ if constexpr (is_lua_reference_v<KeyU> && is_lua_reference_v<ValueU>) {
+ if (key.get_type() == type::string) {
+ stack::push(L, key);
+ std::string string_key = stack::pop<std::string>(L);
+ this->set<T>(L, string_key, std::forward<Value>(value));
+ }
+ else {
+ lua_reference_func ref_additions_fx { key, value };
+
+ this->for_each_table(L, ref_additions_fx);
+ this->auxiliary_keys.insert_or_assign(std::forward<Key>(key), std::forward<Value>(value));
+ }
+ }
+ else {
+ reference ref_key = make_reference(L, std::forward<Key>(key));
+ reference ref_value = make_reference(L, std::forward<Value>(value));
+ lua_reference_func ref_additions_fx { key, value };
+
+ this->for_each_table(L, ref_additions_fx);
+ this->auxiliary_keys.insert_or_assign(std::move(ref_key), std::move(ref_value));
+ }
+ }
+ }
+
+ template <typename T>
+ template <typename Key, typename Value>
+ void usertype_storage<T>::set(lua_State* L, Key&& key, Value&& value) {
+ static_cast<usertype_storage_base&>(*this).set<T>(L, std::forward<Key>(key), std::forward<Value>(value));
+ }
+
+ template <typename T>
+ inline usertype_storage<T>& create_usertype_storage(lua_State* L) {
+ const char* gcmetakey = &usertype_traits<T>::gc_table()[0];
+
+ // Make sure userdata's memory is properly in lua first,
+ // otherwise all the light userdata we make later will become invalid
+ int usertype_storage_push_count = stack::push<user<usertype_storage<T>>>(L, no_metatable, L);
+ stack_reference usertype_storage_ref(L, -usertype_storage_push_count);
+
+ // create and push onto the stack a table to use as metatable for this GC
+ // we create a metatable to attach to the regular gc_table
+ // so that the destructor is called for the usertype storage
+ int usertype_storage_metatabe_count = stack::push(L, new_table(0, 1));
+ stack_reference usertype_storage_metatable(L, -usertype_storage_metatabe_count);
+ // set the destruction routine on the metatable
+ stack::set_field(L, meta_function::garbage_collect, &destruct_usertype_storage<T>, usertype_storage_metatable.stack_index());
+ // set the metatable on the usertype storage userdata
+ stack::set_field(L, metatable_key, usertype_storage_metatable, usertype_storage_ref.stack_index());
+ usertype_storage_metatable.pop();
+
+ // set the usertype storage and its metatable
+ // into the global table...
+ stack::set_field<true>(L, gcmetakey, usertype_storage_ref);
+ usertype_storage_ref.pop();
+
+ // then retrieve the lua-stored version so we have a well-pinned
+ // reference that does not die
+ stack::get_field<true>(L, gcmetakey);
+ usertype_storage<T>& target_umt = stack::pop<user<usertype_storage<T>>>(L);
+ return target_umt;
+ }
+
+ inline optional<usertype_storage_base&> maybe_get_usertype_storage_base(lua_State* L, int index) {
+ stack::record tracking;
+ if (!stack::check<user<usertype_storage_base>>(L, index)) {
+ return nullopt;
+ }
+ usertype_storage_base& target_umt = stack::stack_detail::unchecked_unqualified_get<user<usertype_storage_base>>(L, -1, tracking);
+ return target_umt;
+ }
+
+ inline optional<usertype_storage_base&> maybe_get_usertype_storage_base(lua_State* L, const char* gcmetakey) {
+ stack::get_field<true>(L, gcmetakey);
+ auto maybe_storage = maybe_get_usertype_storage_base(L, lua_gettop(L));
+ lua_pop(L, 1);
+ return maybe_storage;
+ }
+
+ inline usertype_storage_base& get_usertype_storage_base(lua_State* L, const char* gcmetakey) {
+ stack::get_field<true>(L, gcmetakey);
+ stack::record tracking;
+ usertype_storage_base& target_umt = stack::stack_detail::unchecked_unqualified_get<user<usertype_storage_base>>(L, -1, tracking);
+ lua_pop(L, 1);
+ return target_umt;
+ }
+
+ template <typename T>
+ inline optional<usertype_storage<T>&> maybe_get_usertype_storage(lua_State* L) {
+ const char* gcmetakey = &usertype_traits<T>::gc_table()[0];
+ stack::get_field<true>(L, gcmetakey);
+ int target = lua_gettop(L);
+ if (!stack::check<user<usertype_storage<T>>>(L, target)) {
+ return nullopt;
+ }
+ usertype_storage<T>& target_umt = stack::pop<user<usertype_storage<T>>>(L);
+ return target_umt;
+ }
+
+ template <typename T>
+ inline usertype_storage<T>& get_usertype_storage(lua_State* L) {
+ const char* gcmetakey = &usertype_traits<T>::gc_table()[0];
+ stack::get_field<true>(L, gcmetakey);
+ usertype_storage<T>& target_umt = stack::pop<user<usertype_storage<T>>>(L);
+ return target_umt;
+ }
+
+ template <typename T>
+ inline void delete_usertype_storage(lua_State* L) {
+ using u_traits = usertype_traits<T>;
+#if 0
+ using u_const_traits = usertype_traits<const T>;
+ using u_unique_traits = usertype_traits<detail::unique_usertype<T>>;
+ using u_ref_traits = usertype_traits<T*>;
+ using u_const_ref_traits = usertype_traits<T const*>;
+#endif
+ using uts = usertype_storage<T>;
+
+ const char* gcmetakey = &u_traits::gc_table()[0];
+ stack::get_field<true>(L, gcmetakey);
+ if (!stack::check<user<uts>>(L)) {
+ lua_pop(L, 1);
+ return;
+ }
+ usertype_storage<T>& target_umt = stack::pop<user<usertype_storage<T>>>(L);
+ target_umt.clear();
+
+ // get the registry
+#if 0
+ stack_reference registry(L, raw_index(LUA_REGISTRYINDEX));
+ registry.push();
+ // eliminate all named entries for this usertype
+ // in the registry (luaL_newmetatable does
+ // [name] = new table
+ // in registry upon creation
+ stack::set_field(L, &u_traits::metatable()[0], lua_nil, registry.stack_index());
+ stack::set_field(L, &u_const_traits::metatable()[0], lua_nil, registry.stack_index());
+ stack::set_field(L, &u_const_ref_traits::metatable()[0], lua_nil, registry.stack_index());
+ stack::set_field(L, &u_ref_traits::metatable()[0], lua_nil, registry.stack_index());
+ stack::set_field(L, &u_unique_traits::metatable()[0], lua_nil, registry.stack_index());
+ registry.pop();
+#endif // Registry Cleanout
+
+ stack::set_field<true>(L, gcmetakey, lua_nil);
+ }
+
+ template <typename T>
+ inline int register_usertype(lua_State* L, automagic_enrollments enrollments = {}) {
+ using u_traits = usertype_traits<T>;
+ using u_const_traits = usertype_traits<const T>;
+ using u_unique_traits = usertype_traits<detail::unique_usertype<T>>;
+ using u_ref_traits = usertype_traits<T*>;
+ using u_const_ref_traits = usertype_traits<T const*>;
+ using uts = usertype_storage<T>;
+
+ // always have __new_index point to usertype_storage method
+ // have __index always point to regular fast-lookup
+ // meta_method table
+ // if __new_index is invoked, runtime-swap
+ // to slow __index if necessary
+ // (no speed penalty because function calls
+ // are all read-only -- only depend on __index
+ // to retrieve function and then call happens VIA Lua)
+
+ // __type entry:
+ // table contains key -> value lookup,
+ // where key is entry in metatable
+ // and value is type information as a string as
+ // best as we can give it
+
+ // name entry:
+ // string that contains raw class name,
+ // as defined from C++
+
+ // is entry:
+ // checks if argument supplied is of type T
+
+ // __storage entry:
+ // a light userdata pointing to the storage
+ // mostly to enable this new abstraction
+ // to not require the type name `T`
+ // to get at the C++ usertype storage within
+
+ // we then let typical definitions potentially override these intrinsics
+ // it's the user's fault if they override things or screw them up:
+ // these names have been reserved and documented since sol3
+
+ // STEP 0: tell the old usertype (if it exists)
+ // to fuck off
+ delete_usertype_storage<T>(L);
+
+ // STEP 1: Create backing store for usertype storage
+ // Pretty much the most important step.
+ // STEP 2: Create Lua tables used for fast method indexing.
+ // This is done inside of the storage table's constructor
+ usertype_storage<T>& storage = create_usertype_storage<T>(L);
+ usertype_storage_base& base_storage = storage;
+ void* light_storage = static_cast<void*>(&storage);
+ void* light_base_storage = static_cast<void*>(&base_storage);
+
+ // STEP 3: set up GC escape hatch table entirely
+ storage.gc_names_table.push();
+ stack_reference gnt(L, -1);
+ stack::set_field(L, submetatable_type::named, &u_traits::gc_table()[0], gnt.stack_index());
+ stack::set_field(L, submetatable_type::const_value, &u_const_traits::metatable()[0], gnt.stack_index());
+ stack::set_field(L, submetatable_type::const_reference, &u_const_ref_traits::metatable()[0], gnt.stack_index());
+ stack::set_field(L, submetatable_type::reference, &u_ref_traits::metatable()[0], gnt.stack_index());
+ stack::set_field(L, submetatable_type::unique, &u_unique_traits::metatable()[0], gnt.stack_index());
+ stack::set_field(L, submetatable_type::value, &u_traits::metatable()[0], gnt.stack_index());
+ gnt.pop();
+
+ // STEP 4: add some useful information to the type table
+ stack_reference stacked_type_table(L, -storage.type_table.push());
+ stack::set_field(L, "name", detail::demangle<T>(), stacked_type_table.stack_index());
+ stack::set_field(L, "is", &detail::is_check<T>, stacked_type_table.stack_index());
+ stacked_type_table.pop();
+
+ // STEP 5: create and hook up metatable,
+ // add intrinsics
+ // this one is the actual meta-handling table,
+ // the next one will be the one for
+ int for_each_backing_metatable_calls = 0;
+ auto for_each_backing_metatable = [&](lua_State* L, submetatable_type smt, reference& fast_index_table) {
+ // Pointer types, AKA "references" from C++
+ const char* metakey = nullptr;
+ switch (smt) {
+ case submetatable_type::const_value:
+ metakey = &u_const_traits::metatable()[0];
+ break;
+ case submetatable_type::reference:
+ metakey = &u_ref_traits::metatable()[0];
+ break;
+ case submetatable_type::unique:
+ metakey = &u_unique_traits::metatable()[0];
+ break;
+ case submetatable_type::const_reference:
+ metakey = &u_const_ref_traits::metatable()[0];
+ break;
+ case submetatable_type::named:
+ metakey = &u_traits::user_metatable()[0];
+ break;
+ case submetatable_type::value:
+ default:
+ metakey = &u_traits::metatable()[0];
+ break;
+ }
+
+ luaL_newmetatable(L, metakey);
+ if (smt == submetatable_type::named) {
+ // the named table itself
+ // gets the associated name value
+ storage.named_metatable = reference(L, -1);
+ lua_pop(L, 1);
+ // but the thing we perform the methods on
+ // is still the metatable of the named
+ // table
+ lua_createtable(L, 0, 6);
+ }
+ stack_reference t(L, -1);
+ fast_index_table = reference(t);
+ stack::set_field<false, true>(L, meta_function::type, storage.type_table, t.stack_index());
+ if constexpr (std::is_destructible_v<T>) {
+ // destructible: serialize default
+ // destructor here
+ switch (smt) {
+ case submetatable_type::const_reference:
+ case submetatable_type::reference:
+ case submetatable_type::named:
+ break;
+ case submetatable_type::unique:
+ stack::set_field<false, true>(L, meta_function::garbage_collect, &detail::unique_destruct<T>, t.stack_index());
+ break;
+ case submetatable_type::value:
+ case submetatable_type::const_value:
+ default:
+ stack::set_field<false, true>(L, meta_function::garbage_collect, detail::make_destructor<T>(), t.stack_index());
+ break;
+ }
+ }
+ else {
+ // not destructible: serialize a
+ // "hey you messed up"
+ // destructor
+ switch (smt) {
+ case submetatable_type::const_reference:
+ case submetatable_type::reference:
+ case submetatable_type::named:
+ break;
+ case submetatable_type::unique:
+ stack::set_field<false, true>(L, meta_function::garbage_collect, &detail::cannot_destruct<T>, t.stack_index());
+ break;
+ case submetatable_type::value:
+ case submetatable_type::const_value:
+ default:
+ stack::set_field<false, true>(L, meta_function::garbage_collect, &detail::cannot_destruct<T>, t.stack_index());
+ break;
+ }
+ }
+
+ static_assert(sizeof(void*) <= sizeof(detail::inheritance_check_function),
+ "The size of this data pointer is too small to fit the inheritance checking function: file a bug "
+ "report.");
+ static_assert(sizeof(void*) <= sizeof(detail::inheritance_cast_function),
+ "The size of this data pointer is too small to fit the inheritance checking function: file a bug "
+ "report.");
+ stack::set_field<false, true>(L, detail::base_class_check_key(), reinterpret_cast<void*>(&detail::inheritance<T>::type_check), t.stack_index());
+ stack::set_field<false, true>(L, detail::base_class_cast_key(), reinterpret_cast<void*>(&detail::inheritance<T>::type_cast), t.stack_index());
+
+ auto prop_fx = detail::properties_enrollment_allowed(for_each_backing_metatable_calls, storage.properties, enrollments);
+ auto insert_fx = [&L, &t, &storage](meta_function mf, lua_CFunction reg) {
+ stack::set_field<false, true>(L, mf, reg, t.stack_index());
+ storage.properties[static_cast<int>(mf)] = true;
+ };
+ detail::insert_default_registrations<T>(insert_fx, prop_fx);
+
+ // There are no variables, so serialize the fast function stuff
+ // be sure to reset the index stuff to the non-fast version
+ // if the user ever adds something later!
+ if (smt == submetatable_type::named) {
+ // add escape hatch storage pointer and gc names
+ stack::set_field<false, true>(L, meta_function::storage, light_base_storage, t.stack_index());
+ stack::set_field<false, true>(L, meta_function::gc_names, storage.gc_names_table, t.stack_index());
+
+ // fancy new_indexing when using the named table
+ {
+ absolute_index named_metatable_index(L, -storage.named_metatable.push());
+ stack::set_field<false, true>(L, metatable_key, t, named_metatable_index);
+ storage.named_metatable.pop();
+ }
+ stack_reference stack_metametatable(L, -storage.named_index_table.push());
+ stack::set_field<false, true>(L,
+ meta_function::index,
+ make_closure(uts::template meta_index_call<false>, nullptr, light_storage, light_base_storage, nullptr, toplevel_magic),
+ stack_metametatable.stack_index());
+ stack::set_field<false, true>(L,
+ meta_function::new_index,
+ make_closure(uts::template meta_index_call<true>, nullptr, light_storage, light_base_storage, nullptr, toplevel_magic),
+ stack_metametatable.stack_index());
+ stack_metametatable.pop();
+ }
+ else {
+ // otherwise just plain for index,
+ // and elaborated for new_index
+ stack::set_field<false, true>(L, meta_function::index, t, t.stack_index());
+ stack::set_field<false, true>(L,
+ meta_function::new_index,
+ make_closure(uts::template index_call<true>, nullptr, light_storage, light_base_storage, nullptr, toplevel_magic),
+ t.stack_index());
+ storage.is_using_new_index = true;
+ }
+
+ ++for_each_backing_metatable_calls;
+ fast_index_table = reference(L, t);
+ t.pop();
+ };
+
+ storage.for_each_table(L, for_each_backing_metatable);
+
+ // can only use set AFTER we initialize all the metatables
+ if constexpr (std::is_default_constructible_v<T>) {
+ if (enrollments.default_constructor) {
+ storage.set(L, meta_function::construct, constructors<T()>());
+ }
+ }
+
+ // return the named metatable we want names linked into
+ storage.named_metatable.push();
+ return 1;
+ }
+}} // namespace sol::u_detail
+
+// end of sol/usertype_storage.hpp
+
+// beginning of sol/usertype_proxy.hpp
+
+namespace sol {
+ template <typename Table, typename Key>
+ struct usertype_proxy : public proxy_base<usertype_proxy<Table, Key>> {
+ private:
+ using key_type = detail::proxy_key_t<Key>;
+
+ template <typename T, std::size_t... I>
+ decltype(auto) tuple_get(std::index_sequence<I...>) const & {
+ return tbl.template traverse_get<T>(std::get<I>(key)...);
+ }
+
+ template <typename T, std::size_t... I>
+ decltype(auto) tuple_get(std::index_sequence<I...>) && {
+ return tbl.template traverse_get<T>(std::get<I>(std::move(key))...);
+ }
+
+ template <std::size_t... I, typename T>
+ void tuple_set(std::index_sequence<I...>, T&& value) & {
+ if constexpr (sizeof...(I) > 1) {
+ tbl.traverse_set(std::get<I>(key)..., std::forward<T>(value));
+ }
+ else {
+ tbl.set(std::get<I>(key)..., std::forward<T>(value));
+ }
+ }
+
+ template <std::size_t... I, typename T>
+ void tuple_set(std::index_sequence<I...>, T&& value) && {
+ if constexpr (sizeof...(I) > 1) {
+ tbl.traverse_set(std::get<I>(std::move(key))..., std::forward<T>(value));
+ }
+ else {
+ tbl.set(std::get<I>(std::move(key))..., std::forward<T>(value));
+ }
+ }
+
+ public:
+ Table tbl;
+ key_type key;
+
+ template <typename T>
+ usertype_proxy(Table table, T&& k)
+ : tbl(table), key(std::forward<T>(k)) {
+ }
+
+ template <typename T>
+ usertype_proxy& set(T&& item) & {
+ using idx_seq = std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>;
+ tuple_set(idx_seq(), std::forward<T>(item));
+ return *this;
+ }
+
+ template <typename T>
+ usertype_proxy&& set(T&& item) && {
+ using idx_seq = std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>;
+ std::move(*this).tuple_set(idx_seq(), std::forward<T>(item));
+ return std::move(*this);
+ }
+
+ template <typename T>
+ usertype_proxy& operator=(T&& other) & {
+ return set(std::forward<T>(other));
+ }
+
+ template <typename T>
+ usertype_proxy&& operator=(T&& other) && {
+ return std::move(*this).set(std::forward<T>(other));
+ }
+
+ template <typename T>
+ usertype_proxy& operator=(std::initializer_list<T> other) & {
+ return set(std::move(other));
+ }
+
+ template <typename T>
+ usertype_proxy&& operator=(std::initializer_list<T> other) && {
+ return std::move(*this).set(std::move(other));
+ }
+
+ template <typename T>
+ decltype(auto) get() const& {
+ using idx_seq = std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>;
+ return tuple_get<T>(idx_seq());
+ }
+
+ template <typename T>
+ decltype(auto) get() && {
+ using idx_seq = std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>;
+ return std::move(*this).template tuple_get<T>(idx_seq());
+ }
+
+ template <typename K>
+ decltype(auto) operator[](K&& k) const& {
+ auto keys = meta::tuplefy(key, std::forward<K>(k));
+ return usertype_proxy<Table, decltype(keys)>(tbl, std::move(keys));
+ }
+
+ template <typename K>
+ decltype(auto) operator[](K&& k) & {
+ auto keys = meta::tuplefy(key, std::forward<K>(k));
+ return usertype_proxy<Table, decltype(keys)>(tbl, std::move(keys));
+ }
+
+ template <typename K>
+ decltype(auto) operator[](K&& k) && {
+ auto keys = meta::tuplefy(std::move(key), std::forward<K>(k));
+ return usertype_proxy<Table, decltype(keys)>(tbl, std::move(keys));
+ }
+
+ template <typename... Ret, typename... Args>
+ decltype(auto) call(Args&&... args) {
+#if !defined(__clang__) && defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 191200000
+ // MSVC is ass sometimes
+ return get<function>().call<Ret...>(std::forward<Args>(args)...);
+#else
+ return get<function>().template call<Ret...>(std::forward<Args>(args)...);
+#endif
+ }
+
+ template <typename... Args>
+ decltype(auto) operator()(Args&&... args) {
+ return call<>(std::forward<Args>(args)...);
+ }
+
+ bool valid() const {
+ auto pp = stack::push_pop(tbl);
+ auto p = stack::probe_get_field<std::is_same<meta::unqualified_t<Table>, global_table>::value>(lua_state(), key, lua_gettop(lua_state()));
+ lua_pop(lua_state(), p.levels);
+ return p;
+ }
+
+ int push() const noexcept {
+ return push(this->lua_state());
+ }
+
+ int push(lua_State* L) const noexcept {
+ return get<reference>().push(L);
+ }
+
+ type get_type() const {
+ type t = type::none;
+ auto pp = stack::push_pop(tbl);
+ auto p = stack::probe_get_field<std::is_same<meta::unqualified_t<Table>, global_table>::value>(lua_state(), key, lua_gettop(lua_state()));
+ if (p) {
+ t = type_of(lua_state(), -1);
+ }
+ lua_pop(lua_state(), p.levels);
+ return t;
+ }
+
+ lua_State* lua_state() const {
+ return tbl.lua_state();
+ }
+ };
+} // namespace sol
+
+// end of sol/usertype_proxy.hpp
+
+// beginning of sol/metatable.hpp
+
+// beginning of sol/table_core.hpp
+
+// beginning of sol/table_proxy.hpp
+
+namespace sol {
+
+ template <typename Table, typename Key>
+ struct table_proxy : public proxy_base<table_proxy<Table, Key>> {
+ private:
+ using key_type = detail::proxy_key_t<Key>;
+
+ template <typename T, std::size_t... I>
+ decltype(auto) tuple_get(std::index_sequence<I...>) const& {
+ return tbl.template traverse_get<T>(std::get<I>(key)...);
+ }
+
+ template <typename T, std::size_t... I>
+ decltype(auto) tuple_get(std::index_sequence<I...>) && {
+ return tbl.template traverse_get<T>(std::get<I>(std::move(key))...);
+ }
+
+ template <std::size_t... I, typename T>
+ void tuple_set(std::index_sequence<I...>, T&& value) & {
+ tbl.traverse_set(std::get<I>(key)..., std::forward<T>(value));
+ }
+
+ template <std::size_t... I, typename T>
+ void tuple_set(std::index_sequence<I...>, T&& value) && {
+ tbl.traverse_set(std::get<I>(std::move(key))..., std::forward<T>(value));
+ }
+
+ auto setup_table(std::true_type) {
+ auto p = stack::probe_get_field<std::is_same_v<meta::unqualified_t<Table>, global_table>>(lua_state(), key, tbl.stack_index());
+ lua_pop(lua_state(), p.levels);
+ return p;
+ }
+
+ bool is_valid(std::false_type) {
+ auto pp = stack::push_pop(tbl);
+ auto p = stack::probe_get_field<std::is_same_v<meta::unqualified_t<Table>, global_table>>(lua_state(), key, lua_gettop(lua_state()));
+ lua_pop(lua_state(), p.levels);
+ return p;
+ }
+
+ public:
+ Table tbl;
+ key_type key;
+
+ template <typename T>
+ table_proxy(Table table, T&& k) : tbl(table), key(std::forward<T>(k)) {
+ }
+
+ template <typename T>
+ table_proxy& set(T&& item) & {
+ tuple_set(std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>(), std::forward<T>(item));
+ return *this;
+ }
+
+ template <typename T>
+ table_proxy&& set(T&& item) && {
+ tuple_set(std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>(), std::forward<T>(item));
+ return std::move(*this);
+ }
+
+ template <typename... Args>
+ table_proxy& set_function(Args&&... args) & {
+ tbl.set_function(key, std::forward<Args>(args)...);
+ return *this;
+ }
+
+ template <typename... Args>
+ table_proxy&& set_function(Args&&... args) && {
+ tbl.set_function(std::move(key), std::forward<Args>(args)...);
+ return std::move(*this);
+ }
+
+ template <typename T>
+ table_proxy& operator=(T&& other) & {
+ using Tu = meta::unwrap_unqualified_t<T>;
+ if constexpr (!is_lua_reference_or_proxy_v<Tu> && meta::is_callable_v<Tu>) {
+ return set_function(std::forward<T>(other));
+ }
+ else {
+ return set(std::forward<T>(other));
+ }
+ }
+
+ template <typename T>
+ table_proxy&& operator=(T&& other) && {
+ using Tu = meta::unwrap_unqualified_t<T>;
+ if constexpr (!is_lua_reference_or_proxy_v<Tu> && meta::is_callable_v<Tu>) {
+ return std::move(*this).set_function(std::forward<T>(other));
+ }
+ else {
+ return std::move(*this).set(std::forward<T>(other));
+ }
+ }
+
+ template <typename T>
+ table_proxy& operator=(std::initializer_list<T> other) & {
+ return set(std::move(other));
+ }
+
+ template <typename T>
+ table_proxy&& operator=(std::initializer_list<T> other) && {
+ return std::move(*this).set(std::move(other));
+ }
+
+ template <typename T>
+ decltype(auto) get() const& {
+ using idx_seq = std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>;
+ return tuple_get<T>(idx_seq());
+ }
+
+ template <typename T>
+ decltype(auto) get() && {
+ using idx_seq = std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>;
+ return std::move(*this).template tuple_get<T>(idx_seq());
+ }
+
+ template <typename T>
+ decltype(auto) get_or(T&& otherwise) const {
+ typedef decltype(get<T>()) U;
+ optional<U> option = get<optional<U>>();
+ if (option) {
+ return static_cast<U>(option.value());
+ }
+ return static_cast<U>(std::forward<T>(otherwise));
+ }
+
+ template <typename T, typename D>
+ decltype(auto) get_or(D&& otherwise) const {
+ optional<T> option = get<optional<T>>();
+ if (option) {
+ return static_cast<T>(option.value());
+ }
+ return static_cast<T>(std::forward<D>(otherwise));
+ }
+
+ template <typename T>
+ decltype(auto) get_or_create() {
+ return get_or_create<T>(new_table());
+ }
+
+ template <typename T, typename Otherwise>
+ decltype(auto) get_or_create(Otherwise&& other) {
+ if (!this->valid()) {
+ this->set(std::forward<Otherwise>(other));
+ }
+ return get<T>();
+ }
+
+ template <typename K>
+ decltype(auto) operator[](K&& k) const& {
+ auto keys = meta::tuplefy(key, std::forward<K>(k));
+ return table_proxy<Table, decltype(keys)>(tbl, std::move(keys));
+ }
+
+ template <typename K>
+ decltype(auto) operator[](K&& k) & {
+ auto keys = meta::tuplefy(key, std::forward<K>(k));
+ return table_proxy<Table, decltype(keys)>(tbl, std::move(keys));
+ }
+
+ template <typename K>
+ decltype(auto) operator[](K&& k) && {
+ auto keys = meta::tuplefy(std::move(key), std::forward<K>(k));
+ return table_proxy<Table, decltype(keys)>(tbl, std::move(keys));
+ }
+
+ template <typename... Ret, typename... Args>
+ decltype(auto) call(Args&&... args) {
+ lua_State* L = this->lua_state();
+ push(L);
+ int idx = lua_gettop(L);
+ stack_aligned_function func(L, idx);
+ return func.call<Ret...>(std::forward<Args>(args)...);
+ }
+
+ template <typename... Args>
+ decltype(auto) operator()(Args&&... args) {
+ return call<>(std::forward<Args>(args)...);
+ }
+
+ bool valid() const {
+ auto pp = stack::push_pop(tbl);
+ auto p = stack::probe_get_field<std::is_same<meta::unqualified_t<Table>, global_table>::value>(lua_state(), key, lua_gettop(lua_state()));
+ lua_pop(lua_state(), p.levels);
+ return p;
+ }
+
+ int push() const noexcept {
+ return push(this->lua_state());
+ }
+
+ int push(lua_State* L) const noexcept {
+ if constexpr (std::is_same_v<meta::unqualified_t<Table>, global_table> || is_stack_table_v<meta::unqualified_t<Table>>) {
+ auto pp = stack::push_pop<true>(tbl);
+ int tableindex = pp.index_of(tbl);
+ int top_index = lua_gettop(L);
+ stack::get_field<true>(lua_state(), key, tableindex);
+ lua_replace(L, top_index + 1);
+ lua_settop(L, top_index + 1);
+ }
+ else {
+ auto pp = stack::push_pop<false>(tbl);
+ int tableindex = pp.index_of(tbl);
+ int aftertableindex = lua_gettop(L);
+ stack::get_field<false>(lua_state(), key, tableindex);
+ lua_replace(L, tableindex);
+ lua_settop(L, aftertableindex + 1);
+ }
+ return 1;
+ }
+
+ type get_type() const {
+ type t = type::none;
+ auto pp = stack::push_pop(tbl);
+ auto p = stack::probe_get_field<std::is_same<meta::unqualified_t<Table>, global_table>::value>(lua_state(), key, lua_gettop(lua_state()));
+ if (p) {
+ t = type_of(lua_state(), -1);
+ }
+ lua_pop(lua_state(), p.levels);
+ return t;
+ }
+
+ lua_State* lua_state() const {
+ return tbl.lua_state();
+ }
+
+ table_proxy& force() {
+ if (!this->valid()) {
+ this->set(new_table());
+ }
+ return *this;
+ }
+ };
+
+ template <typename Table, typename Key, typename T>
+ inline bool operator==(T&& left, const table_proxy<Table, Key>& right) {
+ using G = decltype(stack::get<T>(nullptr, 0));
+ return right.template get<optional<G>>() == left;
+ }
+
+ template <typename Table, typename Key, typename T>
+ inline bool operator==(const table_proxy<Table, Key>& right, T&& left) {
+ using G = decltype(stack::get<T>(nullptr, 0));
+ return right.template get<optional<G>>() == left;
+ }
+
+ template <typename Table, typename Key, typename T>
+ inline bool operator!=(T&& left, const table_proxy<Table, Key>& right) {
+ using G = decltype(stack::get<T>(nullptr, 0));
+ return right.template get<optional<G>>() != left;
+ }
+
+ template <typename Table, typename Key, typename T>
+ inline bool operator!=(const table_proxy<Table, Key>& right, T&& left) {
+ using G = decltype(stack::get<T>(nullptr, 0));
+ return right.template get<optional<G>>() != left;
+ }
+
+ template <typename Table, typename Key>
+ inline bool operator==(lua_nil_t, const table_proxy<Table, Key>& right) {
+ return !right.valid();
+ }
+
+ template <typename Table, typename Key>
+ inline bool operator==(const table_proxy<Table, Key>& right, lua_nil_t) {
+ return !right.valid();
+ }
+
+ template <typename Table, typename Key>
+ inline bool operator!=(lua_nil_t, const table_proxy<Table, Key>& right) {
+ return right.valid();
+ }
+
+ template <typename Table, typename Key>
+ inline bool operator!=(const table_proxy<Table, Key>& right, lua_nil_t) {
+ return right.valid();
+ }
+
+ template <bool b>
+ template <typename Super>
+ basic_reference<b>& basic_reference<b>::operator=(proxy_base<Super>&& r) {
+ basic_reference<b> v = r;
+ this->operator=(std::move(v));
+ return *this;
+ }
+
+ template <bool b>
+ template <typename Super>
+ basic_reference<b>& basic_reference<b>::operator=(const proxy_base<Super>& r) {
+ basic_reference<b> v = r;
+ this->operator=(std::move(v));
+ return *this;
+ }
+
+ namespace stack {
+ template <typename Table, typename Key>
+ struct unqualified_pusher<table_proxy<Table, Key>> {
+ static int push(lua_State* L, const table_proxy<Table, Key>& p) {
+ return p.push(L);
+ }
+ };
+ } // namespace stack
+} // namespace sol
+
+// end of sol/table_proxy.hpp
+
+// beginning of sol/table_iterator.hpp
+
+#include <iterator>
+
+namespace sol {
+
+ template <typename reference_type>
+ class basic_table_iterator {
+ public:
+ typedef object key_type;
+ typedef object mapped_type;
+ typedef std::pair<object, object> value_type;
+ typedef std::input_iterator_tag iterator_category;
+ typedef std::ptrdiff_t difference_type;
+ typedef value_type* pointer;
+ typedef value_type& reference;
+ typedef const value_type& const_reference;
+
+ private:
+ std::pair<object, object> kvp;
+ reference_type ref;
+ int tableidx = 0;
+ int keyidx = 0;
+ std::ptrdiff_t idx = 0;
+
+ public:
+ basic_table_iterator() : keyidx(-1), idx(-1) {
+ }
+
+ basic_table_iterator(reference_type x) : ref(std::move(x)) {
+ ref.push();
+ tableidx = lua_gettop(ref.lua_state());
+ stack::push(ref.lua_state(), lua_nil);
+ this->operator++();
+ if (idx == -1) {
+ return;
+ }
+ --idx;
+ }
+
+ basic_table_iterator& operator++() {
+ if (idx == -1)
+ return *this;
+
+ if (lua_next(ref.lua_state(), tableidx) == 0) {
+ idx = -1;
+ keyidx = -1;
+ return *this;
+ }
+ ++idx;
+ kvp.first = object(ref.lua_state(), -2);
+ kvp.second = object(ref.lua_state(), -1);
+ lua_pop(ref.lua_state(), 1);
+ // leave key on the stack
+ keyidx = lua_gettop(ref.lua_state());
+ return *this;
+ }
+
+ basic_table_iterator operator++(int) {
+ auto saved = *this;
+ this->operator++();
+ return saved;
+ }
+
+ reference operator*() {
+ return kvp;
+ }
+
+ const_reference operator*() const {
+ return kvp;
+ }
+
+ bool operator==(const basic_table_iterator& right) const {
+ return idx == right.idx;
+ }
+
+ bool operator!=(const basic_table_iterator& right) const {
+ return idx != right.idx;
+ }
+
+ ~basic_table_iterator() {
+ if (keyidx != -1) {
+ stack::remove(ref.lua_state(), keyidx, 1);
+ }
+ if (ref.lua_state() != nullptr && ref.valid()) {
+ stack::remove(ref.lua_state(), tableidx, 1);
+ }
+ }
+ };
+
+} // namespace sol
+
+// end of sol/table_iterator.hpp
+
+namespace sol {
+ namespace detail {
+ template <std::size_t n>
+ struct clean {
+ lua_State* L;
+ clean(lua_State* luastate) : L(luastate) {
+ }
+ ~clean() {
+ lua_pop(L, static_cast<int>(n));
+ }
+ };
+
+ struct ref_clean {
+ lua_State* L;
+ int& n;
+ ref_clean(lua_State* luastate, int& n) : L(luastate), n(n) {
+ }
+ ~ref_clean() {
+ lua_pop(L, static_cast<int>(n));
+ }
+ };
+
+ inline int fail_on_newindex(lua_State* L) {
+ return luaL_error(L, "sol: cannot modify the elements of an enumeration table");
+ }
+
+ } // namespace detail
+
+ template <bool top_level, typename ref_t>
+ class basic_table_core : public basic_object<ref_t> {
+ private:
+ using base_t = basic_object<ref_t>;
+
+ friend class state;
+ friend class state_view;
+ template <typename, typename>
+ friend class basic_usertype;
+ template <typename>
+ friend class basic_metatable;
+
+ template <bool raw, typename... Ret, typename... Keys>
+ decltype(auto) tuple_get(int table_index, Keys&&... keys) const {
+ if constexpr (sizeof...(Ret) < 2) {
+ return traverse_get_single_maybe_tuple<raw, Ret...>(table_index, std::forward<Keys>(keys)...);
+ }
+ else {
+ using multi_ret = decltype(stack::pop<std::tuple<Ret...>>(nullptr));
+ return multi_ret(traverse_get_single_maybe_tuple<raw, Ret>(table_index, std::forward<Keys>(keys))...);
+ }
+ }
+
+ template <bool raw, typename Ret, size_t... I, typename Key>
+ decltype(auto) traverse_get_single_tuple(int table_index, std::index_sequence<I...>, Key&& key) const {
+ return traverse_get_single<raw, Ret>(table_index, std::get<I>(std::forward<Key>(key))...);
+ }
+
+ template <bool raw, typename Ret, typename Key>
+ decltype(auto) traverse_get_single_maybe_tuple(int table_index, Key&& key) const {
+ if constexpr (meta::is_tuple_v<meta::unqualified_t<Key>>) {
+ return traverse_get_single_tuple<raw, Ret>(
+ table_index, std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<Key>>>(), std::forward<Key>(key));
+ }
+ else {
+ return traverse_get_single<raw, Ret>(table_index, std::forward<Key>(key));
+ }
+ }
+
+ template <bool raw, typename Ret, typename... Keys>
+ decltype(auto) traverse_get_single(int table_index, Keys&&... keys) const {
+ constexpr static bool global = top_level && (meta::count_for_to_pack_v<1, meta::is_c_str, meta::unqualified_t<Keys>...> > 0);
+ if constexpr (meta::is_optional_v<meta::unqualified_t<Ret>>) {
+ int popcount = 0;
+ detail::ref_clean c(base_t::lua_state(), popcount);
+ return traverse_get_deep_optional<global, raw, detail::insert_mode::none, Ret>(popcount, table_index, std::forward<Keys>(keys)...);
+ }
+ else {
+ detail::clean<sizeof...(Keys) - meta::count_for_pack_v<detail::is_insert_mode, meta::unqualified_t<Keys>...>> c(base_t::lua_state());
+ return traverse_get_deep<global, raw, detail::insert_mode::none, Ret>(table_index, std::forward<Keys>(keys)...);
+ }
+ }
+
+ template <bool raw, typename Pairs, std::size_t... I>
+ void tuple_set(std::index_sequence<I...>, Pairs&& pairs) {
+ constexpr static bool global = top_level
+ && (meta::count_even_for_pack_v<meta::is_c_str, meta::unqualified_t<decltype(std::get<I * 2>(std::forward<Pairs>(pairs)))>...> > 0);
+ auto pp = stack::push_pop<global>(*this);
+ int table_index = pp.index_of(*this);
+ lua_State* L = base_t::lua_state();
+ (void)table_index;
+ (void)L;
+ void(detail::swallow { (stack::set_field<(top_level), raw>(
+ L, std::get<I * 2>(std::forward<Pairs>(pairs)), std::get<I * 2 + 1>(std::forward<Pairs>(pairs)), table_index),
+ 0)... });
+ }
+
+ template <bool global, bool raw, detail::insert_mode mode, typename T, typename Key, typename... Keys>
+ decltype(auto) traverse_get_deep(int table_index, Key&& key, Keys&&... keys) const {
+ if constexpr (std::is_same_v<meta::unqualified_t<Key>, create_if_nil_t>) {
+ (void)key;
+ return traverse_get_deep<false, raw, static_cast<detail::insert_mode>(mode | detail::insert_mode::create_if_nil), T>(
+ table_index, std::forward<Keys>(keys)...);
+ }
+ else {
+ lua_State* L = base_t::lua_state();
+ stack::get_field<global, raw>(L, std::forward<Key>(key), table_index);
+ if constexpr (sizeof...(Keys) > 0) {
+ if constexpr ((mode & detail::insert_mode::create_if_nil) == detail::insert_mode::create_if_nil) {
+ type t = type_of(L, -1);
+ if (t == type::lua_nil || t == type::none) {
+ lua_pop(L, 1);
+ stack::push(L, new_table(0, 0));
+ }
+ }
+ return traverse_get_deep<false, raw, mode, T>(lua_gettop(L), std::forward<Keys>(keys)...);
+ }
+ else {
+ if constexpr ((mode & detail::insert_mode::create_if_nil) == detail::insert_mode::create_if_nil) {
+ type t = type_of(L, -1);
+ if ((t == type::lua_nil || t == type::none) && (is_table_like_v<T>)) {
+ lua_pop(L, 1);
+ stack::push(L, new_table(0, 0));
+ }
+ }
+ return stack::get<T>(L);
+ }
+ }
+ }
+
+ template <bool global, bool raw, detail::insert_mode mode, typename T, typename Key, typename... Keys>
+ decltype(auto) traverse_get_deep_optional(int& popcount, int table_index, Key&& key, Keys&&... keys) const {
+ if constexpr (std::is_same_v<meta::unqualified_t<Key>, create_if_nil_t>) {
+ constexpr detail::insert_mode new_mode = static_cast<detail::insert_mode>(mode | detail::insert_mode::create_if_nil);
+ (void)key;
+ return traverse_get_deep_optional<global, raw, new_mode, T>(popcount, table_index, std::forward<Keys>(keys)...);
+ }
+ else if constexpr (std::is_same_v<meta::unqualified_t<Key>, update_if_empty_t>) {
+ constexpr detail::insert_mode new_mode = static_cast<detail::insert_mode>(mode | detail::insert_mode::update_if_empty);
+ (void)key;
+ return traverse_get_deep_optional<global, raw, new_mode, T>(popcount, table_index, std::forward<Keys>(keys)...);
+ }
+ else if constexpr (std::is_same_v<meta::unqualified_t<Key>, override_value_t>) {
+ constexpr detail::insert_mode new_mode = static_cast<detail::insert_mode>(mode | detail::insert_mode::override_value);
+ (void)key;
+ return traverse_get_deep_optional<global, raw, new_mode, T>(popcount, table_index, std::forward<Keys>(keys)...);
+ }
+ else {
+ if constexpr (sizeof...(Keys) > 0) {
+ lua_State* L = base_t::lua_state();
+ auto p = stack::probe_get_field<global, raw>(L, std::forward<Key>(key), table_index);
+ popcount += p.levels;
+ if (!p.success) {
+ if constexpr ((mode & detail::insert_mode::create_if_nil) == detail::insert_mode::create_if_nil) {
+ lua_pop(L, 1);
+ constexpr bool is_seq = meta::count_for_to_pack_v<1, std::is_integral, Keys...> > 0;
+ stack::push(L, new_table(static_cast<int>(is_seq), static_cast<int>(!is_seq)));
+ stack::set_field<global, raw>(L, std::forward<Key>(key), stack_reference(L, -1), table_index);
+ }
+ else {
+ return T(nullopt);
+ }
+ }
+ return traverse_get_deep_optional<false, raw, mode, T>(popcount, lua_gettop(L), std::forward<Keys>(keys)...);
+ }
+ else {
+ using R = decltype(stack::get<T>(nullptr));
+ using value_type = typename meta::unqualified_t<R>::value_type;
+ lua_State* L = base_t::lua_state();
+ auto p = stack::probe_get_field<global, raw, value_type>(L, key, table_index);
+ popcount += p.levels;
+ if (!p.success) {
+ if constexpr ((mode & detail::insert_mode::create_if_nil) == detail::insert_mode::create_if_nil) {
+ lua_pop(L, 1);
+ stack::push(L, new_table(0, 0));
+ stack::set_field<global, raw>(L, std::forward<Key>(key), stack_reference(L, -1), table_index);
+ if (stack::check<value_type>(L, lua_gettop(L), no_panic)) {
+ return stack::get<T>(L);
+ }
+ }
+ return R(nullopt);
+ }
+ return stack::get<T>(L);
+ }
+ }
+ }
+
+ template <bool global, bool raw, detail::insert_mode mode, typename Key, typename... Keys>
+ void traverse_set_deep(int table_index, Key&& key, Keys&&... keys) const {
+ using KeyU = meta::unqualified_t<Key>;
+ if constexpr (std::is_same_v<KeyU, update_if_empty_t>) {
+ (void)key;
+ traverse_set_deep<global, raw, static_cast<detail::insert_mode>(mode | detail::insert_mode::update_if_empty)>(
+ table_index, std::forward<Keys>(keys)...);
+ }
+ else if constexpr (std::is_same_v<KeyU, create_if_nil_t>) {
+ (void)key;
+ traverse_set_deep<global, raw, static_cast<detail::insert_mode>(mode | detail::insert_mode::create_if_nil)>(
+ table_index, std::forward<Keys>(keys)...);
+ }
+ else if constexpr (std::is_same_v<KeyU, override_value_t>) {
+ (void)key;
+ traverse_set_deep<global, raw, static_cast<detail::insert_mode>(mode | detail::insert_mode::override_value)>(
+ table_index, std::forward<Keys>(keys)...);
+ }
+ else {
+ lua_State* L = base_t::lua_state();
+ if constexpr (sizeof...(Keys) == 1) {
+ if constexpr ((mode & detail::insert_mode::update_if_empty) == detail::insert_mode::update_if_empty) {
+ auto p = stack::probe_get_field<global, raw>(L, key, table_index);
+ lua_pop(L, p.levels);
+ if (!p.success) {
+ stack::set_field<global, raw>(L, std::forward<Key>(key), std::forward<Keys>(keys)..., table_index);
+ }
+ }
+ else {
+ stack::set_field<global, raw>(L, std::forward<Key>(key), std::forward<Keys>(keys)..., table_index);
+ }
+ }
+ else {
+ if constexpr (mode != detail::insert_mode::none) {
+ stack::get_field<global, raw>(L, key, table_index);
+ type vt = type_of(L, -1);
+ if constexpr ((mode & detail::insert_mode::update_if_empty) == detail::insert_mode::update_if_empty
+ || (mode & detail::insert_mode::create_if_nil) == detail::insert_mode::create_if_nil) {
+ if (vt == type::lua_nil || vt == type::none) {
+ constexpr bool is_seq = meta::count_for_to_pack_v<1, std::is_integral, Keys...> > 0;
+ lua_pop(L, 1);
+ stack::push(L, new_table(static_cast<int>(is_seq), static_cast<int>(!is_seq)));
+ stack::set_field<global, raw>(L, std::forward<Key>(key), stack_reference(L, -1), table_index);
+ }
+ }
+ else {
+ if (vt != type::table) {
+ constexpr bool is_seq = meta::count_for_to_pack_v<1, std::is_integral, Keys...> > 0;
+ lua_pop(L, 1);
+ stack::push(L, new_table(static_cast<int>(is_seq), static_cast<int>(!is_seq)));
+ stack::set_field<global, raw>(L, std::forward<Key>(key), stack_reference(L, -1), table_index);
+ }
+ }
+ }
+ else {
+ stack::get_field<global, raw>(L, std::forward<Key>(key), table_index);
+ }
+ traverse_set_deep<false, raw, mode>(lua_gettop(L), std::forward<Keys>(keys)...);
+ }
+ }
+ }
+
+ basic_table_core(lua_State* L, detail::global_tag t) noexcept : base_t(L, t) {
+ }
+
+ protected:
+ basic_table_core(detail::no_safety_tag, lua_nil_t n) : base_t(n) {
+ }
+ basic_table_core(detail::no_safety_tag, lua_State* L, int index) : base_t(L, index) {
+ }
+ basic_table_core(detail::no_safety_tag, lua_State* L, ref_index index) : base_t(L, index) {
+ }
+ template <typename T,
+ 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>
+ basic_table_core(detail::no_safety_tag, T&& r) noexcept : base_t(std::forward<T>(r)) {
+ }
+ template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+ basic_table_core(detail::no_safety_tag, lua_State* L, T&& r) noexcept : base_t(L, std::forward<T>(r)) {
+ }
+
+ public:
+ using iterator = basic_table_iterator<ref_t>;
+ using const_iterator = iterator;
+
+ using base_t::lua_state;
+
+ basic_table_core() noexcept = default;
+ basic_table_core(const basic_table_core&) = default;
+ basic_table_core(basic_table_core&&) = default;
+ basic_table_core& operator=(const basic_table_core&) = default;
+ basic_table_core& operator=(basic_table_core&&) = default;
+ basic_table_core(const stack_reference& r) : basic_table_core(r.lua_state(), r.stack_index()) {
+ }
+ basic_table_core(stack_reference&& r) : basic_table_core(r.lua_state(), r.stack_index()) {
+ }
+ 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)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ auto pp = stack::push_pop(*this);
+ int table_index = pp.index_of(*this);
+ constructor_handler handler {};
+ stack::check<basic_table_core>(lua_state(), table_index, handler);
+#endif // Safety
+ }
+ basic_table_core(lua_State* L, const new_table& nt) : base_t(L, -stack::push(L, nt)) {
+ if (!is_stack_based<meta::unqualified_t<ref_t>>::value) {
+ lua_pop(L, 1);
+ }
+ }
+ 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_)
+ constructor_handler handler {};
+ stack::check<basic_table_core>(L, index, handler);
+#endif // Safety
+ }
+ 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_)
+ auto pp = stack::push_pop(*this);
+ int table_index = pp.index_of(*this);
+ constructor_handler handler {};
+ stack::check<basic_table_core>(lua_state(), table_index, handler);
+#endif // Safety
+ }
+ template <typename T,
+ 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>
+ 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 (!is_table<meta::unqualified_t<T>>::value) {
+ auto pp = stack::push_pop(*this);
+ int table_index = pp.index_of(*this);
+ constructor_handler handler {};
+ stack::check<basic_table_core>(lua_state(), table_index, handler);
+ }
+#endif // Safety
+ }
+ basic_table_core(lua_nil_t r) noexcept : basic_table_core(detail::no_safety, r) {
+ }
+
+ iterator begin() const {
+ if (this->get_type() == type::table) {
+ return iterator(*this);
+ }
+ return iterator();
+ }
+
+ iterator end() const {
+ return iterator();
+ }
+
+ const_iterator cbegin() const {
+ return begin();
+ }
+
+ const_iterator cend() const {
+ return end();
+ }
+
+ void clear() {
+ auto pp = stack::push_pop<false>(*this);
+ int table_index = pp.index_of(*this);
+ stack::clear(lua_state(), table_index);
+ }
+
+ template <typename... Ret, typename... Keys>
+ decltype(auto) get(Keys&&... keys) const {
+ static_assert(sizeof...(Keys) == sizeof...(Ret), "number of keys and number of return types do not match");
+ constexpr static bool global = meta::all<meta::boolean<top_level>, meta::is_c_str<meta::unqualified_t<Keys>>...>::value;
+ auto pp = stack::push_pop<global>(*this);
+ int table_index = pp.index_of(*this);
+ return tuple_get<false, Ret...>(table_index, std::forward<Keys>(keys)...);
+ }
+
+ template <typename T, typename Key>
+ decltype(auto) get_or(Key&& key, T&& otherwise) const {
+ typedef decltype(get<T>("")) U;
+ optional<U> option = get<optional<U>>(std::forward<Key>(key));
+ if (option) {
+ return static_cast<U>(option.value());
+ }
+ return static_cast<U>(std::forward<T>(otherwise));
+ }
+
+ template <typename T, typename Key, typename D>
+ decltype(auto) get_or(Key&& key, D&& otherwise) const {
+ optional<T> option = get<optional<T>>(std::forward<Key>(key));
+ if (option) {
+ return static_cast<T>(option.value());
+ }
+ return static_cast<T>(std::forward<D>(otherwise));
+ }
+
+ template <typename T, typename... Keys>
+ decltype(auto) traverse_get(Keys&&... keys) const {
+ static_assert(sizeof...(Keys) > 0, "must pass at least 1 key to get");
+ constexpr static bool global = top_level && (meta::count_for_to_pack_v<1, meta::is_c_str, meta::unqualified_t<Keys>...> > 0);
+ auto pp = stack::push_pop<global>(*this);
+ int table_index = pp.index_of(*this);
+ return traverse_get_single<false, T>(table_index, std::forward<Keys>(keys)...);
+ }
+
+ template <typename... Keys>
+ basic_table_core& traverse_set(Keys&&... keys) {
+ static_assert(sizeof...(Keys) > 1, "must pass at least 1 key and 1 value to set");
+ constexpr static bool global
+ = top_level && (meta::count_when_for_to_pack_v<detail::is_not_insert_mode, 1, meta::is_c_str, meta::unqualified_t<Keys>...> > 0);
+ auto pp = stack::push_pop<global>(*this);
+ int table_index = pp.index_of(*this);
+ lua_State* L = base_t::lua_state();
+ auto pn = stack::pop_n(L, static_cast<int>(sizeof...(Keys) - 2 - meta::count_for_pack_v<detail::is_insert_mode, meta::unqualified_t<Keys>...>));
+ traverse_set_deep<top_level, false, detail::insert_mode::none>(table_index, std::forward<Keys>(keys)...);
+ return *this;
+ }
+
+ template <typename... Args>
+ basic_table_core& set(Args&&... args) {
+ if constexpr (sizeof...(Args) == 2) {
+ traverse_set(std::forward<Args>(args)...);
+ }
+ else {
+ tuple_set<false>(std::make_index_sequence<sizeof...(Args) / 2>(), std::forward_as_tuple(std::forward<Args>(args)...));
+ }
+ return *this;
+ }
+
+ template <typename... Ret, typename... Keys>
+ decltype(auto) raw_get(Keys&&... keys) const {
+ static_assert(sizeof...(Keys) == sizeof...(Ret), "number of keys and number of return types do not match");
+ constexpr static bool global = top_level && (meta::count_for_to_pack_v<1, meta::is_c_str, meta::unqualified_t<Keys>...> > 0);
+ auto pp = stack::push_pop<global>(*this);
+ int table_index = pp.index_of(*this);
+ return tuple_get<true, Ret...>(table_index, std::forward<Keys>(keys)...);
+ }
+
+ template <typename T, typename Key>
+ decltype(auto) raw_get_or(Key&& key, T&& otherwise) const {
+ typedef decltype(raw_get<T>("")) U;
+ optional<U> option = raw_get<optional<U>>(std::forward<Key>(key));
+ if (option) {
+ return static_cast<U>(option.value());
+ }
+ return static_cast<U>(std::forward<T>(otherwise));
+ }
+
+ template <typename T, typename Key, typename D>
+ decltype(auto) raw_get_or(Key&& key, D&& otherwise) const {
+ optional<T> option = raw_get<optional<T>>(std::forward<Key>(key));
+ if (option) {
+ return static_cast<T>(option.value());
+ }
+ return static_cast<T>(std::forward<D>(otherwise));
+ }
+
+ template <typename T, typename... Keys>
+ decltype(auto) traverse_raw_get(Keys&&... keys) const {
+ constexpr static bool global = top_level && (meta::count_for_to_pack_v<1, meta::is_c_str, meta::unqualified_t<Keys>...> > 0);
+ auto pp = stack::push_pop<global>(*this);
+ int table_index = pp.index_of(*this);
+ return traverse_get_single<true, T>(table_index, std::forward<Keys>(keys)...);
+ }
+
+ template <typename... Keys>
+ basic_table_core& traverse_raw_set(Keys&&... keys) {
+ constexpr static bool global = top_level && (meta::count_for_to_pack_v<1, meta::is_c_str, meta::unqualified_t<Keys>...> > 0);
+ auto pp = stack::push_pop<global>(*this);
+ lua_State* L = base_t::lua_state();
+ auto pn = stack::pop_n(L, static_cast<int>(sizeof...(Keys) - 2 - meta::count_for_pack_v<detail::is_insert_mode, meta::unqualified_t<Keys>...>));
+ traverse_set_deep<top_level, true, false>(std::forward<Keys>(keys)...);
+ return *this;
+ }
+
+ template <typename... Args>
+ basic_table_core& raw_set(Args&&... args) {
+ tuple_set<true>(std::make_index_sequence<sizeof...(Args) / 2>(), std::forward_as_tuple(std::forward<Args>(args)...));
+ return *this;
+ }
+
+ template <typename Class, typename Key>
+ usertype<Class> new_usertype(Key&& key);
+
+ template <typename Class, typename Key>
+ usertype<Class> new_usertype(Key&& key, automagic_enrollments enrollment);
+
+ template <typename Class, typename Key, typename Arg, typename... Args,
+ typename = std::enable_if_t<!std::is_same_v<meta::unqualified_t<Arg>, automagic_enrollments>>>
+ usertype<Class> new_usertype(Key&& key, Arg&& arg, Args&&... args);
+
+ template <bool read_only = true, typename... Args>
+ table new_enum(const string_view& name, Args&&... args) {
+ table target = create_with(std::forward<Args>(args)...);
+ if (read_only) {
+ table x = create_with(meta_function::new_index, detail::fail_on_newindex, meta_function::index, target);
+ table shim = create_named(name, metatable_key, x);
+ return shim;
+ }
+ else {
+ set(name, target);
+ return target;
+ }
+ }
+
+ template <typename T, bool read_only = true>
+ table new_enum(const string_view& name, std::initializer_list<std::pair<string_view, T>> items) {
+ table target = create(static_cast<int>(items.size()), static_cast<int>(0));
+ for (const auto& kvp : items) {
+ target.set(kvp.first, kvp.second);
+ }
+ if constexpr (read_only) {
+ table x = create_with(meta_function::new_index, detail::fail_on_newindex, meta_function::index, target);
+ table shim = create_named(name, metatable_key, x);
+ return shim;
+ }
+ else {
+ set(name, target);
+ return target;
+ }
+ }
+
+ template <typename Key = object, typename Value = object, typename Fx>
+ void for_each(Fx&& fx) const {
+ lua_State* L = base_t::lua_state();
+ if constexpr (std::is_invocable_v<Fx, Key, Value>) {
+ auto pp = stack::push_pop(*this);
+ int table_index = pp.index_of(*this);
+ stack::push(L, lua_nil);
+ while (lua_next(L, table_index)) {
+ Key key(L, -2);
+ Value value(L, -1);
+ auto pn = stack::pop_n(L, 1);
+ fx(key, value);
+ }
+ }
+ else {
+ auto pp = stack::push_pop(*this);
+ int table_index = pp.index_of(*this);
+ stack::push(L, lua_nil);
+ while (lua_next(L, table_index)) {
+ Key key(L, -2);
+ Value value(L, -1);
+ auto pn = stack::pop_n(L, 1);
+ std::pair<Key&, Value&> keyvalue(key, value);
+ fx(keyvalue);
+ }
+ }
+ }
+
+ size_t size() const {
+ auto pp = stack::push_pop(*this);
+ int table_index = pp.index_of(*this);
+ lua_State* L = base_t::lua_state();
+ lua_len(L, table_index);
+ return stack::pop<size_t>(L);
+ }
+
+ bool empty() const {
+ return cbegin() == cend();
+ }
+
+ template <typename T>
+ auto operator[](T&& key) & {
+ return table_proxy<basic_table_core&, detail::proxy_key_t<T>>(*this, std::forward<T>(key));
+ }
+
+ template <typename T>
+ auto operator[](T&& key) const& {
+ return table_proxy<const basic_table_core&, detail::proxy_key_t<T>>(*this, std::forward<T>(key));
+ }
+
+ template <typename T>
+ auto operator[](T&& key) && {
+ return table_proxy<basic_table_core, detail::proxy_key_t<T>>(std::move(*this), std::forward<T>(key));
+ }
+
+ template <typename Sig, typename Key, typename... Args>
+ basic_table_core& set_function(Key&& key, Args&&... args) {
+ set_fx(types<Sig>(), std::forward<Key>(key), std::forward<Args>(args)...);
+ return *this;
+ }
+
+ template <typename Key, typename... Args>
+ basic_table_core& set_function(Key&& key, Args&&... args) {
+ set_fx(types<>(), std::forward<Key>(key), std::forward<Args>(args)...);
+ return *this;
+ }
+
+ template <typename... Args>
+ basic_table_core& add(Args&&... args) {
+ auto pp = stack::push_pop(*this);
+ int table_index = pp.index_of(*this);
+ lua_State* L = base_t::lua_state();
+ (void)detail::swallow { 0, (stack::set_ref(L, std::forward<Args>(args), table_index), 0)... };
+ return *this;
+ }
+
+ private:
+ template <typename R, typename... Args, typename Fx, typename Key, typename = std::invoke_result_t<Fx, Args...>>
+ void set_fx(types<R(Args...)>, Key&& key, Fx&& fx) {
+ set_resolved_function<R(Args...)>(std::forward<Key>(key), std::forward<Fx>(fx));
+ }
+
+ template <typename Fx, typename Key, meta::enable<meta::is_specialization_of<meta::unqualified_t<Fx>, overload_set>> = meta::enabler>
+ void set_fx(types<>, Key&& key, Fx&& fx) {
+ set(std::forward<Key>(key), std::forward<Fx>(fx));
+ }
+
+ template <typename Fx, typename Key, typename... Args,
+ meta::disable<meta::is_specialization_of<meta::unqualified_t<Fx>, overload_set>> = meta::enabler>
+ void set_fx(types<>, Key&& key, Fx&& fx, Args&&... args) {
+ set(std::forward<Key>(key), as_function_reference(std::forward<Fx>(fx), std::forward<Args>(args)...));
+ }
+
+ template <typename... Sig, typename... Args, typename Key>
+ void set_resolved_function(Key&& key, Args&&... args) {
+ set(std::forward<Key>(key), as_function_reference<function_sig<Sig...>>(std::forward<Args>(args)...));
+ }
+
+ public:
+ static inline table create(lua_State* L, int narr = 0, int nrec = 0) {
+ lua_createtable(L, narr, nrec);
+ table result(L);
+ lua_pop(L, 1);
+ return result;
+ }
+
+ template <typename Key, typename Value, typename... Args>
+ static inline table create(lua_State* L, int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
+ lua_createtable(L, narr, nrec);
+ table result(L);
+ result.set(std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
+ lua_pop(L, 1);
+ return result;
+ }
+
+ template <typename... Args>
+ static inline table create_with(lua_State* L, Args&&... args) {
+ static_assert(sizeof...(Args) % 2 == 0, "You must have an even number of arguments for a key, value ... list.");
+ constexpr int narr = static_cast<int>(meta::count_odd_for_pack_v<std::is_integral, Args...>);
+ return create(L, narr, static_cast<int>((sizeof...(Args) / 2) - narr), std::forward<Args>(args)...);
+ }
+
+ table create(int narr = 0, int nrec = 0) {
+ return create(base_t::lua_state(), narr, nrec);
+ }
+
+ template <typename Key, typename Value, typename... Args>
+ table create(int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
+ return create(base_t::lua_state(), narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
+ }
+
+ template <typename Name>
+ table create(Name&& name, int narr = 0, int nrec = 0) {
+ table x = create(base_t::lua_state(), narr, nrec);
+ this->set(std::forward<Name>(name), x);
+ return x;
+ }
+
+ template <typename Name, typename Key, typename Value, typename... Args>
+ table create(Name&& name, int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
+ table x = create(base_t::lua_state(), narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
+ this->set(std::forward<Name>(name), x);
+ return x;
+ }
+
+ template <typename... Args>
+ table create_with(Args&&... args) {
+ return create_with(base_t::lua_state(), std::forward<Args>(args)...);
+ }
+
+ template <typename Name, typename... Args>
+ table create_named(Name&& name, Args&&... args) {
+ static const int narr = static_cast<int>(meta::count_even_for_pack_v<std::is_integral, Args...>);
+ return create(std::forward<Name>(name), narr, (sizeof...(Args) / 2) - narr, std::forward<Args>(args)...);
+ }
+ };
+} // namespace sol
+
+// end of sol/table_core.hpp
+
+namespace sol {
+
+ template <typename base_type>
+ class basic_metatable : public basic_table<base_type> {
+ typedef basic_table<base_type> base_t;
+ friend class state;
+ friend class state_view;
+
+ protected:
+ basic_metatable(detail::no_safety_tag, lua_nil_t n) : base_t(n) {
+ }
+ basic_metatable(detail::no_safety_tag, lua_State* L, int index) : base_t(L, index) {
+ }
+ basic_metatable(detail::no_safety_tag, lua_State* L, ref_index index) : base_t(L, index) {
+ }
+ template <typename T,
+ 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>
+ basic_metatable(detail::no_safety_tag, T&& r) noexcept : base_t(std::forward<T>(r)) {
+ }
+ template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+ basic_metatable(detail::no_safety_tag, lua_State* L, T&& r) noexcept : base_t(L, std::forward<T>(r)) {
+ }
+
+ public:
+ using base_t::lua_state;
+
+ basic_metatable() noexcept = default;
+ basic_metatable(const basic_metatable&) = default;
+ basic_metatable(basic_metatable&&) = default;
+ basic_metatable& operator=(const basic_metatable&) = default;
+ basic_metatable& operator=(basic_metatable&&) = default;
+ basic_metatable(const stack_reference& r) : basic_metatable(r.lua_state(), r.stack_index()) {
+ }
+ basic_metatable(stack_reference&& r) : basic_metatable(r.lua_state(), r.stack_index()) {
+ }
+ 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)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ auto pp = stack::push_pop(*this);
+ constructor_handler handler{};
+ stack::check<basic_metatable>(lua_state(), -1, handler);
+#endif // Safety
+ }
+ basic_metatable(lua_State* L, int index = -1) : basic_metatable(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ constructor_handler handler{};
+ stack::check<basic_metatable>(L, index, handler);
+#endif // Safety
+ }
+ basic_metatable(lua_State* L, ref_index index) : basic_metatable(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ auto pp = stack::push_pop(*this);
+ constructor_handler handler{};
+ stack::check<basic_metatable>(lua_state(), -1, handler);
+#endif // Safety
+ }
+ template <typename T,
+ 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>
+ basic_metatable(T&& r) noexcept : basic_metatable(detail::no_safety, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ if (!is_table<meta::unqualified_t<T>>::value) {
+ auto pp = stack::push_pop(*this);
+ constructor_handler handler{};
+ stack::check<basic_metatable>(base_t::lua_state(), -1, handler);
+ }
+#endif // Safety
+ }
+ basic_metatable(lua_nil_t r) noexcept : basic_metatable(detail::no_safety, r) {
+ }
+
+ template <typename Key, typename Value>
+ void set(Key&& key, Value&& value);
+
+ void unregister() {
+ using ustorage_base = u_detail::usertype_storage_base;
+
+ lua_State* L = this->lua_state();
+
+ auto pp = stack::push_pop(*this);
+ int top = lua_gettop(L);
+
+ stack_reference mt(L, -1);
+ stack::get_field(L, meta_function::gc_names, mt.stack_index());
+ if (type_of(L, -1) != type::table) {
+ return;
+ }
+ stack_reference gc_names_table(L, -1);
+ stack::get_field(L, meta_function::storage, mt.stack_index());
+ if (type_of(L, -1) != type::lightuserdata) {
+ return;
+ }
+ ustorage_base& base_storage = *static_cast<ustorage_base*>(stack::get<void*>(L, -1));
+ std::array<string_view, 6> registry_traits;
+ for (std::size_t i = 0; i < registry_traits.size(); ++i) {
+ u_detail::submetatable_type smt = static_cast<u_detail::submetatable_type>(i);
+ stack::get_field<false, true>(L, smt, gc_names_table.stack_index());
+ registry_traits[i] = stack::get<string_view>(L, -1);
+ }
+
+ // get the registry
+ stack_reference registry(L, raw_index(LUA_REGISTRYINDEX));
+ registry.push();
+ // eliminate all named entries for this usertype
+ // in the registry (luaL_newmetatable does
+ // [name] = new table
+ // in registry upon creation)
+ for (std::size_t i = 0; i < registry_traits.size(); ++i) {
+ u_detail::submetatable_type smt = static_cast<u_detail::submetatable_type>(i);
+ const string_view& gcmetakey = registry_traits[i];
+ if (smt == u_detail::submetatable_type::named) {
+ // use .data() to make it treat it like a c string,
+ // which it is...
+ stack::set_field<true>(L, gcmetakey.data(), lua_nil);
+ }
+ else {
+ // do not change the values in the registry: they need to be present
+ // no matter what, for safety's sake
+ //stack::set_field(L, gcmetakey, lua_nil, registry.stack_index());
+ }
+ }
+
+ // destroy all storage and tables
+ base_storage.clear();
+
+ // 6 strings from gc_names table,
+ // + 1 registry,
+ // + 1 gc_names table
+ // + 1 light userdata of storage
+ // + 1 registry
+ // 10 total, 4 left since popping off 6 gc_names tables
+ lua_settop(L, top);
+ }
+ };
+
+} // namespace sol
+
+// end of sol/metatable.hpp
+
+namespace sol {
+
+ template <typename T, typename base_type>
+ class basic_usertype : private basic_metatable<base_type> {
+ private:
+ using base_t = basic_metatable<base_type>;
+ using table_base_t = basic_table<base_type>;
+
+ template <typename>
+ friend class basic_metatable;
+
+ template <bool, typename>
+ friend class basic_table_core;
+
+ template <std::size_t... I, typename... Args>
+ void tuple_set(std::index_sequence<I...>, std::tuple<Args...>&& args) {
+ (void)args;
+ (void)detail::swallow{ 0,
+ (this->set(std::get<I * 2>(std::move(args)), std::get<I * 2 + 1>(std::move(args))), 0)... };
+ }
+
+ public:
+ using base_t::base_t;
+
+ using base_t::pop;
+ using base_t::push;
+ using base_t::lua_state;
+ using base_t::get;
+ using base_t::set_function;
+ using base_t::traverse_set;
+ using base_t::traverse_get;
+ using base_t::unregister;
+
+ template <typename Key, typename Value>
+ void set(Key&& key, Value&& value) {
+ optional<u_detail::usertype_storage<T>&> maybe_uts = u_detail::maybe_get_usertype_storage<T>(this->lua_state());
+ if (maybe_uts) {
+ u_detail::usertype_storage<T>& uts = *maybe_uts;
+ uts.set(this->lua_state(), std::forward<Key>(key), std::forward<Value>(value));
+ }
+ else {
+ using ValueU = meta::unqualified_t<Value>;
+ // cannot get metatable: try regular table set?
+ if constexpr (detail::is_non_factory_constructor_v<ValueU> || detail::is_policy_v<ValueU>) {
+ // tag constructors so we don't get destroyed by lack of info
+ table_base_t::set(std::forward<Key>(key), detail::tagged<T, Value>(std::forward<Value>(value)));
+ }
+ else {
+ table_base_t::set(std::forward<Key>(key), std::forward<Value>(value));
+ }
+ }
+ }
+
+ template <typename Key>
+ usertype_proxy<basic_usertype&, std::decay_t<Key>> operator[](Key&& key) {
+ return usertype_proxy<basic_usertype&, std::decay_t<Key>>(*this, std::forward<Key>(key));
+ }
+
+ template <typename Key>
+ usertype_proxy<const basic_usertype&, std::decay_t<Key>> operator[](Key&& key) const {
+ return usertype_proxy<const basic_usertype&, std::decay_t<Key>>(*this, std::forward<Key>(key));
+ }
+ };
+
+} // namespace sol
+
+// end of sol/usertype.hpp
+
+// beginning of sol/table.hpp
+
+// beginning of sol/lua_table.hpp
+
+namespace sol {
+
+ template <typename ref_t>
+ struct basic_lua_table : basic_table_core<false, ref_t> {
+ private:
+ using base_t = basic_table_core<false, ref_t>;
+
+ friend class state;
+ friend class state_view;
+
+ public:
+ using base_t::lua_state;
+
+ basic_lua_table() noexcept = default;
+ basic_lua_table(const basic_lua_table&) = default;
+ basic_lua_table(basic_lua_table&&) = default;
+ basic_lua_table& operator=(const basic_lua_table&) = default;
+ basic_lua_table& operator=(basic_lua_table&&) = default;
+ basic_lua_table(const stack_reference& r) : basic_lua_table(r.lua_state(), r.stack_index()) {
+ }
+ basic_lua_table(stack_reference&& r) : basic_lua_table(r.lua_state(), r.stack_index()) {
+ }
+ 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)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ auto pp = stack::push_pop(*this);
+ constructor_handler handler{};
+ stack::check<basic_lua_table>(lua_state(), -1, handler);
+#endif // Safety
+ }
+ basic_lua_table(lua_State* L, const new_table& nt) : base_t(L, nt) {
+ if (!is_stack_based<meta::unqualified_t<ref_t>>::value) {
+ lua_pop(L, 1);
+ }
+ }
+ basic_lua_table(lua_State* L, int index = -1) : base_t(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ constructor_handler handler{};
+ stack::check<basic_lua_table>(L, index, handler);
+#endif // Safety
+ }
+ basic_lua_table(lua_State* L, ref_index index) : base_t(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ auto pp = stack::push_pop(*this);
+ constructor_handler handler{};
+ stack::check<basic_lua_table>(lua_state(), -1, handler);
+#endif // Safety
+ }
+ template <typename T,
+ 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>
+ 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 (!is_table<meta::unqualified_t<T>>::value) {
+ auto pp = stack::push_pop(*this);
+ constructor_handler handler{};
+ stack::check<basic_lua_table>(lua_state(), -1, handler);
+ }
+#endif // Safety
+ }
+ basic_lua_table(lua_nil_t r) noexcept : basic_lua_table(detail::no_safety, r) {
+ }
+ };
+
+}
+
+// end of sol/lua_table.hpp
+
+namespace sol {
+ typedef table_core<false> table;
+
+ template <bool is_global, typename base_type>
+ template <typename Class, typename Key>
+ usertype<Class> basic_table_core<is_global, base_type>::new_usertype(Key&& key) {
+ automagic_enrollments enrollments;
+ return this->new_usertype<Class>(std::forward<Key>(key), std::move(enrollments));
+ }
+
+ template <bool is_global, typename base_type>
+ template <typename Class, typename Key>
+ usertype<Class> basic_table_core<is_global, base_type>::new_usertype(Key&& key, automagic_enrollments enrollments) {
+ int mt_index = u_detail::register_usertype<Class>(this->lua_state(), std::move(enrollments));
+ usertype<Class> mt(this->lua_state(), -mt_index);
+ lua_pop(this->lua_state(), 1);
+ set(std::forward<Key>(key), mt);
+ return mt;
+ }
+
+ template <bool is_global, typename base_type>
+ template <typename Class, typename Key, typename Arg, typename... Args, typename>
+ usertype<Class> basic_table_core<is_global, base_type>::new_usertype(Key&& key, Arg&& arg, Args&&... args) {
+ automagic_enrollments enrollments;
+ enrollments.default_constructor = !detail::any_is_constructor_v<Arg, Args...>;
+ enrollments.destructor = !detail::any_is_destructor_v<Arg, Args...>;
+ usertype<Class> ut = this->new_usertype<Class>(std::forward<Key>(key), std::move(enrollments));
+ static_assert(sizeof...(Args) % 2 == static_cast<std::size_t>(!detail::any_is_constructor_v<Arg>),
+ "you must pass an even number of arguments to new_usertype after first passing a constructor");
+ if constexpr (detail::any_is_constructor_v<Arg>) {
+ ut.set(meta_function::construct, std::forward<Arg>(arg));
+ ut.tuple_set(std::make_index_sequence<(sizeof...(Args)) / 2>(), std::forward_as_tuple(std::forward<Args>(args)...));
+ }
+ else {
+ ut.tuple_set(std::make_index_sequence<(sizeof...(Args) + 1) / 2>(), std::forward_as_tuple(std::forward<Arg>(arg), std::forward<Args>(args)...));
+ }
+ return ut;
+ }
+
+ template <typename base_type>
+ template <typename Key, typename Value>
+ void basic_metatable<base_type>::set(Key&& key, Value&& value) {
+ this->push();
+ lua_State* L = this->lua_state();
+ int target = lua_gettop(L);
+ optional<u_detail::usertype_storage_base&> maybe_uts = u_detail::maybe_get_usertype_storage_base(L, target);
+ lua_pop(L, 1);
+ if (maybe_uts) {
+ u_detail::usertype_storage_base& uts = *maybe_uts;
+ uts.set(L, std::forward<Key>(key), std::forward<Value>(value));
+ }
+ else {
+ base_t::set(std::forward<Key>(key), std::forward<Value>(value));
+ }
+ }
+
+ namespace stack {
+ template <>
+ struct unqualified_getter<metatable_key_t> {
+ static table get(lua_State* L, int index = -1) {
+ if (lua_getmetatable(L, index) == 0) {
+ return table(L, ref_index(LUA_REFNIL));
+ }
+ return table(L, -1);
+ }
+ };
+ } // namespace stack
+} // namespace sol
+
+// end of sol/table.hpp
+
+// beginning of sol/state.hpp
+
+// beginning of sol/state_view.hpp
+
+// beginning of sol/environment.hpp
+
+namespace sol {
+
+ template <typename base_type>
+ struct basic_environment : basic_table<base_type> {
+ private:
+ typedef basic_table<base_type> base_t;
+
+ public:
+ using base_t::lua_state;
+
+ basic_environment() noexcept = default;
+ basic_environment(const basic_environment&) = default;
+ basic_environment(basic_environment&&) = default;
+ basic_environment& operator=(const basic_environment&) = default;
+ basic_environment& operator=(basic_environment&&) = default;
+ basic_environment(const stack_reference& r) : basic_environment(r.lua_state(), r.stack_index()) {
+ }
+ basic_environment(stack_reference&& r) : basic_environment(r.lua_state(), r.stack_index()) {
+ }
+
+ basic_environment(lua_State* L, new_table nt) : base_t(L, std::move(nt)) {
+ }
+ template <bool b>
+ basic_environment(lua_State* L, new_table t, const basic_reference<b>& fallback) : basic_environment(L, std::move(t)) {
+ stack_table mt(L, new_table(0, 1));
+ mt.set(meta_function::index, fallback);
+ this->set(metatable_key, mt);
+ mt.pop();
+ }
+
+ 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)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ constructor_handler handler {};
+ stack::check<env_key_t>(this->lua_state(), -1, handler);
+#endif // Safety
+ lua_pop(this->lua_state(), 2);
+ }
+ template <bool b>
+ 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)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ constructor_handler handler {};
+ stack::check<env_key_t>(this->lua_state(), -1, handler);
+#endif // Safety
+ lua_pop(this->lua_state(), 2);
+ }
+ basic_environment(lua_State* L, int index = -1) : base_t(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ constructor_handler handler {};
+ stack::check<basic_environment>(L, index, handler);
+#endif // Safety
+ }
+ basic_environment(lua_State* L, ref_index index) : base_t(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ auto pp = stack::push_pop(*this);
+ constructor_handler handler {};
+ stack::check<basic_environment>(L, -1, handler);
+#endif // Safety
+ }
+ template <typename T,
+ 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>
+ basic_environment(T&& r) noexcept : base_t(detail::no_safety, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ if (!is_environment<meta::unqualified_t<T>>::value) {
+ auto pp = stack::push_pop(*this);
+ constructor_handler handler {};
+ stack::check<basic_environment>(lua_state(), -1, handler);
+ }
+#endif // Safety
+ }
+ basic_environment(lua_nil_t r) noexcept : base_t(detail::no_safety, r) {
+ }
+
+ 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)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ if (!is_environment<meta::unqualified_t<T>>::value) {
+ auto pp = stack::push_pop(*this);
+ constructor_handler handler {};
+ stack::check<basic_environment>(lua_state(), -1, handler);
+ }
+#endif // Safety
+ }
+
+ template <typename T>
+ void set_on(const T& target) const {
+ lua_State* L = target.lua_state();
+ auto pp = stack::push_pop(target);
+#if SOL_LUA_VESION_I_ < 502
+ // Use lua_setfenv
+ this->push();
+ lua_setfenv(L, -2);
+#else
+ // Use upvalues as explained in Lua 5.2 and beyond's manual
+ this->push();
+ const char* name = lua_setupvalue(L, -2, 1);
+ if (name == nullptr) {
+ this->pop();
+ }
+#endif
+ }
+ };
+
+ template <typename T, typename E>
+ void set_environment(const basic_environment<E>& env, const T& target) {
+ env.set_on(target);
+ }
+
+ template <typename E = reference, typename T>
+ basic_environment<E> get_environment(const T& target) {
+ lua_State* L = target.lua_state();
+ auto pp = stack::pop_n(L, stack::push_environment_of(target));
+ return basic_environment<E>(L, -1);
+ }
+
+ struct this_environment {
+ optional<environment> env;
+
+ this_environment() : env(nullopt) {
+ }
+ this_environment(environment e) : env(std::move(e)) {
+ }
+ this_environment(const this_environment&) = default;
+ this_environment(this_environment&&) = default;
+ this_environment& operator=(const this_environment&) = default;
+ this_environment& operator=(this_environment&&) = default;
+
+ explicit operator bool() const {
+ return static_cast<bool>(env);
+ }
+
+ operator optional<environment> &() {
+ return env;
+ }
+
+ operator const optional<environment> &() const {
+ return env;
+ }
+
+ operator environment&() {
+ return env.value();
+ }
+
+ operator const environment&() const {
+ return env.value();
+ }
+ };
+
+ namespace stack {
+ template <>
+ struct unqualified_getter<env_key_t> {
+ static environment get(lua_State* L, int index, record& tracking) {
+ tracking.use(1);
+ return get_environment(stack_reference(L, raw_index(index)));
+ }
+ };
+
+ template <>
+ struct unqualified_getter<this_environment> {
+ static this_environment get(lua_State* L, int, record& tracking) {
+ tracking.use(0);
+ lua_Debug info;
+ // Level 0 means current function (this C function, which may or may not be useful for us?)
+ // Level 1 means next call frame up the stack. (Can be nothing if function called directly from C++ with lua_p/call)
+ int pre_stack_size = lua_gettop(L);
+ if (lua_getstack(L, 1, &info) != 1) {
+ if (lua_getstack(L, 0, &info) != 1) {
+ lua_settop(L, pre_stack_size);
+ return this_environment();
+ }
+ }
+ if (lua_getinfo(L, "f", &info) == 0) {
+ lua_settop(L, pre_stack_size);
+ return this_environment();
+ }
+
+ stack_reference f(L, -1);
+ environment env(env_key, f);
+ if (!env.valid()) {
+ lua_settop(L, pre_stack_size);
+ return this_environment();
+ }
+ return this_environment(std::move(env));
+ }
+ };
+ } // namespace stack
+} // namespace sol
+
+// end of sol/environment.hpp
+
+// beginning of sol/load_result.hpp
+
+#include <cstdint>
+
+namespace sol {
+ struct load_result : public proxy_base<load_result> {
+ private:
+ lua_State* L;
+ int index;
+ int returncount;
+ int popcount;
+ load_status err;
+
+ public:
+ load_result() noexcept = default;
+ 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) {
+ }
+
+ // We do not want anyone to copy these around willy-nilly
+ // Will likely break people, but also will probably get rid of quiet bugs that have
+ // been lurking. (E.g., Vanilla Lua will just quietly discard over-pops and under-pops:
+ // LuaJIT and other Lua engines will implode and segfault at random later times.)
+ load_result(const load_result&) = delete;
+ load_result& operator=(const load_result&) = delete;
+
+ load_result(load_result&& o) noexcept : L(o.L), index(o.index), returncount(o.returncount), popcount(o.popcount), err(o.err) {
+ // Must be manual, otherwise destructor will screw us
+ // return count being 0 is enough to keep things clean
+ // but we will be thorough
+ o.L = nullptr;
+ o.index = 0;
+ o.returncount = 0;
+ o.popcount = 0;
+ o.err = load_status::syntax;
+ }
+ load_result& operator=(load_result&& o) noexcept {
+ L = o.L;
+ index = o.index;
+ returncount = o.returncount;
+ popcount = o.popcount;
+ err = o.err;
+ // Must be manual, otherwise destructor will screw us
+ // return count being 0 is enough to keep things clean
+ // but we will be thorough
+ o.L = nullptr;
+ o.index = 0;
+ o.returncount = 0;
+ o.popcount = 0;
+ o.err = load_status::syntax;
+ return *this;
+ }
+
+ load_status status() const noexcept {
+ return err;
+ }
+
+ bool valid() const noexcept {
+ return status() == load_status::ok;
+ }
+
+ template <typename T>
+ T get() const {
+ using UT = meta::unqualified_t<T>;
+ if constexpr (meta::is_optional_v<UT>) {
+ using ValueType = typename UT::value_type;
+ if constexpr (std::is_same_v<ValueType, error>) {
+ if (valid()) {
+ return UT(nullopt);
+ }
+ return error(detail::direct_error, stack::get<std::string>(L, index));
+ }
+ else {
+ if (!valid()) {
+ return UT(nullopt);
+ }
+ return stack::get<UT>(L, index);
+ }
+ }
+ else {
+ if constexpr (std::is_same_v<T, error>) {
+#if SOL_IS_ON(SOL_SAFE_PROXIES_I_)
+ if (valid()) {
+ 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
+ return error(detail::direct_error, stack::get<std::string>(L, index));
+ }
+ else {
+#if SOL_IS_ON(SOL_SAFE_PROXIES_I_)
+ if (!valid()) {
+ type_panic_c_str(L, index, type_of(L, index), type::none);
+ }
+#endif // Check proxy type's safety
+ return stack::get<T>(L, index);
+ }
+ }
+ }
+
+ template <typename... Ret, typename... Args>
+ decltype(auto) call(Args&&... args) {
+#if !defined(__clang__) && defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 191200000
+ // MSVC is ass sometimes
+ return get<protected_function>().call<Ret...>(std::forward<Args>(args)...);
+#else
+ return get<protected_function>().template call<Ret...>(std::forward<Args>(args)...);
+#endif
+ }
+
+ template <typename... Args>
+ decltype(auto) operator()(Args&&... args) {
+ return call<>(std::forward<Args>(args)...);
+ }
+
+ lua_State* lua_state() const noexcept {
+ return L;
+ };
+ int stack_index() const noexcept {
+ return index;
+ };
+
+ ~load_result() {
+ stack::remove(L, index, popcount);
+ }
+ };
+} // namespace sol
+
+// end of sol/load_result.hpp
+
+// beginning of sol/state_handling.hpp
+
+// beginning of sol/lua_value.hpp
+
+namespace sol {
+ struct lua_value {
+ public:
+ struct arr : detail::ebco<std::initializer_list<lua_value>> {
+ private:
+ using base_t = detail::ebco<std::initializer_list<lua_value>>;
+
+ public:
+ using base_t::base_t;
+ };
+
+ private:
+ template <typename T>
+ using is_reference_or_lua_value_init_list
+ = meta::any<meta::is_specialization_of<T, std::initializer_list>, std::is_same<T, reference>, std::is_same<T, arr>>;
+
+ template <typename 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() {
+#if SOL_IS_ON(SOL_USE_THREAD_LOCAL_I_)
+ static thread_local lua_State* L = nullptr;
+#else
+ static lua_State* L = nullptr;
+#endif
+ return L;
+ }
+
+ reference ref_value;
+
+ public:
+ static void set_lua_state(lua_State* L) {
+ thread_local_lua_state() = L;
+ }
+
+ template <typename T, meta::disable<is_reference_or_lua_value_init_list<meta::unqualified_t<T>>> = meta::enabler>
+ lua_value(lua_State* L_, T&& value) : lua_value(((set_lua_state(L_)), std::forward<T>(value))) {
+ }
+
+ template <typename T, meta::disable<is_lua_value_single_constructible<meta::unqualified_t<T>>> = meta::enabler>
+ lua_value(T&& value) : ref_value(make_reference(thread_local_lua_state(), std::forward<T>(value))) {
+ }
+
+ lua_value(lua_State* L_, std::initializer_list<std::pair<lua_value, lua_value>> il)
+ : lua_value([&L_, &il]() {
+ set_lua_state(L_);
+ return std::move(il);
+ }()) {
+ }
+
+ lua_value(std::initializer_list<std::pair<lua_value, lua_value>> il) : ref_value(make_reference(thread_local_lua_state(), std::move(il))) {
+ }
+
+ lua_value(lua_State* L_, arr il)
+ : lua_value([&L_, &il]() {
+ set_lua_state(L_);
+ return std::move(il);
+ }()) {
+ }
+
+ lua_value(arr il) : ref_value(make_reference(thread_local_lua_state(), std::move(il.value()))) {
+ }
+
+ lua_value(lua_State* L_, reference r)
+ : lua_value([&L_, &r]() {
+ set_lua_state(L_);
+ return std::move(r);
+ }()) {
+ }
+
+ lua_value(reference r) : ref_value(std::move(r)) {
+ }
+
+ lua_value(const lua_value&) noexcept = default;
+ lua_value(lua_value&&) = default;
+ lua_value& operator=(const lua_value&) = default;
+ lua_value& operator=(lua_value&&) = default;
+
+ const reference& value() const& {
+ return ref_value;
+ }
+
+ reference& value() & {
+ return ref_value;
+ }
+
+ reference&& value() && {
+ return std::move(ref_value);
+ }
+
+ template <typename T>
+ decltype(auto) as() const {
+ ref_value.push();
+ return stack::pop<T>(ref_value.lua_state());
+ }
+
+ template <typename T>
+ bool is() const {
+ int r = ref_value.registry_index();
+ if (r == LUA_REFNIL)
+ return meta::any_same<meta::unqualified_t<T>, lua_nil_t, nullopt_t, std::nullptr_t>::value ? true : false;
+ if (r == LUA_NOREF)
+ return false;
+ auto pp = stack::push_pop(ref_value);
+ return stack::check<T>(ref_value.lua_state(), -1, no_panic);
+ }
+ };
+
+ using array_value = typename lua_value::arr;
+
+ namespace stack {
+ template <>
+ struct unqualified_pusher<lua_value> {
+ static int push(lua_State* L, const lua_value& lv) {
+ return stack::push(L, lv.value());
+ }
+
+ static int push(lua_State* L, lua_value&& lv) {
+ return stack::push(L, std::move(lv).value());
+ }
+ };
+
+ template <>
+ struct unqualified_getter<lua_value> {
+ static lua_value get(lua_State* L, int index, record& tracking) {
+ return lua_value(L, stack::get<reference>(L, index, tracking));
+ }
+ };
+ } // namespace stack
+} // namespace sol
+
+// end of sol/lua_value.hpp
+
+#if SOL_IS_ON(SOL_PRINT_ERRORS_I_)
+#include <iostream>
+#endif
+
+namespace sol {
+ inline void register_main_thread(lua_State* L) {
+#if SOL_LUA_VESION_I_ < 502
+ if (L == nullptr) {
+ lua_pushnil(L);
+ lua_setglobal(L, detail::default_main_thread_name());
+ return;
+ }
+ lua_pushthread(L);
+ lua_setglobal(L, detail::default_main_thread_name());
+#else
+ (void)L;
+#endif
+ }
+
+ inline int default_at_panic(lua_State* L) {
+#if SOL_IS_OFF(SOL_EXCEPTIONS_I_)
+ (void)L;
+ return -1;
+#else
+ size_t messagesize;
+ const char* message = lua_tolstring(L, -1, &messagesize);
+ if (message) {
+ std::string err(message, messagesize);
+ lua_settop(L, 0);
+#if SOL_IS_ON(SOL_PRINT_ERRORS_I_)
+ std::cerr << "[sol3] An error occurred and panic has been invoked: ";
+ std::cerr << err;
+ std::cerr << std::endl;
+#endif
+ throw error(err);
+ }
+ lua_settop(L, 0);
+ throw error(std::string("An unexpected error occurred and panic has been invoked"));
+#endif // Printing Errors
+ }
+
+ inline int default_traceback_error_handler(lua_State* L) {
+ std::string msg = "An unknown error has triggered the default error handler";
+ optional<string_view> maybetopmsg = stack::unqualified_check_get<string_view>(L, 1, no_panic);
+ if (maybetopmsg) {
+ const string_view& topmsg = maybetopmsg.value();
+ msg.assign(topmsg.data(), topmsg.size());
+ }
+ luaL_traceback(L, L, msg.c_str(), 1);
+ optional<string_view> maybetraceback = stack::unqualified_check_get<string_view>(L, -1, no_panic);
+ if (maybetraceback) {
+ const string_view& traceback = maybetraceback.value();
+ msg.assign(traceback.data(), traceback.size());
+ }
+#if SOL_IS_ON(SOL_PRINT_ERRORS_I_)
+ // std::cerr << "[sol3] An error occurred and was caught in traceback: ";
+ // std::cerr << msg;
+ // std::cerr << std::endl;
+#endif // Printing
+ return stack::push(L, msg);
+ }
+
+ inline void set_default_state(lua_State* L, lua_CFunction panic_function = &default_at_panic,
+ lua_CFunction traceback_function = c_call<decltype(&default_traceback_error_handler), &default_traceback_error_handler>,
+ exception_handler_function exf = detail::default_exception_handler) {
+ lua_atpanic(L, panic_function);
+ protected_function::set_default_handler(object(L, in_place, traceback_function));
+ set_default_exception_handler(L, exf);
+ register_main_thread(L);
+ stack::luajit_exception_handler(L);
+ lua_value::set_lua_state(L);
+ }
+
+ inline std::size_t total_memory_used(lua_State* L) {
+ std::size_t kb = lua_gc(L, LUA_GCCOUNT, 0);
+ kb *= 1024;
+ kb += lua_gc(L, LUA_GCCOUNTB, 0);
+ return kb;
+ }
+
+ inline protected_function_result script_pass_on_error(lua_State*, protected_function_result result) {
+ return result;
+ }
+
+ inline protected_function_result script_throw_on_error(lua_State* L, protected_function_result result) {
+ type t = type_of(L, result.stack_index());
+ std::string err = "sol: ";
+ err += to_string(result.status());
+ err += " error";
+#if SOL_IS_ON(SOL_EXCEPTIONS_I_)
+ std::exception_ptr eptr = std::current_exception();
+ if (eptr) {
+ err += " with a ";
+ try {
+ std::rethrow_exception(eptr);
+ }
+ catch (const std::exception& ex) {
+ err += "std::exception -- ";
+ err.append(ex.what());
+ }
+ catch (const std::string& message) {
+ err += "thrown message -- ";
+ err.append(message);
+ }
+ catch (const char* message) {
+ err += "thrown message -- ";
+ err.append(message);
+ }
+ catch (...) {
+ err.append("thrown but unknown type, cannot serialize into error message");
+ }
+ }
+#endif // serialize exception information if possible
+ if (t == type::string) {
+ err += ": ";
+ string_view serr = stack::unqualified_get<string_view>(L, result.stack_index());
+ err.append(serr.data(), serr.size());
+ }
+#if SOL_IS_ON(SOL_PRINT_ERRORS_I_)
+ std::cerr << "[sol3] An error occurred and has been passed to an error handler: ";
+ std::cerr << err;
+ std::cerr << std::endl;
+#endif
+ // replacing information of stack error into pfr
+ int target = result.stack_index();
+ if (result.pop_count() > 0) {
+ stack::remove(L, target, result.pop_count());
+ }
+ stack::push(L, err);
+ int top = lua_gettop(L);
+ int towards = top - target;
+ if (towards != 0) {
+ lua_rotate(L, top, towards);
+ }
+#if SOL_IS_OFF(SOL_EXCEPTIONS_I_)
+ return result;
+#else
+ // just throw our error
+ throw error(detail::direct_error, err);
+#endif // If exceptions are allowed
+ }
+
+ 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_)
+ return script_pass_on_error(L, std::move(pfr));
+#else
+ return script_throw_on_error(L, std::move(pfr));
+#endif
+ }
+
+ namespace stack {
+ inline error get_traceback_or_errors(lua_State* L) {
+ int p = default_traceback_error_handler(L);
+ sol::error err = stack::get<sol::error>(L, -p);
+ lua_pop(L, p);
+ return err;
+ }
+ } // namespace stack
+} // namespace sol
+
+// end of sol/state_handling.hpp
+
+#include <memory>
+#include <cstddef>
+
+namespace sol {
+
+ class state_view {
+ private:
+ lua_State* L;
+ table reg;
+ global_table global;
+
+ optional<object> is_loaded_package(const std::string& key) {
+ auto loaded = reg.traverse_get<optional<object>>("_LOADED", key);
+ bool is53mod = loaded && !(loaded->is<bool>() && !loaded->as<bool>());
+ if (is53mod)
+ return loaded;
+#if SOL_LUA_VESION_I_ <= 501
+ auto loaded51 = global.traverse_get<optional<object>>("package", "loaded", key);
+ bool is51mod = loaded51 && !(loaded51->is<bool>() && !loaded51->as<bool>());
+ if (is51mod)
+ return loaded51;
+#endif
+ return nullopt;
+ }
+
+ template <typename T>
+ void ensure_package(const std::string& key, T&& sr) {
+#if SOL_LUA_VESION_I_ <= 501
+ auto pkg = global["package"];
+ if (!pkg.valid()) {
+ pkg = create_table_with("loaded", create_table_with(key, sr));
+ }
+ else {
+ auto ld = pkg["loaded"];
+ if (!ld.valid()) {
+ ld = create_table_with(key, sr);
+ }
+ else {
+ ld[key] = sr;
+ }
+ }
+#endif
+ auto loaded = reg["_LOADED"];
+ if (!loaded.valid()) {
+ loaded = create_table_with(key, sr);
+ }
+ else {
+ loaded[key] = sr;
+ }
+ }
+
+ template <typename Fx>
+ object require_core(const std::string& key, Fx&& action, bool create_global = true) {
+ optional<object> loaded = is_loaded_package(key);
+ if (loaded && loaded->valid())
+ return std::move(*loaded);
+ action();
+ stack_reference sr(L, -1);
+ if (create_global)
+ set(key, sr);
+ ensure_package(key, sr);
+ return stack::pop<object>(L);
+ }
+
+ public:
+ using iterator = typename global_table::iterator;
+ using const_iterator = typename global_table::const_iterator;
+
+ state_view(lua_State* Ls) : L(Ls), reg(Ls, LUA_REGISTRYINDEX), global(Ls, detail::global_) {
+ }
+
+ state_view(this_state Ls) : state_view(Ls.L) {
+ }
+
+ lua_State* lua_state() const {
+ return L;
+ }
+
+ template <typename... Args>
+ void open_libraries(Args&&... args) {
+ static_assert(meta::all_same<lib, meta::unqualified_t<Args>...>::value, "all types must be libraries");
+ if constexpr (sizeof...(args) == 0) {
+ luaL_openlibs(L);
+ return;
+ }
+ else {
+ lib libraries[1 + sizeof...(args)] = { lib::count, std::forward<Args>(args)... };
+
+ for (auto&& library : libraries) {
+ switch (library) {
+#if SOL_LUA_VESION_I_ <= 501 && defined(SOL_LUAJIT)
+ case lib::coroutine:
+#endif // luajit opens coroutine base stuff
+ case lib::base:
+ luaL_requiref(L, "base", luaopen_base, 1);
+ lua_pop(L, 1);
+ break;
+ case lib::package:
+ luaL_requiref(L, "package", luaopen_package, 1);
+ lua_pop(L, 1);
+ break;
+#if !defined(SOL_LUAJIT)
+ case lib::coroutine:
+#if SOL_LUA_VESION_I_ > 501
+ luaL_requiref(L, "coroutine", luaopen_coroutine, 1);
+ lua_pop(L, 1);
+#endif // Lua 5.2+ only
+ break;
+#endif // Not LuaJIT - comes builtin
+ case lib::string:
+ luaL_requiref(L, "string", luaopen_string, 1);
+ lua_pop(L, 1);
+ break;
+ case lib::table:
+ luaL_requiref(L, "table", luaopen_table, 1);
+ lua_pop(L, 1);
+ break;
+ case lib::math:
+ luaL_requiref(L, "math", luaopen_math, 1);
+ lua_pop(L, 1);
+ break;
+ case lib::bit32:
+#ifdef SOL_LUAJIT
+ luaL_requiref(L, "bit32", luaopen_bit, 1);
+ lua_pop(L, 1);
+#elif (SOL_LUA_VESION_I_ == 502) || defined(LUA_COMPAT_BITLIB) || defined(LUA_COMPAT_5_2)
+ luaL_requiref(L, "bit32", luaopen_bit32, 1);
+ lua_pop(L, 1);
+#else
+#endif // Lua 5.2 only (deprecated in 5.3 (503)) (Can be turned on with Compat flags)
+ break;
+ case lib::io:
+ luaL_requiref(L, "io", luaopen_io, 1);
+ lua_pop(L, 1);
+ break;
+ case lib::os:
+ luaL_requiref(L, "os", luaopen_os, 1);
+ lua_pop(L, 1);
+ break;
+ case lib::debug:
+ luaL_requiref(L, "debug", luaopen_debug, 1);
+ lua_pop(L, 1);
+ break;
+ case lib::utf8:
+#if SOL_LUA_VESION_I_ > 502 && !defined(SOL_LUAJIT)
+ luaL_requiref(L, "utf8", luaopen_utf8, 1);
+ lua_pop(L, 1);
+#endif // Lua 5.3+ only
+ break;
+ case lib::ffi:
+#ifdef SOL_LUAJIT
+ luaL_requiref(L, "ffi", luaopen_ffi, 1);
+ lua_pop(L, 1);
+#endif // LuaJIT only
+ break;
+ case lib::jit:
+#ifdef SOL_LUAJIT
+ luaL_requiref(L, "jit", luaopen_jit, 0);
+ lua_pop(L, 1);
+#endif // LuaJIT Only
+ break;
+ case lib::count:
+ default:
+ break;
+ }
+ }
+ }
+ }
+
+ object require(const std::string& key, lua_CFunction open_function, bool create_global = true) {
+ luaL_requiref(L, key.c_str(), open_function, create_global ? 1 : 0);
+ return stack::pop<object>(L);
+ }
+
+ object require_script(const std::string& key, const string_view& code, bool create_global = true,
+ const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+ auto action = [this, &code, &chunkname, &mode]() { stack::script(L, code, chunkname, mode); };
+ return require_core(key, action, create_global);
+ }
+
+ object require_file(const std::string& key, const std::string& filename, bool create_global = true, load_mode mode = load_mode::any) {
+ auto action = [this, &filename, &mode]() { stack::script_file(L, filename, mode); };
+ return require_core(key, action, create_global);
+ }
+
+ void clear_package_loaders() {
+ optional<table> maybe_package = this->global["package"];
+ if (!maybe_package) {
+ // package lib wasn't opened
+ // open package lib
+ return;
+ }
+ table& package = *maybe_package;
+ // yay for version differences...
+ // one day Lua 5.1 will die a peaceful death
+ // and its old bones will find blissful rest
+ auto loaders_proxy = package
+#if SOL_LUA_VESION_I_ < 502
+ ["loaders"]
+#else
+ ["searchers"]
+#endif
+ ;
+ if (!loaders_proxy.valid()) {
+ // nothing to clear
+ return;
+ }
+ // we need to create the table for loaders
+ // table does not exist, so create and move forward
+ loaders_proxy = new_table(1, 0);
+ }
+
+ template <typename Fx>
+ void add_package_loader(Fx&& fx, bool clear_all_package_loaders = false) {
+ optional<table> maybe_package = this->global["package"];
+ if (!maybe_package) {
+ // package lib wasn't opened
+ // open package lib
+ return;
+ }
+ table& package = *maybe_package;
+ // yay for version differences...
+ // one day Lua 5.1 will die a peaceful death
+ // and its old bones will find blissful rest
+ auto loaders_proxy = package
+#if SOL_LUA_VESION_I_ < 502
+ ["loaders"]
+#else
+ ["searchers"]
+#endif
+ ;
+ bool make_new_table = clear_all_package_loaders || !loaders_proxy.valid();
+ if (make_new_table) {
+ // we need to create the table for loaders
+ // table does not exist, so create and move forward
+ loaders_proxy = new_table(1, 0);
+ }
+ optional<table> maybe_loaders = loaders_proxy;
+ if (!maybe_loaders) {
+ // loaders/searches
+ // thing exists in package, but it
+ // ain't a table or a table-alike...!
+ return;
+ }
+ table loaders = loaders_proxy;
+ loaders.add(std::forward<Fx>(fx));
+ }
+
+ template <typename E>
+ protected_function_result do_reader(lua_Reader reader, void* data, const basic_environment<E>& env,
+ const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+ detail::typical_chunk_name_t basechunkname = {};
+ const char* chunknametarget = detail::make_chunk_name("lua_Reader", chunkname, basechunkname);
+ load_status x = static_cast<load_status>(lua_load(L, reader, data, chunknametarget, to_string(mode).c_str()));
+ if (x != load_status::ok) {
+ return protected_function_result(L, absolute_index(L, -1), 0, 1, static_cast<call_status>(x));
+ }
+ stack_aligned_protected_function pf(L, -1);
+ set_environment(env, pf);
+ return pf();
+ }
+
+ protected_function_result do_reader(
+ lua_Reader reader, void* data, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+ detail::typical_chunk_name_t basechunkname = {};
+ const char* chunknametarget = detail::make_chunk_name("lua_Reader", chunkname, basechunkname);
+ load_status x = static_cast<load_status>(lua_load(L, reader, data, chunknametarget, to_string(mode).c_str()));
+ if (x != load_status::ok) {
+ return protected_function_result(L, absolute_index(L, -1), 0, 1, static_cast<call_status>(x));
+ }
+ stack_aligned_protected_function pf(L, -1);
+ return pf();
+ }
+
+ template <typename E>
+ protected_function_result do_string(const string_view& code, const basic_environment<E>& env,
+ const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+ detail::typical_chunk_name_t basechunkname = {};
+ const char* chunknametarget = detail::make_chunk_name(code, chunkname, basechunkname);
+ load_status x = static_cast<load_status>(luaL_loadbufferx(L, code.data(), code.size(), chunknametarget, to_string(mode).c_str()));
+ if (x != load_status::ok) {
+ return protected_function_result(L, absolute_index(L, -1), 0, 1, static_cast<call_status>(x));
+ }
+ stack_aligned_protected_function pf(L, -1);
+ set_environment(env, pf);
+ return pf();
+ }
+
+ protected_function_result do_string(
+ const string_view& code, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+ detail::typical_chunk_name_t basechunkname = {};
+ const char* chunknametarget = detail::make_chunk_name(code, chunkname, basechunkname);
+ load_status x = static_cast<load_status>(luaL_loadbufferx(L, code.data(), code.size(), chunknametarget, to_string(mode).c_str()));
+ if (x != load_status::ok) {
+ return protected_function_result(L, absolute_index(L, -1), 0, 1, static_cast<call_status>(x));
+ }
+ stack_aligned_protected_function pf(L, -1);
+ return pf();
+ }
+
+ template <typename E>
+ protected_function_result do_file(const std::string& filename, const basic_environment<E>& env, load_mode mode = load_mode::any) {
+ load_status x = static_cast<load_status>(luaL_loadfilex(L, filename.c_str(), to_string(mode).c_str()));
+ if (x != load_status::ok) {
+ return protected_function_result(L, absolute_index(L, -1), 0, 1, static_cast<call_status>(x));
+ }
+ stack_aligned_protected_function pf(L, -1);
+ set_environment(env, pf);
+ return pf();
+ }
+
+ protected_function_result do_file(const std::string& filename, load_mode mode = load_mode::any) {
+ load_status x = static_cast<load_status>(luaL_loadfilex(L, filename.c_str(), to_string(mode).c_str()));
+ if (x != load_status::ok) {
+ return protected_function_result(L, absolute_index(L, -1), 0, 1, static_cast<call_status>(x));
+ }
+ stack_aligned_protected_function pf(L, -1);
+ return pf();
+ }
+
+ template <typename Fx,
+ meta::disable_any<meta::is_string_constructible<meta::unqualified_t<Fx>>,
+ meta::is_specialization_of<meta::unqualified_t<Fx>, basic_environment>> = meta::enabler>
+ protected_function_result safe_script(
+ lua_Reader reader, void* data, Fx&& on_error, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+ protected_function_result pfr = do_reader(reader, data, chunkname, mode);
+ if (!pfr.valid()) {
+ return on_error(L, std::move(pfr));
+ }
+ return pfr;
+ }
+
+ protected_function_result safe_script(
+ lua_Reader reader, void* data, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+ return safe_script(reader, data, script_default_on_error, chunkname, mode);
+ }
+
+ template <typename Fx,
+ meta::disable_any<meta::is_string_constructible<meta::unqualified_t<Fx>>,
+ meta::is_specialization_of<meta::unqualified_t<Fx>, basic_environment>> = meta::enabler>
+ protected_function_result safe_script(
+ const string_view& code, Fx&& on_error, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+ protected_function_result pfr = do_string(code, chunkname, mode);
+ if (!pfr.valid()) {
+ return on_error(L, std::move(pfr));
+ }
+ return pfr;
+ }
+
+ template <typename Fx, typename E>
+ protected_function_result safe_script(const string_view& code, const basic_environment<E>& env, Fx&& on_error,
+ const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+ protected_function_result pfr = do_string(code, env, chunkname, mode);
+ if (!pfr.valid()) {
+ return on_error(L, std::move(pfr));
+ }
+ return pfr;
+ }
+
+ template <typename E>
+ protected_function_result safe_script(const string_view& code, const basic_environment<E>& env,
+ const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+ return safe_script(code, env, script_default_on_error, chunkname, mode);
+ }
+
+ protected_function_result safe_script(
+ const string_view& code, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+ return safe_script(code, script_default_on_error, chunkname, mode);
+ }
+
+ template <typename Fx,
+ meta::disable_any<meta::is_string_constructible<meta::unqualified_t<Fx>>,
+ meta::is_specialization_of<meta::unqualified_t<Fx>, basic_environment>> = meta::enabler>
+ protected_function_result safe_script_file(const std::string& filename, Fx&& on_error, load_mode mode = load_mode::any) {
+ protected_function_result pfr = do_file(filename, mode);
+ if (!pfr.valid()) {
+ return on_error(L, std::move(pfr));
+ }
+ return pfr;
+ }
+
+ template <typename Fx, typename E>
+ protected_function_result safe_script_file(
+ const std::string& filename, const basic_environment<E>& env, Fx&& on_error, load_mode mode = load_mode::any) {
+ protected_function_result pfr = do_file(filename, env, mode);
+ if (!pfr.valid()) {
+ return on_error(L, std::move(pfr));
+ }
+ return pfr;
+ }
+
+ template <typename E>
+ protected_function_result safe_script_file(const std::string& filename, const basic_environment<E>& env, load_mode mode = load_mode::any) {
+ return safe_script_file(filename, env, script_default_on_error, mode);
+ }
+
+ protected_function_result safe_script_file(const std::string& filename, load_mode mode = load_mode::any) {
+ return safe_script_file(filename, script_default_on_error, mode);
+ }
+
+ template <typename E>
+ unsafe_function_result unsafe_script(lua_Reader reader, void* data, const basic_environment<E>& env,
+ const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+ detail::typical_chunk_name_t basechunkname = {};
+ const char* chunknametarget = detail::make_chunk_name("lua_Reader", chunkname, basechunkname);
+ int index = lua_gettop(L);
+ if (lua_load(L, reader, data, chunknametarget, to_string(mode).c_str())) {
+ lua_error(L);
+ }
+ set_environment(env, stack_reference(L, raw_index(index + 1)));
+ if (lua_pcall(L, 0, LUA_MULTRET, 0)) {
+ lua_error(L);
+ }
+ int postindex = lua_gettop(L);
+ int returns = postindex - index;
+ return unsafe_function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
+ }
+
+ unsafe_function_result unsafe_script(
+ lua_Reader reader, void* data, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+ int index = lua_gettop(L);
+ stack::script(L, reader, data, chunkname, mode);
+ int postindex = lua_gettop(L);
+ int returns = postindex - index;
+ return unsafe_function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
+ }
+
+ template <typename E>
+ unsafe_function_result unsafe_script(const string_view& code, const basic_environment<E>& env,
+ const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+ detail::typical_chunk_name_t basechunkname = {};
+ const char* chunknametarget = detail::make_chunk_name(code, chunkname, basechunkname);
+ int index = lua_gettop(L);
+ if (luaL_loadbufferx(L, code.data(), code.size(), chunknametarget, to_string(mode).c_str())) {
+ lua_error(L);
+ }
+ set_environment(env, stack_reference(L, raw_index(index + 1)));
+ if (lua_pcall(L, 0, LUA_MULTRET, 0)) {
+ lua_error(L);
+ }
+ int postindex = lua_gettop(L);
+ int returns = postindex - index;
+ return unsafe_function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
+ }
+
+ unsafe_function_result unsafe_script(
+ const string_view& code, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+ int index = lua_gettop(L);
+ stack::script(L, code, chunkname, mode);
+ int postindex = lua_gettop(L);
+ int returns = postindex - index;
+ return unsafe_function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
+ }
+
+ template <typename E>
+ unsafe_function_result unsafe_script_file(const std::string& filename, const basic_environment<E>& env, load_mode mode = load_mode::any) {
+ int index = lua_gettop(L);
+ if (luaL_loadfilex(L, filename.c_str(), to_string(mode).c_str())) {
+ lua_error(L);
+ }
+ set_environment(env, stack_reference(L, raw_index(index + 1)));
+ if (lua_pcall(L, 0, LUA_MULTRET, 0)) {
+ lua_error(L);
+ }
+ int postindex = lua_gettop(L);
+ int returns = postindex - index;
+ return unsafe_function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
+ }
+
+ unsafe_function_result unsafe_script_file(const std::string& filename, load_mode mode = load_mode::any) {
+ int index = lua_gettop(L);
+ stack::script_file(L, filename, mode);
+ int postindex = lua_gettop(L);
+ int returns = postindex - index;
+ return unsafe_function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
+ }
+
+ template <typename Fx,
+ meta::disable_any<meta::is_string_constructible<meta::unqualified_t<Fx>>,
+ meta::is_specialization_of<meta::unqualified_t<Fx>, basic_environment>> = meta::enabler>
+ protected_function_result script(
+ const string_view& code, Fx&& on_error, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+ return safe_script(code, std::forward<Fx>(on_error), chunkname, mode);
+ }
+
+ template <typename Fx,
+ meta::disable_any<meta::is_string_constructible<meta::unqualified_t<Fx>>,
+ meta::is_specialization_of<meta::unqualified_t<Fx>, basic_environment>> = meta::enabler>
+ protected_function_result script_file(const std::string& filename, Fx&& on_error, load_mode mode = load_mode::any) {
+ return safe_script_file(filename, std::forward<Fx>(on_error), mode);
+ }
+
+ template <typename Fx, typename E>
+ protected_function_result script(const string_view& code, const basic_environment<E>& env, Fx&& on_error,
+ const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+ return safe_script(code, env, std::forward<Fx>(on_error), chunkname, mode);
+ }
+
+ template <typename Fx, typename E>
+ protected_function_result script_file(const std::string& filename, const basic_environment<E>& env, Fx&& on_error, load_mode mode = load_mode::any) {
+ return safe_script_file(filename, env, std::forward<Fx>(on_error), mode);
+ }
+
+ protected_function_result script(
+ const string_view& code, const environment& env, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+ return safe_script(code, env, script_default_on_error, chunkname, mode);
+ }
+
+ protected_function_result script_file(const std::string& filename, const environment& env, load_mode mode = load_mode::any) {
+ return safe_script_file(filename, env, script_default_on_error, mode);
+ }
+
+#if SOL_IS_ON(SOL_SAFE_FUNCTION_OBJECTS_I_)
+ protected_function_result script(
+ 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);
+ }
+
+ protected_function_result script(
+ const string_view& code, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+ return safe_script(code, chunkname, mode);
+ }
+
+ protected_function_result script_file(const std::string& filename, load_mode mode = load_mode::any) {
+ return safe_script_file(filename, mode);
+ }
+#else
+ unsafe_function_result script(const string_view& code, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+ return unsafe_script(code, chunkname, mode);
+ }
+
+ unsafe_function_result script_file(const std::string& filename, load_mode mode = load_mode::any) {
+ return unsafe_script_file(filename, mode);
+ }
+#endif
+ load_result load(const string_view& code, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+ detail::typical_chunk_name_t basechunkname = {};
+ const char* chunknametarget = detail::make_chunk_name(code, chunkname, basechunkname);
+ load_status x = static_cast<load_status>(luaL_loadbufferx(L, code.data(), code.size(), chunknametarget, to_string(mode).c_str()));
+ return load_result(L, absolute_index(L, -1), 1, 1, x);
+ }
+
+ load_result load_buffer(const char* buff, size_t size, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+ return load(string_view(buff, size), chunkname, mode);
+ }
+
+ load_result load_buffer(
+ const std::byte* buff, size_t size, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+ return load(string_view(reinterpret_cast<const char*>(buff), size), chunkname, mode);
+ }
+
+ load_result load_file(const std::string& filename, load_mode mode = load_mode::any) {
+ load_status x = static_cast<load_status>(luaL_loadfilex(L, filename.c_str(), to_string(mode).c_str()));
+ return load_result(L, absolute_index(L, -1), 1, 1, x);
+ }
+
+ load_result load(lua_Reader reader, void* data, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+ detail::typical_chunk_name_t basechunkname = {};
+ const char* chunknametarget = detail::make_chunk_name("lua_Reader", chunkname, basechunkname);
+ load_status x = static_cast<load_status>(lua_load(L, reader, data, chunknametarget, to_string(mode).c_str()));
+ return load_result(L, absolute_index(L, -1), 1, 1, x);
+ }
+
+ iterator begin() const {
+ return global.begin();
+ }
+
+ iterator end() const {
+ return global.end();
+ }
+
+ const_iterator cbegin() const {
+ return global.cbegin();
+ }
+
+ const_iterator cend() const {
+ return global.cend();
+ }
+
+ global_table globals() const {
+ // if we return a reference
+ // we'll be screwed a bit
+ return global;
+ }
+
+ global_table& globals() {
+ return global;
+ }
+
+ table registry() const {
+ return reg;
+ }
+
+ std::size_t memory_used() const {
+ return total_memory_used(lua_state());
+ }
+
+ int stack_top() const {
+ return stack::top(L);
+ }
+
+ int stack_clear() {
+ int s = stack_top();
+ lua_pop(L, s);
+ return s;
+ }
+
+ bool supports_gc_mode(gc_mode mode) const noexcept {
+#if SOL_LUA_VESION_I_ >= 504
+ // supports all modes
+ (void)mode;
+ return true;
+#endif
+ return mode == gc_mode::default_value;
+ }
+
+ bool is_gc_on() const {
+#if SOL_LUA_VESION_I_ >= 502
+ return lua_gc(lua_state(), LUA_GCISRUNNING, 0) == 1;
+#else
+ // You cannot turn it off in Lua 5.1
+ return true;
+#endif
+ }
+
+ void collect_garbage() {
+ lua_gc(lua_state(), LUA_GCCOLLECT, 0);
+ }
+
+ void collect_gc() {
+ collect_garbage();
+ }
+
+ bool step_gc(int step_size_kilobytes) {
+ // THOUGHT: std::chrono-alikes to map "kilobyte size" here...?
+ // Make it harder to give MB or KB to a B parameter...?
+ // Probably overkill for now.
+#if SOL_LUA_VESION_I_ >= 504
+ // The manual implies that this function is almost always successful...
+ // is it?? It could depend on the GC mode...
+ return lua_gc(lua_state(), LUA_GCSTEP, step_size_kilobytes) != 0;
+#else
+ return lua_gc(lua_state(), LUA_GCSTEP, step_size_kilobytes) == 1;
+#endif
+ }
+
+ void restart_gc() {
+ lua_gc(lua_state(), LUA_GCRESTART, 0);
+ }
+
+ void stop_gc() {
+ lua_gc(lua_state(), LUA_GCSTOP, 0);
+ }
+
+ // Returns the old GC mode. Check support using the supports_gc_mode function.
+ gc_mode change_gc_mode_incremental(int pause, int step_multiplier, int step_byte_size) {
+ // "What the fuck does any of this mean??"
+ // http://www.lua.org/manual/5.4/manual.html#2.5.1
+
+ // THOUGHT: std::chrono-alikes to map "byte size" here...?
+ // Make it harder to give MB or KB to a B parameter...?
+ // Probably overkill for now.
+#if SOL_LUA_VESION_I_ >= 504
+ int old_mode = lua_gc(lua_state(), LUA_GCINC, pause, step_multiplier, step_byte_size);
+ if (old_mode == LUA_GCGEN) {
+ return gc_mode::generational;
+ }
+ else if (old_mode == LUA_GCINC) {
+ return gc_mode::incremental;
+ }
+#else
+ lua_gc(lua_state(), LUA_GCSETPAUSE, pause);
+ lua_gc(lua_state(), LUA_GCSETSTEPMUL, step_multiplier);
+ (void)step_byte_size; // means nothing in older versions
+#endif
+ return gc_mode::default_value;
+ }
+
+ // Returns the old GC mode. Check support using the supports_gc_mode function.
+ gc_mode change_gc_mode_generational(int minor_multiplier, int major_multiplier) {
+#if SOL_LUA_VESION_I_ >= 504
+ // "What does this shit mean?"
+ // http://www.lua.org/manual/5.4/manual.html#2.5.2
+ int old_mode = lua_gc(lua_state(), LUA_GCGEN, minor_multiplier, major_multiplier);
+ if (old_mode == LUA_GCGEN) {
+ return gc_mode::generational;
+ }
+ else if (old_mode == LUA_GCINC) {
+ return gc_mode::incremental;
+ }
+#endif
+ return gc_mode::default_value;
+ }
+
+ operator lua_State*() const {
+ return lua_state();
+ }
+
+ void set_panic(lua_CFunction panic) {
+ lua_atpanic(lua_state(), panic);
+ }
+
+ void set_exception_handler(exception_handler_function handler) {
+ set_default_exception_handler(lua_state(), handler);
+ }
+
+ template <typename... Args, typename... Keys>
+ decltype(auto) get(Keys&&... keys) const {
+ return global.get<Args...>(std::forward<Keys>(keys)...);
+ }
+
+ template <typename T, typename Key>
+ decltype(auto) get_or(Key&& key, T&& otherwise) const {
+ return global.get_or(std::forward<Key>(key), std::forward<T>(otherwise));
+ }
+
+ template <typename T, typename Key, typename D>
+ decltype(auto) get_or(Key&& key, D&& otherwise) const {
+ return global.get_or<T>(std::forward<Key>(key), std::forward<D>(otherwise));
+ }
+
+ template <typename... Args>
+ state_view& set(Args&&... args) {
+ global.set(std::forward<Args>(args)...);
+ return *this;
+ }
+
+ template <typename T, typename... Keys>
+ decltype(auto) traverse_get(Keys&&... keys) const {
+ return global.traverse_get<T>(std::forward<Keys>(keys)...);
+ }
+
+ template <typename... Args>
+ state_view& traverse_set(Args&&... args) {
+ global.traverse_set(std::forward<Args>(args)...);
+ return *this;
+ }
+
+ template <typename Class, typename... Args>
+ usertype<Class> new_usertype(const std::string& name, Args&&... args) {
+ return global.new_usertype<Class>(name, std::forward<Args>(args)...);
+ }
+
+ template <bool read_only = true, typename... Args>
+ state_view& new_enum(const string_view& name, Args&&... args) {
+ global.new_enum<read_only>(name, std::forward<Args>(args)...);
+ return *this;
+ }
+
+ template <typename T, bool read_only = true>
+ state_view& new_enum(const string_view& name, std::initializer_list<std::pair<string_view, T>> items) {
+ global.new_enum<T, read_only>(name, std::move(items));
+ return *this;
+ }
+
+ template <typename Fx>
+ void for_each(Fx&& fx) {
+ global.for_each(std::forward<Fx>(fx));
+ }
+
+ template <typename T>
+ table_proxy<global_table&, detail::proxy_key_t<T>> operator[](T&& key) {
+ return global[std::forward<T>(key)];
+ }
+
+ template <typename T>
+ table_proxy<const global_table&, detail::proxy_key_t<T>> operator[](T&& key) const {
+ return global[std::forward<T>(key)];
+ }
+
+ template <typename Sig, typename... Args, typename Key>
+ state_view& set_function(Key&& key, Args&&... args) {
+ global.set_function<Sig>(std::forward<Key>(key), std::forward<Args>(args)...);
+ return *this;
+ }
+
+ template <typename... Args, typename Key>
+ state_view& set_function(Key&& key, Args&&... args) {
+ global.set_function(std::forward<Key>(key), std::forward<Args>(args)...);
+ return *this;
+ }
+
+ template <typename Name>
+ table create_table(Name&& name, int narr = 0, int nrec = 0) {
+ return global.create(std::forward<Name>(name), narr, nrec);
+ }
+
+ template <typename Name, typename Key, typename Value, typename... Args>
+ table create_table(Name&& name, int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
+ return global.create(std::forward<Name>(name), narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
+ }
+
+ template <typename Name, typename... Args>
+ table create_named_table(Name&& name, Args&&... args) {
+ table x = global.create_with(std::forward<Args>(args)...);
+ global.set(std::forward<Name>(name), x);
+ return x;
+ }
+
+ table create_table(int narr = 0, int nrec = 0) {
+ return create_table(lua_state(), narr, nrec);
+ }
+
+ template <typename Key, typename Value, typename... Args>
+ table create_table(int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
+ return create_table(lua_state(), narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
+ }
+
+ template <typename... Args>
+ table create_table_with(Args&&... args) {
+ return create_table_with(lua_state(), std::forward<Args>(args)...);
+ }
+
+ static inline table create_table(lua_State* L, int narr = 0, int nrec = 0) {
+ return global_table::create(L, narr, nrec);
+ }
+
+ template <typename Key, typename Value, typename... Args>
+ static inline table create_table(lua_State* L, int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
+ return global_table::create(L, narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
+ }
+
+ template <typename... Args>
+ static inline table create_table_with(lua_State* L, Args&&... args) {
+ return global_table::create_with(L, std::forward<Args>(args)...);
+ }
+ };
+} // namespace sol
+
+// end of sol/state_view.hpp
+
+// beginning of sol/thread.hpp
+
+namespace sol {
+ struct lua_thread_state {
+ lua_State* L;
+
+ lua_thread_state(lua_State* Ls)
+ : L(Ls) {
+ }
+
+ lua_State* lua_state() const noexcept {
+ return L;
+ }
+ operator lua_State*() const noexcept {
+ return lua_state();
+ }
+ lua_State* operator->() const noexcept {
+ return lua_state();
+ }
+ };
+
+ namespace stack {
+ template <>
+ struct unqualified_pusher<lua_thread_state> {
+ int push(lua_State*, lua_thread_state lts) {
+ lua_pushthread(lts.L);
+ return 1;
+ }
+ };
+
+ template <>
+ struct unqualified_getter<lua_thread_state> {
+ lua_thread_state get(lua_State* L, int index, record& tracking) {
+ tracking.use(1);
+ lua_thread_state lts( lua_tothread(L, index) );
+ return lts;
+ }
+ };
+
+ template <>
+ struct unqualified_check_getter<lua_thread_state> {
+ template <typename Handler>
+ optional<lua_thread_state> get(lua_State* L, int index, Handler&& handler, record& tracking) {
+ lua_thread_state lts( lua_tothread(L, index) );
+ if (lts.lua_state() == nullptr) {
+ handler(L, index, type::thread, type_of(L, index), "value is not a valid thread type");
+ return nullopt;
+ }
+ tracking.use(1);
+ return lts;
+ }
+ };
+ } // namespace stack
+
+ template <typename ref_t>
+ class basic_thread : public basic_object<ref_t> {
+ private:
+ using base_t = basic_object<ref_t>;
+
+ public:
+ using base_t::lua_state;
+
+ basic_thread() noexcept = default;
+ basic_thread(const basic_thread&) = default;
+ basic_thread(basic_thread&&) = default;
+ 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>
+ basic_thread(T&& r)
+ : base_t(std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ auto pp = stack::push_pop(*this);
+ constructor_handler handler{};
+ stack::check<basic_thread>(lua_state(), -1, handler);
+#endif // Safety
+ }
+ basic_thread(const stack_reference& r)
+ : basic_thread(r.lua_state(), r.stack_index()){};
+ basic_thread(stack_reference&& r)
+ : basic_thread(r.lua_state(), r.stack_index()){};
+ basic_thread& operator=(const basic_thread&) = default;
+ basic_thread& operator=(basic_thread&&) = default;
+ 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)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ auto pp = stack::push_pop(*this);
+ constructor_handler handler{};
+ stack::check<basic_thread>(lua_state(), -1, handler);
+#endif // Safety
+ }
+ basic_thread(lua_State* L, int index = -1)
+ : base_t(L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ constructor_handler handler{};
+ stack::check<basic_thread>(L, index, handler);
+#endif // Safety
+ }
+ basic_thread(lua_State* L, ref_index index)
+ : base_t(L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ auto pp = stack::push_pop(*this);
+ constructor_handler handler{};
+ stack::check<basic_thread>(lua_state(), -1, handler);
+#endif // Safety
+ }
+ basic_thread(lua_State* L, lua_State* actualthread)
+ : basic_thread(L, lua_thread_state{ actualthread }) {
+ }
+ 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)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ constructor_handler handler{};
+ stack::check<basic_thread>(lua_state(), -1, handler);
+#endif // Safety
+ if (!is_stack_based<base_t>::value) {
+ lua_pop(lua_state(), 1);
+ }
+ }
+
+ state_view state() const {
+ return state_view(this->thread_state());
+ }
+
+ bool is_main_thread() const {
+ return stack::is_main_thread(this->thread_state());
+ }
+
+ lua_State* thread_state() const {
+ auto pp = stack::push_pop(*this);
+ lua_State* lthread = lua_tothread(lua_state(), -1);
+ return lthread;
+ }
+
+ thread_status status() const {
+ lua_State* lthread = thread_state();
+ auto lstat = static_cast<thread_status>(lua_status(lthread));
+ if (lstat == thread_status::ok) {
+ lua_Debug ar;
+ if (lua_getstack(lthread, 0, &ar) > 0)
+ return thread_status::ok;
+ else if (lua_gettop(lthread) == 0)
+ return thread_status::dead;
+ else
+ return thread_status::yielded;
+ }
+ return lstat;
+ }
+
+ basic_thread create() {
+ return create(lua_state());
+ }
+
+ static basic_thread create(lua_State* L) {
+ lua_newthread(L);
+ basic_thread result(L);
+ if (!is_stack_based<base_t>::value) {
+ lua_pop(L, 1);
+ }
+ return result;
+ }
+ };
+
+ typedef basic_thread<reference> thread;
+ typedef basic_thread<stack_reference> stack_thread;
+} // namespace sol
+
+// end of sol/thread.hpp
+
+namespace sol {
+
+ class state : private std::unique_ptr<lua_State, detail::state_deleter>, public state_view {
+ private:
+ typedef std::unique_ptr<lua_State, detail::state_deleter> unique_base;
+
+ public:
+ state(lua_CFunction panic = default_at_panic)
+ : unique_base(luaL_newstate()), state_view(unique_base::get()) {
+ set_default_state(unique_base::get(), panic);
+ }
+
+ state(lua_CFunction panic, lua_Alloc alfunc, void* alpointer = nullptr)
+ : unique_base(lua_newstate(alfunc, alpointer)), state_view(unique_base::get()) {
+ set_default_state(unique_base::get(), panic);
+ }
+
+ state(const state&) = delete;
+ state(state&&) = default;
+ state& operator=(const state&) = delete;
+ state& operator=(state&& that) {
+ state_view::operator=(std::move(that));
+ unique_base::operator=(std::move(that));
+ return *this;
+ }
+
+ using state_view::get;
+
+ ~state() {
+ }
+ };
+} // namespace sol
+
+// end of sol/state.hpp
+
+// beginning of sol/coroutine.hpp
+
+namespace sol {
+ template <typename ref_t>
+ class basic_coroutine : public basic_object<ref_t> {
+ private:
+ using base_t = basic_object<ref_t>;
+
+ public:
+ typedef reference handler_t;
+ handler_t error_handler;
+
+ private:
+ call_status stats = call_status::yielded;
+
+ void luacall(std::ptrdiff_t argcount, std::ptrdiff_t) {
+#if SOL_LUA_VESION_I_ >= 504
+ int nresults;
+ stats = static_cast<call_status>(lua_resume(lua_state(), nullptr, static_cast<int>(argcount), &nresults));
+#else
+ stats = static_cast<call_status>(lua_resume(lua_state(), nullptr, static_cast<int>(argcount)));
+#endif
+ }
+
+ template <std::size_t... I, typename... Ret>
+ auto invoke(types<Ret...>, std::index_sequence<I...>, std::ptrdiff_t n) {
+ luacall(n, sizeof...(Ret));
+ return stack::pop<std::tuple<Ret...>>(lua_state());
+ }
+
+ template <std::size_t I, typename Ret>
+ Ret invoke(types<Ret>, std::index_sequence<I>, std::ptrdiff_t n) {
+ luacall(n, 1);
+ return stack::pop<Ret>(lua_state());
+ }
+
+ template <std::size_t I>
+ void invoke(types<void>, std::index_sequence<I>, std::ptrdiff_t n) {
+ luacall(n, 0);
+ }
+
+ protected_function_result invoke(types<>, std::index_sequence<>, std::ptrdiff_t n) {
+ int firstreturn = 1;
+ luacall(n, LUA_MULTRET);
+ int poststacksize = lua_gettop(this->lua_state());
+ int returncount = poststacksize - (firstreturn - 1);
+ if (error()) {
+ if (error_handler.valid()) {
+ string_view err = stack::get<string_view>(this->lua_state(), poststacksize);
+ error_handler.push();
+ stack::push(this->lua_state(), err);
+ lua_call(lua_state(), 1, 1);
+ }
+ return protected_function_result(this->lua_state(), lua_absindex(this->lua_state(), -1), 1, returncount, status());
+ }
+ return protected_function_result(this->lua_state(), firstreturn, returncount, returncount, status());
+ }
+
+ public:
+ using base_t::lua_state;
+
+ basic_coroutine() = default;
+ template <typename T,
+ meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_coroutine>>,
+ 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>
+ basic_coroutine(T&& r) noexcept
+ : base_t(std::forward<T>(r)), 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 (!is_function<meta::unqualified_t<T>>::value) {
+ auto pp = stack::push_pop(*this);
+ constructor_handler handler {};
+ stack::check<basic_coroutine>(lua_state(), -1, handler);
+ }
+#endif // Safety
+ }
+ basic_coroutine(const basic_coroutine&) = default;
+ basic_coroutine& operator=(const basic_coroutine&) = default;
+ basic_coroutine(basic_coroutine&&) = default;
+ basic_coroutine& operator=(basic_coroutine&&) = default;
+ basic_coroutine(const basic_function<base_t>& b)
+ : basic_coroutine(b, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(b.lua_state())) {
+ }
+ basic_coroutine(basic_function<base_t>&& b)
+ : basic_coroutine(std::move(b), detail::get_default_handler<reference, is_main_threaded<base_t>::value>(b.lua_state())) {
+ }
+ basic_coroutine(const basic_function<base_t>& b, handler_t eh) : base_t(b), error_handler(std::move(eh)) {
+ }
+ basic_coroutine(basic_function<base_t>&& b, handler_t eh) : base_t(std::move(b)), error_handler(std::move(eh)) {
+ }
+ basic_coroutine(const stack_reference& r)
+ : basic_coroutine(r.lua_state(), r.stack_index(), detail::get_default_handler<reference, is_main_threaded<base_t>::value>(r.lua_state())) {
+ }
+ basic_coroutine(stack_reference&& r)
+ : basic_coroutine(r.lua_state(), r.stack_index(), detail::get_default_handler<reference, is_main_threaded<base_t>::value>(r.lua_state())) {
+ }
+ basic_coroutine(const stack_reference& r, handler_t eh) : basic_coroutine(r.lua_state(), r.stack_index(), std::move(eh)) {
+ }
+ basic_coroutine(stack_reference&& r, handler_t eh) : basic_coroutine(r.lua_state(), r.stack_index(), std::move(eh)) {
+ }
+
+ template <typename Super>
+ basic_coroutine(const proxy_base<Super>& p)
+ : basic_coroutine(p, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(p.lua_state())) {
+ }
+ template <typename Super>
+ basic_coroutine(proxy_base<Super>&& p)
+ : basic_coroutine(std::move(p), detail::get_default_handler<reference, is_main_threaded<base_t>::value>(p.lua_state())) {
+ }
+ template <typename Proxy, typename Handler,
+ meta::enable<std::is_base_of<proxy_base_tag, meta::unqualified_t<Proxy>>, meta::neg<is_lua_index<meta::unqualified_t<Handler>>>> = meta::enabler>
+ basic_coroutine(Proxy&& p, Handler&& eh) : basic_coroutine(detail::force_cast<base_t>(p), std::forward<Handler>(eh)) {
+ }
+
+ template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+ basic_coroutine(lua_State* L, T&& r)
+ : basic_coroutine(L, std::forward<T>(r), detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
+ }
+ 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)), error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ auto pp = stack::push_pop(*this);
+ constructor_handler handler {};
+ stack::check<basic_coroutine>(lua_state(), -1, handler);
+#endif // Safety
+ }
+
+ basic_coroutine(lua_nil_t n) : base_t(n), error_handler(n) {
+ }
+
+ basic_coroutine(lua_State* L, int index = -1)
+ : basic_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
+ }
+ basic_coroutine(lua_State* L, int index, handler_t eh) : base_t(L, index), error_handler(std::move(eh)) {
+#ifdef SOL_SAFE_REFERENCES
+ constructor_handler handler {};
+ stack::check<basic_coroutine>(L, index, handler);
+#endif // Safety
+ }
+ basic_coroutine(lua_State* L, absolute_index index)
+ : 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), error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ constructor_handler handler {};
+ stack::check<basic_coroutine>(L, index, handler);
+#endif // Safety
+ }
+ basic_coroutine(lua_State* L, raw_index index)
+ : 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), error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ constructor_handler handler {};
+ stack::check<basic_coroutine>(L, index, handler);
+#endif // Safety
+ }
+ basic_coroutine(lua_State* L, ref_index index)
+ : 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), error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ auto pp = stack::push_pop(*this);
+ constructor_handler handler {};
+ stack::check<basic_coroutine>(lua_state(), -1, handler);
+#endif // Safety
+ }
+
+ call_status status() const noexcept {
+ return stats;
+ }
+
+ bool error() const noexcept {
+ call_status cs = status();
+ return cs != call_status::ok && cs != call_status::yielded;
+ }
+
+ bool runnable() const noexcept {
+ return base_t::valid() && (status() == call_status::yielded);
+ }
+
+ explicit operator bool() const noexcept {
+ return runnable();
+ }
+
+ template <typename... Args>
+ protected_function_result operator()(Args&&... args) {
+ return call<>(std::forward<Args>(args)...);
+ }
+
+ template <typename... Ret, typename... Args>
+ decltype(auto) operator()(types<Ret...>, Args&&... args) {
+ return call<Ret...>(std::forward<Args>(args)...);
+ }
+
+ template <typename... Ret, typename... Args>
+ decltype(auto) call(Args&&... args) {
+ // some users screw up coroutine.create
+ // and try to use it with sol::coroutine without ever calling the first resume in Lua
+ // this makes the stack incompatible with other kinds of stacks: protect against this
+ // make sure coroutines don't screw us over
+ base_t::push();
+ int pushcount = stack::multi_push_reference(lua_state(), std::forward<Args>(args)...);
+ return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), pushcount);
+ }
+ };
+} // namespace sol
+
+// end of sol/coroutine.hpp
+
+// beginning of sol/userdata.hpp
+
+namespace sol {
+ template <typename base_type>
+ class basic_userdata : public basic_table<base_type> {
+ private:
+ using base_t = basic_table<base_type>;
+
+ public:
+ using base_t::lua_state;
+
+ basic_userdata() noexcept = default;
+ template <typename T, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_userdata>>, meta::neg<std::is_same<base_t, stack_reference>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+ basic_userdata(T&& r) noexcept
+ : base_t(std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ if (!is_userdata<meta::unqualified_t<T>>::value) {
+ auto pp = stack::push_pop(*this);
+ type_assert(lua_state(), -1, type::userdata);
+ }
+#endif // Safety
+ }
+ basic_userdata(const basic_userdata&) = default;
+ basic_userdata(basic_userdata&&) = default;
+ basic_userdata& operator=(const basic_userdata&) = default;
+ basic_userdata& operator=(basic_userdata&&) = default;
+ basic_userdata(const stack_reference& r)
+ : basic_userdata(r.lua_state(), r.stack_index()) {
+ }
+ basic_userdata(stack_reference&& r)
+ : basic_userdata(r.lua_state(), r.stack_index()) {
+ }
+ template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+ basic_userdata(lua_State* L, T&& r)
+ : base_t(L, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ auto pp = stack::push_pop(*this);
+ constructor_handler handler{};
+ stack::check<basic_userdata>(L, -1, handler);
+#endif // Safety
+ }
+ basic_userdata(lua_State* L, int index = -1)
+ : base_t(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ constructor_handler handler{};
+ stack::check<basic_userdata>(L, index, handler);
+#endif // Safety
+ }
+ basic_userdata(lua_State* L, ref_index index)
+ : base_t(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ auto pp = stack::push_pop(*this);
+ constructor_handler handler{};
+ stack::check<basic_userdata>(L, -1, handler);
+#endif // Safety
+ }
+ };
+
+ template <typename base_type>
+ class basic_lightuserdata : public basic_object_base<base_type> {
+ typedef basic_object_base<base_type> base_t;
+
+ public:
+ using base_t::lua_state;
+
+ basic_lightuserdata() noexcept = default;
+ template <typename T, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_lightuserdata>>, meta::neg<std::is_same<base_t, stack_reference>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+ basic_lightuserdata(T&& r) noexcept
+ : base_t(std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ if (!is_lightuserdata<meta::unqualified_t<T>>::value) {
+ auto pp = stack::push_pop(*this);
+ type_assert(lua_state(), -1, type::lightuserdata);
+ }
+#endif // Safety
+ }
+ basic_lightuserdata(const basic_lightuserdata&) = default;
+ basic_lightuserdata(basic_lightuserdata&&) = default;
+ basic_lightuserdata& operator=(const basic_lightuserdata&) = default;
+ basic_lightuserdata& operator=(basic_lightuserdata&&) = default;
+ basic_lightuserdata(const stack_reference& r)
+ : basic_lightuserdata(r.lua_state(), r.stack_index()) {
+ }
+ basic_lightuserdata(stack_reference&& r)
+ : basic_lightuserdata(r.lua_state(), r.stack_index()) {
+ }
+ template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+ basic_lightuserdata(lua_State* L, T&& r)
+ : basic_lightuserdata(L, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ auto pp = stack::push_pop(*this);
+ constructor_handler handler{};
+ stack::check<basic_lightuserdata>(lua_state(), -1, handler);
+#endif // Safety
+ }
+ basic_lightuserdata(lua_State* L, int index = -1)
+ : base_t(L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ constructor_handler handler{};
+ stack::check<basic_lightuserdata>(L, index, handler);
+#endif // Safety
+ }
+ basic_lightuserdata(lua_State* L, ref_index index)
+ : base_t(L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
+ auto pp = stack::push_pop(*this);
+ constructor_handler handler{};
+ stack::check<basic_lightuserdata>(lua_state(), index, handler);
+#endif // Safety
+ }
+ };
+
+} // namespace sol
+
+// end of sol/userdata.hpp
+
+// beginning of sol/as_args.hpp
+
+namespace sol {
+ template <typename T>
+ struct as_args_t {
+ T src;
+ };
+
+ template <typename Source>
+ auto as_args(Source&& source) {
+ return as_args_t<Source> { std::forward<Source>(source) };
+ }
+
+ namespace stack {
+ template <typename T>
+ struct unqualified_pusher<as_args_t<T>> {
+ int push(lua_State* L, const as_args_t<T>& e) {
+ int p = 0;
+ for (const auto& i : e.src) {
+ p += stack::push(L, i);
+ }
+ return p;
+ }
+ };
+ } // namespace stack
+} // namespace sol
+
+// end of sol/as_args.hpp
+
+// beginning of sol/variadic_args.hpp
+
+#include <limits>
+#include <iterator>
+
+namespace sol {
+ struct variadic_args {
+ private:
+ lua_State* L;
+ int index;
+ int stacktop;
+
+ public:
+ typedef stack_proxy reference_type;
+ typedef stack_proxy value_type;
+ typedef stack_proxy* pointer;
+ typedef std::ptrdiff_t difference_type;
+ typedef std::size_t size_type;
+ typedef stack_iterator<stack_proxy, false> iterator;
+ typedef stack_iterator<stack_proxy, true> const_iterator;
+ typedef std::reverse_iterator<iterator> reverse_iterator;
+ typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+ variadic_args() = default;
+ variadic_args(lua_State* luastate, int stackindex = -1)
+ : L(luastate), index(lua_absindex(luastate, stackindex)), stacktop(lua_gettop(luastate)) {
+ }
+ variadic_args(lua_State* luastate, int stackindex, int lastindex)
+ : L(luastate), index(lua_absindex(luastate, stackindex)), stacktop(lastindex) {
+ }
+ variadic_args(const variadic_args&) = default;
+ variadic_args& operator=(const variadic_args&) = default;
+ variadic_args(variadic_args&& o)
+ : L(o.L), index(o.index), stacktop(o.stacktop) {
+ // Must be manual, otherwise destructor will screw us
+ // return count being 0 is enough to keep things clean
+ // but will be thorough
+ o.L = nullptr;
+ o.index = 0;
+ o.stacktop = 0;
+ }
+ variadic_args& operator=(variadic_args&& o) {
+ L = o.L;
+ index = o.index;
+ stacktop = o.stacktop;
+ // Must be manual, otherwise destructor will screw us
+ // return count being 0 is enough to keep things clean
+ // but will be thorough
+ o.L = nullptr;
+ o.index = 0;
+ o.stacktop = 0;
+ return *this;
+ }
+
+ iterator begin() {
+ return iterator(L, index, stacktop + 1);
+ }
+ iterator end() {
+ return iterator(L, stacktop + 1, stacktop + 1);
+ }
+ const_iterator begin() const {
+ return const_iterator(L, index, stacktop + 1);
+ }
+ const_iterator end() const {
+ return const_iterator(L, stacktop + 1, stacktop + 1);
+ }
+ const_iterator cbegin() const {
+ return begin();
+ }
+ const_iterator cend() const {
+ return end();
+ }
+
+ reverse_iterator rbegin() {
+ return std::reverse_iterator<iterator>(begin());
+ }
+ reverse_iterator rend() {
+ return std::reverse_iterator<iterator>(end());
+ }
+ const_reverse_iterator rbegin() const {
+ return std::reverse_iterator<const_iterator>(begin());
+ }
+ const_reverse_iterator rend() const {
+ return std::reverse_iterator<const_iterator>(end());
+ }
+ const_reverse_iterator crbegin() const {
+ return std::reverse_iterator<const_iterator>(cbegin());
+ }
+ const_reverse_iterator crend() const {
+ return std::reverse_iterator<const_iterator>(cend());
+ }
+
+ int push() const {
+ return push(L);
+ }
+
+ int push(lua_State* target) const {
+ int pushcount = 0;
+ for (int i = index; i <= stacktop; ++i) {
+ lua_pushvalue(L, i);
+ pushcount += 1;
+ }
+ if (target != L) {
+ lua_xmove(L, target, pushcount);
+ }
+ return pushcount;
+ }
+
+ template <typename T>
+ decltype(auto) get(difference_type index_offset = 0) const {
+ return stack::get<T>(L, index + static_cast<int>(index_offset));
+ }
+
+ type get_type(difference_type index_offset = 0) const noexcept {
+ return type_of(L, index + static_cast<int>(index_offset));
+ }
+
+ stack_proxy operator[](difference_type index_offset) const {
+ return stack_proxy(L, index + static_cast<int>(index_offset));
+ }
+
+ lua_State* lua_state() const {
+ return L;
+ };
+ int stack_index() const {
+ return index;
+ };
+ int leftover_count() const {
+ return stacktop - (index - 1);
+ }
+ std::size_t size() const {
+ return static_cast<std::size_t>(leftover_count());
+ }
+ int top() const {
+ return stacktop;
+ }
+ };
+
+ namespace stack {
+ template <>
+ struct unqualified_getter<variadic_args> {
+ static variadic_args get(lua_State* L, int index, record& tracking) {
+ tracking.last = 0;
+ return variadic_args(L, index);
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<variadic_args> {
+ static int push(lua_State* L, const variadic_args& ref) {
+ return ref.push(L);
+ }
+ };
+ } // namespace stack
+} // namespace sol
+
+// end of sol/variadic_args.hpp
+
+// beginning of sol/variadic_results.hpp
+
+// beginning of sol/as_returns.hpp
+
+namespace sol {
+ template <typename T>
+ struct as_returns_t {
+ T src;
+ };
+
+ template <typename Source>
+ auto as_returns(Source&& source) {
+ return as_returns_t<std::decay_t<Source>>{ std::forward<Source>(source) };
+ }
+
+ namespace stack {
+ template <typename T>
+ struct unqualified_pusher<as_returns_t<T>> {
+ int push(lua_State* L, const as_returns_t<T>& e) {
+ auto& src = detail::unwrap(e.src);
+ int p = 0;
+ for (const auto& i : src) {
+ p += stack::push(L, i);
+ }
+ return p;
+ }
+ };
+ } // namespace stack
+} // namespace sol
+
+// end of sol/as_returns.hpp
+
+#include <vector>
+
+namespace sol {
+
+ template <typename Al = typename std::allocator<object>>
+ struct basic_variadic_results : public std::vector<object, Al> {
+ private:
+ using base_t = std::vector<object, Al>;
+
+ public:
+ basic_variadic_results() : base_t() {
+ }
+
+ basic_variadic_results(unsafe_function_result fr) : base_t() {
+ this->reserve(fr.return_count());
+ this->insert(this->cend(), fr.begin(), fr.end());
+ }
+
+ basic_variadic_results(protected_function_result fr) : base_t() {
+ this->reserve(fr.return_count());
+ this->insert(this->cend(), fr.begin(), fr.end());
+ }
+
+ template <typename Arg0, typename... Args,
+ meta::disable_any<std::is_same<meta::unqualified_t<Arg0>, basic_variadic_results>, std::is_same<meta::unqualified_t<Arg0>, function_result>,
+ std::is_same<meta::unqualified_t<Arg0>, protected_function_result>> = meta::enabler>
+ basic_variadic_results(Arg0&& arg0, Args&&... args) : base_t(std::forward<Arg0>(arg0), std::forward<Args>(args)...) {
+ }
+
+ basic_variadic_results(const basic_variadic_results&) = default;
+ basic_variadic_results(basic_variadic_results&&) = default;
+ };
+
+ struct variadic_results : public basic_variadic_results<> {
+ private:
+ using base_t = basic_variadic_results<>;
+
+ public:
+ using base_t::base_t;
+ };
+
+ template <typename Al>
+ struct is_container<basic_variadic_results<Al>> : std::false_type { };
+
+ template <>
+ struct is_container<variadic_results> : std::false_type { };
+
+ namespace stack {
+ template <typename Al>
+ struct unqualified_pusher<basic_variadic_results<Al>> {
+ int push(lua_State* L, const basic_variadic_results<Al>& e) {
+ int p = 0;
+ for (const auto& i : e) {
+ p += stack::push(L, i);
+ }
+ return p;
+ }
+ };
+
+ template <>
+ struct unqualified_pusher<variadic_results> {
+ int push(lua_State* L, const variadic_results& r) {
+ using base_t = basic_variadic_results<>;
+ return stack::push(L, static_cast<const base_t&>(r));
+ }
+ };
+ } // namespace stack
+
+} // namespace sol
+
+// end of sol/variadic_results.hpp
+
+#if SOL_IS_ON(SOL_COMPILER_GCC_I_)
+#pragma GCC diagnostic pop
+#elif SOL_IS_ON(SOL_COMPILER_VCXX_I_)
+#pragma warning(pop)
+#endif // g++
+
+#if SOL_IS_ON(SOL_INSIDE_UNREAL_ENGINE_I_)
+#undef check
+#pragma pop_macro("check")
+#endif // Unreal Engine 4 Bullshit
+
+#endif // SOL_HPP
+// end of sol/sol.hpp
+
+#endif // SOL_SINGLE_INCLUDE_HPP
diff --git a/3rdparty/sol2/sol/stack.hpp b/3rdparty/sol2/sol/stack.hpp
deleted file mode 100644
index b3bf6dec200..00000000000
--- a/3rdparty/sol2/sol/stack.hpp
+++ /dev/null
@@ -1,229 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_STACK_HPP
-#define SOL_STACK_HPP
-
-#include "stack_core.hpp"
-#include "stack_reference.hpp"
-#include "stack_check.hpp"
-#include "stack_get.hpp"
-#include "stack_check_get.hpp"
-#include "stack_push.hpp"
-#include "stack_pop.hpp"
-#include "stack_field.hpp"
-#include "stack_probe.hpp"
-#include <cstring>
-#include <array>
-
-namespace sol {
- namespace stack {
- namespace stack_detail {
- template<typename T>
- inline int push_as_upvalues(lua_State* L, T& item) {
- typedef std::decay_t<T> TValue;
- const static std::size_t itemsize = sizeof(TValue);
- const static std::size_t voidsize = sizeof(void*);
- const static std::size_t voidsizem1 = voidsize - 1;
- const static std::size_t data_t_count = (sizeof(TValue) + voidsizem1) / voidsize;
- typedef std::array<void*, data_t_count> data_t;
-
- data_t data{ {} };
- std::memcpy(&data[0], std::addressof(item), itemsize);
- int pushcount = 0;
- for (auto&& v : data) {
- pushcount += push(L, lightuserdata_value(v));
- }
- return pushcount;
- }
-
- template<typename T>
- inline std::pair<T, int> get_as_upvalues(lua_State* L, int index = 1) {
- const static std::size_t data_t_count = (sizeof(T) + (sizeof(void*) - 1)) / sizeof(void*);
- typedef std::array<void*, data_t_count> data_t;
- data_t voiddata{ {} };
- for (std::size_t i = 0, d = 0; d < sizeof(T); ++i, d += sizeof(void*)) {
- voiddata[i] = get<lightuserdata_value>(L, upvalue_index(index++));
- }
- return std::pair<T, int>(*reinterpret_cast<T*>(static_cast<void*>(voiddata.data())), index);
- }
-
- struct evaluator {
- template <typename Fx, typename... Args>
- static decltype(auto) eval(types<>, std::index_sequence<>, lua_State*, int, record&, Fx&& fx, Args&&... args) {
- return std::forward<Fx>(fx)(std::forward<Args>(args)...);
- }
-
- template <typename Fx, typename Arg, typename... Args, std::size_t I, std::size_t... Is, typename... FxArgs>
- static decltype(auto) eval(types<Arg, Args...>, std::index_sequence<I, Is...>, lua_State* L, int start, record& tracking, Fx&& fx, FxArgs&&... fxargs) {
- return eval(types<Args...>(), std::index_sequence<Is...>(), L, start, tracking, std::forward<Fx>(fx), std::forward<FxArgs>(fxargs)..., stack_detail::unchecked_get<Arg>(L, start + tracking.used, tracking));
- }
- };
-
- template <bool checkargs = default_check_arguments, std::size_t... I, typename R, typename... Args, typename Fx, typename... FxArgs, typename = std::enable_if_t<!std::is_void<R>::value>>
- inline decltype(auto) call(types<R>, types<Args...> ta, std::index_sequence<I...> tai, lua_State* L, int start, Fx&& fx, FxArgs&&... args) {
-#ifndef _MSC_VER
- static_assert(meta::all<meta::is_not_move_only<Args>...>::value, "One of the arguments being bound is a move-only type, and it is not being taken by reference: this will break your code. Please take a reference and std::move it manually if this was your intention.");
-#endif // This compiler make me so fucking sad
- multi_check<checkargs, Args...>(L, start, type_panic);
- record tracking{};
- return evaluator{}.eval(ta, tai, L, start, tracking, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
- }
-
- template <bool checkargs = default_check_arguments, std::size_t... I, typename... Args, typename Fx, typename... FxArgs>
- inline void call(types<void>, types<Args...> ta, std::index_sequence<I...> tai, lua_State* L, int start, Fx&& fx, FxArgs&&... args) {
-#ifndef _MSC_VER
- static_assert(meta::all<meta::is_not_move_only<Args>...>::value, "One of the arguments being bound is a move-only type, and it is not being taken by reference: this will break your code. Please take a reference and std::move it manually if this was your intention.");
-#endif // This compiler make me so fucking sad
- multi_check<checkargs, Args...>(L, start, type_panic);
- record tracking{};
- evaluator{}.eval(ta, tai, L, start, tracking, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
- }
- } // stack_detail
-
- template <typename T>
- int set_ref(lua_State* L, T&& arg, int tableindex = -2) {
- push(L, std::forward<T>(arg));
- return luaL_ref(L, tableindex);
- }
-
- inline void remove(lua_State* L, int index, int count) {
- if (count < 1)
- return;
- int top = lua_gettop(L);
- if (index == -1 || top == index) {
- // Slice them right off the top
- lua_pop(L, static_cast<int>(count));
- return;
- }
-
- // Remove each item one at a time using stack operations
- // Probably slower, maybe, haven't benchmarked,
- // but necessary
- if (index < 0) {
- index = lua_gettop(L) + (index + 1);
- }
- int last = index + count;
- for (int i = index; i < last; ++i) {
- lua_remove(L, index);
- }
- }
-
- template <bool check_args = stack_detail::default_check_arguments, typename R, typename... Args, typename Fx, typename... FxArgs, typename = std::enable_if_t<!std::is_void<R>::value>>
- inline decltype(auto) call(types<R> tr, types<Args...> ta, lua_State* L, int start, Fx&& fx, FxArgs&&... args) {
- typedef std::make_index_sequence<sizeof...(Args)> args_indices;
- return stack_detail::call<check_args>(tr, ta, args_indices(), L, start, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
- }
-
- template <bool check_args = stack_detail::default_check_arguments, typename R, typename... Args, typename Fx, typename... FxArgs, typename = std::enable_if_t<!std::is_void<R>::value>>
- inline decltype(auto) call(types<R> tr, types<Args...> ta, lua_State* L, Fx&& fx, FxArgs&&... args) {
- return call<check_args>(tr, ta, L, 1, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
- }
-
- template <bool check_args = stack_detail::default_check_arguments, typename... Args, typename Fx, typename... FxArgs>
- inline void call(types<void> tr, types<Args...> ta, lua_State* L, int start, Fx&& fx, FxArgs&&... args) {
- typedef std::make_index_sequence<sizeof...(Args)> args_indices;
- stack_detail::call<check_args>(tr, ta, args_indices(), L, start, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
- }
-
- template <bool check_args = stack_detail::default_check_arguments, typename... Args, typename Fx, typename... FxArgs>
- inline void call(types<void> tr, types<Args...> ta, lua_State* L, Fx&& fx, FxArgs&&... args) {
- call<check_args>(tr, ta, L, 1, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
- }
-
- template <bool check_args = stack_detail::default_check_arguments, typename R, typename... Args, typename Fx, typename... FxArgs, typename = std::enable_if_t<!std::is_void<R>::value>>
- inline decltype(auto) call_from_top(types<R> tr, types<Args...> ta, lua_State* L, Fx&& fx, FxArgs&&... args) {
- return call<check_args>(tr, ta, L, static_cast<int>(lua_gettop(L) - sizeof...(Args)), std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
- }
-
- template <bool check_args = stack_detail::default_check_arguments, typename... Args, typename Fx, typename... FxArgs>
- inline void call_from_top(types<void> tr, types<Args...> ta, lua_State* L, Fx&& fx, FxArgs&&... args) {
- call<check_args>(tr, ta, L, static_cast<int>(lua_gettop(L) - sizeof...(Args)), std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
- }
-
- template<bool check_args = stack_detail::default_check_arguments, typename... Args, typename Fx, typename... FxArgs>
- inline int call_into_lua(types<void> tr, types<Args...> ta, lua_State* L, int start, Fx&& fx, FxArgs&&... fxargs) {
- call<check_args>(tr, ta, L, start, std::forward<Fx>(fx), std::forward<FxArgs>(fxargs)...);
- lua_settop(L, 0);
- return 0;
- }
-
- template<bool check_args = stack_detail::default_check_arguments, typename Ret0, typename... Ret, typename... Args, typename Fx, typename... FxArgs, typename = std::enable_if_t<meta::neg<std::is_void<Ret0>>::value>>
- inline int call_into_lua(types<Ret0, Ret...>, types<Args...> ta, lua_State* L, int start, Fx&& fx, FxArgs&&... fxargs) {
- decltype(auto) r = call<check_args>(types<meta::return_type_t<Ret0, Ret...>>(), ta, L, start, std::forward<Fx>(fx), std::forward<FxArgs>(fxargs)...);
- lua_settop(L, 0);
- return push_reference(L, std::forward<decltype(r)>(r));
- }
-
- template<bool check_args = stack_detail::default_check_arguments, typename Fx, typename... FxArgs>
- inline int call_lua(lua_State* L, int start, Fx&& fx, FxArgs&&... fxargs) {
- typedef lua_bind_traits<meta::unqualified_t<Fx>> traits_type;
- typedef typename traits_type::args_list args_list;
- typedef typename traits_type::returns_list returns_list;
- return call_into_lua(returns_list(), args_list(), L, start, std::forward<Fx>(fx), std::forward<FxArgs>(fxargs)...);
- }
-
- inline call_syntax get_call_syntax(lua_State* L, const std::string& key, int index) {
- if (lua_gettop(L) == 0) {
- return call_syntax::dot;
- }
- luaL_getmetatable(L, key.c_str());
- auto pn = pop_n(L, 1);
- if (lua_compare(L, -1, index, LUA_OPEQ) != 1) {
- return call_syntax::dot;
- }
- return call_syntax::colon;
- }
-
- inline void script(lua_State* L, const std::string& code) {
- if (luaL_dostring(L, code.c_str())) {
- lua_error(L);
- }
- }
-
- inline void script_file(lua_State* L, const std::string& filename) {
- if (luaL_dofile(L, filename.c_str())) {
- lua_error(L);
- }
- }
-
- inline void luajit_exception_handler(lua_State* L, int(*handler)(lua_State*, lua_CFunction) = detail::c_trampoline) {
-#ifdef SOL_LUAJIT
- lua_pushlightuserdata(L, (void*)handler);
- auto pn = pop_n(L, 1);
- luaJIT_setmode(L, -1, LUAJIT_MODE_WRAPCFUNC | LUAJIT_MODE_ON);
-#else
- (void)L;
- (void)handler;
-#endif
- }
-
- inline void luajit_exception_off(lua_State* L) {
-#ifdef SOL_LUAJIT
- luaJIT_setmode(L, -1, LUAJIT_MODE_WRAPCFUNC | LUAJIT_MODE_OFF);
-#else
- (void)L;
-#endif
- }
- } // stack
-} // sol
-
-#endif // SOL_STACK_HPP
diff --git a/3rdparty/sol2/sol/stack_check.hpp b/3rdparty/sol2/sol/stack_check.hpp
deleted file mode 100644
index 82739c831a7..00000000000
--- a/3rdparty/sol2/sol/stack_check.hpp
+++ /dev/null
@@ -1,385 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_STACK_CHECK_HPP
-#define SOL_STACK_CHECK_HPP
-
-#include "stack_core.hpp"
-#include "usertype_traits.hpp"
-#include "inheritance.hpp"
-#include <memory>
-#include <functional>
-#include <utility>
-
-namespace sol {
- namespace stack {
- namespace stack_detail {
- template <typename T, bool poptable = true>
- inline bool check_metatable(lua_State* L, int index = -2) {
- const auto& metakey = usertype_traits<T>::metatable();
- luaL_getmetatable(L, &metakey[0]);
- const type expectedmetatabletype = static_cast<type>(lua_type(L, -1));
- if (expectedmetatabletype != type::lua_nil) {
- if (lua_rawequal(L, -1, index) == 1) {
- lua_pop(L, 1 + static_cast<int>(poptable));
- return true;
- }
- }
- lua_pop(L, 1);
- return false;
- }
-
- template <type expected, int(*check_func)(lua_State*, int)>
- struct basic_check {
- template <typename Handler>
- static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
- tracking.use(1);
- bool success = check_func(L, index) == 1;
- if (!success) {
- // expected type, actual type
- handler(L, index, expected, type_of(L, index));
- }
- return success;
- }
- };
- } // stack_detail
-
- template <typename T, type expected, typename>
- struct checker {
- template <typename Handler>
- static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
- tracking.use(1);
- const type indextype = type_of(L, index);
- bool success = expected == indextype;
- if (!success) {
- // expected type, actual type
- handler(L, index, expected, indextype);
- }
- return success;
- }
- };
-
- template<typename T>
- struct checker<T, type::number, std::enable_if_t<std::is_integral<T>::value>> {
- template <typename Handler>
- static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
- tracking.use(1);
- bool success = lua_isinteger(L, index) == 1;
- if (!success) {
- // expected type, actual type
- handler(L, index, type::number, type_of(L, index));
- }
- return success;
- }
- };
-
- template<typename T>
- struct checker<T, type::number, std::enable_if_t<std::is_floating_point<T>::value>> {
- template <typename Handler>
- static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
- tracking.use(1);
- bool success = lua_isnumber(L, index) == 1;
- if (!success) {
- // expected type, actual type
- handler(L, index, type::number, type_of(L, index));
- }
- return success;
- }
- };
-
- template <type expected, typename C>
- struct checker<lua_nil_t, expected, C> {
- template <typename Handler>
- static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
- bool success = lua_isnil(L, index);
- if (success) {
- tracking.use(1);
- return success;
- }
- tracking.use(0);
- success = lua_isnone(L, index);
- if (!success) {
- // expected type, actual type
- handler(L, index, expected, type_of(L, index));
- }
- return success;
- }
- };
-
- template <type expected, typename C>
- struct checker<nullopt_t, expected, C> : checker<lua_nil_t> {};
-
- template <typename C>
- struct checker<this_state, type::poly, C> {
- template <typename Handler>
- static bool check(lua_State*, int, Handler&&, record& tracking) {
- tracking.use(0);
- return true;
- }
- };
-
- template <typename C>
- struct checker<variadic_args, type::poly, C> {
- template <typename Handler>
- static bool check(lua_State*, int, Handler&&, record& tracking) {
- tracking.use(0);
- return true;
- }
- };
-
- template <typename C>
- struct checker<type, type::poly, C> {
- template <typename Handler>
- static bool check(lua_State*, int, Handler&&, record& tracking) {
- tracking.use(0);
- return true;
- }
- };
-
- template <typename T, typename C>
- struct checker<T, type::poly, C> {
- template <typename Handler>
- static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
- tracking.use(1);
- bool success = !lua_isnone(L, index);
- if (!success) {
- // expected type, actual type
- handler(L, index, type::none, type_of(L, index));
- }
- return success;
- }
- };
-
- template <typename T, typename C>
- struct checker<T, type::lightuserdata, C> {
- template <typename Handler>
- static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
- tracking.use(1);
- type t = type_of(L, index);
- bool success = t == type::userdata || t == type::lightuserdata;
- if (!success) {
- // expected type, actual type
- handler(L, index, type::lightuserdata, t);
- }
- return success;
- }
- };
-
- template <typename C>
- struct checker<userdata_value, type::userdata, C> {
- template <typename Handler>
- static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
- tracking.use(1);
- type t = type_of(L, index);
- bool success = t == type::userdata;
- if (!success) {
- // expected type, actual type
- handler(L, index, type::userdata, t);
- }
- return success;
- }
- };
-
- template <typename T, typename C>
- struct checker<user<T>, type::userdata, C> : checker<user<T>, type::lightuserdata, C> {};
-
- template <typename T, typename C>
- struct checker<non_null<T>, type::userdata, C> : checker<T, lua_type_of<T>::value, C> {};
-
- template <typename C>
- struct checker<lua_CFunction, type::function, C> : stack_detail::basic_check<type::function, lua_iscfunction> {};
- template <typename C>
- struct checker<std::remove_pointer_t<lua_CFunction>, type::function, C> : checker<lua_CFunction, type::function, C> {};
- template <typename C>
- struct checker<c_closure, type::function, C> : checker<lua_CFunction, type::function, C> {};
-
- template <typename T, typename C>
- struct checker<T, type::function, C> {
- template <typename Handler>
- static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
- tracking.use(1);
- type t = type_of(L, index);
- if (t == type::lua_nil || t == type::none || t == type::function) {
- // allow for lua_nil to be returned
- return true;
- }
- if (t != type::userdata && t != type::table) {
- handler(L, index, type::function, t);
- return false;
- }
- // Do advanced check for call-style userdata?
- static const auto& callkey = name_of(meta_function::call);
- if (lua_getmetatable(L, index) == 0) {
- // No metatable, no __call key possible
- handler(L, index, type::function, t);
- return false;
- }
- if (lua_isnoneornil(L, -1)) {
- lua_pop(L, 1);
- handler(L, index, type::function, t);
- return false;
- }
- lua_getfield(L, -1, &callkey[0]);
- if (lua_isnoneornil(L, -1)) {
- lua_pop(L, 2);
- handler(L, index, type::function, t);
- return false;
- }
- // has call, is definitely a function
- lua_pop(L, 2);
- return true;
- }
- };
-
- template <typename T, typename C>
- struct checker<T, type::table, C> {
- template <typename Handler>
- static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
- tracking.use(1);
- type t = type_of(L, index);
- if (t == type::table) {
- return true;
- }
- if (t != type::userdata) {
- handler(L, index, type::function, t);
- return false;
- }
- return true;
- }
- };
-
- template <typename T, typename C>
- struct checker<detail::as_value_tag<T>, type::userdata, C> {
- template <typename U, typename Handler>
- static bool check(types<U>, lua_State* L, type indextype, int index, Handler&& handler, record& tracking) {
- tracking.use(1);
- if (indextype != type::userdata) {
- handler(L, index, type::userdata, indextype);
- return false;
- }
- if (meta::any<std::is_same<T, lightuserdata_value>, std::is_same<T, userdata_value>, std::is_same<T, userdata>, std::is_same<T, lightuserdata>>::value)
- return true;
- if (lua_getmetatable(L, index) == 0) {
- return true;
- }
- int metatableindex = lua_gettop(L);
- if (stack_detail::check_metatable<U>(L, metatableindex))
- return true;
- if (stack_detail::check_metatable<U*>(L, metatableindex))
- return true;
- if (stack_detail::check_metatable<detail::unique_usertype<U>>(L, metatableindex))
- return true;
- bool success = false;
- if (detail::has_derived<T>::value) {
- auto pn = stack::pop_n(L, 1);
- lua_pushstring(L, &detail::base_class_check_key()[0]);
- lua_rawget(L, metatableindex);
- if (type_of(L, -1) != type::lua_nil) {
- void* basecastdata = lua_touserdata(L, -1);
- detail::inheritance_check_function ic = (detail::inheritance_check_function)basecastdata;
- success = ic(detail::id_for<T>::value);
- }
- }
- if (!success) {
- lua_pop(L, 1);
- handler(L, index, type::userdata, indextype);
- return false;
- }
- lua_pop(L, 1);
- return true;
- }
- };
-
- template <typename T, typename C>
- struct checker<T, type::userdata, C> {
- template <typename Handler>
- static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
- const type indextype = type_of(L, index);
- return checker<detail::as_value_tag<T>, type::userdata, C>{}.check(types<T>(), L, indextype, index, std::forward<Handler>(handler), tracking);
- }
- };
-
- template <typename T, typename C>
- struct checker<T*, type::userdata, C> {
- template <typename Handler>
- static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
- const type indextype = type_of(L, index);
- // Allow lua_nil to be transformed to nullptr
- if (indextype == type::lua_nil) {
- tracking.use(1);
- return true;
- }
- return checker<meta::unqualified_t<T>, type::userdata, C>{}.check(L, index, std::forward<Handler>(handler), tracking);
- }
- };
-
- template<typename T>
- struct checker<T, type::userdata, std::enable_if_t<is_unique_usertype<T>::value>> {
- template <typename Handler>
- static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
- return checker<typename unique_usertype_traits<T>::type, type::userdata>{}.check(L, index, std::forward<Handler>(handler), tracking);
- }
- };
-
- template<typename T, typename C>
- struct checker<std::reference_wrapper<T>, type::userdata, C> {
- template <typename Handler>
- static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
- return checker<T, type::userdata, C>{}.check(L, index, std::forward<Handler>(handler), tracking);
- }
- };
-
- template<typename... Args, typename C>
- struct checker<std::tuple<Args...>, type::poly, C> {
- template <typename Handler>
- static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
- return stack::multi_check<Args...>(L, index, std::forward<Handler>(handler), tracking);
- }
- };
-
- template<typename A, typename B, typename C>
- struct checker<std::pair<A, B>, type::poly, C> {
- template <typename Handler>
- static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
- return stack::multi_check<A, B>(L, index, std::forward<Handler>(handler), tracking);
- }
- };
-
- template<typename T, typename C>
- struct checker<optional<T>, type::poly, C> {
- template <typename Handler>
- static bool check(lua_State* L, int index, Handler&&, record& tracking) {
- type t = type_of(L, index);
- if (t == type::none) {
- tracking.use(0);
- return true;
- }
- if (t == type::lua_nil) {
- tracking.use(1);
- return true;
- }
- return stack::check<T>(L, index, no_panic, tracking);
- }
- };
- } // stack
-} // sol
-
-#endif // SOL_STACK_CHECK_HPP
diff --git a/3rdparty/sol2/sol/stack_check_get.hpp b/3rdparty/sol2/sol/stack_check_get.hpp
deleted file mode 100644
index 728d7d9a448..00000000000
--- a/3rdparty/sol2/sol/stack_check_get.hpp
+++ /dev/null
@@ -1,114 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_STACK_CHECK_GET_HPP
-#define SOL_STACK_CHECK_GET_HPP
-
-#include "stack_core.hpp"
-#include "stack_get.hpp"
-#include "stack_check.hpp"
-#include "optional.hpp"
-
-namespace sol {
- namespace stack {
- template <typename T, typename>
- struct check_getter {
- typedef decltype(stack_detail::unchecked_get<T>(nullptr, 0, std::declval<record&>())) R;
-
- template <typename Handler>
- static optional<R> get(lua_State* L, int index, Handler&& handler, record& tracking) {
- if (!check<T>(L, index, std::forward<Handler>(handler))) {
- tracking.use(static_cast<int>(!lua_isnone(L, index)));
- return nullopt;
- }
- return stack_detail::unchecked_get<T>(L, index, tracking);
- }
- };
-
- template <typename T>
- struct check_getter<optional<T>> {
- template <typename Handler>
- static decltype(auto) get(lua_State* L, int index, Handler&&, record& tracking) {
- return check_get<T>(L, index, no_panic, tracking);
- }
- };
-
- template <typename T>
- struct check_getter<T, std::enable_if_t<std::is_integral<T>::value && lua_type_of<T>::value == type::number>> {
- template <typename Handler>
- static optional<T> get(lua_State* L, int index, Handler&& handler, record& tracking) {
- int isnum = 0;
- lua_Integer value = lua_tointegerx(L, index, &isnum);
- if (isnum == 0) {
- type t = type_of(L, index);
- tracking.use(static_cast<int>(t != type::none));
- handler(L, index, type::number, t);
- return nullopt;
- }
- tracking.use(1);
- return static_cast<T>(value);
- }
- };
-
- template <typename T>
- struct check_getter<T, std::enable_if_t<std::is_enum<T>::value && !meta::any_same<T, meta_function, type>::value>> {
- template <typename Handler>
- static optional<T> get(lua_State* L, int index, Handler&& handler, record& tracking) {
- int isnum = 0;
- lua_Integer value = lua_tointegerx(L, index, &isnum);
- if (isnum == 0) {
- type t = type_of(L, index);
- tracking.use(static_cast<int>(t != type::none));
- handler(L, index, type::number, t);
- return nullopt;
- }
- tracking.use(1);
- return static_cast<T>(value);
- }
- };
-
- template <typename T>
- struct check_getter<T, std::enable_if_t<std::is_floating_point<T>::value>> {
- template <typename Handler>
- static optional<T> get(lua_State* L, int index, Handler&& handler, record& tracking) {
- int isnum = 0;
- lua_Number value = lua_tonumberx(L, index, &isnum);
- if (isnum == 0) {
- type t = type_of(L, index);
- tracking.use(static_cast<int>(t != type::none));
- handler(L, index, type::number, t);
- return nullopt;
- }
- tracking.use(1);
- return static_cast<T>(value);
- }
- };
-
- template <typename T>
- struct getter<optional<T>> {
- static decltype(auto) get(lua_State* L, int index, record& tracking) {
- return check_get<T>(L, index, no_panic, tracking);
- }
- };
- } // stack
-} // sol
-
-#endif // SOL_STACK_CHECK_GET_HPP
diff --git a/3rdparty/sol2/sol/stack_core.hpp b/3rdparty/sol2/sol/stack_core.hpp
deleted file mode 100644
index 5eceaeaf90b..00000000000
--- a/3rdparty/sol2/sol/stack_core.hpp
+++ /dev/null
@@ -1,410 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_STACK_CORE_HPP
-#define SOL_STACK_CORE_HPP
-
-#include "types.hpp"
-#include "reference.hpp"
-#include "stack_reference.hpp"
-#include "userdata.hpp"
-#include "tuple.hpp"
-#include "traits.hpp"
-#include "tie.hpp"
-#include "stack_guard.hpp"
-#include <vector>
-#include <string>
-
-namespace sol {
- namespace detail {
- struct as_reference_tag {};
- template <typename T>
- struct as_pointer_tag {};
- template <typename T>
- struct as_value_tag {};
-
- using special_destruct_func = void(*)(void*);
-
- template <typename T, typename Real>
- inline void special_destruct(void* memory) {
- T** pointerpointer = static_cast<T**>(memory);
- special_destruct_func* dx = static_cast<special_destruct_func*>(static_cast<void*>(pointerpointer + 1));
- Real* target = static_cast<Real*>(static_cast<void*>(dx + 1));
- target->~Real();
- }
-
- template <typename T>
- inline int unique_destruct(lua_State* L) {
- void* memory = lua_touserdata(L, 1);
- T** pointerpointer = static_cast<T**>(memory);
- special_destruct_func& dx = *static_cast<special_destruct_func*>(static_cast<void*>(pointerpointer + 1));
- (dx)(memory);
- return 0;
- }
-
- template <typename T>
- inline int user_alloc_destroy(lua_State* L) {
- void* rawdata = lua_touserdata(L, 1);
- T* data = static_cast<T*>(rawdata);
- std::allocator<T> alloc;
- alloc.destroy(data);
- return 0;
- }
-
- template <typename T>
- inline int usertype_alloc_destroy(lua_State* L) {
- void* rawdata = lua_touserdata(L, 1);
- T** pdata = static_cast<T**>(rawdata);
- T* data = *pdata;
- std::allocator<T> alloc{};
- alloc.destroy(data);
- return 0;
- }
-
- template <typename T>
- void reserve(T&, std::size_t) {}
-
- template <typename T, typename Al>
- void reserve(std::vector<T, Al>& arr, std::size_t hint) {
- arr.reserve(hint);
- }
-
- template <typename T, typename Tr, typename Al>
- void reserve(std::basic_string<T, Tr, Al>& arr, std::size_t hint) {
- arr.reserve(hint);
- }
- } // detail
-
- namespace stack {
-
- template<typename T, bool global = false, bool raw = false, typename = void>
- struct field_getter;
- template <typename T, bool global = false, bool raw = false, typename = void>
- struct probe_field_getter;
- template<typename T, bool global = false, bool raw = false, typename = void>
- struct field_setter;
- template<typename T, typename = void>
- struct getter;
- template<typename T, typename = void>
- struct popper;
- template<typename T, typename = void>
- struct pusher;
- template<typename T, type = lua_type_of<T>::value, typename = void>
- struct checker;
- template<typename T, typename = void>
- struct check_getter;
-
- struct probe {
- bool success;
- int levels;
-
- probe(bool s, int l) : success(s), levels(l) {}
-
- operator bool() const { return success; };
- };
-
- struct record {
- int last;
- int used;
-
- record() : last(), used() {}
- void use(int count) {
- last = count;
- used += count;
- }
- };
-
- namespace stack_detail {
- template <typename T>
- struct strip {
- typedef T type;
- };
- template <typename T>
- struct strip<std::reference_wrapper<T>> {
- typedef T& type;
- };
- template <typename T>
- struct strip<user<T>> {
- typedef T& type;
- };
- template <typename T>
- struct strip<non_null<T>> {
- typedef T type;
- };
- template <typename T>
- using strip_t = typename strip<T>::type;
- const bool default_check_arguments =
-#ifdef SOL_CHECK_ARGUMENTS
- true;
-#else
- false;
-#endif
- template<typename T>
- inline decltype(auto) unchecked_get(lua_State* L, int index, record& tracking) {
- return getter<meta::unqualified_t<T>>{}.get(L, index, tracking);
- }
- } // stack_detail
-
- inline bool maybe_indexable(lua_State* L, int index = -1) {
- type t = type_of(L, index);
- return t == type::userdata || t == type::table;
- }
-
- template<typename T, typename... Args>
- inline int push(lua_State* L, T&& t, Args&&... args) {
- return pusher<meta::unqualified_t<T>>{}.push(L, std::forward<T>(t), std::forward<Args>(args)...);
- }
-
- // allow a pusher of a specific type, but pass in any kind of args
- template<typename T, typename Arg, typename... Args>
- inline int push_specific(lua_State* L, Arg&& arg, Args&&... args) {
- return pusher<meta::unqualified_t<T>>{}.push(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
- }
-
- template<typename T, typename... Args>
- inline int push_reference(lua_State* L, T&& t, Args&&... args) {
- typedef meta::all<
- std::is_lvalue_reference<T>,
- meta::neg<std::is_const<T>>,
- meta::neg<is_lua_primitive<meta::unqualified_t<T>>>,
- meta::neg<is_unique_usertype<meta::unqualified_t<T>>>
- > use_reference_tag;
- return pusher<std::conditional_t<use_reference_tag::value, detail::as_reference_tag, meta::unqualified_t<T>>>{}.push(L, std::forward<T>(t), std::forward<Args>(args)...);
- }
-
- inline int multi_push(lua_State*) {
- // do nothing
- return 0;
- }
-
- template<typename T, typename... Args>
- inline int multi_push(lua_State* L, T&& t, Args&&... args) {
- int pushcount = push(L, std::forward<T>(t));
- void(sol::detail::swallow{ (pushcount += sol::stack::push(L, std::forward<Args>(args)), 0)... });
- return pushcount;
- }
-
- inline int multi_push_reference(lua_State*) {
- // do nothing
- return 0;
- }
-
- template<typename T, typename... Args>
- inline int multi_push_reference(lua_State* L, T&& t, Args&&... args) {
- int pushcount = push_reference(L, std::forward<T>(t));
- void(sol::detail::swallow{ (pushcount += sol::stack::push_reference(L, std::forward<Args>(args)), 0)... });
- return pushcount;
- }
-
- template <typename T, typename Handler>
- bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
- typedef meta::unqualified_t<T> Tu;
- checker<Tu> c;
- // VC++ has a bad warning here: shut it up
- (void)c;
- return c.check(L, index, std::forward<Handler>(handler), tracking);
- }
-
- template <typename T, typename Handler>
- bool check(lua_State* L, int index, Handler&& handler) {
- record tracking{};
- return check<T>(L, index, std::forward<Handler>(handler), tracking);
- }
-
- template <typename T>
- bool check(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
- auto handler = no_panic;
- return check<T>(L, index, handler);
- }
-
- template<typename T, typename Handler>
- inline decltype(auto) check_get(lua_State* L, int index, Handler&& handler, record& tracking) {
- return check_getter<meta::unqualified_t<T>>{}.get(L, index, std::forward<Handler>(handler), tracking);
- }
-
- template<typename T, typename Handler>
- inline decltype(auto) check_get(lua_State* L, int index, Handler&& handler) {
- record tracking{};
- return check_get<T>(L, index, handler, tracking);
- }
-
- template<typename T>
- inline decltype(auto) check_get(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
- auto handler = no_panic;
- return check_get<T>(L, index, handler);
- }
-
- namespace stack_detail {
-
-#ifdef SOL_CHECK_ARGUMENTS
- template <typename T>
- inline auto tagged_get(types<T>, lua_State* L, int index, record& tracking) -> decltype(stack_detail::unchecked_get<T>(L, index, tracking)) {
- auto op = check_get<T>(L, index, type_panic, tracking);
- return *std::move(op);
- }
-#else
- template <typename T>
- inline decltype(auto) tagged_get(types<T>, lua_State* L, int index, record& tracking) {
- return stack_detail::unchecked_get<T>(L, index, tracking);
- }
-#endif
-
- template <typename T>
- inline decltype(auto) tagged_get(types<optional<T>>, lua_State* L, int index, record& tracking) {
- return stack_detail::unchecked_get<optional<T>>(L, index, tracking);
- }
-
- template <bool b>
- struct check_types {
- template <typename T, typename... Args, typename Handler>
- static bool check(types<T, Args...>, lua_State* L, int firstargument, Handler&& handler, record& tracking) {
- if (!stack::check<T>(L, firstargument + tracking.used, handler, tracking))
- return false;
- return check(types<Args...>(), L, firstargument, std::forward<Handler>(handler), tracking);
- }
-
- template <typename Handler>
- static bool check(types<>, lua_State*, int, Handler&&, record&) {
- return true;
- }
- };
-
- template <>
- struct check_types<false> {
- template <typename... Args, typename Handler>
- static bool check(types<Args...>, lua_State*, int, Handler&&, record&) {
- return true;
- }
- };
-
- } // stack_detail
-
- template <bool b, typename... Args, typename Handler>
- bool multi_check(lua_State* L, int index, Handler&& handler, record& tracking) {
- return stack_detail::check_types<b>{}.check(types<meta::unqualified_t<Args>...>(), L, index, std::forward<Handler>(handler), tracking);
- }
-
- template <bool b, typename... Args, typename Handler>
- bool multi_check(lua_State* L, int index, Handler&& handler) {
- record tracking{};
- return multi_check<b, Args...>(L, index, std::forward<Handler>(handler), tracking);
- }
-
- template <bool b, typename... Args>
- bool multi_check(lua_State* L, int index) {
- auto handler = no_panic;
- return multi_check<b, Args...>(L, index, handler);
- }
-
- template <typename... Args, typename Handler>
- bool multi_check(lua_State* L, int index, Handler&& handler, record& tracking) {
- return multi_check<true, Args...>(L, index, std::forward<Handler>(handler), tracking);
- }
-
- template <typename... Args, typename Handler>
- bool multi_check(lua_State* L, int index, Handler&& handler) {
- return multi_check<true, Args...>(L, index, std::forward<Handler>(handler));
- }
-
- template <typename... Args>
- bool multi_check(lua_State* L, int index) {
- return multi_check<true, Args...>(L, index);
- }
-
- template<typename T>
- inline decltype(auto) get(lua_State* L, int index, record& tracking) {
- return stack_detail::tagged_get(types<T>(), L, index, tracking);
- }
-
- template<typename T>
- inline decltype(auto) get(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
- record tracking{};
- return get<T>(L, index, tracking);
- }
-
- template<typename T>
- inline decltype(auto) pop(lua_State* L) {
- return popper<meta::unqualified_t<T>>{}.pop(L);
- }
-
- template <bool global = false, bool raw = false, typename Key>
- void get_field(lua_State* L, Key&& key) {
- field_getter<meta::unqualified_t<Key>, global, raw>{}.get(L, std::forward<Key>(key));
- }
-
- template <bool global = false, bool raw = false, typename Key>
- void get_field(lua_State* L, Key&& key, int tableindex) {
- field_getter<meta::unqualified_t<Key>, global, raw>{}.get(L, std::forward<Key>(key), tableindex);
- }
-
- template <bool global = false, typename Key>
- void raw_get_field(lua_State* L, Key&& key) {
- get_field<global, true>(L, std::forward<Key>(key));
- }
-
- template <bool global = false, typename Key>
- void raw_get_field(lua_State* L, Key&& key, int tableindex) {
- get_field<global, true>(L, std::forward<Key>(key), tableindex);
- }
-
- template <bool global = false, bool raw = false, typename Key>
- probe probe_get_field(lua_State* L, Key&& key) {
- return probe_field_getter<meta::unqualified_t<Key>, global, raw>{}.get(L, std::forward<Key>(key));
- }
-
- template <bool global = false, bool raw = false, typename Key>
- probe probe_get_field(lua_State* L, Key&& key, int tableindex) {
- return probe_field_getter<meta::unqualified_t<Key>, global, raw>{}.get(L, std::forward<Key>(key), tableindex);
- }
-
- template <bool global = false, typename Key>
- probe probe_raw_get_field(lua_State* L, Key&& key) {
- return probe_get_field<global, true>(L, std::forward<Key>(key));
- }
-
- template <bool global = false, typename Key>
- probe probe_raw_get_field(lua_State* L, Key&& key, int tableindex) {
- return probe_get_field<global, true>(L, std::forward<Key>(key), tableindex);
- }
-
- template <bool global = false, bool raw = false, typename Key, typename Value>
- void set_field(lua_State* L, Key&& key, Value&& value) {
- field_setter<meta::unqualified_t<Key>, global, raw>{}.set(L, std::forward<Key>(key), std::forward<Value>(value));
- }
-
- template <bool global = false, bool raw = false, typename Key, typename Value>
- void set_field(lua_State* L, Key&& key, Value&& value, int tableindex) {
- field_setter<meta::unqualified_t<Key>, global, raw>{}.set(L, std::forward<Key>(key), std::forward<Value>(value), tableindex);
- }
-
- template <bool global = false, typename Key, typename Value>
- void raw_set_field(lua_State* L, Key&& key, Value&& value) {
- set_field<global, true>(L, std::forward<Key>(key), std::forward<Value>(value));
- }
-
- template <bool global = false, typename Key, typename Value>
- void raw_set_field(lua_State* L, Key&& key, Value&& value, int tableindex) {
- set_field<global, true>(L, std::forward<Key>(key), std::forward<Value>(value), tableindex);
- }
- } // stack
-} // sol
-
-#endif // SOL_STACK_CORE_HPP
diff --git a/3rdparty/sol2/sol/stack_field.hpp b/3rdparty/sol2/sol/stack_field.hpp
deleted file mode 100644
index 48ebe99220d..00000000000
--- a/3rdparty/sol2/sol/stack_field.hpp
+++ /dev/null
@@ -1,261 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_STACK_FIELD_HPP
-#define SOL_STACK_FIELD_HPP
-
-#include "stack_core.hpp"
-#include "stack_push.hpp"
-#include "stack_get.hpp"
-#include "stack_check_get.hpp"
-
-namespace sol {
- namespace stack {
- template <typename T, bool, bool, typename>
- struct field_getter {
- template <typename Key>
- void get(lua_State* L, Key&& key, int tableindex = -2) {
- push(L, std::forward<Key>(key));
- lua_gettable(L, tableindex);
- }
- };
-
- template <typename T, bool global, typename C>
- struct field_getter<T, global, true, C> {
- template <typename Key>
- void get(lua_State* L, Key&& key, int tableindex = -2) {
- push(L, std::forward<Key>(key));
- lua_rawget(L, tableindex);
- }
- };
-
- template <bool b, bool raw, typename C>
- struct field_getter<metatable_key_t, b, raw, C> {
- void get(lua_State* L, metatable_key_t, int tableindex = -1) {
- if (lua_getmetatable(L, tableindex) == 0)
- push(L, lua_nil);
- }
- };
-
- template <typename T, bool raw>
- struct field_getter<T, true, raw, std::enable_if_t<meta::is_c_str<T>::value>> {
- template <typename Key>
- void get(lua_State* L, Key&& key, int = -1) {
- lua_getglobal(L, &key[0]);
- }
- };
-
- template <typename T>
- struct field_getter<T, false, false, std::enable_if_t<meta::is_c_str<T>::value>> {
- template <typename Key>
- void get(lua_State* L, Key&& key, int tableindex = -1) {
- lua_getfield(L, tableindex, &key[0]);
- }
- };
-
-#if SOL_LUA_VERSION >= 503
- template <typename T>
- struct field_getter<T, false, false, std::enable_if_t<std::is_integral<T>::value>> {
- template <typename Key>
- void get(lua_State* L, Key&& key, int tableindex = -1) {
- lua_geti(L, tableindex, static_cast<lua_Integer>(key));
- }
- };
-#endif // Lua 5.3.x
-
-#if SOL_LUA_VERSION >= 502
- template <typename C>
- struct field_getter<void*, false, true, C> {
- void get(lua_State* L, void* key, int tableindex = -1) {
- lua_rawgetp(L, tableindex, key);
- }
- };
-#endif // Lua 5.3.x
-
- template <typename T>
- struct field_getter<T, false, true, std::enable_if_t<std::is_integral<T>::value>> {
- template <typename Key>
- void get(lua_State* L, Key&& key, int tableindex = -1) {
- lua_rawgeti(L, tableindex, static_cast<lua_Integer>(key));
- }
- };
-
- template <typename... Args, bool b, bool raw, typename C>
- struct field_getter<std::tuple<Args...>, b, raw, C> {
- template <std::size_t... I, typename Keys>
- void apply(std::index_sequence<0, I...>, lua_State* L, Keys&& keys, int tableindex) {
- get_field<b, raw>(L, detail::forward_get<0>(keys), tableindex);
- void(detail::swallow{ (get_field<false, raw>(L, detail::forward_get<I>(keys)), 0)... });
- reference saved(L, -1);
- lua_pop(L, static_cast<int>(sizeof...(I)));
- saved.push();
- }
-
- template <typename Keys>
- void get(lua_State* L, Keys&& keys) {
- apply(std::make_index_sequence<sizeof...(Args)>(), L, std::forward<Keys>(keys), lua_absindex(L, -1));
- }
-
- template <typename Keys>
- void get(lua_State* L, Keys&& keys, int tableindex) {
- apply(std::make_index_sequence<sizeof...(Args)>(), L, std::forward<Keys>(keys), tableindex);
- }
- };
-
- template <typename A, typename B, bool b, bool raw, typename C>
- struct field_getter<std::pair<A, B>, b, raw, C> {
- template <typename Keys>
- void get(lua_State* L, Keys&& keys, int tableindex) {
- get_field<b, raw>(L, detail::forward_get<0>(keys), tableindex);
- get_field<false, raw>(L, detail::forward_get<1>(keys));
- reference saved(L, -1);
- lua_pop(L, static_cast<int>(2));
- saved.push();
- }
-
- template <typename Keys>
- void get(lua_State* L, Keys&& keys) {
- get_field<b, raw>(L, detail::forward_get<0>(keys));
- get_field<false, raw>(L, detail::forward_get<1>(keys));
- reference saved(L, -1);
- lua_pop(L, static_cast<int>(2));
- saved.push();
- }
- };
-
- template <typename T, bool, bool, typename>
- struct field_setter {
- template <typename Key, typename Value>
- void set(lua_State* L, Key&& key, Value&& value, int tableindex = -3) {
- push(L, std::forward<Key>(key));
- push(L, std::forward<Value>(value));
- lua_settable(L, tableindex);
- }
- };
-
- template <typename T, bool b, typename C>
- struct field_setter<T, b, true, C> {
- template <typename Key, typename Value>
- void set(lua_State* L, Key&& key, Value&& value, int tableindex = -3) {
- push(L, std::forward<Key>(key));
- push(L, std::forward<Value>(value));
- lua_rawset(L, tableindex);
- }
- };
-
- template <bool b, bool raw, typename C>
- struct field_setter<metatable_key_t, b, raw, C> {
- template <typename Value>
- void set(lua_State* L, metatable_key_t, Value&& value, int tableindex = -2) {
- push(L, std::forward<Value>(value));
- lua_setmetatable(L, tableindex);
- }
- };
-
- template <typename T, bool raw>
- struct field_setter<T, true, raw, std::enable_if_t<meta::is_c_str<T>::value>> {
- template <typename Key, typename Value>
- void set(lua_State* L, Key&& key, Value&& value, int = -2) {
- push(L, std::forward<Value>(value));
- lua_setglobal(L, &key[0]);
- }
- };
-
- template <typename T>
- struct field_setter<T, false, false, std::enable_if_t<meta::is_c_str<T>::value>> {
- template <typename Key, typename Value>
- void set(lua_State* L, Key&& key, Value&& value, int tableindex = -2) {
- push(L, std::forward<Value>(value));
- lua_setfield(L, tableindex, &key[0]);
- }
- };
-
-#if SOL_LUA_VERSION >= 503
- template <typename T>
- struct field_setter<T, false, false, std::enable_if_t<std::is_integral<T>::value>> {
- template <typename Key, typename Value>
- void set(lua_State* L, Key&& key, Value&& value, int tableindex = -2) {
- push(L, std::forward<Value>(value));
- lua_seti(L, tableindex, static_cast<lua_Integer>(key));
- }
- };
-#endif // Lua 5.3.x
-
- template <typename T>
- struct field_setter<T, false, true, std::enable_if_t<std::is_integral<T>::value>> {
- template <typename Key, typename Value>
- void set(lua_State* L, Key&& key, Value&& value, int tableindex = -2) {
- push(L, std::forward<Value>(value));
- lua_rawseti(L, tableindex, static_cast<lua_Integer>(key));
- }
- };
-
-#if SOL_LUA_VERSION >= 502
- template <typename C>
- struct field_setter<void*, false, true, C> {
- template <typename Key, typename Value>
- void set(lua_State* L, void* key, Value&& value, int tableindex = -2) {
- push(L, std::forward<Value>(value));
- lua_rawsetp(L, tableindex, key);
- }
- };
-#endif // Lua 5.2.x
-
- template <typename... Args, bool b, bool raw, typename C>
- struct field_setter<std::tuple<Args...>, b, raw, C> {
- template <bool g, std::size_t I, typename Key, typename Value>
- void apply(std::index_sequence<I>, lua_State* L, Key&& keys, Value&& value, int tableindex) {
- I < 1 ?
- set_field<g, raw>(L, detail::forward_get<I>(keys), std::forward<Value>(value), tableindex) :
- set_field<g, raw>(L, detail::forward_get<I>(keys), std::forward<Value>(value));
- }
-
- template <bool g, std::size_t I0, std::size_t I1, std::size_t... I, typename Keys, typename Value>
- void apply(std::index_sequence<I0, I1, I...>, lua_State* L, Keys&& keys, Value&& value, int tableindex) {
- I0 < 1 ? get_field<g, raw>(L, detail::forward_get<I0>(keys), tableindex) : get_field<g, raw>(L, detail::forward_get<I0>(keys), -1);
- apply<false>(std::index_sequence<I1, I...>(), L, std::forward<Keys>(keys), std::forward<Value>(value), -1);
- }
-
- template <bool g, std::size_t I0, std::size_t... I, typename Keys, typename Value>
- void top_apply(std::index_sequence<I0, I...>, lua_State* L, Keys&& keys, Value&& value, int tableindex) {
- apply<g>(std::index_sequence<I0, I...>(), L, std::forward<Keys>(keys), std::forward<Value>(value), tableindex);
- lua_pop(L, static_cast<int>(sizeof...(I)));
- }
-
- template <typename Keys, typename Value>
- void set(lua_State* L, Keys&& keys, Value&& value, int tableindex = -3) {
- top_apply<b>(std::make_index_sequence<sizeof...(Args)>(), L, std::forward<Keys>(keys), std::forward<Value>(value), tableindex);
- }
- };
-
- template <typename A, typename B, bool b, bool raw, typename C>
- struct field_setter<std::pair<A, B>, b, raw, C> {
- template <typename Keys, typename Value>
- void set(lua_State* L, Keys&& keys, Value&& value, int tableindex = -1) {
- get_field<b, raw>(L, detail::forward_get<0>(keys), tableindex);
- set_field<false, raw>(L, detail::forward_get<1>(keys), std::forward<Value>(value));
- lua_pop(L, 1);
- }
- };
- } // stack
-} // sol
-
-#endif // SOL_STACK_FIELD_HPP
diff --git a/3rdparty/sol2/sol/stack_get.hpp b/3rdparty/sol2/sol/stack_get.hpp
deleted file mode 100644
index a39eec4a997..00000000000
--- a/3rdparty/sol2/sol/stack_get.hpp
+++ /dev/null
@@ -1,551 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_STACK_GET_HPP
-#define SOL_STACK_GET_HPP
-
-#include "stack_core.hpp"
-#include "usertype_traits.hpp"
-#include "inheritance.hpp"
-#include "overload.hpp"
-#include "error.hpp"
-#include <memory>
-#include <functional>
-#include <utility>
-#ifdef SOL_CODECVT_SUPPORT
-#include <codecvt>
-#include <locale>
-#endif
-
-namespace sol {
- namespace stack {
-
- template<typename T, typename>
- struct getter {
- static T& get(lua_State* L, int index, record& tracking) {
- return getter<sol::detail::as_value_tag<T>>{}.get(L, index, tracking);
- }
- };
-
- template<typename T>
- struct getter<T, std::enable_if_t<std::is_floating_point<T>::value>> {
- static T get(lua_State* L, int index, record& tracking) {
- tracking.use(1);
- return static_cast<T>(lua_tonumber(L, index));
- }
- };
-
- template<typename T>
- struct getter<T, std::enable_if_t<meta::all<std::is_integral<T>, std::is_signed<T>>::value>> {
- static T get(lua_State* L, int index, record& tracking) {
- tracking.use(1);
- return static_cast<T>(lua_tointeger(L, index));
- }
- };
-
- template<typename T>
- struct getter<T, std::enable_if_t<meta::all<std::is_integral<T>, std::is_unsigned<T>>::value>> {
- static T get(lua_State* L, int index, record& tracking) {
- tracking.use(1);
- return static_cast<T>(lua_tointeger(L, index));
- }
- };
-
- template<typename T>
- struct getter<T, std::enable_if_t<std::is_enum<T>::value>> {
- static T get(lua_State* L, int index, record& tracking) {
- tracking.use(1);
- return static_cast<T>(lua_tointegerx(L, index, nullptr));
- }
- };
-
- template<typename T>
- struct getter<as_table_t<T>, std::enable_if_t<!meta::has_key_value_pair<meta::unqualified_t<T>>::value>> {
- static T get(lua_State* L, int index, record& tracking) {
- typedef typename T::value_type V;
- tracking.use(1);
-
- index = lua_absindex(L, index);
- T arr;
- get_field<false, true>(L, static_cast<lua_Integer>(-1), index);
- int isnum;
- std::size_t sizehint = static_cast<std::size_t>(lua_tointegerx(L, -1, &isnum));
- if (isnum != 0) {
- detail::reserve(arr, sizehint);
- }
- lua_pop(L, 1);
-#if SOL_LUA_VERSION >= 503
- // This method is HIGHLY performant over regular table iteration thanks to the Lua API changes in 5.3
- for (lua_Integer i = 0; ; i += lua_size<V>::value, lua_pop(L, lua_size<V>::value)) {
- for (int vi = 0; vi < lua_size<V>::value; ++vi) {
- type t = static_cast<type>(lua_geti(L, index, i + vi));
- if (t == type::lua_nil) {
- if (i == 0) {
- continue;
- }
- else {
- lua_pop(L, (vi + 1));
- return arr;
- }
- }
- }
- arr.push_back(stack::get<V>(L, -lua_size<V>::value));
- }
-#else
- // Zzzz slower but necessary thanks to the lower version API and missing functions qq
- for (lua_Integer i = 0; ; i += lua_size<V>::value, lua_pop(L, lua_size<V>::value)) {
- for (int vi = 0; vi < lua_size<V>::value; ++vi) {
- lua_pushinteger(L, i);
- lua_gettable(L, index);
- type t = type_of(L, -1);
- if (t == type::lua_nil) {
- if (i == 0) {
- continue;
- }
- else {
- lua_pop(L, (vi + 1));
- return arr;
- }
- }
- }
- arr.push_back(stack::get<V>(L, -1));
- }
-#endif
- return arr;
- }
- };
-
- template<typename T>
- struct getter<as_table_t<T>, std::enable_if_t<meta::has_key_value_pair<meta::unqualified_t<T>>::value>> {
- static T get(lua_State* L, int index, record& tracking) {
- typedef typename T::value_type P;
- typedef typename P::first_type K;
- typedef typename P::second_type V;
- tracking.use(1);
-
- T associative;
- index = lua_absindex(L, index);
- lua_pushnil(L);
- while (lua_next(L, index) != 0) {
- decltype(auto) key = stack::check_get<K>(L, -2);
- if (!key) {
- lua_pop(L, 1);
- continue;
- }
- associative.emplace(std::forward<decltype(*key)>(*key), stack::get<V>(L, -1));
- lua_pop(L, 1);
- }
- return associative;
- }
- };
-
- template<typename T>
- struct getter<T, std::enable_if_t<std::is_base_of<reference, T>::value || std::is_base_of<stack_reference, T>::value>> {
- static T get(lua_State* L, int index, record& tracking) {
- tracking.use(1);
- return T(L, index);
- }
- };
-
- template<>
- struct getter<userdata_value> {
- static userdata_value get(lua_State* L, int index, record& tracking) {
- tracking.use(1);
- return userdata_value(lua_touserdata(L, index));
- }
- };
-
- template<>
- struct getter<lightuserdata_value> {
- static lightuserdata_value get(lua_State* L, int index, record& tracking) {
- tracking.use(1);
- return lightuserdata_value(lua_touserdata(L, index));
- }
- };
-
- template<typename T>
- struct getter<light<T>> {
- static light<T> get(lua_State* L, int index, record& tracking) {
- tracking.use(1);
- return light<T>(static_cast<T*>(lua_touserdata(L, index)));
- }
- };
-
- template<typename T>
- struct getter<user<T>> {
- static T& get(lua_State* L, int index, record& tracking) {
- tracking.use(1);
- return *static_cast<T*>(lua_touserdata(L, index));
- }
- };
-
- template<typename T>
- struct getter<user<T*>> {
- static T* get(lua_State* L, int index, record& tracking) {
- tracking.use(1);
- return static_cast<T*>(lua_touserdata(L, index));
- }
- };
-
- template<>
- struct getter<type> {
- static type get(lua_State *L, int index, record& tracking) {
- tracking.use(1);
- return static_cast<type>(lua_type(L, index));
- }
- };
-
- template<>
- struct getter<bool> {
- static bool get(lua_State* L, int index, record& tracking) {
- tracking.use(1);
- return lua_toboolean(L, index) != 0;
- }
- };
-
- template<>
- struct getter<std::string> {
- static std::string get(lua_State* L, int index, record& tracking) {
- tracking.use(1);
- std::size_t len;
- auto str = lua_tolstring(L, index, &len);
- return std::string( str, len );
- }
- };
-
- template <>
- struct getter<string_detail::string_shim> {
- string_detail::string_shim get(lua_State* L, int index, record& tracking) {
- tracking.use(1);
- size_t len;
- const char* p = lua_tolstring(L, index, &len);
- return string_detail::string_shim(p, len);
- }
- };
-
- template<>
- struct getter<const char*> {
- static const char* get(lua_State* L, int index, record& tracking) {
- tracking.use(1);
- return lua_tostring(L, index);
- }
- };
-
- template<>
- struct getter<char> {
- static char get(lua_State* L, int index, record& tracking) {
- tracking.use(1);
- size_t len;
- auto str = lua_tolstring(L, index, &len);
- return len > 0 ? str[0] : '\0';
- }
- };
-
-#ifdef SOL_CODECVT_SUPPORT
- template<>
- struct getter<std::wstring> {
- static std::wstring get(lua_State* L, int index, record& tracking) {
- tracking.use(1);
- size_t len;
- auto str = lua_tolstring(L, index, &len);
- if (len < 1)
- return std::wstring();
- if (sizeof(wchar_t) == 2) {
- static std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> convert;
- std::wstring r = convert.from_bytes(str, str + len);
-#ifdef __MINGW32__
- // Fuck you, MinGW, and fuck you libstdc++ for introducing this absolutely asinine bug
- // https://sourceforge.net/p/mingw-w64/bugs/538/
- // http://chat.stackoverflow.com/transcript/message/32271369#32271369
- for (auto& c : r) {
- uint8_t* b = reinterpret_cast<uint8_t*>(&c);
- std::swap(b[0], b[1]);
- }
-#endif
- return r;
- }
- static std::wstring_convert<std::codecvt_utf8<wchar_t>> convert;
- std::wstring r = convert.from_bytes(str, str + len);
- return r;
- }
- };
-
- template<>
- struct getter<std::u16string> {
- static std::u16string get(lua_State* L, int index, record& tracking) {
- tracking.use(1);
- size_t len;
- auto str = lua_tolstring(L, index, &len);
- if (len < 1)
- return std::u16string();
-#ifdef _MSC_VER
- static std::wstring_convert<std::codecvt_utf8_utf16<int16_t>, int16_t> convert;
- auto intd = convert.from_bytes(str, str + len);
- std::u16string r(intd.size(), '\0');
- std::memcpy(&r[0], intd.data(), intd.size() * sizeof(char16_t));
-#else
- static std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
- std::u16string r = convert.from_bytes(str, str + len);
-#endif // VC++ is a shit
- return r;
- }
- };
-
- template<>
- struct getter<std::u32string> {
- static std::u32string get(lua_State* L, int index, record& tracking) {
- tracking.use(1);
- size_t len;
- auto str = lua_tolstring(L, index, &len);
- if (len < 1)
- return std::u32string();
-#ifdef _MSC_VER
- static std::wstring_convert<std::codecvt_utf8<int32_t>, int32_t> convert;
- auto intd = convert.from_bytes(str, str + len);
- std::u32string r(intd.size(), '\0');
- std::memcpy(&r[0], intd.data(), r.size() * sizeof(char32_t));
-#else
- static std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> convert;
- std::u32string r = convert.from_bytes(str, str + len);
-#endif // VC++ is a shit
- return r;
- }
- };
-
- template<>
- struct getter<wchar_t> {
- static wchar_t get(lua_State* L, int index, record& tracking) {
- auto str = getter<std::wstring>{}.get(L, index, tracking);
- return str.size() > 0 ? str[0] : wchar_t(0);
- }
- };
-
- template<>
- struct getter<char16_t> {
- static char16_t get(lua_State* L, int index, record& tracking) {
- auto str = getter<std::u16string>{}.get(L, index, tracking);
- return str.size() > 0 ? str[0] : char16_t(0);
- }
- };
-
- template<>
- struct getter<char32_t> {
- static char32_t get(lua_State* L, int index, record& tracking) {
- auto str = getter<std::u32string>{}.get(L, index, tracking);
- return str.size() > 0 ? str[0] : char32_t(0);
- }
- };
-#endif // codecvt header support
-
- template<>
- struct getter<meta_function> {
- static meta_function get(lua_State *L, int index, record& tracking) {
- tracking.use(1);
- const char* name = getter<const char*>{}.get(L, index, tracking);
- for (std::size_t i = 0; i < meta_function_names.size(); ++i)
- if (meta_function_names[i] == name)
- return static_cast<meta_function>(i);
- return meta_function::construct;
- }
- };
-
- template<>
- struct getter<lua_nil_t> {
- static lua_nil_t get(lua_State*, int, record& tracking) {
- tracking.use(1);
- return lua_nil;
- }
- };
-
- template<>
- struct getter<std::nullptr_t> {
- static std::nullptr_t get(lua_State*, int, record& tracking) {
- tracking.use(1);
- return nullptr;
- }
- };
-
- template<>
- struct getter<nullopt_t> {
- static nullopt_t get(lua_State*, int, record& tracking) {
- tracking.use(1);
- return nullopt;
- }
- };
-
- template<>
- struct getter<this_state> {
- static this_state get(lua_State* L, int, record& tracking) {
- tracking.use(0);
- return this_state{ L };
- }
- };
-
- template<>
- struct getter<lua_CFunction> {
- static lua_CFunction get(lua_State* L, int index, record& tracking) {
- tracking.use(1);
- return lua_tocfunction(L, index);
- }
- };
-
- template<>
- struct getter<c_closure> {
- static c_closure get(lua_State* L, int index, record& tracking) {
- tracking.use(1);
- return c_closure(lua_tocfunction(L, index), -1);
- }
- };
-
- template<>
- struct getter<error> {
- static error get(lua_State* L, int index, record& tracking) {
- tracking.use(1);
- size_t sz = 0;
- const char* err = lua_tolstring(L, index, &sz);
- if (err == nullptr) {
- return error(detail::direct_error, "");
- }
- return error(detail::direct_error, std::string(err, sz));
- }
- };
-
- template<>
- struct getter<void*> {
- static void* get(lua_State* L, int index, record& tracking) {
- tracking.use(1);
- return lua_touserdata(L, index);
- }
- };
-
- template<typename T>
- struct getter<detail::as_value_tag<T>> {
- static T* get_no_lua_nil(lua_State* L, int index, record& tracking) {
- tracking.use(1);
- void** pudata = static_cast<void**>(lua_touserdata(L, index));
- void* udata = *pudata;
- return get_no_lua_nil_from(L, udata, index, tracking);
- }
-
- static T* get_no_lua_nil_from(lua_State* L, void* udata, int index, record&) {
- if (detail::has_derived<T>::value && luaL_getmetafield(L, index, &detail::base_class_cast_key()[0]) != 0) {
- void* basecastdata = lua_touserdata(L, -1);
- detail::inheritance_cast_function ic = (detail::inheritance_cast_function)basecastdata;
- // use the casting function to properly adjust the pointer for the desired T
- udata = ic(udata, detail::id_for<T>::value);
- lua_pop(L, 1);
- }
- T* obj = static_cast<T*>(udata);
- return obj;
- }
-
- static T& get(lua_State* L, int index, record& tracking) {
- return *get_no_lua_nil(L, index, tracking);
- }
- };
-
- template<typename T>
- struct getter<detail::as_pointer_tag<T>> {
- static T* get(lua_State* L, int index, record& tracking) {
- type t = type_of(L, index);
- if (t == type::lua_nil) {
- tracking.use(1);
- return nullptr;
- }
- return getter<detail::as_value_tag<T>>::get_no_lua_nil(L, index, tracking);
- }
- };
-
- template<typename T>
- struct getter<non_null<T*>> {
- static T* get(lua_State* L, int index, record& tracking) {
- return getter<detail::as_value_tag<T>>::get_no_lua_nil(L, index, tracking);
- }
- };
-
- template<typename T>
- struct getter<T&> {
- static T& get(lua_State* L, int index, record& tracking) {
- return getter<detail::as_value_tag<T>>::get(L, index, tracking);
- }
- };
-
- template<typename T>
- struct getter<std::reference_wrapper<T>> {
- static T& get(lua_State* L, int index, record& tracking) {
- return getter<T&>{}.get(L, index, tracking);
- }
- };
-
- template<typename T>
- struct getter<T*> {
- static T* get(lua_State* L, int index, record& tracking) {
- return getter<detail::as_pointer_tag<T>>::get(L, index, tracking);
- }
- };
-
- template<typename T>
- struct getter<T, std::enable_if_t<is_unique_usertype<T>::value>> {
- typedef typename unique_usertype_traits<T>::type P;
- typedef typename unique_usertype_traits<T>::actual_type Real;
-
- static Real& get(lua_State* L, int index, record& tracking) {
- tracking.use(1);
- P** pref = static_cast<P**>(lua_touserdata(L, index));
- detail::special_destruct_func* fx = static_cast<detail::special_destruct_func*>(static_cast<void*>(pref + 1));
- Real* mem = static_cast<Real*>(static_cast<void*>(fx + 1));
- return *mem;
- }
- };
-
- template<typename... Args>
- struct getter<std::tuple<Args...>> {
- typedef std::tuple<decltype(stack::get<Args>(nullptr, 0))...> R;
-
- template <typename... TArgs>
- static R apply(std::index_sequence<>, lua_State*, int, record&, TArgs&&... args) {
- // Fuck you too, VC++
- return R{std::forward<TArgs>(args)...};
- }
-
- template <std::size_t I, std::size_t... Ix, typename... TArgs>
- static R apply(std::index_sequence<I, Ix...>, lua_State* L, int index, record& tracking, TArgs&&... args) {
- // Fuck you too, VC++
- typedef std::tuple_element_t<I, std::tuple<Args...>> T;
- return apply(std::index_sequence<Ix...>(), L, index, tracking, std::forward<TArgs>(args)..., stack::get<T>(L, index + tracking.used, tracking));
- }
-
- static R get(lua_State* L, int index, record& tracking) {
- return apply(std::make_index_sequence<sizeof...(Args)>(), L, index, tracking);
- }
- };
-
- template<typename A, typename B>
- struct getter<std::pair<A, B>> {
- static decltype(auto) get(lua_State* L, int index, record& tracking) {
- return std::pair<decltype(stack::get<A>(L, index)), decltype(stack::get<B>(L, index))>{stack::get<A>(L, index, tracking), stack::get<B>(L, index + tracking.used, tracking)};
- }
- };
-
- } // stack
-} // sol
-
-#endif // SOL_STACK_GET_HPP
diff --git a/3rdparty/sol2/sol/stack_guard.hpp b/3rdparty/sol2/sol/stack_guard.hpp
deleted file mode 100644
index 54e359fecb8..00000000000
--- a/3rdparty/sol2/sol/stack_guard.hpp
+++ /dev/null
@@ -1,63 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_STACK_GUARD_HPP
-#define SOL_STACK_GUARD_HPP
-
-#include "compatibility/version.hpp"
-#include "error.hpp"
-#include <functional>
-
-namespace sol {
- namespace detail {
- inline void stack_fail(int, int) {
-#ifndef SOL_NO_EXCEPTIONS
- throw error(detail::direct_error, "imbalanced stack after operation finish");
-#else
- // Lol, what do you want, an error printout? :3c
- // There's no sane default here. The right way would be C-style abort(), and that's not acceptable, so
- // hopefully someone will register their own stack_fail thing for the `fx` parameter of stack_guard.
-#endif // No Exceptions
- }
- } // detail
-
- struct stack_guard {
- lua_State* L;
- int top;
- std::function<void(int, int)> on_mismatch;
-
- stack_guard(lua_State* L) : stack_guard(L, lua_gettop(L)) {}
- stack_guard(lua_State* L, int top, std::function<void(int, int)> fx = detail::stack_fail) : L(L), top(top), on_mismatch(std::move(fx)) {}
- bool check_stack(int modification = 0) const {
- int bottom = lua_gettop(L) + modification;
- if (top == bottom) {
- return true;
- }
- on_mismatch(top, bottom);
- return false;
- }
- ~stack_guard() {
- check_stack();
- }
- };
-} // sol
-
-#endif // SOL_STACK_GUARD_HPP
diff --git a/3rdparty/sol2/sol/stack_pop.hpp b/3rdparty/sol2/sol/stack_pop.hpp
deleted file mode 100644
index f69701311e5..00000000000
--- a/3rdparty/sol2/sol/stack_pop.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_STACK_POP_HPP
-#define SOL_STACK_POP_HPP
-
-#include "stack_core.hpp"
-#include "stack_get.hpp"
-#include <utility>
-#include <tuple>
-
-namespace sol {
- namespace stack {
- template <typename T, typename>
- struct popper {
- inline static decltype(auto) pop(lua_State* L) {
- record tracking{};
- decltype(auto) r = get<T>(L, -lua_size<T>::value, tracking);
- lua_pop(L, tracking.used);
- return r;
- }
- };
-
- template <typename T>
- struct popper<T, std::enable_if_t<std::is_base_of<stack_reference, meta::unqualified_t<T>>::value>> {
- static_assert(meta::neg<std::is_base_of<stack_reference, meta::unqualified_t<T>>>::value, "You cannot pop something that derives from stack_reference: it will not remain on the stack and thusly will go out of scope!");
- };
- } // stack
-} // sol
-
-#endif // SOL_STACK_POP_HPP
diff --git a/3rdparty/sol2/sol/stack_probe.hpp b/3rdparty/sol2/sol/stack_probe.hpp
deleted file mode 100644
index 62185f4f34b..00000000000
--- a/3rdparty/sol2/sol/stack_probe.hpp
+++ /dev/null
@@ -1,87 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_STACK_PROBE_HPP
-#define SOL_STACK_PROBE_HPP
-
-#include "stack_core.hpp"
-#include "stack_field.hpp"
-#include "stack_check.hpp"
-
-namespace sol {
- namespace stack {
- template <typename T, bool b, bool raw, typename>
- struct probe_field_getter {
- template <typename Key>
- probe get(lua_State* L, Key&& key, int tableindex = -2) {
- if (!b && !maybe_indexable(L, tableindex)) {
- return probe(false, 0);
- }
- get_field<b, raw>(L, std::forward<Key>(key), tableindex);
- return probe(!check<lua_nil_t>(L), 1);
- }
- };
-
- template <typename A, typename B, bool b, bool raw, typename C>
- struct probe_field_getter<std::pair<A, B>, b, raw, C> {
- template <typename Keys>
- probe get(lua_State* L, Keys&& keys, int tableindex = -2) {
- if (!b && !maybe_indexable(L, tableindex)) {
- return probe(false, 0);
- }
- get_field<b, raw>(L, std::get<0>(keys), tableindex);
- if (!maybe_indexable(L)) {
- return probe(false, 1);
- }
- get_field<false, raw>(L, std::get<1>(keys), tableindex);
- return probe(!check<lua_nil_t>(L), 2);
- }
- };
-
- template <typename... Args, bool b, bool raw, typename C>
- struct probe_field_getter<std::tuple<Args...>, b, raw, C> {
- template <std::size_t I, typename Keys>
- probe apply(std::index_sequence<I>, int sofar, lua_State* L, Keys&& keys, int tableindex) {
- get_field < I < 1 && b, raw>(L, std::get<I>(keys), tableindex);
- return probe(!check<lua_nil_t>(L), sofar);
- }
-
- template <std::size_t I, std::size_t I1, std::size_t... In, typename Keys>
- probe apply(std::index_sequence<I, I1, In...>, int sofar, lua_State* L, Keys&& keys, int tableindex) {
- get_field < I < 1 && b, raw>(L, std::get<I>(keys), tableindex);
- if (!maybe_indexable(L)) {
- return probe(false, sofar);
- }
- return apply(std::index_sequence<I1, In...>(), sofar + 1, L, std::forward<Keys>(keys), -1);
- }
-
- template <typename Keys>
- probe get(lua_State* L, Keys&& keys, int tableindex = -2) {
- if (!b && !maybe_indexable(L, tableindex)) {
- return probe(false, 0);
- }
- return apply(std::index_sequence_for<Args...>(), 1, L, std::forward<Keys>(keys), tableindex);
- }
- };
- } // stack
-} // sol
-
-#endif // SOL_STACK_PROBE_HPP \ No newline at end of file
diff --git a/3rdparty/sol2/sol/stack_proxy.hpp b/3rdparty/sol2/sol/stack_proxy.hpp
deleted file mode 100644
index 487e4b29772..00000000000
--- a/3rdparty/sol2/sol/stack_proxy.hpp
+++ /dev/null
@@ -1,128 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_STACK_PROXY_HPP
-#define SOL_STACK_PROXY_HPP
-
-#include "stack.hpp"
-#include "function.hpp"
-#include "protected_function.hpp"
-#include "proxy_base.hpp"
-
-namespace sol {
- struct stack_proxy : public proxy_base<stack_proxy> {
- private:
- lua_State* L;
- int index;
-
- public:
- stack_proxy() : L(nullptr), index(0) {}
- stack_proxy(lua_State* L, int index) : L(L), index(index) {}
-
- template<typename T>
- decltype(auto) get() const {
- return stack::get<T>(L, stack_index());
- }
-
- int push() const {
- return push(L);
- }
-
- int push(lua_State* Ls) const {
- lua_pushvalue(Ls, index);
- return 1;
- }
-
- lua_State* lua_state() const { return L; }
- int stack_index() const { return index; }
-
- template<typename... Ret, typename... Args>
- decltype(auto) call(Args&&... args) {
- return get<function>().template call<Ret...>(std::forward<Args>(args)...);
- }
-
- template<typename... Args>
- decltype(auto) operator()(Args&&... args) {
- return call<>(std::forward<Args>(args)...);
- }
- };
-
- namespace stack {
- template <>
- struct getter<stack_proxy> {
- static stack_proxy get(lua_State* L, int index = -1) {
- return stack_proxy(L, index);
- }
- };
-
- template <>
- struct pusher<stack_proxy> {
- static int push(lua_State*, const stack_proxy& ref) {
- return ref.push();
- }
- };
- } // stack
-
- namespace detail {
- template <>
- struct is_speshul<function_result> : std::true_type {};
- template <>
- struct is_speshul<protected_function_result> : std::true_type {};
-
- template <std::size_t I, typename... Args, typename T>
- stack_proxy get(types<Args...>, index_value<0>, index_value<I>, const T& fr) {
- return stack_proxy(fr.lua_state(), static_cast<int>(fr.stack_index() + I));
- }
-
- template <std::size_t I, std::size_t N, typename Arg, typename... Args, typename T, meta::enable<meta::boolean<(N > 0)>> = meta::enabler>
- stack_proxy get(types<Arg, Args...>, index_value<N>, index_value<I>, const T& fr) {
- return get(types<Args...>(), index_value<N - 1>(), index_value<I + lua_size<Arg>::value>(), fr);
- }
- }
-
- template <>
- struct tie_size<function_result> : std::integral_constant<std::size_t, SIZE_MAX> {};
-
- template <std::size_t I>
- stack_proxy get(const function_result& fr) {
- return stack_proxy(fr.lua_state(), static_cast<int>(fr.stack_index() + I));
- }
-
- template <std::size_t I, typename... Args>
- stack_proxy get(types<Args...> t, const function_result& fr) {
- return detail::get(t, index_value<I>(), index_value<0>(), fr);
- }
-
- template <>
- struct tie_size<protected_function_result> : std::integral_constant<std::size_t, SIZE_MAX> {};
-
- template <std::size_t I>
- stack_proxy get(const protected_function_result& fr) {
- return stack_proxy(fr.lua_state(), static_cast<int>(fr.stack_index() + I));
- }
-
- template <std::size_t I, typename... Args>
- stack_proxy get(types<Args...> t, const protected_function_result& fr) {
- return detail::get(t, index_value<I>(), index_value<0>(), fr);
- }
-} // sol
-
-#endif // SOL_STACK_PROXY_HPP
diff --git a/3rdparty/sol2/sol/stack_push.hpp b/3rdparty/sol2/sol/stack_push.hpp
deleted file mode 100644
index 6e407cceb84..00000000000
--- a/3rdparty/sol2/sol/stack_push.hpp
+++ /dev/null
@@ -1,694 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_STACK_PUSH_HPP
-#define SOL_STACK_PUSH_HPP
-
-#include "stack_core.hpp"
-#include "raii.hpp"
-#include "optional.hpp"
-#include <memory>
-#ifdef SOL_CODECVT_SUPPORT
-#include <codecvt>
-#include <locale>
-#endif
-
-namespace sol {
- namespace stack {
- template <typename T>
- struct pusher<detail::as_value_tag<T>> {
- template <typename F, typename... Args>
- static int push_fx(lua_State* L, F&& f, Args&&... args) {
- // Basically, we store all user-data like this:
- // If it's a movable/copyable value (no std::ref(x)), then we store the pointer to the new
- // data in the first sizeof(T*) bytes, and then however many bytes it takes to
- // do the actual object. Things that are std::ref or plain T* are stored as
- // just the sizeof(T*), and nothing else.
- T** pointerpointer = static_cast<T**>(lua_newuserdata(L, sizeof(T*) + sizeof(T)));
- T*& referencereference = *pointerpointer;
- T* allocationtarget = reinterpret_cast<T*>(pointerpointer + 1);
- referencereference = allocationtarget;
- std::allocator<T> alloc{};
- alloc.construct(allocationtarget, std::forward<Args>(args)...);
- f();
- return 1;
- }
-
- template <typename K, typename... Args>
- static int push_keyed(lua_State* L, K&& k, Args&&... args) {
- return push_fx(L, [&L, &k]() {
- luaL_newmetatable(L, &k[0]);
- lua_setmetatable(L, -2);
- }, std::forward<Args>(args)...);
- }
-
- template <typename... Args>
- static int push(lua_State* L, Args&&... args) {
- return push_keyed(L, usertype_traits<T>::metatable(), std::forward<Args>(args)...);
- }
- };
-
- template <typename T>
- struct pusher<detail::as_pointer_tag<T>> {
- template <typename F>
- static int push_fx(lua_State* L, F&& f, T* obj) {
- if (obj == nullptr)
- return stack::push(L, lua_nil);
- T** pref = static_cast<T**>(lua_newuserdata(L, sizeof(T*)));
- *pref = obj;
- f();
- return 1;
- }
-
- template <typename K>
- static int push_keyed(lua_State* L, K&& k, T* obj) {
- return push_fx(L, [&L, &k]() {
- luaL_newmetatable(L, &k[0]);
- lua_setmetatable(L, -2);
- }, obj);
- }
-
- static int push(lua_State* L, T* obj) {
- return push_keyed(L, usertype_traits<meta::unqualified_t<T>*>::metatable(), obj);
- }
- };
-
- template <>
- struct pusher<detail::as_reference_tag> {
- template <typename T>
- static int push(lua_State* L, T&& obj) {
- return stack::push(L, detail::ptr(obj));
- }
- };
-
- template<typename T, typename>
- struct pusher {
- template <typename... Args>
- static int push(lua_State* L, Args&&... args) {
- return pusher<detail::as_value_tag<T>>{}.push(L, std::forward<Args>(args)...);
- }
- };
-
- template<typename T>
- struct pusher<T*, meta::disable_if_t<meta::all<is_container<meta::unqualified_t<T>>, meta::neg<meta::any<std::is_base_of<reference, meta::unqualified_t<T>>, std::is_base_of<stack_reference, meta::unqualified_t<T>>>>>::value>> {
- template <typename... Args>
- static int push(lua_State* L, Args&&... args) {
- return pusher<detail::as_pointer_tag<T>>{}.push(L, std::forward<Args>(args)...);
- }
- };
-
- template<typename T>
- struct pusher<T, std::enable_if_t<is_unique_usertype<T>::value>> {
- typedef typename unique_usertype_traits<T>::type P;
- typedef typename unique_usertype_traits<T>::actual_type Real;
-
- template <typename Arg, meta::enable<std::is_base_of<Real, meta::unqualified_t<Arg>>> = meta::enabler>
- static int push(lua_State* L, Arg&& arg) {
- if (unique_usertype_traits<T>::is_null(arg))
- return stack::push(L, lua_nil);
- return push_deep(L, std::forward<Arg>(arg));
- }
-
- template <typename Arg0, typename Arg1, typename... Args>
- static int push(lua_State* L, Arg0&& arg0, Arg0&& arg1, Args&&... args) {
- return push_deep(L, std::forward<Arg0>(arg0), std::forward<Arg1>(arg1), std::forward<Args>(args)...);
- }
-
- template <typename... Args>
- static int push_deep(lua_State* L, Args&&... args) {
- P** pref = static_cast<P**>(lua_newuserdata(L, sizeof(P*) + sizeof(detail::special_destruct_func) + sizeof(Real)));
- detail::special_destruct_func* fx = static_cast<detail::special_destruct_func*>(static_cast<void*>(pref + 1));
- Real* mem = static_cast<Real*>(static_cast<void*>(fx + 1));
- *fx = detail::special_destruct<P, Real>;
- detail::default_construct::construct(mem, std::forward<Args>(args)...);
- *pref = unique_usertype_traits<T>::get(*mem);
- if (luaL_newmetatable(L, &usertype_traits<detail::unique_usertype<P>>::metatable()[0]) == 1) {
- set_field(L, "__gc", detail::unique_destruct<P>);
- }
- lua_setmetatable(L, -2);
- return 1;
- }
- };
-
- template<typename T>
- struct pusher<std::reference_wrapper<T>> {
- static int push(lua_State* L, const std::reference_wrapper<T>& t) {
- return stack::push(L, std::addressof(detail::deref(t.get())));
- }
- };
-
- template<typename T>
- struct pusher<T, std::enable_if_t<std::is_floating_point<T>::value>> {
- static int push(lua_State* L, const T& value) {
- lua_pushnumber(L, value);
- return 1;
- }
- };
-
- template<typename T>
- struct pusher<T, std::enable_if_t<meta::all<std::is_integral<T>, std::is_signed<T>>::value>> {
- static int push(lua_State* L, const T& value) {
- lua_pushinteger(L, static_cast<lua_Integer>(value));
- return 1;
- }
- };
-
- template<typename T>
- struct pusher<T, std::enable_if_t<std::is_enum<T>::value>> {
- static int push(lua_State* L, const T& value) {
- if (std::is_same<char, T>::value) {
- return stack::push(L, static_cast<int>(value));
- }
- return stack::push(L, static_cast<std::underlying_type_t<T>>(value));
- }
- };
-
- template<typename T>
- struct pusher<T, std::enable_if_t<meta::all<std::is_integral<T>, std::is_unsigned<T>>::value>> {
- static int push(lua_State* L, const T& value) {
- lua_pushinteger(L, static_cast<lua_Integer>(value));
- return 1;
- }
- };
-
- template<typename T>
- struct pusher<as_table_t<T>, std::enable_if_t<!meta::has_key_value_pair<meta::unqualified_t<std::remove_pointer_t<T>>>::value>> {
- static int push(lua_State* L, const as_table_t<T>& tablecont) {
- auto& cont = detail::deref(detail::unwrap(tablecont.source));
- lua_createtable(L, static_cast<int>(cont.size()), 0);
- int tableindex = lua_gettop(L);
- std::size_t index = 1;
- for (const auto& i : cont) {
-#if SOL_LUA_VERSION >= 503
- int p = stack::push(L, i);
- for (int pi = 0; pi < p; ++pi) {
- lua_seti(L, tableindex, static_cast<lua_Integer>(index++));
- }
-#else
- lua_pushinteger(L, static_cast<lua_Integer>(index));
- int p = stack::push(L, i);
- if (p == 1) {
- ++index;
- lua_settable(L, tableindex);
- }
- else {
- int firstindex = tableindex + 1 + 1;
- for (int pi = 0; pi < p; ++pi) {
- stack::push(L, index);
- lua_pushvalue(L, firstindex);
- lua_settable(L, tableindex);
- ++index;
- ++firstindex;
- }
- lua_pop(L, 1 + p);
- }
-#endif
- }
- // TODO: figure out a better way to do this...?
- //set_field(L, -1, cont.size());
- return 1;
- }
- };
-
- template<typename T>
- struct pusher<as_table_t<T>, std::enable_if_t<meta::has_key_value_pair<meta::unqualified_t<std::remove_pointer_t<T>>>::value>> {
- static int push(lua_State* L, const as_table_t<T>& tablecont) {
- auto& cont = detail::deref(detail::unwrap(tablecont.source));
- lua_createtable(L, static_cast<int>(cont.size()), 0);
- int tableindex = lua_gettop(L);
- for (const auto& pair : cont) {
- set_field(L, pair.first, pair.second, tableindex);
- }
- return 1;
- }
- };
-
- template<typename T>
- struct pusher<T, std::enable_if_t<std::is_base_of<reference, T>::value || std::is_base_of<stack_reference, T>::value>> {
- static int push(lua_State* L, const T& ref) {
- return ref.push(L);
- }
-
- static int push(lua_State* L, T&& ref) {
- return ref.push(L);
- }
- };
-
- template<>
- struct pusher<bool> {
- static int push(lua_State* L, bool b) {
- lua_pushboolean(L, b);
- return 1;
- }
- };
-
- template<>
- struct pusher<lua_nil_t> {
- static int push(lua_State* L, lua_nil_t) {
- lua_pushnil(L);
- return 1;
- }
- };
-
- template<>
- struct pusher<metatable_key_t> {
- static int push(lua_State* L, metatable_key_t) {
- lua_pushlstring(L, "__mt", 4);
- return 1;
- }
- };
-
- template<>
- struct pusher<std::remove_pointer_t<lua_CFunction>> {
- static int push(lua_State* L, lua_CFunction func, int n = 0) {
- lua_pushcclosure(L, func, n);
- return 1;
- }
- };
-
- template<>
- struct pusher<lua_CFunction> {
- static int push(lua_State* L, lua_CFunction func, int n = 0) {
- lua_pushcclosure(L, func, n);
- return 1;
- }
- };
-
- template<>
- struct pusher<c_closure> {
- static int push(lua_State* L, c_closure cc) {
- lua_pushcclosure(L, cc.c_function, cc.upvalues);
- return 1;
- }
- };
-
- template<typename Arg, typename... Args>
- struct pusher<closure<Arg, Args...>> {
- template <std::size_t... I, typename T>
- static int push(std::index_sequence<I...>, lua_State* L, T&& c) {
- int pushcount = multi_push(L, detail::forward_get<I>(c.upvalues)...);
- return stack::push(L, c_closure(c.c_function, pushcount));
- }
-
- template <typename T>
- static int push(lua_State* L, T&& c) {
- return push(std::make_index_sequence<1 + sizeof...(Args)>(), L, std::forward<T>(c));
- }
- };
-
- template<>
- struct pusher<void*> {
- static int push(lua_State* L, void* userdata) {
- lua_pushlightuserdata(L, userdata);
- return 1;
- }
- };
-
- template<>
- struct pusher<lightuserdata_value> {
- static int push(lua_State* L, lightuserdata_value userdata) {
- lua_pushlightuserdata(L, userdata);
- return 1;
- }
- };
-
- template<typename T>
- struct pusher<light<T>> {
- static int push(lua_State* L, light<T> l) {
- lua_pushlightuserdata(L, static_cast<void*>(l.value));
- return 1;
- }
- };
-
- template<typename T>
- struct pusher<user<T>> {
- template <bool with_meta = true, typename Key, typename... Args>
- static int push_with(lua_State* L, Key&& name, Args&&... args) {
- // A dumb pusher
- void* rawdata = lua_newuserdata(L, sizeof(T));
- T* data = static_cast<T*>(rawdata);
- std::allocator<T> alloc;
- alloc.construct(data, std::forward<Args>(args)...);
- if (with_meta) {
- lua_CFunction cdel = detail::user_alloc_destroy<T>;
- // Make sure we have a plain GC set for this data
- if (luaL_newmetatable(L, name) != 0) {
- lua_pushcclosure(L, cdel, 0);
- lua_setfield(L, -2, "__gc");
- }
- lua_setmetatable(L, -2);
- }
- return 1;
- }
-
- template <typename Arg, typename... Args, meta::disable<meta::any_same<meta::unqualified_t<Arg>, no_metatable_t, metatable_key_t>> = meta::enabler>
- static int push(lua_State* L, Arg&& arg, Args&&... args) {
- const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
- return push_with(L, name, std::forward<Arg>(arg), std::forward<Args>(args)...);
- }
-
- template <typename... Args>
- static int push(lua_State* L, no_metatable_t, Args&&... args) {
- const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
- return push_with<false>(L, name, std::forward<Args>(args)...);
- }
-
- template <typename Key, typename... Args>
- static int push(lua_State* L, metatable_key_t, Key&& key, Args&&... args) {
- const auto name = &key[0];
- return push_with<true>(L, name, std::forward<Args>(args)...);
- }
-
- static int push(lua_State* L, const user<T>& u) {
- const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
- return push_with(L, name, u.value);
- }
-
- static int push(lua_State* L, user<T>&& u) {
- const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
- return push_with(L, name, std::move(u.value));
- }
-
- static int push(lua_State* L, no_metatable_t, const user<T>& u) {
- const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
- return push_with<false>(L, name, u.value);
- }
-
- static int push(lua_State* L, no_metatable_t, user<T>&& u) {
- const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
- return push_with<false>(L, name, std::move(u.value));
- }
- };
-
- template<>
- struct pusher<userdata_value> {
- static int push(lua_State* L, userdata_value data) {
- void** ud = static_cast<void**>(lua_newuserdata(L, sizeof(void*)));
- *ud = data.value;
- return 1;
- }
- };
-
- template<>
- struct pusher<const char*> {
- static int push_sized(lua_State* L, const char* str, std::size_t len) {
- lua_pushlstring(L, str, len);
- return 1;
- }
-
- static int push(lua_State* L, const char* str) {
- if (str == nullptr)
- return stack::push(L, lua_nil);
- return push_sized(L, str, std::char_traits<char>::length(str));
- }
-
- static int push(lua_State* L, const char* strb, const char* stre) {
- return push_sized(L, strb, stre - strb);
- }
-
- static int push(lua_State* L, const char* str, std::size_t len) {
- return push_sized(L, str, len);
- }
- };
-
- template<size_t N>
- struct pusher<char[N]> {
- static int push(lua_State* L, const char(&str)[N]) {
- lua_pushlstring(L, str, N - 1);
- return 1;
- }
-
- static int push(lua_State* L, const char(&str)[N], std::size_t sz) {
- lua_pushlstring(L, str, sz);
- return 1;
- }
- };
-
- template <>
- struct pusher<char> {
- static int push(lua_State* L, char c) {
- const char str[2] = { c, '\0' };
- return stack::push(L, str, 1);
- }
- };
-
- template<>
- struct pusher<std::string> {
- static int push(lua_State* L, const std::string& str) {
- lua_pushlstring(L, str.c_str(), str.size());
- return 1;
- }
-
- static int push(lua_State* L, const std::string& str, std::size_t sz) {
- lua_pushlstring(L, str.c_str(), sz);
- return 1;
- }
- };
-
- template<>
- struct pusher<meta_function> {
- static int push(lua_State* L, meta_function m) {
- const std::string& str = name_of(m);
- lua_pushlstring(L, str.c_str(), str.size());
- return 1;
- }
- };
-
-#ifdef SOL_CODECVT_SUPPORT
- template<>
- struct pusher<const wchar_t*> {
- static int push(lua_State* L, const wchar_t* wstr) {
- return push(L, wstr, std::char_traits<wchar_t>::length(wstr));
- }
-
- static int push(lua_State* L, const wchar_t* wstr, std::size_t sz) {
- return push(L, wstr, wstr + sz);
- }
-
- static int push(lua_State* L, const wchar_t* strb, const wchar_t* stre) {
- if (sizeof(wchar_t) == 2) {
- static std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> convert;
- std::string u8str = convert.to_bytes(strb, stre);
- return stack::push(L, u8str);
- }
- static std::wstring_convert<std::codecvt_utf8<wchar_t>> convert;
- std::string u8str = convert.to_bytes(strb, stre);
- return stack::push(L, u8str);
- }
- };
-
- template<>
- struct pusher<const char16_t*> {
- static int push(lua_State* L, const char16_t* u16str) {
- return push(L, u16str, std::char_traits<char16_t>::length(u16str));
- }
-
- static int push(lua_State* L, const char16_t* u16str, std::size_t sz) {
- return push(L, u16str, u16str + sz);
- }
-
- static int push(lua_State* L, const char16_t* strb, const char16_t* stre) {
-#ifdef _MSC_VER
- static std::wstring_convert<std::codecvt_utf8_utf16<int16_t>, int16_t> convert;
- std::string u8str = convert.to_bytes(reinterpret_cast<const int16_t*>(strb), reinterpret_cast<const int16_t*>(stre));
-#else
- static std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
- std::string u8str = convert.to_bytes(strb, stre);
-#endif // VC++ is a shit
- return stack::push(L, u8str);
- }
- };
-
- template<>
- struct pusher<const char32_t*> {
- static int push(lua_State* L, const char32_t* u32str) {
- return push(L, u32str, u32str + std::char_traits<char32_t>::length(u32str));
- }
-
- static int push(lua_State* L, const char32_t* u32str, std::size_t sz) {
- return push(L, u32str, u32str + sz);
- }
-
- static int push(lua_State* L, const char32_t* strb, const char32_t* stre) {
-#ifdef _MSC_VER
- static std::wstring_convert<std::codecvt_utf8<int32_t>, int32_t> convert;
- std::string u8str = convert.to_bytes(reinterpret_cast<const int32_t*>(strb), reinterpret_cast<const int32_t*>(stre));
-#else
- static std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> convert;
- std::string u8str = convert.to_bytes(strb, stre);
-#endif // VC++ is a shit
- return stack::push(L, u8str);
- }
- };
-
- template<size_t N>
- struct pusher<wchar_t[N]> {
- static int push(lua_State* L, const wchar_t(&str)[N]) {
- return push(L, str, N - 1);
- }
-
- static int push(lua_State* L, const wchar_t(&str)[N], std::size_t sz) {
- return stack::push_specific<const wchar_t*>(L, str, str + sz);
- }
- };
-
- template<size_t N>
- struct pusher<char16_t[N]> {
- static int push(lua_State* L, const char16_t(&str)[N]) {
- return push(L, str, N - 1);
- }
-
- static int push(lua_State* L, const char16_t(&str)[N], std::size_t sz) {
- return stack::push_specific<const char16_t*>(L, str, str + sz);
- }
- };
-
- template<size_t N>
- struct pusher<char32_t[N]> {
- static int push(lua_State* L, const char32_t(&str)[N]) {
- return push(L, str, N - 1);
- }
-
- static int push(lua_State* L, const char32_t(&str)[N], std::size_t sz) {
- return stack::push_specific<const char32_t*>(L, str, str + sz);
- }
- };
-
- template <>
- struct pusher<wchar_t> {
- static int push(lua_State* L, wchar_t c) {
- const wchar_t str[2] = { c, '\0' };
- return stack::push(L, str, 1);
- }
- };
-
- template <>
- struct pusher<char16_t> {
- static int push(lua_State* L, char16_t c) {
- const char16_t str[2] = { c, '\0' };
- return stack::push(L, str, 1);
- }
- };
-
- template <>
- struct pusher<char32_t> {
- static int push(lua_State* L, char32_t c) {
- const char32_t str[2] = { c, '\0' };
- return stack::push(L, str, 1);
- }
- };
-
- template<>
- struct pusher<std::wstring> {
- static int push(lua_State* L, const std::wstring& wstr) {
- return push(L, wstr.data(), wstr.size());
- }
-
- static int push(lua_State* L, const std::wstring& wstr, std::size_t sz) {
- return stack::push(L, wstr.data(), wstr.data() + sz);
- }
- };
-
- template<>
- struct pusher<std::u16string> {
- static int push(lua_State* L, const std::u16string& u16str) {
- return push(L, u16str, u16str.size());
- }
-
- static int push(lua_State* L, const std::u16string& u16str, std::size_t sz) {
- return stack::push(L, u16str.data(), u16str.data() + sz);
- }
- };
-
- template<>
- struct pusher<std::u32string> {
- static int push(lua_State* L, const std::u32string& u32str) {
- return push(L, u32str, u32str.size());
- }
-
- static int push(lua_State* L, const std::u32string& u32str, std::size_t sz) {
- return stack::push(L, u32str.data(), u32str.data() + sz);
- }
- };
-#endif // codecvt Header Support
-
- template<typename... Args>
- struct pusher<std::tuple<Args...>> {
- template <std::size_t... I, typename T>
- static int push(std::index_sequence<I...>, lua_State* L, T&& t) {
- int pushcount = 0;
- (void)detail::swallow{ 0, (pushcount += stack::push(L,
- detail::forward_get<I>(t)
- ), 0)... };
- return pushcount;
- }
-
- template <typename T>
- static int push(lua_State* L, T&& t) {
- return push(std::index_sequence_for<Args...>(), L, std::forward<T>(t));
- }
- };
-
- template<typename A, typename B>
- struct pusher<std::pair<A, B>> {
- template <typename T>
- static int push(lua_State* L, T&& t) {
- int pushcount = stack::push(L, detail::forward_get<0>(t));
- pushcount += stack::push(L, detail::forward_get<1>(t));
- return pushcount;
- }
- };
-
- template<typename O>
- struct pusher<optional<O>> {
- template <typename T>
- static int push(lua_State* L, T&& t) {
- if (t == nullopt) {
- return stack::push(L, nullopt);
- }
- return stack::push(L, t.value());
- }
- };
-
- template<>
- struct pusher<nullopt_t> {
- static int push(lua_State* L, nullopt_t) {
- return stack::push(L, lua_nil);
- }
- };
-
- template<>
- struct pusher<std::nullptr_t> {
- static int push(lua_State* L, std::nullptr_t) {
- return stack::push(L, lua_nil);
- }
- };
-
- template<>
- struct pusher<this_state> {
- static int push(lua_State*, const this_state&) {
- return 0;
- }
- };
- } // stack
-} // sol
-
-#endif // SOL_STACK_PUSH_HPP
diff --git a/3rdparty/sol2/sol/stack_reference.hpp b/3rdparty/sol2/sol/stack_reference.hpp
deleted file mode 100644
index 561690664c3..00000000000
--- a/3rdparty/sol2/sol/stack_reference.hpp
+++ /dev/null
@@ -1,96 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_STACK_REFERENCE_HPP
-#define SOL_STACK_REFERENCE_HPP
-
-namespace sol {
- class stack_reference {
- private:
- lua_State* L = nullptr;
- int index = 0;
-
- protected:
- int registry_index() const noexcept {
- return LUA_NOREF;
- }
-
- public:
- stack_reference() noexcept = default;
- stack_reference(lua_nil_t) noexcept : stack_reference() {};
- stack_reference(lua_State* L, int i) noexcept : L(L), index(lua_absindex(L, i)) {}
- stack_reference(lua_State* L, absolute_index i) noexcept : L(L), index(i) {}
- stack_reference(lua_State* L, raw_index i) noexcept : L(L), index(i) {}
- stack_reference(lua_State* L, ref_index i) noexcept = delete;
- stack_reference(stack_reference&& o) noexcept = default;
- stack_reference& operator=(stack_reference&&) noexcept = default;
- stack_reference(const stack_reference&) noexcept = default;
- stack_reference& operator=(const stack_reference&) noexcept = default;
-
- int push() const noexcept {
- return push(lua_state());
- }
-
- int push(lua_State* Ls) const noexcept {
- lua_pushvalue(lua_state(), index);
- if (Ls != lua_state()) {
- lua_xmove(lua_state(), Ls, 1);
- }
- return 1;
- }
-
- void pop() const noexcept {
- pop(lua_state());
- }
-
- void pop(lua_State* Ls, int n = 1) const noexcept {
- lua_pop(Ls, n);
- }
-
- int stack_index() const noexcept {
- return index;
- }
-
- type get_type() const noexcept {
- int result = lua_type(L, index);
- return static_cast<type>(result);
- }
-
- lua_State* lua_state() const noexcept {
- return L;
- }
-
- bool valid() const noexcept {
- type t = get_type();
- return t != type::lua_nil && t != type::none;
- }
- };
-
- inline bool operator== (const stack_reference& l, const stack_reference& r) {
- return lua_compare(l.lua_state(), l.stack_index(), r.stack_index(), LUA_OPEQ) == 0;
- }
-
- inline bool operator!= (const stack_reference& l, const stack_reference& r) {
- return !operator==(l, r);
- }
-} // sol
-
-#endif // SOL_STACK_REFERENCE_HPP
diff --git a/3rdparty/sol2/sol/state.hpp b/3rdparty/sol2/sol/state.hpp
deleted file mode 100644
index 97bbc260dc6..00000000000
--- a/3rdparty/sol2/sol/state.hpp
+++ /dev/null
@@ -1,94 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_STATE_HPP
-#define SOL_STATE_HPP
-
-#include "state_view.hpp"
-
-namespace sol {
- inline int default_at_panic(lua_State* L) {
-#ifdef SOL_NO_EXCEPTIONS
- (void)L;
- return -1;
-#else
- const char* message = lua_tostring(L, -1);
- if (message) {
- std::string err = message;
- lua_pop(L, 1);
- throw error(err);
- }
- throw error(std::string("An unexpected error occurred and forced the lua state to call atpanic"));
-#endif
- }
-
- inline int default_error_handler(lua_State*L) {
- using namespace sol;
- std::string msg = "An unknown error has triggered the default error handler";
- optional<string_detail::string_shim> maybetopmsg = stack::check_get<string_detail::string_shim>(L, 1);
- if (maybetopmsg) {
- const string_detail::string_shim& topmsg = maybetopmsg.value();
- msg.assign(topmsg.c_str(), topmsg.size());
- }
- luaL_traceback(L, L, msg.c_str(), 1);
- optional<string_detail::string_shim> maybetraceback = stack::check_get<string_detail::string_shim>(L, -1);
- if (maybetraceback) {
- const string_detail::string_shim& traceback = maybetraceback.value();
- msg.assign(traceback.c_str(), traceback.size());
- }
- return stack::push(L, msg);
- }
-
-
- class state : private std::unique_ptr<lua_State, void(*)(lua_State*)>, public state_view {
- private:
- typedef std::unique_ptr<lua_State, void(*)(lua_State*)> unique_base;
- public:
- state(lua_CFunction panic = default_at_panic) : unique_base(luaL_newstate(), lua_close),
- state_view(unique_base::get()) {
- set_panic(panic);
- stack::luajit_exception_handler(unique_base::get());
- }
-
- state(lua_CFunction panic, lua_Alloc alfunc, void* alpointer = nullptr) : unique_base(lua_newstate(alfunc, alpointer), lua_close),
- state_view(unique_base::get()) {
- set_panic(panic);
- sol::protected_function::set_default_handler(sol::object(lua_state(), in_place, default_error_handler));
- stack::luajit_exception_handler(unique_base::get());
- }
-
- state(const state&) = delete;
- state(state&&) = default;
- state& operator=(const state&) = delete;
- state& operator=(state&&) = default;
-
- using state_view::get;
-
- ~state() {
- auto& handler = protected_function::get_default_handler();
- if (handler.lua_state() == this->lua_state()) {
- protected_function::set_default_handler(reference());
- }
- }
- };
-} // sol
-
-#endif // SOL_STATE_HPP
diff --git a/3rdparty/sol2/sol/state_view.hpp b/3rdparty/sol2/sol/state_view.hpp
deleted file mode 100644
index 14032d65ac5..00000000000
--- a/3rdparty/sol2/sol/state_view.hpp
+++ /dev/null
@@ -1,491 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_STATE_VIEW_HPP
-#define SOL_STATE_VIEW_HPP
-
-#include "error.hpp"
-#include "table.hpp"
-#include "load_result.hpp"
-#include <memory>
-
-namespace sol {
- enum class lib : char {
- base,
- package,
- coroutine,
- string,
- os,
- math,
- table,
- debug,
- bit32,
- io,
- ffi,
- jit,
- utf8,
- count
- };
-
- inline std::size_t total_memory_used(lua_State* L) {
- std::size_t kb = lua_gc(L, LUA_GCCOUNT, 0);
- kb *= 1024;
- kb += lua_gc(L, LUA_GCCOUNTB, 0);
- return kb;
- }
-
- class state_view {
- private:
- lua_State* L;
- table reg;
- global_table global;
-
- optional<object> is_loaded_package(const std::string& key) {
- auto loaded = reg.traverse_get<optional<object>>("_LOADED", key);
- bool is53mod = loaded && !(loaded->is<bool>() && !loaded->as<bool>());
- if (is53mod)
- return loaded;
-#if SOL_LUA_VERSION <= 501
- auto loaded51 = global.traverse_get<optional<object>>("package", "loaded", key);
- bool is51mod = loaded51 && !(loaded51->is<bool>() && !loaded51->as<bool>());
- if (is51mod)
- return loaded51;
-#endif
- return nullopt;
- }
-
- template <typename T>
- void ensure_package(const std::string& key, T&& sr) {
-#if SOL_LUA_VERSION <= 501
- auto pkg = global["package"];
- if (!pkg.valid()) {
- pkg = create_table_with("loaded", create_table_with(key, sr));
- }
- else {
- auto ld = pkg["loaded"];
- if (!ld.valid()) {
- ld = create_table_with(key, sr);
- }
- else {
- ld[key] = sr;
- }
- }
-#endif
- auto loaded = reg["_LOADED"];
- if (!loaded.valid()) {
- loaded = create_table_with(key, sr);
- }
- else {
- loaded[key] = sr;
- }
- }
-
- template <typename Fx>
- object require_core(const std::string& key, Fx&& action, bool create_global = true) {
- optional<object> loaded = is_loaded_package(key);
- if (loaded && loaded->valid())
- return std::move(*loaded);
- action();
- auto sr = stack::get<stack_reference>(L);
- if (create_global)
- set(key, sr);
- ensure_package(key, sr);
- return stack::pop<object>(L);
- }
-
- public:
- typedef global_table::iterator iterator;
- typedef global_table::const_iterator const_iterator;
-
- state_view(lua_State* Ls) :
- L(Ls),
- reg(Ls, LUA_REGISTRYINDEX),
- global(Ls, detail::global_) {
-
- }
-
- state_view(this_state Ls) : state_view(Ls.L){
-
- }
-
- lua_State* lua_state() const {
- return L;
- }
-
- template<typename... Args>
- void open_libraries(Args&&... args) {
- static_assert(meta::all_same<lib, Args...>::value, "all types must be libraries");
- if (sizeof...(args) == 0) {
- luaL_openlibs(L);
- return;
- }
-
- lib libraries[1 + sizeof...(args)] = { lib::count, std::forward<Args>(args)... };
-
- for (auto&& library : libraries) {
- switch (library) {
-#if SOL_LUA_VERSION <= 501 && defined(SOL_LUAJIT)
- case lib::coroutine:
-#endif // luajit opens coroutine base stuff
- case lib::base:
- luaL_requiref(L, "base", luaopen_base, 1);
- lua_pop(L, 1);
- break;
- case lib::package:
- luaL_requiref(L, "package", luaopen_package, 1);
- lua_pop(L, 1);
- break;
-#if !defined(SOL_LUAJIT)
- case lib::coroutine:
-#if SOL_LUA_VERSION > 501
- luaL_requiref(L, "coroutine", luaopen_coroutine, 1);
- lua_pop(L, 1);
-#endif // Lua 5.2+ only
- break;
-#endif // Not LuaJIT - comes builtin
- case lib::string:
- luaL_requiref(L, "string", luaopen_string, 1);
- lua_pop(L, 1);
- break;
- case lib::table:
- luaL_requiref(L, "table", luaopen_table, 1);
- lua_pop(L, 1);
- break;
- case lib::math:
- luaL_requiref(L, "math", luaopen_math, 1);
- lua_pop(L, 1);
- break;
- case lib::bit32:
-#ifdef SOL_LUAJIT
- luaL_requiref(L, "bit32", luaopen_bit, 1);
- lua_pop(L, 1);
-#elif (SOL_LUA_VERSION == 502) || defined(LUA_COMPAT_BITLIB) || defined(LUA_COMPAT_5_2)
- luaL_requiref(L, "bit32", luaopen_bit32, 1);
- lua_pop(L, 1);
-#else
-#endif // Lua 5.2 only (deprecated in 5.3 (503)) (Can be turned on with Compat flags)
- break;
- case lib::io:
- luaL_requiref(L, "io", luaopen_io, 1);
- lua_pop(L, 1);
- break;
- case lib::os:
- luaL_requiref(L, "os", luaopen_os, 1);
- lua_pop(L, 1);
- break;
- case lib::debug:
- luaL_requiref(L, "debug", luaopen_debug, 1);
- lua_pop(L, 1);
- break;
- case lib::utf8:
-#if SOL_LUA_VERSION > 502 && !defined(SOL_LUAJIT)
- luaL_requiref(L, "utf8", luaopen_utf8, 1);
- lua_pop(L, 1);
-#endif // Lua 5.3+ only
- break;
- case lib::ffi:
-#ifdef SOL_LUAJIT
- luaL_requiref(L, "ffi", luaopen_ffi, 1);
- lua_pop(L, 1);
-#endif // LuaJIT only
- break;
- case lib::jit:
-#ifdef SOL_LUAJIT
- luaL_requiref(L, "jit", luaopen_jit, 1);
- lua_pop(L, 1);
-#endif // LuaJIT Only
- break;
- case lib::count:
- default:
- break;
- }
- }
- }
-
- object require(const std::string& key, lua_CFunction open_function, bool create_global = true) {
- luaL_requiref(L, key.c_str(), open_function, create_global ? 1 : 0);
- return stack::pop<object>(L);
- }
-
- object require_script(const std::string& key, const std::string& code, bool create_global = true) {
- return require_core(key, [this, &code]() {stack::script(L, code); }, create_global);
- }
-
- object require_file(const std::string& key, const std::string& filename, bool create_global = true) {
- return require_core(key, [this, &filename]() {stack::script_file(L, filename); }, create_global);
- }
-
- protected_function_result do_string(const std::string& code) {
- sol::protected_function pf = load(code);
- return pf();
- }
-
- protected_function_result do_file(const std::string& filename) {
- sol::protected_function pf = load_file(filename);
- return pf();
- }
-
- function_result script(const std::string& code) {
- int index = lua_gettop(L);
- stack::script(L, code);
- int postindex = lua_gettop(L);
- int returns = postindex - index;
- return function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
- }
-
- function_result script_file(const std::string& filename) {
- int index = lua_gettop(L);
- stack::script_file(L, filename);
- int postindex = lua_gettop(L);
- int returns = postindex - index;
- return function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
- }
-
- load_result load(const std::string& code) {
- load_status x = static_cast<load_status>(luaL_loadstring(L, code.c_str()));
- return load_result(L, lua_absindex(L, -1), 1, 1, x);
- }
-
- load_result load_file(const std::string& filename) {
- load_status x = static_cast<load_status>(luaL_loadfile(L, filename.c_str()));
- return load_result(L, lua_absindex(L, -1), 1, 1, x);
- }
-
- load_result load_buffer(const char *buff, size_t size, const char *name, const char* mode = nullptr) {
- load_status x = static_cast<load_status>(luaL_loadbufferx(L, buff, size, name, mode));
- return load_result(L, lua_absindex(L, -1), 1, 1, x);
- }
-
- iterator begin() const {
- return global.begin();
- }
-
- iterator end() const {
- return global.end();
- }
-
- const_iterator cbegin() const {
- return global.cbegin();
- }
-
- const_iterator cend() const {
- return global.cend();
- }
-
- global_table globals() const {
- return global;
- }
-
- table registry() const {
- return reg;
- }
-
- std::size_t memory_used() const {
- return total_memory_used(lua_state());
- }
-
- void collect_garbage() {
- lua_gc(lua_state(), LUA_GCCOLLECT, 0);
- }
-
- operator lua_State* () const {
- return lua_state();
- }
-
- void set_panic(lua_CFunction panic) {
- lua_atpanic(L, panic);
- }
-
- template<typename... Args, typename... Keys>
- decltype(auto) get(Keys&&... keys) const {
- return global.get<Args...>(std::forward<Keys>(keys)...);
- }
-
- template<typename T, typename Key>
- decltype(auto) get_or(Key&& key, T&& otherwise) const {
- return global.get_or(std::forward<Key>(key), std::forward<T>(otherwise));
- }
-
- template<typename T, typename Key, typename D>
- decltype(auto) get_or(Key&& key, D&& otherwise) const {
- return global.get_or<T>(std::forward<Key>(key), std::forward<D>(otherwise));
- }
-
- template<typename... Args>
- state_view& set(Args&&... args) {
- global.set(std::forward<Args>(args)...);
- return *this;
- }
-
- template<typename T, typename... Keys>
- decltype(auto) traverse_get(Keys&&... keys) const {
- return global.traverse_get<T>(std::forward<Keys>(keys)...);
- }
-
- template<typename... Args>
- state_view& traverse_set(Args&&... args) {
- global.traverse_set(std::forward<Args>(args)...);
- return *this;
- }
-
- template<typename T>
- state_view& set_usertype(usertype<T>& user) {
- return set_usertype(usertype_traits<T>::name(), user);
- }
-
- template<typename Key, typename T>
- state_view& set_usertype(Key&& key, usertype<T>& user) {
- global.set_usertype(std::forward<Key>(key), user);
- return *this;
- }
-
- template<typename Class, typename... Args>
- state_view& new_usertype(const std::string& name, Args&&... args) {
- global.new_usertype<Class>(name, std::forward<Args>(args)...);
- return *this;
- }
-
- template<typename Class, typename CTor0, typename... CTor, typename... Args>
- state_view& new_usertype(const std::string& name, Args&&... args) {
- global.new_usertype<Class, CTor0, CTor...>(name, std::forward<Args>(args)...);
- return *this;
- }
-
- template<typename Class, typename... CArgs, typename... Args>
- state_view& new_usertype(const std::string& name, constructors<CArgs...> ctor, Args&&... args) {
- global.new_usertype<Class>(name, ctor, std::forward<Args>(args)...);
- return *this;
- }
-
- template<typename Class, typename... Args>
- state_view& new_simple_usertype(const std::string& name, Args&&... args) {
- global.new_simple_usertype<Class>(name, std::forward<Args>(args)...);
- return *this;
- }
-
- template<typename Class, typename CTor0, typename... CTor, typename... Args>
- state_view& new_simple_usertype(const std::string& name, Args&&... args) {
- global.new_simple_usertype<Class, CTor0, CTor...>(name, std::forward<Args>(args)...);
- return *this;
- }
-
- template<typename Class, typename... CArgs, typename... Args>
- state_view& new_simple_usertype(const std::string& name, constructors<CArgs...> ctor, Args&&... args) {
- global.new_simple_usertype<Class>(name, ctor, std::forward<Args>(args)...);
- return *this;
- }
-
- template<typename Class, typename... Args>
- simple_usertype<Class> create_simple_usertype(Args&&... args) {
- return global.create_simple_usertype<Class>(std::forward<Args>(args)...);
- }
-
- template<typename Class, typename CTor0, typename... CTor, typename... Args>
- simple_usertype<Class> create_simple_usertype(Args&&... args) {
- return global.create_simple_usertype<Class, CTor0, CTor...>(std::forward<Args>(args)...);
- }
-
- template<typename Class, typename... CArgs, typename... Args>
- simple_usertype<Class> create_simple_usertype(constructors<CArgs...> ctor, Args&&... args) {
- return global.create_simple_usertype<Class>(ctor, std::forward<Args>(args)...);
- }
-
- template<bool read_only = true, typename... Args>
- state_view& new_enum(const std::string& name, Args&&... args) {
- global.new_enum<read_only>(name, std::forward<Args>(args)...);
- return *this;
- }
-
- template <typename Fx>
- void for_each(Fx&& fx) {
- global.for_each(std::forward<Fx>(fx));
- }
-
- template<typename T>
- proxy<global_table&, T> operator[](T&& key) {
- return global[std::forward<T>(key)];
- }
-
- template<typename T>
- proxy<const global_table&, T> operator[](T&& key) const {
- return global[std::forward<T>(key)];
- }
-
- template<typename Sig, typename... Args, typename Key>
- state_view& set_function(Key&& key, Args&&... args) {
- global.set_function<Sig>(std::forward<Key>(key), std::forward<Args>(args)...);
- return *this;
- }
-
- template<typename... Args, typename Key>
- state_view& set_function(Key&& key, Args&&... args) {
- global.set_function(std::forward<Key>(key), std::forward<Args>(args)...);
- return *this;
- }
-
- template <typename Name>
- table create_table(Name&& name, int narr = 0, int nrec = 0) {
- return global.create(std::forward<Name>(name), narr, nrec);
- }
-
- template <typename Name, typename Key, typename Value, typename... Args>
- table create_table(Name&& name, int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
- return global.create(std::forward<Name>(name), narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
- }
-
- template <typename Name, typename... Args>
- table create_named_table(Name&& name, Args&&... args) {
- table x = global.create_with(std::forward<Args>(args)...);
- global.set(std::forward<Name>(name), x);
- return x;
- }
-
- table create_table(int narr = 0, int nrec = 0) {
- return create_table(lua_state(), narr, nrec);
- }
-
- template <typename Key, typename Value, typename... Args>
- table create_table(int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
- return create_table(lua_state(), narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
- }
-
- template <typename... Args>
- table create_table_with(Args&&... args) {
- return create_table_with(lua_state(), std::forward<Args>(args)...);
- }
-
- static inline table create_table(lua_State* L, int narr = 0, int nrec = 0) {
- return global_table::create(L, narr, nrec);
- }
-
- template <typename Key, typename Value, typename... Args>
- static inline table create_table(lua_State* L, int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
- return global_table::create(L, narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
- }
-
- template <typename... Args>
- static inline table create_table_with(lua_State* L, Args&&... args) {
- return global_table::create_with(L, std::forward<Args>(args)...);
- }
- };
-} // sol
-
-#endif // SOL_STATE_VIEW_HPP
diff --git a/3rdparty/sol2/sol/string_shim.hpp b/3rdparty/sol2/sol/string_shim.hpp
deleted file mode 100644
index 73aa81646fb..00000000000
--- a/3rdparty/sol2/sol/string_shim.hpp
+++ /dev/null
@@ -1,88 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_STRING_SHIM_HPP
-#define SOL_STRING_SHIM_HPP
-
-#include <cstddef>
-#include <string>
-
-namespace sol {
- namespace string_detail {
- struct string_shim {
- std::size_t s;
- const char* p;
-
- string_shim(const std::string& r) : string_shim(r.data(), r.size()) {}
- string_shim(const char* ptr) : string_shim(ptr, std::char_traits<char>::length(ptr)) {}
- string_shim(const char* ptr, std::size_t sz) : s(sz), p(ptr) {}
-
- static int compare(const char* lhs_p, std::size_t lhs_sz, const char* rhs_p, std::size_t rhs_sz) {
- int result = std::char_traits<char>::compare(lhs_p, rhs_p, lhs_sz < rhs_sz ? lhs_sz : rhs_sz);
- if (result != 0)
- return result;
- if (lhs_sz < rhs_sz)
- return -1;
- if (lhs_sz > rhs_sz)
- return 1;
- return 0;
- }
-
- const char* c_str() const {
- return p;
- }
-
- const char* data() const {
- return p;
- }
-
- std::size_t size() const {
- return s;
- }
-
- bool operator==(const string_shim& r) const {
- return compare(p, s, r.data(), r.size()) == 0;
- }
-
- bool operator==(const char* r) const {
- return compare(r, std::char_traits<char>::length(r), p, s) == 0;
- }
-
- bool operator==(const std::string& r) const {
- return compare(r.data(), r.size(), p, s) == 0;
- }
-
- bool operator!=(const string_shim& r) const {
- return !(*this == r);
- }
-
- bool operator!=(const char* r) const {
- return !(*this == r);
- }
-
- bool operator!=(const std::string& r) const {
- return !(*this == r);
- }
- };
- }
-}
-
-#endif // SOL_STRING_SHIM_HPP
diff --git a/3rdparty/sol2/sol/table.hpp b/3rdparty/sol2/sol/table.hpp
deleted file mode 100644
index fd556a6117d..00000000000
--- a/3rdparty/sol2/sol/table.hpp
+++ /dev/null
@@ -1,31 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_TABLE_HPP
-#define SOL_TABLE_HPP
-
-#include "table_core.hpp"
-
-namespace sol {
- typedef table_core<false> table;
-} // sol
-
-#endif // SOL_TABLE_HPP
diff --git a/3rdparty/sol2/sol/table_core.hpp b/3rdparty/sol2/sol/table_core.hpp
deleted file mode 100644
index 8004ebd2180..00000000000
--- a/3rdparty/sol2/sol/table_core.hpp
+++ /dev/null
@@ -1,475 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_TABLE_CORE_HPP
-#define SOL_TABLE_CORE_HPP
-
-#include "proxy.hpp"
-#include "stack.hpp"
-#include "function_types.hpp"
-#include "usertype.hpp"
-#include "table_iterator.hpp"
-
-namespace sol {
- namespace detail {
- template <std::size_t n>
- struct clean { lua_State* L; clean(lua_State* luastate) : L(luastate) {} ~clean() { lua_pop(L, static_cast<int>(n)); } };
- struct ref_clean { lua_State* L; int& n; ref_clean(lua_State* luastate, int& n) : L(luastate), n(n) {} ~ref_clean() { lua_pop(L, static_cast<int>(n)); } };
- inline int fail_on_newindex(lua_State* L) {
- return luaL_error(L, "sol: cannot modify the elements of an enumeration table");
- }
- }
-
- template <bool top_level, typename base_t>
- class basic_table_core : public base_t {
- friend class state;
- friend class state_view;
-
- template <typename... Args>
- using is_global = meta::all<meta::boolean<top_level>, meta::is_c_str<Args>...>;
-
- template<typename Fx>
- void for_each(std::true_type, Fx&& fx) const {
- auto pp = stack::push_pop(*this);
- stack::push(base_t::lua_state(), lua_nil);
- while (lua_next(base_t::lua_state(), -2)) {
- sol::object key(base_t::lua_state(), -2);
- sol::object value(base_t::lua_state(), -1);
- std::pair<sol::object&, sol::object&> keyvalue(key, value);
- auto pn = stack::pop_n(base_t::lua_state(), 1);
- fx(keyvalue);
- }
- }
-
- template<typename Fx>
- void for_each(std::false_type, Fx&& fx) const {
- auto pp = stack::push_pop(*this);
- stack::push(base_t::lua_state(), lua_nil);
- while (lua_next(base_t::lua_state(), -2)) {
- sol::object key(base_t::lua_state(), -2);
- sol::object value(base_t::lua_state(), -1);
- auto pn = stack::pop_n(base_t::lua_state(), 1);
- fx(key, value);
- }
- }
-
- template<typename Ret0, typename Ret1, typename... Ret, std::size_t... I, typename Keys>
- auto tuple_get(types<Ret0, Ret1, Ret...>, std::index_sequence<0, 1, I...>, Keys&& keys) const
- -> decltype(stack::pop<std::tuple<Ret0, Ret1, Ret...>>(nullptr)) {
- typedef decltype(stack::pop<std::tuple<Ret0, Ret1, Ret...>>(nullptr)) Tup;
- return Tup(
- traverse_get_optional<top_level, Ret0>(meta::is_specialization_of<sol::optional, meta::unqualified_t<Ret0>>(), detail::forward_get<0>(keys)),
- traverse_get_optional<top_level, Ret1>(meta::is_specialization_of<sol::optional, meta::unqualified_t<Ret1>>(), detail::forward_get<1>(keys)),
- traverse_get_optional<top_level, Ret>(meta::is_specialization_of<sol::optional, meta::unqualified_t<Ret>>(), detail::forward_get<I>(keys))...
- );
- }
-
- template<typename Ret, std::size_t I, typename Keys>
- decltype(auto) tuple_get(types<Ret>, std::index_sequence<I>, Keys&& keys) const {
- return traverse_get_optional<top_level, Ret>(meta::is_specialization_of<sol::optional, meta::unqualified_t<Ret>>(), detail::forward_get<I>(keys));
- }
-
- template<typename Pairs, std::size_t... I>
- void tuple_set(std::index_sequence<I...>, Pairs&& pairs) {
- auto pp = stack::push_pop<top_level && (is_global<decltype(detail::forward_get<I * 2>(pairs))...>::value)>(*this);
- void(detail::swallow{ (stack::set_field<top_level>(base_t::lua_state(),
- detail::forward_get<I * 2>(pairs),
- detail::forward_get<I * 2 + 1>(pairs),
- lua_gettop(base_t::lua_state())
- ), 0)... });
- }
-
- template <bool global, typename T, typename Key>
- decltype(auto) traverse_get_deep(Key&& key) const {
- stack::get_field<global>(base_t::lua_state(), std::forward<Key>(key));
- return stack::get<T>(base_t::lua_state());
- }
-
- template <bool global, typename T, typename Key, typename... Keys>
- decltype(auto) traverse_get_deep(Key&& key, Keys&&... keys) const {
- stack::get_field<global>(base_t::lua_state(), std::forward<Key>(key));
- return traverse_get_deep<false, T>(std::forward<Keys>(keys)...);
- }
-
- template <bool global, typename T, std::size_t I, typename Key>
- decltype(auto) traverse_get_deep_optional(int& popcount, Key&& key) const {
- typedef decltype(stack::get<T>(base_t::lua_state())) R;
- auto p = stack::probe_get_field<global>(base_t::lua_state(), std::forward<Key>(key), lua_gettop(base_t::lua_state()));
- popcount += p.levels;
- if (!p.success)
- return R(nullopt);
- return stack::get<T>(base_t::lua_state());
- }
-
- template <bool global, typename T, std::size_t I, typename Key, typename... Keys>
- decltype(auto) traverse_get_deep_optional(int& popcount, Key&& key, Keys&&... keys) const {
- auto p = I > 0 ? stack::probe_get_field<global>(base_t::lua_state(), std::forward<Key>(key), -1) : stack::probe_get_field<global>(base_t::lua_state(), std::forward<Key>(key), lua_gettop(base_t::lua_state()));
- popcount += p.levels;
- if (!p.success)
- return T(nullopt);
- return traverse_get_deep_optional<false, T, I + 1>(popcount, std::forward<Keys>(keys)...);
- }
-
- template <bool global, typename T, typename... Keys>
- decltype(auto) traverse_get_optional(std::false_type, Keys&&... keys) const {
- detail::clean<sizeof...(Keys)> c(base_t::lua_state());
- return traverse_get_deep<top_level, T>(std::forward<Keys>(keys)...);
- }
-
- template <bool global, typename T, typename... Keys>
- decltype(auto) traverse_get_optional(std::true_type, Keys&&... keys) const {
- int popcount = 0;
- detail::ref_clean c(base_t::lua_state(), popcount);
- return traverse_get_deep_optional<top_level, T, 0>(popcount, std::forward<Keys>(keys)...);
- }
-
- template <bool global, typename Key, typename Value>
- void traverse_set_deep(Key&& key, Value&& value) const {
- stack::set_field<global>(base_t::lua_state(), std::forward<Key>(key), std::forward<Value>(value));
- }
-
- template <bool global, typename Key, typename... Keys>
- void traverse_set_deep(Key&& key, Keys&&... keys) const {
- stack::get_field<global>(base_t::lua_state(), std::forward<Key>(key));
- traverse_set_deep<false>(std::forward<Keys>(keys)...);
- }
-
- basic_table_core(lua_State* L, detail::global_tag t) noexcept : reference(L, t) { }
-
- public:
- typedef basic_table_iterator<base_t> iterator;
- typedef iterator const_iterator;
-
- basic_table_core() noexcept : base_t() { }
- template <typename T, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_table_core>>, meta::neg<std::is_same<base_t, stack_reference>>, std::is_base_of<base_t, meta::unqualified_t<T>>> = meta::enabler>
- basic_table_core(T&& r) noexcept : base_t(std::forward<T>(r)) {
-#ifdef SOL_CHECK_ARGUMENTS
- if (!is_table<meta::unqualified_t<T>>::value) {
- auto pp = stack::push_pop(*this);
- stack::check<basic_table_core>(base_t::lua_state(), -1, type_panic);
- }
-#endif // Safety
- }
- basic_table_core(const basic_table_core&) = default;
- basic_table_core(basic_table_core&&) = default;
- basic_table_core& operator=(const basic_table_core&) = default;
- basic_table_core& operator=(basic_table_core&&) = default;
- basic_table_core(const stack_reference& r) : basic_table_core(r.lua_state(), r.stack_index()) {}
- basic_table_core(stack_reference&& r) : basic_table_core(r.lua_state(), r.stack_index()) {}
- template <typename T, meta::enable<meta::neg<std::is_integral<meta::unqualified_t<T>>>, meta::neg<std::is_same<T, ref_index>>> = meta::enabler>
- basic_table_core(lua_State* L, T&& r) : basic_table_core(L, sol::ref_index(r.registry_index())) {}
- basic_table_core(lua_State* L, int index = -1) : base_t(L, index) {
-#ifdef SOL_CHECK_ARGUMENTS
- stack::check<basic_table_core>(L, index, type_panic);
-#endif // Safety
- }
- basic_table_core(lua_State* L, ref_index index) : base_t(L, index) {
-#ifdef SOL_CHECK_ARGUMENTS
- auto pp = stack::push_pop(*this);
- stack::check<basic_table_core>(L, -1, type_panic);
-#endif // Safety
- }
-
- iterator begin() const {
- return iterator(*this);
- }
-
- iterator end() const {
- return iterator();
- }
-
- const_iterator cbegin() const {
- return begin();
- }
-
- const_iterator cend() const {
- return end();
- }
-
- template<typename... Ret, typename... Keys>
- decltype(auto) get(Keys&&... keys) const {
- static_assert(sizeof...(Keys) == sizeof...(Ret), "number of keys and number of return types do not match");
- auto pp = stack::push_pop<is_global<Keys...>::value>(*this);
- return tuple_get(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), std::forward_as_tuple(std::forward<Keys>(keys)...));
- }
-
- template<typename T, typename Key>
- decltype(auto) get_or(Key&& key, T&& otherwise) const {
- typedef decltype(get<T>("")) U;
- sol::optional<U> option = get<sol::optional<U>>(std::forward<Key>(key));
- if (option) {
- return static_cast<U>(option.value());
- }
- return static_cast<U>(std::forward<T>(otherwise));
- }
-
- template<typename T, typename Key, typename D>
- decltype(auto) get_or(Key&& key, D&& otherwise) const {
- sol::optional<T> option = get<sol::optional<T>>(std::forward<Key>(key));
- if (option) {
- return static_cast<T>(option.value());
- }
- return static_cast<T>(std::forward<D>(otherwise));
- }
-
- template <typename T, typename... Keys>
- decltype(auto) traverse_get(Keys&&... keys) const {
- auto pp = stack::push_pop<is_global<Keys...>::value>(*this);
- return traverse_get_optional<top_level, T>(meta::is_specialization_of<sol::optional, meta::unqualified_t<T>>(), std::forward<Keys>(keys)...);
- }
-
- template <typename... Keys>
- basic_table_core& traverse_set(Keys&&... keys) {
- auto pp = stack::push_pop<is_global<Keys...>::value>(*this);
- auto pn = stack::pop_n(base_t::lua_state(), static_cast<int>(sizeof...(Keys)-2));
- traverse_set_deep<top_level>(std::forward<Keys>(keys)...);
- return *this;
- }
-
- template<typename... Args>
- basic_table_core& set(Args&&... args) {
- tuple_set(std::make_index_sequence<sizeof...(Args) / 2>(), std::forward_as_tuple(std::forward<Args>(args)...));
- return *this;
- }
-
- template<typename T>
- basic_table_core& set_usertype(usertype<T>& user) {
- return set_usertype(usertype_traits<T>::name(), user);
- }
-
- template<typename Key, typename T>
- basic_table_core& set_usertype(Key&& key, usertype<T>& user) {
- return set(std::forward<Key>(key), user);
- }
-
- template<typename Class, typename... Args>
- basic_table_core& new_usertype(const std::string& name, Args&&... args) {
- usertype<Class> utype(std::forward<Args>(args)...);
- set_usertype(name, utype);
- return *this;
- }
-
- template<typename Class, typename CTor0, typename... CTor, typename... Args>
- basic_table_core& new_usertype(const std::string& name, Args&&... args) {
- constructors<types<CTor0, CTor...>> ctor{};
- return new_usertype<Class>(name, ctor, std::forward<Args>(args)...);
- }
-
- template<typename Class, typename... CArgs, typename... Args>
- basic_table_core& new_usertype(const std::string& name, constructors<CArgs...> ctor, Args&&... args) {
- usertype<Class> utype(ctor, std::forward<Args>(args)...);
- set_usertype(name, utype);
- return *this;
- }
-
- template<typename Class, typename... Args>
- basic_table_core& new_simple_usertype(const std::string& name, Args&&... args) {
- simple_usertype<Class> utype(base_t::lua_state(), std::forward<Args>(args)...);
- set_usertype(name, utype);
- return *this;
- }
-
- template<typename Class, typename CTor0, typename... CTor, typename... Args>
- basic_table_core& new_simple_usertype(const std::string& name, Args&&... args) {
- constructors<types<CTor0, CTor...>> ctor{};
- return new_simple_usertype<Class>(name, ctor, std::forward<Args>(args)...);
- }
-
- template<typename Class, typename... CArgs, typename... Args>
- basic_table_core& new_simple_usertype(const std::string& name, constructors<CArgs...> ctor, Args&&... args) {
- simple_usertype<Class> utype(base_t::lua_state(), ctor, std::forward<Args>(args)...);
- set_usertype(name, utype);
- return *this;
- }
-
- template<typename Class, typename... Args>
- simple_usertype<Class> create_simple_usertype(Args&&... args) {
- simple_usertype<Class> utype(base_t::lua_state(), std::forward<Args>(args)...);
- return utype;
- }
-
- template<typename Class, typename CTor0, typename... CTor, typename... Args>
- simple_usertype<Class> create_simple_usertype(Args&&... args) {
- constructors<types<CTor0, CTor...>> ctor{};
- return create_simple_usertype<Class>(ctor, std::forward<Args>(args)...);
- }
-
- template<typename Class, typename... CArgs, typename... Args>
- simple_usertype<Class> create_simple_usertype(constructors<CArgs...> ctor, Args&&... args) {
- simple_usertype<Class> utype(base_t::lua_state(), ctor, std::forward<Args>(args)...);
- return utype;
- }
-
- template<bool read_only = true, typename... Args>
- basic_table_core& new_enum(const std::string& name, Args&&... args) {
- if (read_only) {
- table idx = create_with(std::forward<Args>(args)...);
- table x = create_with(
- meta_function::new_index, detail::fail_on_newindex,
- meta_function::index, idx
- );
- table target = create_named(name);
- target[metatable_key] = x;
- }
- else {
- create_named(name, std::forward<Args>(args)...);
- }
- return *this;
- }
-
- template<typename Fx>
- void for_each(Fx&& fx) const {
- typedef meta::is_invokable<Fx(std::pair<sol::object, sol::object>)> is_paired;
- for_each(is_paired(), std::forward<Fx>(fx));
- }
-
- size_t size() const {
- auto pp = stack::push_pop(*this);
- lua_len(base_t::lua_state(), -1);
- return stack::pop<size_t>(base_t::lua_state());
- }
-
- bool empty() const {
- return cbegin() == cend();
- }
-
- template<typename T>
- proxy<basic_table_core&, T> operator[](T&& key) & {
- return proxy<basic_table_core&, T>(*this, std::forward<T>(key));
- }
-
- template<typename T>
- proxy<const basic_table_core&, T> operator[](T&& key) const & {
- return proxy<const basic_table_core&, T>(*this, std::forward<T>(key));
- }
-
- template<typename T>
- proxy<basic_table_core, T> operator[](T&& key) && {
- return proxy<basic_table_core, T>(*this, std::forward<T>(key));
- }
-
- template<typename Sig, typename Key, typename... Args>
- basic_table_core& set_function(Key&& key, Args&&... args) {
- set_fx(types<Sig>(), std::forward<Key>(key), std::forward<Args>(args)...);
- return *this;
- }
-
- template<typename Key, typename... Args>
- basic_table_core& set_function(Key&& key, Args&&... args) {
- set_fx(types<>(), std::forward<Key>(key), std::forward<Args>(args)...);
- return *this;
- }
-
- template <typename... Args>
- basic_table_core& add(Args&&... args) {
- auto pp = stack::push_pop(*this);
- (void)detail::swallow{0,
- (stack::set_ref(base_t::lua_state(), std::forward<Args>(args)), 0)...
- };
- return *this;
- }
-
- private:
- template<typename R, typename... Args, typename Fx, typename Key, typename = std::result_of_t<Fx(Args...)>>
- void set_fx(types<R(Args...)>, Key&& key, Fx&& fx) {
- set_resolved_function<R(Args...)>(std::forward<Key>(key), std::forward<Fx>(fx));
- }
-
- template<typename Fx, typename Key, meta::enable<meta::is_specialization_of<overload_set, meta::unqualified_t<Fx>>> = meta::enabler>
- void set_fx(types<>, Key&& key, Fx&& fx) {
- set(std::forward<Key>(key), std::forward<Fx>(fx));
- }
-
- template<typename Fx, typename Key, typename... Args, meta::disable<meta::is_specialization_of<overload_set, meta::unqualified_t<Fx>>> = meta::enabler>
- void set_fx(types<>, Key&& key, Fx&& fx, Args&&... args) {
- set(std::forward<Key>(key), as_function_reference(std::forward<Fx>(fx), std::forward<Args>(args)...));
- }
-
- template<typename... Sig, typename... Args, typename Key>
- void set_resolved_function(Key&& key, Args&&... args) {
- set(std::forward<Key>(key), as_function_reference<function_sig<Sig...>>(std::forward<Args>(args)...));
- }
-
- public:
- static inline table create(lua_State* L, int narr = 0, int nrec = 0) {
- lua_createtable(L, narr, nrec);
- table result(L);
- lua_pop(L, 1);
- return result;
- }
-
- template <typename Key, typename Value, typename... Args>
- static inline table create(lua_State* L, int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
- lua_createtable(L, narr, nrec);
- table result(L);
- result.set(std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
- lua_pop(L, 1);
- return result;
- }
-
- template <typename... Args>
- static inline table create_with(lua_State* L, Args&&... args) {
- static_assert(sizeof...(Args) % 2 == 0, "You must have an even number of arguments for a key, value ... list.");
- static const int narr = static_cast<int>(meta::count_2_for_pack<std::is_integral, Args...>::value);
- return create(L, narr, static_cast<int>((sizeof...(Args) / 2) - narr), std::forward<Args>(args)...);
- }
-
- table create(int narr = 0, int nrec = 0) {
- return create(base_t::lua_state(), narr, nrec);
- }
-
- template <typename Key, typename Value, typename... Args>
- table create(int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
- return create(base_t::lua_state(), narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
- }
-
- template <typename Name>
- table create(Name&& name, int narr = 0, int nrec = 0) {
- table x = create(base_t::lua_state(), narr, nrec);
- this->set(std::forward<Name>(name), x);
- return x;
- }
-
- template <typename Name, typename Key, typename Value, typename... Args>
- table create(Name&& name, int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
- table x = create(base_t::lua_state(), narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
- this->set(std::forward<Name>(name), x);
- return x;
- }
-
- template <typename... Args>
- table create_with(Args&&... args) {
- return create_with(base_t::lua_state(), std::forward<Args>(args)...);
- }
-
- template <typename Name, typename... Args>
- table create_named(Name&& name, Args&&... args) {
- static const int narr = static_cast<int>(meta::count_2_for_pack<std::is_integral, Args...>::value);
- return create(std::forward<Name>(name), narr, sizeof...(Args) / 2 - narr, std::forward<Args>(args)...);
- }
-
- ~basic_table_core() {
-
- }
- };
-} // sol
-
-#endif // SOL_TABLE_CORE_HPP
diff --git a/3rdparty/sol2/sol/table_iterator.hpp b/3rdparty/sol2/sol/table_iterator.hpp
deleted file mode 100644
index c1102a8eff6..00000000000
--- a/3rdparty/sol2/sol/table_iterator.hpp
+++ /dev/null
@@ -1,120 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_TABLE_ITERATOR_HPP
-#define SOL_TABLE_ITERATOR_HPP
-
-#include "object.hpp"
-#include <iterator>
-
-namespace sol {
-
- template <typename reference_type>
- class basic_table_iterator : public std::iterator<std::input_iterator_tag, std::pair<object, object>> {
- private:
- typedef std::iterator<std::input_iterator_tag, std::pair<object, object>> base_t;
- public:
- typedef object key_type;
- typedef object mapped_type;
- typedef base_t::value_type value_type;
- typedef base_t::iterator_category iterator_category;
- typedef base_t::difference_type difference_type;
- typedef base_t::pointer pointer;
- typedef base_t::reference reference;
- typedef const value_type& const_reference;
-
- private:
- std::pair<object, object> kvp;
- reference_type ref;
- int tableidx = 0;
- int keyidx = 0;
- std::ptrdiff_t idx = 0;
-
- public:
-
- basic_table_iterator() : keyidx(-1), idx(-1) {
-
- }
-
- basic_table_iterator(reference_type x) : ref(std::move(x)) {
- ref.push();
- tableidx = lua_gettop(ref.lua_state());
- stack::push(ref.lua_state(), lua_nil);
- this->operator++();
- if (idx == -1) {
- return;
- }
- --idx;
- }
-
- basic_table_iterator& operator++() {
- if (idx == -1)
- return *this;
-
- if (lua_next(ref.lua_state(), tableidx) == 0) {
- idx = -1;
- keyidx = -1;
- return *this;
- }
- ++idx;
- kvp.first = object(ref.lua_state(), -2);
- kvp.second = object(ref.lua_state(), -1);
- lua_pop(ref.lua_state(), 1);
- // leave key on the stack
- keyidx = lua_gettop(ref.lua_state());
- return *this;
- }
-
- basic_table_iterator operator++(int) {
- auto saved = *this;
- this->operator++();
- return saved;
- }
-
- reference operator*() {
- return kvp;
- }
-
- const_reference operator*() const {
- return kvp;
- }
-
- bool operator== (const basic_table_iterator& right) const {
- return idx == right.idx;
- }
-
- bool operator!= (const basic_table_iterator& right) const {
- return idx != right.idx;
- }
-
- ~basic_table_iterator() {
- if (keyidx != -1) {
- stack::remove(ref.lua_state(), keyidx, 1);
- }
- if (ref.valid()) {
- stack::remove(ref.lua_state(), tableidx, 1);
- }
- }
- };
-
-} // sol
-
-#endif // SOL_TABLE_ITERATOR_HPP
diff --git a/3rdparty/sol2/sol/thread.hpp b/3rdparty/sol2/sol/thread.hpp
deleted file mode 100644
index 5e57ad1de02..00000000000
--- a/3rdparty/sol2/sol/thread.hpp
+++ /dev/null
@@ -1,158 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_THREAD_HPP
-#define SOL_THREAD_HPP
-
-#include "reference.hpp"
-#include "stack.hpp"
-
-namespace sol {
- struct lua_thread_state {
- lua_State* L;
- operator lua_State* () const {
- return L;
- }
- lua_State* operator-> () const {
- return L;
- }
- };
-
- namespace stack {
-
- template <>
- struct pusher<lua_thread_state> {
- int push(lua_State*, lua_thread_state lts) {
- lua_pushthread(lts.L);
- return 1;
- }
- };
-
- template <>
- struct getter<lua_thread_state> {
- lua_thread_state get(lua_State* L, int index, record& tracking) {
- tracking.use(1);
- lua_thread_state lts{ lua_tothread(L, index) };
- return lts;
- }
- };
-
- template <>
- struct check_getter<lua_thread_state> {
- template <typename Handler>
- optional<lua_thread_state> get(lua_State* L, int index, Handler&& handler, record& tracking) {
- lua_thread_state lts{ lua_tothread(L, index) };
- if (lts.L == nullptr) {
- handler(L, index, type::thread, type_of(L, index));
- return nullopt;
- }
- tracking.use(1);
- return lts;
- }
- };
-
- }
-
-#if SOL_LUA_VERSION < 502
- inline lua_State* main_thread(lua_State*, lua_State* backup_if_unsupported = nullptr) {
- return backup_if_unsupported;
- }
-#else
- inline lua_State* main_thread(lua_State* L, lua_State* = nullptr) {
- lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_MAINTHREAD);
- lua_thread_state s = stack::pop<lua_thread_state>(L);
- return s.L;
- }
-#endif // Lua 5.2+ has the main thread getter
-
- class thread : public reference {
- public:
- thread() noexcept = default;
- thread(const thread&) = default;
- thread(thread&&) = default;
- template <typename T, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, thread>>, std::is_base_of<reference, meta::unqualified_t<T>>> = meta::enabler>
- thread(T&& r) : reference(std::forward<T>(r)) {}
- thread(const stack_reference& r) : thread(r.lua_state(), r.stack_index()) {};
- thread(stack_reference&& r) : thread(r.lua_state(), r.stack_index()) {};
- thread& operator=(const thread&) = default;
- thread& operator=(thread&&) = default;
- template <typename T, meta::enable<meta::neg<std::is_integral<meta::unqualified_t<T>>>, meta::neg<std::is_same<T, ref_index>>> = meta::enabler>
- thread(lua_State* L, T&& r) : thread(L, sol::ref_index(r.registry_index())) {}
- thread(lua_State* L, int index = -1) : reference(L, index) {
-#ifdef SOL_CHECK_ARGUMENTS
- type_assert(L, index, type::thread);
-#endif // Safety
- }
- thread(lua_State* L, ref_index index) : reference(L, index) {
-#ifdef SOL_CHECK_ARGUMENTS
- auto pp = stack::push_pop(*this);
- type_assert(L, -1, type::thread);
-#endif // Safety
- }
- thread(lua_State* L, lua_State* actualthread) : thread(L, lua_thread_state{ actualthread }) {}
- thread(lua_State* L, sol::this_state actualthread) : thread(L, lua_thread_state{ actualthread.L }) {}
- thread(lua_State* L, lua_thread_state actualthread) : reference(L, -stack::push(L, actualthread)) {
-#ifdef SOL_CHECK_ARGUMENTS
- type_assert(L, -1, type::thread);
-#endif // Safety
- lua_pop(L, 1);
- }
-
- state_view state() const {
- return state_view(this->thread_state());
- }
-
- bool is_main_thread() const {
- int ismainthread = lua_pushthread(this->thread_state());
- lua_pop(this->thread_state(), 1);
- return ismainthread == 1;
- }
-
- lua_State* thread_state() const {
- auto pp = stack::push_pop(*this);
- lua_State* lthread = lua_tothread(lua_state(), -1);
- return lthread;
- }
-
- thread_status status() const {
- lua_State* lthread = thread_state();
- thread_status lstat = static_cast<thread_status>(lua_status(lthread));
- if (lstat != thread_status::ok && lua_gettop(lthread) == 0) {
- // No thing on the thread's stack means its dead
- return thread_status::dead;
- }
- return lstat;
- }
-
- thread create() {
- return create(lua_state());
- }
-
- static thread create(lua_State* L) {
- lua_newthread(L);
- thread result(L);
- lua_pop(L, 1);
- return result;
- }
- };
-} // sol
-
-#endif // SOL_THREAD_HPP
diff --git a/3rdparty/sol2/sol/tie.hpp b/3rdparty/sol2/sol/tie.hpp
deleted file mode 100644
index 9157ed008d1..00000000000
--- a/3rdparty/sol2/sol/tie.hpp
+++ /dev/null
@@ -1,101 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_TIE_HPP
-#define SOL_TIE_HPP
-
-#include "traits.hpp"
-
-namespace sol {
-
- namespace detail {
- template <typename T>
- struct is_speshul : std::false_type {};
- }
-
- template <typename T>
- struct tie_size : std::tuple_size<T> {};
-
- template <typename T>
- struct is_tieable : std::integral_constant<bool, (::sol::tie_size<T>::value > 0)> {};
-
- template <typename... Tn>
- struct tie_t : public std::tuple<std::add_lvalue_reference_t<Tn>...> {
- private:
- typedef std::tuple<std::add_lvalue_reference_t<Tn>...> base_t;
-
- template <typename T>
- void set(std::false_type, T&& target) {
- std::get<0>(*this) = std::forward<T>(target);
- }
-
- template <typename T>
- void set(std::true_type, T&& target) {
- typedef tie_size<meta::unqualified_t<T>> value_size;
- typedef tie_size<std::tuple<Tn...>> tie_size;
- typedef std::conditional_t<(value_size::value < tie_size::value), value_size, tie_size> indices_size;
- typedef std::make_index_sequence<indices_size::value> indices;
- set_extra(detail::is_speshul<meta::unqualified_t<T>>(), indices(), std::forward<T>(target));
- }
-
- template <std::size_t... I, typename T>
- void set_extra(std::true_type, std::index_sequence<I...>, T&& target) {
- using std::get;
- (void)detail::swallow{ 0,
- (get<I>(static_cast<base_t&>(*this)) = get<I>(types<Tn...>(), target), 0)...
- , 0 };
- }
-
- template <std::size_t... I, typename T>
- void set_extra(std::false_type, std::index_sequence<I...>, T&& target) {
- using std::get;
- (void)detail::swallow{ 0,
- (get<I>(static_cast<base_t&>(*this)) = get<I>(target), 0)...
- , 0 };
- }
-
- public:
- using base_t::base_t;
-
- template <typename T>
- tie_t& operator= (T&& value) {
- typedef is_tieable<meta::unqualified_t<T>> tieable;
- set(tieable(), std::forward<T>(value));
- return *this;
- }
-
- };
-
- template <typename... Tn>
- struct tie_size< tie_t<Tn...> > : std::tuple_size< std::tuple<Tn...> > { };
-
- namespace adl_barrier_detail {
- template <typename... Tn>
- inline tie_t<std::remove_reference_t<Tn>...> tie(Tn&&... argn) {
- return tie_t<std::remove_reference_t<Tn>...>(std::forward<Tn>(argn)...);
- }
- }
-
- using namespace adl_barrier_detail;
-
-} // sol
-
-#endif // SOL_TIE_HPP
diff --git a/3rdparty/sol2/sol/traits.hpp b/3rdparty/sol2/sol/traits.hpp
deleted file mode 100644
index 762bc84b947..00000000000
--- a/3rdparty/sol2/sol/traits.hpp
+++ /dev/null
@@ -1,428 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_TRAITS_HPP
-#define SOL_TRAITS_HPP
-
-#include "tuple.hpp"
-#include "bind_traits.hpp"
-#include <type_traits>
-#include <memory>
-#include <functional>
-
-namespace sol {
- template<std::size_t I>
- using index_value = std::integral_constant<std::size_t, I>;
-
- namespace meta {
- template<typename T>
- struct identity { typedef T type; };
-
- template<typename T>
- using identity_t = typename identity<T>::type;
-
- template<typename... Args>
- struct is_tuple : std::false_type { };
-
- template<typename... Args>
- struct is_tuple<std::tuple<Args...>> : std::true_type { };
-
- template <typename T>
- struct is_builtin_type : std::integral_constant<bool, std::is_arithmetic<T>::value || std::is_pointer<T>::value || std::is_array<T>::value> {};
-
- template<typename T>
- struct unwrapped {
- typedef T type;
- };
-
- template<typename T>
- struct unwrapped<std::reference_wrapper<T>> {
- typedef T type;
- };
-
- template<typename T>
- using unwrapped_t = typename unwrapped<T>::type;
-
- template <typename T>
- struct unwrap_unqualified : unwrapped<unqualified_t<T>> {};
-
- template <typename T>
- using unwrap_unqualified_t = typename unwrap_unqualified<T>::type;
-
- template<typename T>
- struct remove_member_pointer;
-
- template<typename R, typename T>
- struct remove_member_pointer<R T::*> {
- typedef R type;
- };
-
- template<typename R, typename T>
- struct remove_member_pointer<R T::* const> {
- typedef R type;
- };
-
- template<typename T>
- using remove_member_pointer_t = remove_member_pointer<T>;
-
- template<template<typename...> class Templ, typename T>
- struct is_specialization_of : std::false_type { };
- template<typename... T, template<typename...> class Templ>
- struct is_specialization_of<Templ, Templ<T...>> : std::true_type { };
-
- template<class T, class...>
- struct all_same : std::true_type { };
-
- template<class T, class U, class... Args>
- struct all_same<T, U, Args...> : std::integral_constant <bool, std::is_same<T, U>::value && all_same<T, Args...>::value> { };
-
- template<class T, class...>
- struct any_same : std::false_type { };
-
- template<class T, class U, class... Args>
- struct any_same<T, U, Args...> : std::integral_constant <bool, std::is_same<T, U>::value || any_same<T, Args...>::value> { };
-
- template<typename T>
- using invoke_t = typename T::type;
-
- template<bool B>
- using boolean = std::integral_constant<bool, B>;
-
- template<typename T>
- using neg = boolean<!T::value>;
-
- template<typename Condition, typename Then, typename Else>
- using condition = std::conditional_t<Condition::value, Then, Else>;
-
- template<typename... Args>
- struct all : boolean<true> {};
-
- template<typename T, typename... Args>
- struct all<T, Args...> : condition<T, all<Args...>, boolean<false>> {};
-
- template<typename... Args>
- struct any : boolean<false> {};
-
- template<typename T, typename... Args>
- struct any<T, Args...> : condition<T, boolean<true>, any<Args...>> {};
-
- enum class enable_t {
- _
- };
-
- constexpr const auto enabler = enable_t::_;
-
- template<bool value, typename T = void>
- using disable_if_t = std::enable_if_t<!value, T>;
-
- template<typename... Args>
- using enable = std::enable_if_t<all<Args...>::value, enable_t>;
-
- template<typename... Args>
- using disable = std::enable_if_t<neg<all<Args...>>::value, enable_t>;
-
- template<typename... Args>
- using disable_any = std::enable_if_t<neg<any<Args...>>::value, enable_t>;
-
- template<typename V, typename... Vs>
- struct find_in_pack_v : boolean<false> { };
-
- template<typename V, typename Vs1, typename... Vs>
- struct find_in_pack_v<V, Vs1, Vs...> : any<boolean<(V::value == Vs1::value)>, find_in_pack_v<V, Vs...>> { };
-
- namespace meta_detail {
- template<std::size_t I, typename T, typename... Args>
- struct index_in_pack : std::integral_constant<std::size_t, SIZE_MAX> { };
-
- template<std::size_t I, typename T, typename T1, typename... Args>
- struct index_in_pack<I, T, T1, Args...> : std::conditional_t<std::is_same<T, T1>::value, std::integral_constant<std::ptrdiff_t, I>, index_in_pack<I + 1, T, Args...>> { };
- }
-
- template<typename T, typename... Args>
- struct index_in_pack : meta_detail::index_in_pack<0, T, Args...> { };
-
- template<typename T, typename List>
- struct index_in : meta_detail::index_in_pack<0, T, List> { };
-
- template<typename T, typename... Args>
- struct index_in<T, types<Args...>> : meta_detail::index_in_pack<0, T, Args...> { };
-
- template<std::size_t I, typename... Args>
- struct at_in_pack {};
-
- template<std::size_t I, typename... Args>
- using at_in_pack_t = typename at_in_pack<I, Args...>::type;
-
- template<std::size_t I, typename Arg, typename... Args>
- struct at_in_pack<I, Arg, Args...> : std::conditional<I == 0, Arg, at_in_pack_t<I - 1, Args...>> {};
-
- template<typename Arg, typename... Args>
- struct at_in_pack<0, Arg, Args...> { typedef Arg type; };
-
- namespace meta_detail {
- template<std::size_t Limit, std::size_t I, template<typename...> class Pred, typename... Ts>
- struct count_for_pack : std::integral_constant<std::size_t, 0> {};
- template<std::size_t Limit, std::size_t I, template<typename...> class Pred, typename T, typename... Ts>
- struct count_for_pack<Limit, I, Pred, T, Ts...> : std::conditional_t < sizeof...(Ts) == 0 || Limit < 2,
- std::integral_constant<std::size_t, I + static_cast<std::size_t>(Limit != 0 && Pred<T>::value)>,
- count_for_pack<Limit - 1, I + static_cast<std::size_t>(Pred<T>::value), Pred, Ts...>
- > { };
- template<std::size_t I, template<typename...> class Pred, typename... Ts>
- struct count_2_for_pack : std::integral_constant<std::size_t, 0> {};
- template<std::size_t I, template<typename...> class Pred, typename T, typename U, typename... Ts>
- struct count_2_for_pack<I, Pred, T, U, Ts...> : std::conditional_t<sizeof...(Ts) == 0,
- std::integral_constant<std::size_t, I + static_cast<std::size_t>(Pred<T>::value)>,
- count_2_for_pack<I + static_cast<std::size_t>(Pred<T>::value), Pred, Ts...>
- > { };
- } // meta_detail
-
- template<template<typename...> class Pred, typename... Ts>
- struct count_for_pack : meta_detail::count_for_pack<sizeof...(Ts), 0, Pred, Ts...> { };
-
- template<template<typename...> class Pred, typename List>
- struct count_for;
-
- template<template<typename...> class Pred, typename... Args>
- struct count_for<Pred, types<Args...>> : count_for_pack<Pred, Args...> {};
-
- template<std::size_t Limit, template<typename...> class Pred, typename... Ts>
- struct count_for_to_pack : meta_detail::count_for_pack<Limit, 0, Pred, Ts...> { };
-
- template<template<typename...> class Pred, typename... Ts>
- struct count_2_for_pack : meta_detail::count_2_for_pack<0, Pred, Ts...> { };
-
- template<typename... Args>
- struct return_type {
- typedef std::tuple<Args...> type;
- };
-
- template<typename T>
- struct return_type<T> {
- typedef T type;
- };
-
- template<>
- struct return_type<> {
- typedef void type;
- };
-
- template <typename... Args>
- using return_type_t = typename return_type<Args...>::type;
-
- namespace meta_detail {
- template <typename> struct always_true : std::true_type {};
- struct is_invokable_tester {
- template <typename Fun, typename... Args>
- always_true<decltype(std::declval<Fun>()(std::declval<Args>()...))> static test(int);
- template <typename...>
- std::false_type static test(...);
- };
- } // meta_detail
-
- template <typename T>
- struct is_invokable;
- template <typename Fun, typename... Args>
- struct is_invokable<Fun(Args...)> : decltype(meta_detail::is_invokable_tester::test<Fun, Args...>(0)) {};
-
- namespace meta_detail {
-
- template<typename T, bool isclass = std::is_class<unqualified_t<T>>::value>
- struct is_callable : std::is_function<std::remove_pointer_t<T>> {};
-
- template<typename T>
- struct is_callable<T, true> {
- using yes = char;
- using no = struct { char s[2]; };
-
- struct F { void operator()() {}; };
- struct Derived : T, F {};
- template<typename U, U> struct Check;
-
- template<typename V>
- static no test(Check<void (F::*)(), &V::operator()>*);
-
- template<typename>
- static yes test(...);
-
- static const bool value = sizeof(test<Derived>(0)) == sizeof(yes);
- };
-
- struct has_begin_end_impl {
- template<typename T, typename U = unqualified_t<T>,
- typename B = decltype(std::declval<U&>().begin()),
- typename E = decltype(std::declval<U&>().end())>
- static std::true_type test(int);
-
- template<typename...>
- static std::false_type test(...);
- };
-
- struct has_key_value_pair_impl {
- template<typename T, typename U = unqualified_t<T>,
- typename V = typename U::value_type,
- typename F = decltype(std::declval<V&>().first),
- typename S = decltype(std::declval<V&>().second)>
- static std::true_type test(int);
-
- template<typename...>
- static std::false_type test(...);
- };
-
- template <typename T, typename U = T, typename = decltype(std::declval<T&>() < std::declval<U&>())>
- std::true_type supports_op_less_test(const T&);
- std::false_type supports_op_less_test(...);
- template <typename T, typename U = T, typename = decltype(std::declval<T&>() == std::declval<U&>())>
- std::true_type supports_op_equal_test(const T&);
- std::false_type supports_op_equal_test(...);
- template <typename T, typename U = T, typename = decltype(std::declval<T&>() <= std::declval<U&>())>
- std::true_type supports_op_less_equal_test(const T&);
- std::false_type supports_op_less_equal_test(...);
-
- } // meta_detail
-
- template <typename T>
- using supports_op_less = decltype(meta_detail::supports_op_less_test(std::declval<T&>()));
- template <typename T>
- using supports_op_equal = decltype(meta_detail::supports_op_equal_test(std::declval<T&>()));
- template <typename T>
- using supports_op_less_equal = decltype(meta_detail::supports_op_less_equal_test(std::declval<T&>()));
-
- template<typename T>
- struct is_callable : boolean<meta_detail::is_callable<T>::value> {};
-
- template<typename T>
- struct has_begin_end : decltype(meta_detail::has_begin_end_impl::test<T>(0)) {};
-
- template<typename T>
- struct has_key_value_pair : decltype(meta_detail::has_key_value_pair_impl::test<T>(0)) {};
-
- template <typename T>
- using is_string_constructible = any<std::is_same<unqualified_t<T>, const char*>, std::is_same<unqualified_t<T>, char>, std::is_same<unqualified_t<T>, std::string>, std::is_same<unqualified_t<T>, std::initializer_list<char>>>;
-
- template <typename T>
- using is_c_str = any<
- std::is_same<std::decay_t<unqualified_t<T>>, const char*>,
- std::is_same<std::decay_t<unqualified_t<T>>, char*>,
- std::is_same<unqualified_t<T>, std::string>
- >;
-
- template <typename T>
- struct is_move_only : all<
- neg<std::is_reference<T>>,
- neg<std::is_copy_constructible<unqualified_t<T>>>,
- std::is_move_constructible<unqualified_t<T>>
- > {};
-
- template <typename T>
- using is_not_move_only = neg<is_move_only<T>>;
-
- namespace meta_detail {
- template <typename T, meta::disable<meta::is_specialization_of<std::tuple, meta::unqualified_t<T>>> = meta::enabler>
- decltype(auto) force_tuple(T&& x) {
- return std::forward_as_tuple(std::forward<T>(x));
- }
-
- template <typename T, meta::enable<meta::is_specialization_of<std::tuple, meta::unqualified_t<T>>> = meta::enabler>
- decltype(auto) force_tuple(T&& x) {
- return std::forward<T>(x);
- }
- } // meta_detail
-
- template <typename... X>
- decltype(auto) tuplefy(X&&... x) {
- return std::tuple_cat(meta_detail::force_tuple(std::forward<X>(x))...);
- }
- } // meta
- namespace detail {
- template <std::size_t I, typename Tuple>
- decltype(auto) forward_get(Tuple&& tuple) {
- return std::forward<meta::tuple_element_t<I, Tuple>>(std::get<I>(tuple));
- }
-
- template <std::size_t... I, typename Tuple>
- auto forward_tuple_impl(std::index_sequence<I...>, Tuple&& tuple) -> decltype(std::tuple<decltype(forward_get<I>(tuple))...>(forward_get<I>(tuple)...)) {
- return std::tuple<decltype(forward_get<I>(tuple))...>(std::move(std::get<I>(tuple))...);
- }
-
- template <typename Tuple>
- auto forward_tuple(Tuple&& tuple) {
- auto x = forward_tuple_impl(std::make_index_sequence<std::tuple_size<meta::unqualified_t<Tuple>>::value>(), std::forward<Tuple>(tuple));
- return x;
- }
-
- template<typename T>
- auto unwrap(T&& item) -> decltype(std::forward<T>(item)) {
- return std::forward<T>(item);
- }
-
- template<typename T>
- T& unwrap(std::reference_wrapper<T> arg) {
- return arg.get();
- }
-
- template<typename T>
- auto deref(T&& item) -> decltype(std::forward<T>(item)) {
- return std::forward<T>(item);
- }
-
- template<typename T>
- inline T& deref(T* item) {
- return *item;
- }
-
- template<typename T, typename Dx>
- inline std::add_lvalue_reference_t<T> deref(std::unique_ptr<T, Dx>& item) {
- return *item;
- }
-
- template<typename T>
- inline std::add_lvalue_reference_t<T> deref(std::shared_ptr<T>& item) {
- return *item;
- }
-
- template<typename T, typename Dx>
- inline std::add_lvalue_reference_t<T> deref(const std::unique_ptr<T, Dx>& item) {
- return *item;
- }
-
- template<typename T>
- inline std::add_lvalue_reference_t<T> deref(const std::shared_ptr<T>& item) {
- return *item;
- }
-
- template<typename T>
- inline T* ptr(T& val) {
- return std::addressof(val);
- }
-
- template<typename T>
- inline T* ptr(std::reference_wrapper<T> val) {
- return std::addressof(val.get());
- }
-
- template<typename T>
- inline T* ptr(T* val) {
- return val;
- }
- } // detail
-} // sol
-
-#endif // SOL_TRAITS_HPP
diff --git a/3rdparty/sol2/sol/tuple.hpp b/3rdparty/sol2/sol/tuple.hpp
deleted file mode 100644
index 07a6d493de1..00000000000
--- a/3rdparty/sol2/sol/tuple.hpp
+++ /dev/null
@@ -1,80 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_TUPLE_HPP
-#define SOL_TUPLE_HPP
-
-#include <tuple>
-#include <cstddef>
-
-namespace sol {
- namespace detail {
- using swallow = std::initializer_list<int>;
- } // detail
-
- template<typename... Args>
- struct types { typedef std::make_index_sequence<sizeof...(Args)> indices; static constexpr std::size_t size() { return sizeof...(Args); } };
- namespace meta {
- namespace detail {
- template<typename... Args>
- struct tuple_types_ { typedef types<Args...> type; };
-
- template<typename... Args>
- struct tuple_types_<std::tuple<Args...>> { typedef types<Args...> type; };
- } // detail
-
- template<typename T>
- using unqualified = std::remove_cv<std::remove_reference_t<T>>;
-
- template<typename T>
- using unqualified_t = typename unqualified<T>::type;
-
- template<typename... Args>
- using tuple_types = typename detail::tuple_types_<Args...>::type;
-
- template<typename Arg>
- struct pop_front_type;
-
- template<typename Arg>
- using pop_front_type_t = typename pop_front_type<Arg>::type;
-
- template<typename... Args>
- struct pop_front_type<types<Args...>> { typedef void front_type; typedef types<Args...> type; };
-
- template<typename Arg, typename... Args>
- struct pop_front_type<types<Arg, Args...>> { typedef Arg front_type; typedef types<Args...> type; };
-
- template <std::size_t N, typename Tuple>
- using tuple_element = std::tuple_element<N, unqualified_t<Tuple>>;
-
- template <std::size_t N, typename Tuple>
- using tuple_element_t = std::tuple_element_t<N, unqualified_t<Tuple>>;
-
- template <std::size_t N, typename Tuple>
- using unqualified_tuple_element = unqualified<tuple_element_t<N, Tuple>>;
-
- template <std::size_t N, typename Tuple>
- using unqualified_tuple_element_t = unqualified_t<tuple_element_t<N, Tuple>>;
-
- } // meta
-} // sol
-
-#endif // SOL_TUPLE_HPP
diff --git a/3rdparty/sol2/sol/types.hpp b/3rdparty/sol2/sol/types.hpp
deleted file mode 100644
index ca349a56d19..00000000000
--- a/3rdparty/sol2/sol/types.hpp
+++ /dev/null
@@ -1,806 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_TYPES_HPP
-#define SOL_TYPES_HPP
-
-#include "optional.hpp"
-#include "compatibility.hpp"
-#include "traits.hpp"
-#include "string_shim.hpp"
-#include <array>
-#include <string>
-
-namespace sol {
- namespace detail {
-#ifdef SOL_NO_EXCEPTIONS
- template <lua_CFunction f>
- int static_trampoline(lua_State* L) {
- return f(L);
- }
-
- template <typename Fx, typename... Args>
- int trampoline(lua_State* L, Fx&& f, Args&&... args) {
- return f(L, std::forward<Args>(args)...);
- }
-
- inline int c_trampoline(lua_State* L, lua_CFunction f) {
- return trampoline(L, f);
- }
-#else
- template <lua_CFunction f>
- int static_trampoline(lua_State* L) {
- try {
- return f(L);
- }
- catch (const char *s) {
- lua_pushstring(L, s);
- }
- catch (const std::exception& e) {
- lua_pushstring(L, e.what());
- }
-#if !defined(SOL_EXCEPTIONS_SAFE_PROPAGATION)
- catch (...) {
- lua_pushstring(L, "caught (...) exception");
- }
-#endif
- return lua_error(L);
- }
-
- template <typename Fx, typename... Args>
- int trampoline(lua_State* L, Fx&& f, Args&&... args) {
- try {
- return f(L, std::forward<Args>(args)...);
- }
- catch (const char *s) {
- lua_pushstring(L, s);
- }
- catch (const std::exception& e) {
- lua_pushstring(L, e.what());
- }
-#if !defined(SOL_EXCEPTIONS_SAFE_PROPAGATION)
- catch (...) {
- lua_pushstring(L, "caught (...) exception");
- }
-#endif
- return lua_error(L);
- }
-
- inline int c_trampoline(lua_State* L, lua_CFunction f) {
- return trampoline(L, f);
- }
-#endif // Exceptions vs. No Exceptions
-
- template <typename T>
- struct unique_usertype {};
-
- template <typename T>
- struct implicit_wrapper {
- T& item;
- implicit_wrapper(T* item) : item(*item) {}
- implicit_wrapper(T& item) : item(item) {}
- operator T& () {
- return item;
- }
- operator T* () {
- return std::addressof(item);
- }
- };
- } // detail
-
- struct lua_nil_t {};
- const lua_nil_t lua_nil{};
- inline bool operator==(lua_nil_t, lua_nil_t) { return true; }
- inline bool operator!=(lua_nil_t, lua_nil_t) { return false; }
-#ifndef __OBJC__
- typedef lua_nil_t nil_t;
- const nil_t nil{};
-#endif
-
- struct metatable_key_t {};
- const metatable_key_t metatable_key = {};
-
- struct no_metatable_t {};
- const no_metatable_t no_metatable = {};
-
- typedef std::remove_pointer_t<lua_CFunction> lua_r_CFunction;
-
- template <typename T>
- struct unique_usertype_traits {
- typedef T type;
- typedef T actual_type;
- static const bool value = false;
-
- template <typename U>
- static bool is_null(U&&) {
- return false;
- }
-
- template <typename U>
- static auto get(U&& value) {
- return std::addressof(detail::deref(value));
- }
- };
-
- template <typename T>
- struct unique_usertype_traits<std::shared_ptr<T>> {
- typedef T type;
- typedef std::shared_ptr<T> actual_type;
- static const bool value = true;
-
- static bool is_null(const actual_type& p) {
- return p == nullptr;
- }
-
- static type* get(const actual_type& p) {
- return p.get();
- }
- };
-
- template <typename T, typename D>
- struct unique_usertype_traits<std::unique_ptr<T, D>> {
- typedef T type;
- typedef std::unique_ptr<T, D> actual_type;
- static const bool value = true;
-
- static bool is_null(const actual_type& p) {
- return p == nullptr;
- }
-
- static type* get(const actual_type& p) {
- return p.get();
- }
- };
-
- template <typename T>
- struct non_null {};
-
- template <typename... Args>
- struct function_sig {};
-
- struct upvalue_index {
- int index;
- upvalue_index(int idx) : index(lua_upvalueindex(idx)) {}
- operator int() const { return index; }
- };
-
- struct raw_index {
- int index;
- raw_index(int i) : index(i) {}
- operator int() const { return index; }
- };
-
- struct absolute_index {
- int index;
- absolute_index(lua_State* L, int idx) : index(lua_absindex(L, idx)) {}
- operator int() const { return index; }
- };
-
- struct ref_index {
- int index;
- ref_index(int idx) : index(idx) {}
- operator int() const { return index; }
- };
-
- struct lightuserdata_value {
- void* value;
- lightuserdata_value(void* data) : value(data) {}
- operator void*() const { return value; }
- };
-
- struct userdata_value {
- void* value;
- userdata_value(void* data) : value(data) {}
- operator void*() const { return value; }
- };
-
- template <typename L>
- struct light {
- L* value;
-
- light(L& x) : value(std::addressof(x)) {}
- light(L* x) : value(x) {}
- light(void* x) : value(static_cast<L*>(x)) {}
- operator L* () const { return value; }
- operator L& () const { return *value; }
- };
-
- template <typename T>
- auto make_light(T& l) {
- typedef meta::unwrapped_t<std::remove_pointer_t<std::remove_pointer_t<T>>> L;
- return light<L>(l);
- }
-
- template <typename U>
- struct user {
- U value;
-
- user(U x) : value(std::move(x)) {}
- operator U* () { return std::addressof(value); }
- operator U& () { return value; }
- operator const U& () const { return value; }
- };
-
- template <typename T>
- auto make_user(T&& u) {
- typedef meta::unwrapped_t<meta::unqualified_t<T>> U;
- return user<U>(std::forward<T>(u));
- }
-
- template <typename T>
- struct metatable_registry_key {
- T key;
-
- metatable_registry_key(T key) : key(std::forward<T>(key)) {}
- };
-
- template <typename T>
- auto meta_registry_key(T&& key) {
- typedef meta::unqualified_t<T> K;
- return metatable_registry_key<K>(std::forward<T>(key));
- }
-
- template <typename... Upvalues>
- struct closure {
- lua_CFunction c_function;
- std::tuple<Upvalues...> upvalues;
- closure(lua_CFunction f, Upvalues... targetupvalues) : c_function(f), upvalues(std::forward<Upvalues>(targetupvalues)...) {}
- };
-
- template <>
- struct closure<> {
- lua_CFunction c_function;
- int upvalues;
- closure(lua_CFunction f, int upvalue_count = 0) : c_function(f), upvalues(upvalue_count) {}
- };
-
- typedef closure<> c_closure;
-
- template <typename... Args>
- closure<Args...> make_closure(lua_CFunction f, Args&&... args) {
- return closure<Args...>(f, std::forward<Args>(args)...);
- }
-
- template <typename Sig, typename... Ps>
- struct function_arguments {
- std::tuple<Ps...> arguments;
- template <typename Arg, typename... Args, meta::disable<std::is_same<meta::unqualified_t<Arg>, function_arguments>> = meta::enabler>
- function_arguments(Arg&& arg, Args&&... args) : arguments(std::forward<Arg>(arg), std::forward<Args>(args)...) {}
- };
-
- template <typename Sig = function_sig<>, typename... Args>
- auto as_function(Args&&... args) {
- return function_arguments<Sig, std::decay_t<Args>...>(std::forward<Args>(args)...);
- }
-
- template <typename Sig = function_sig<>, typename... Args>
- auto as_function_reference(Args&&... args) {
- return function_arguments<Sig, Args...>(std::forward<Args>(args)...);
- }
-
- template <typename T>
- struct as_table_t {
- T source;
- template <typename... Args>
- as_table_t(Args&&... args) : source(std::forward<Args>(args)...) {}
-
- operator std::add_lvalue_reference_t<T> () {
- return source;
- }
- };
-
- template <typename T>
- as_table_t<T> as_table(T&& container) {
- return as_table_t<T>(std::forward<T>(container));
- }
-
- struct this_state {
- lua_State* L;
- operator lua_State* () const {
- return L;
- }
- lua_State* operator-> () const {
- return L;
- }
- };
-
- enum class call_syntax {
- dot = 0,
- colon = 1
- };
-
- enum class call_status : int {
- ok = LUA_OK,
- yielded = LUA_YIELD,
- runtime = LUA_ERRRUN,
- memory = LUA_ERRMEM,
- handler = LUA_ERRERR,
- gc = LUA_ERRGCMM
- };
-
- enum class thread_status : int {
- ok = LUA_OK,
- yielded = LUA_YIELD,
- runtime = LUA_ERRRUN,
- memory = LUA_ERRMEM,
- gc = LUA_ERRGCMM,
- handler = LUA_ERRERR,
- dead = -1,
- };
-
- enum class load_status : int {
- ok = LUA_OK,
- syntax = LUA_ERRSYNTAX,
- memory = LUA_ERRMEM,
- gc = LUA_ERRGCMM,
- file = LUA_ERRFILE,
- };
-
- enum class type : int {
- none = LUA_TNONE,
- lua_nil = LUA_TNIL,
-#ifndef __OBJC__
- nil = lua_nil,
-#endif // Objective C++ Keyword
- string = LUA_TSTRING,
- number = LUA_TNUMBER,
- thread = LUA_TTHREAD,
- boolean = LUA_TBOOLEAN,
- function = LUA_TFUNCTION,
- userdata = LUA_TUSERDATA,
- lightuserdata = LUA_TLIGHTUSERDATA,
- table = LUA_TTABLE,
- poly = none | lua_nil | string | number | thread |
- table | boolean | function | userdata | lightuserdata
- };
-
- enum class meta_function {
- construct,
- index,
- new_index,
- mode,
- call,
- call_function = call,
- metatable,
- to_string,
- length,
- unary_minus,
- addition,
- subtraction,
- multiplication,
- division,
- modulus,
- power_of,
- involution = power_of,
- concatenation,
- equal_to,
- less_than,
- less_than_or_equal_to,
- garbage_collect,
- floor_division,
- bitwise_left_shift,
- bitwise_right_shift,
- bitwise_not,
- bitwise_and,
- bitwise_or,
- bitwise_xor,
- pairs,
- next
- };
-
- typedef meta_function meta_method;
-
- const std::array<std::string, 2> meta_variable_names = { {
- "__index",
- "__newindex",
- } };
-
- const std::array<std::string, 29> meta_function_names = { {
- "new",
- "__index",
- "__newindex",
- "__mode",
- "__call",
- "__mt",
- "__tostring",
- "__len",
- "__unm",
- "__add",
- "__sub",
- "__mul",
- "__div",
- "__mod",
- "__pow",
- "__concat",
- "__eq",
- "__lt",
- "__le",
- "__gc",
-
- "__idiv",
- "__shl",
- "__shr",
- "__bnot",
- "__band",
- "__bor",
- "__bxor",
-
- "__pairs",
- "__next"
- } };
-
- inline const std::string& name_of(meta_function mf) {
- return meta_function_names[static_cast<int>(mf)];
- }
-
- inline type type_of(lua_State* L, int index) {
- return static_cast<type>(lua_type(L, index));
- }
-
- inline int type_panic(lua_State* L, int index, type expected, type actual) {
- return luaL_error(L, "stack index %d, expected %s, received %s", index,
- expected == type::poly ? "anything" : lua_typename(L, static_cast<int>(expected)),
- expected == type::poly ? "anything" : lua_typename(L, static_cast<int>(actual))
- );
- }
-
- // Specify this function as the handler for lua::check if you know there's nothing wrong
- inline int no_panic(lua_State*, int, type, type) noexcept {
- return 0;
- }
-
- inline void type_error(lua_State* L, int expected, int actual) {
- luaL_error(L, "expected %s, received %s", lua_typename(L, expected), lua_typename(L, actual));
- }
-
- inline void type_error(lua_State* L, type expected, type actual) {
- type_error(L, static_cast<int>(expected), static_cast<int>(actual));
- }
-
- inline void type_assert(lua_State* L, int index, type expected, type actual) {
- if (expected != type::poly && expected != actual) {
- type_panic(L, index, expected, actual);
- }
- }
-
- inline void type_assert(lua_State* L, int index, type expected) {
- type actual = type_of(L, index);
- type_assert(L, index, expected, actual);
- }
-
- inline std::string type_name(lua_State* L, type t) {
- return lua_typename(L, static_cast<int>(t));
- }
-
- class reference;
- class stack_reference;
- template <typename Table, typename Key>
- struct proxy;
- template<typename T>
- class usertype;
- template <bool, typename T>
- class basic_table_core;
- template <bool b>
- using table_core = basic_table_core<b, reference>;
- template <bool b>
- using stack_table_core = basic_table_core<b, stack_reference>;
- typedef table_core<false> table;
- typedef table_core<true> global_table;
- typedef stack_table_core<false> stack_table;
- typedef stack_table_core<true> stack_global_table;
- template <typename T>
- class basic_function;
- template <typename T>
- class basic_protected_function;
- using function = basic_function<reference>;
- using protected_function = basic_protected_function<reference>;
- using stack_function = basic_function<stack_reference>;
- using stack_protected_function = basic_protected_function<stack_reference>;
- template <typename base_t>
- class basic_object;
- template <typename base_t>
- class basic_userdata;
- template <typename base_t>
- class basic_lightuserdata;
- struct variadic_args;
- using object = basic_object<reference>;
- using stack_object = basic_object<stack_reference>;
- using userdata = basic_userdata<reference>;
- using stack_userdata = basic_userdata<stack_reference>;
- using lightuserdata = basic_lightuserdata<reference>;
- using stack_lightuserdata = basic_lightuserdata<stack_reference>;
- class coroutine;
- class thread;
- struct variadic_args;
- struct this_state;
-
- namespace detail {
- template <typename T, typename = void>
- struct lua_type_of : std::integral_constant<type, type::userdata> {};
-
- template <>
- struct lua_type_of<std::string> : std::integral_constant<type, type::string> {};
-
- template <>
- struct lua_type_of<std::wstring> : std::integral_constant<type, type::string> {};
-
- template <>
- struct lua_type_of<std::u16string> : std::integral_constant<type, type::string> {};
-
- template <>
- struct lua_type_of<std::u32string> : std::integral_constant<type, type::string> {};
-
- template <std::size_t N>
- struct lua_type_of<char[N]> : std::integral_constant<type, type::string> {};
-
- template <std::size_t N>
- struct lua_type_of<wchar_t[N]> : std::integral_constant<type, type::string> {};
-
- template <std::size_t N>
- struct lua_type_of<char16_t[N]> : std::integral_constant<type, type::string> {};
-
- template <std::size_t N>
- struct lua_type_of<char32_t[N]> : std::integral_constant<type, type::string> {};
-
- template <>
- struct lua_type_of<char> : std::integral_constant<type, type::string> {};
-
- template <>
- struct lua_type_of<wchar_t> : std::integral_constant<type, type::string> {};
-
- template <>
- struct lua_type_of<char16_t> : std::integral_constant<type, type::string> {};
-
- template <>
- struct lua_type_of<char32_t> : std::integral_constant<type, type::string> {};
-
- template <>
- struct lua_type_of<const char*> : std::integral_constant<type, type::string> {};
-
- template <>
- struct lua_type_of<const char16_t*> : std::integral_constant<type, type::string> {};
-
- template <>
- struct lua_type_of<const char32_t*> : std::integral_constant<type, type::string> {};
-
- template <>
- struct lua_type_of<string_detail::string_shim> : std::integral_constant<type, type::string> {};
-
- template <>
- struct lua_type_of<bool> : std::integral_constant<type, type::boolean> {};
-
- template <>
- struct lua_type_of<lua_nil_t> : std::integral_constant<type, type::lua_nil> { };
-
- template <>
- struct lua_type_of<nullopt_t> : std::integral_constant<type, type::lua_nil> { };
-
- template <>
- struct lua_type_of<std::nullptr_t> : std::integral_constant<type, type::lua_nil> { };
-
- template <>
- struct lua_type_of<sol::error> : std::integral_constant<type, type::string> { };
-
- template <bool b, typename Base>
- struct lua_type_of<basic_table_core<b, Base>> : std::integral_constant<type, type::table> { };
-
- template <>
- struct lua_type_of<reference> : std::integral_constant<type, type::poly> {};
-
- template <>
- struct lua_type_of<stack_reference> : std::integral_constant<type, type::poly> {};
-
- template <typename Base>
- struct lua_type_of<basic_object<Base>> : std::integral_constant<type, type::poly> {};
-
- template <typename... Args>
- struct lua_type_of<std::tuple<Args...>> : std::integral_constant<type, type::poly> {};
-
- template <typename A, typename B>
- struct lua_type_of<std::pair<A, B>> : std::integral_constant<type, type::poly> {};
-
- template <>
- struct lua_type_of<void*> : std::integral_constant<type, type::lightuserdata> {};
-
- template <>
- struct lua_type_of<lightuserdata_value> : std::integral_constant<type, type::lightuserdata> {};
-
- template <>
- struct lua_type_of<userdata_value> : std::integral_constant<type, type::userdata> {};
-
- template <typename T>
- struct lua_type_of<light<T>> : std::integral_constant<type, type::lightuserdata> {};
-
- template <typename T>
- struct lua_type_of<user<T>> : std::integral_constant<type, type::userdata> {};
-
- template <typename Base>
- struct lua_type_of<basic_lightuserdata<Base>> : std::integral_constant<type, type::lightuserdata> {};
-
- template <typename Base>
- struct lua_type_of<basic_userdata<Base>> : std::integral_constant<type, type::userdata> {};
-
- template <>
- struct lua_type_of<lua_CFunction> : std::integral_constant<type, type::function> {};
-
- template <>
- struct lua_type_of<std::remove_pointer_t<lua_CFunction>> : std::integral_constant<type, type::function> {};
-
- template <typename Base>
- struct lua_type_of<basic_function<Base>> : std::integral_constant<type, type::function> {};
-
- template <typename Base>
- struct lua_type_of<basic_protected_function<Base>> : std::integral_constant<type, type::function> {};
-
- template <>
- struct lua_type_of<coroutine> : std::integral_constant<type, type::function> {};
-
- template <>
- struct lua_type_of<thread> : std::integral_constant<type, type::thread> {};
-
- template <typename Signature>
- struct lua_type_of<std::function<Signature>> : std::integral_constant<type, type::function> {};
-
- template <typename T>
- struct lua_type_of<optional<T>> : std::integral_constant<type, type::poly> {};
-
- template <>
- struct lua_type_of<variadic_args> : std::integral_constant<type, type::poly> {};
-
- template <>
- struct lua_type_of<this_state> : std::integral_constant<type, type::poly> {};
-
- template <>
- struct lua_type_of<type> : std::integral_constant<type, type::poly> {};
-
- template <typename T>
- struct lua_type_of<T*> : std::integral_constant<type, type::userdata> {};
-
- template <typename T>
- struct lua_type_of<T, std::enable_if_t<std::is_arithmetic<T>::value>> : std::integral_constant<type, type::number> {};
-
- template <typename T>
- struct lua_type_of<T, std::enable_if_t<std::is_enum<T>::value>> : std::integral_constant<type, type::number> {};
-
- template <typename T, typename C = void>
- struct is_container : std::false_type {};
-
- template <typename T>
- struct is_container<T, std::enable_if_t<meta::has_begin_end<meta::unqualified_t<T>>::value>> : std::true_type {};
-
- template <>
- struct lua_type_of<meta_function> : std::integral_constant<type, type::string> {};
-
- template <typename C, C v, template <typename...> class V, typename... Args>
- struct accumulate : std::integral_constant<C, v> {};
-
- template <typename C, C v, template <typename...> class V, typename T, typename... Args>
- struct accumulate<C, v, V, T, Args...> : accumulate<C, v + V<T>::value, V, Args...> {};
- } // detail
-
- template <typename T>
- struct is_unique_usertype : std::integral_constant<bool, unique_usertype_traits<T>::value> {};
-
- template <typename T>
- struct lua_type_of : detail::lua_type_of<T> {};
-
- template <typename T>
- struct lua_size : std::integral_constant<int, 1> { };
-
- template <typename A, typename B>
- struct lua_size<std::pair<A, B>> : std::integral_constant<int, lua_size<A>::value + lua_size<B>::value> { };
-
- template <typename... Args>
- struct lua_size<std::tuple<Args...>> : std::integral_constant<int, detail::accumulate<int, 0, lua_size, Args...>::value> { };
-
- template <typename T>
- struct is_lua_primitive : std::integral_constant<bool,
- type::userdata != lua_type_of<meta::unqualified_t<T>>::value
- || (lua_size<T>::value > 1)
- || std::is_base_of<reference, meta::unqualified_t<T>>::value
- || std::is_base_of<stack_reference, meta::unqualified_t<T>>::value
- || meta::is_specialization_of<std::tuple, meta::unqualified_t<T>>::value
- || meta::is_specialization_of<std::pair, meta::unqualified_t<T>>::value
- > { };
-
- template <typename T>
- struct is_lua_reference : std::integral_constant<bool,
- std::is_base_of<reference, meta::unqualified_t<T>>::value
- || std::is_base_of<stack_reference, meta::unqualified_t<T>>::value
- || meta::is_specialization_of<proxy, meta::unqualified_t<T>>::value
- > { };
-
- template <typename T>
- struct is_lua_primitive<T*> : std::true_type {};
- template <typename T>
- struct is_lua_primitive<std::reference_wrapper<T>> : std::true_type { };
- template <typename T>
- struct is_lua_primitive<user<T>> : std::true_type { };
- template <typename T>
- struct is_lua_primitive<light<T>> : is_lua_primitive<T*> { };
- template <typename T>
- struct is_lua_primitive<optional<T>> : std::true_type {};
- template <>
- struct is_lua_primitive<userdata_value> : std::true_type {};
- template <>
- struct is_lua_primitive<lightuserdata_value> : std::true_type {};
- template <typename T>
- struct is_lua_primitive<non_null<T>> : is_lua_primitive<T*> {};
-
- template <typename T>
- struct is_proxy_primitive : is_lua_primitive<T> { };
-
- template <typename T>
- struct is_transparent_argument : std::false_type {};
-
- template <>
- struct is_transparent_argument<this_state> : std::true_type {};
-
- template <>
- struct is_transparent_argument<variadic_args> : std::true_type {};
-
- template <typename T>
- struct is_variadic_arguments : std::is_same<T, variadic_args> {};
-
- template <typename Signature>
- struct lua_bind_traits : meta::bind_traits<Signature> {
- private:
- typedef meta::bind_traits<Signature> base_t;
- public:
- typedef std::integral_constant<bool, meta::count_for<is_transparent_argument, typename base_t::args_list>::value != 0> runtime_variadics_t;
- static const std::size_t true_arity = base_t::arity;
- static const std::size_t arity = base_t::arity - meta::count_for<is_transparent_argument, typename base_t::args_list>::value;
- static const std::size_t true_free_arity = base_t::free_arity;
- static const std::size_t free_arity = base_t::free_arity - meta::count_for<is_transparent_argument, typename base_t::args_list>::value;
- };
-
- template <typename T>
- struct is_table : std::false_type {};
- template <bool x, typename T>
- struct is_table<basic_table_core<x, T>> : std::true_type {};
-
- template <typename T>
- struct is_function : std::false_type {};
- template <typename T>
- struct is_function<basic_function<T>> : std::true_type {};
- template <typename T>
- struct is_function<basic_protected_function<T>> : std::true_type {};
-
- template <typename T>
- struct is_lightuserdata : std::false_type {};
- template <typename T>
- struct is_lightuserdata<basic_lightuserdata<T>> : std::true_type {};
-
- template <typename T>
- struct is_userdata : std::false_type {};
- template <typename T>
- struct is_userdata<basic_userdata<T>> : std::true_type {};
-
- template <typename T>
- struct is_container : detail::is_container<T>{};
-
- template<typename T>
- inline type type_of() {
- return lua_type_of<meta::unqualified_t<T>>::value;
- }
-} // sol
-
-#endif // SOL_TYPES_HPP
diff --git a/3rdparty/sol2/sol/userdata.hpp b/3rdparty/sol2/sol/userdata.hpp
deleted file mode 100644
index 382f89b17da..00000000000
--- a/3rdparty/sol2/sol/userdata.hpp
+++ /dev/null
@@ -1,98 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_USERDATA_HPP
-#define SOL_USERDATA_HPP
-
-#include "reference.hpp"
-
-namespace sol {
- template <typename base_t>
- class basic_userdata : public base_t {
- public:
- basic_userdata() noexcept = default;
- template <typename T, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_userdata>>, meta::neg<std::is_same<base_t, stack_reference>>, std::is_base_of<base_t, meta::unqualified_t<T>>> = meta::enabler>
- basic_userdata(T&& r) noexcept : base_t(std::forward<T>(r)) {
-#ifdef SOL_CHECK_ARGUMENTS
- if (!is_userdata<meta::unqualified_t<T>>::value) {
- auto pp = stack::push_pop(*this);
- type_assert(base_t::lua_state(), -1, type::userdata);
- }
-#endif // Safety
- }
- basic_userdata(const basic_userdata&) = default;
- basic_userdata(basic_userdata&&) = default;
- basic_userdata& operator=(const basic_userdata&) = default;
- basic_userdata& operator=(basic_userdata&&) = default;
- basic_userdata(const stack_reference& r) : basic_userdata(r.lua_state(), r.stack_index()) {}
- basic_userdata(stack_reference&& r) : basic_userdata(r.lua_state(), r.stack_index()) {}
- template <typename T, meta::enable<meta::neg<std::is_integral<meta::unqualified_t<T>>>, meta::neg<std::is_same<T, ref_index>>> = meta::enabler>
- basic_userdata(lua_State* L, T&& r) : basic_userdata(L, sol::ref_index(r.registry_index())) {}
- basic_userdata(lua_State* L, int index = -1) : base_t(L, index) {
-#ifdef SOL_CHECK_ARGUMENTS
- type_assert(L, index, type::userdata);
-#endif // Safety
- }
- basic_userdata(lua_State* L, ref_index index) : base_t(L, index) {
-#ifdef SOL_CHECK_ARGUMENTS
- auto pp = stack::push_pop(*this);
- type_assert(L, -1, type::userdata);
-#endif // Safety
- }
- };
-
- template <typename base_t>
- class basic_lightuserdata : public base_t {
- public:
- basic_lightuserdata() noexcept = default;
- template <typename T, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_lightuserdata>>, meta::neg<std::is_same<base_t, stack_reference>>, std::is_base_of<base_t, meta::unqualified_t<T>>> = meta::enabler>
- basic_lightuserdata(T&& r) noexcept : base_t(std::forward<T>(r)) {
-#ifdef SOL_CHECK_ARGUMENTS
- if (!is_userdata<meta::unqualified_t<T>>::value) {
- auto pp = stack::push_pop(*this);
- type_assert(base_t::lua_state(), -1, type::lightuserdata);
- }
-#endif // Safety
- }
- basic_lightuserdata(const basic_lightuserdata&) = default;
- basic_lightuserdata(basic_lightuserdata&&) = default;
- basic_lightuserdata& operator=(const basic_lightuserdata&) = default;
- basic_lightuserdata& operator=(basic_lightuserdata&&) = default;
- basic_lightuserdata(const stack_reference& r) : basic_lightuserdata(r.lua_state(), r.stack_index()) {}
- basic_lightuserdata(stack_reference&& r) : basic_lightuserdata(r.lua_state(), r.stack_index()) {}
- template <typename T, meta::enable<meta::neg<std::is_integral<meta::unqualified_t<T>>>, meta::neg<std::is_same<T, ref_index>>> = meta::enabler>
- basic_lightuserdata(lua_State* L, T&& r) : basic_lightuserdata(L, sol::ref_index(r.registry_index())) {}
- basic_lightuserdata(lua_State* L, int index = -1) : base_t(L, index) {
-#ifdef SOL_CHECK_ARGUMENTS
- type_assert(L, index, type::lightuserdata);
-#endif // Safety
- }
- basic_lightuserdata(lua_State* L, ref_index index) : base_t(L, index) {
-#ifdef SOL_CHECK_ARGUMENTS
- auto pp = stack::push_pop(*this);
- type_assert(L, -1, type::lightuserdata);
-#endif // Safety
- }
- };
-
-} // sol
-
-#endif // SOL_USERDATA_HPP
diff --git a/3rdparty/sol2/sol/usertype.hpp b/3rdparty/sol2/sol/usertype.hpp
deleted file mode 100644
index 7fae5119c6d..00000000000
--- a/3rdparty/sol2/sol/usertype.hpp
+++ /dev/null
@@ -1,97 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_USERTYPE_HPP
-#define SOL_USERTYPE_HPP
-
-#include "stack.hpp"
-#include "usertype_metatable.hpp"
-#include "simple_usertype_metatable.hpp"
-#include "container_usertype_metatable.hpp"
-#include <memory>
-
-namespace sol {
-
- template<typename T>
- class usertype {
- private:
- std::unique_ptr<usertype_detail::registrar, detail::deleter> metatableregister;
-
- template<typename... Args>
- usertype(usertype_detail::verified_tag, Args&&... args) : metatableregister(detail::make_unique_deleter<usertype_metatable<T, std::make_index_sequence<sizeof...(Args) / 2>, Args...>, detail::deleter>(std::forward<Args>(args)...)) {}
-
- template<typename... Args>
- usertype(usertype_detail::add_destructor_tag, Args&&... args) : usertype(usertype_detail::verified, std::forward<Args>(args)..., "__gc", default_destructor) {}
-
- template<typename... Args>
- usertype(usertype_detail::check_destructor_tag, Args&&... args) : usertype(meta::condition<meta::all<std::is_destructible<T>, meta::neg<usertype_detail::has_destructor<Args...>>>, usertype_detail::add_destructor_tag, usertype_detail::verified_tag>(), std::forward<Args>(args)...) {}
-
- public:
-
- template<typename... Args>
- usertype(Args&&... args) : usertype(meta::condition<meta::all<std::is_default_constructible<T>, meta::neg<usertype_detail::has_constructor<Args...>>>, decltype(default_constructor), usertype_detail::check_destructor_tag>(), std::forward<Args>(args)...) {}
-
- template<typename... Args, typename... CArgs>
- usertype(constructors<CArgs...> constructorlist, Args&&... args) : usertype(usertype_detail::check_destructor_tag(), std::forward<Args>(args)..., "new", constructorlist) {}
-
- template<typename... Args, typename... Fxs>
- usertype(constructor_wrapper<Fxs...> constructorlist, Args&&... args) : usertype(usertype_detail::check_destructor_tag(), std::forward<Args>(args)..., "new", constructorlist) {}
-
- template<typename... Args>
- usertype(simple_tag, lua_State* L, Args&&... args) : metatableregister(detail::make_unique_deleter<simple_usertype_metatable<T>, detail::deleter>(L, std::forward<Args>(args)...)) {}
-
- usertype_detail::registrar* registrar_data() {
- return metatableregister.get();
- }
-
- int push(lua_State* L) {
- return metatableregister->push_um(L);
- }
- };
-
- template<typename T>
- class simple_usertype : public usertype<T> {
- private:
- typedef usertype<T> base_t;
- lua_State* state;
-
- public:
- template<typename... Args>
- simple_usertype(lua_State* L, Args&&... args) : base_t(simple, L, std::forward<Args>(args)...), state(L) {}
-
- template <typename N, typename F>
- void set(N&& n, F&& f) {
- auto meta = static_cast<simple_usertype_metatable<T>*>(base_t::registrar_data());
- meta->add(state, n, f);
- }
- };
-
- namespace stack {
- template<typename T>
- struct pusher<usertype<T>> {
- static int push(lua_State* L, usertype<T>& user) {
- return user.push(L);
- }
- };
- } // stack
-} // sol
-
-#endif // SOL_USERTYPE_HPP
diff --git a/3rdparty/sol2/sol/usertype_metatable.hpp b/3rdparty/sol2/sol/usertype_metatable.hpp
deleted file mode 100644
index b496d388010..00000000000
--- a/3rdparty/sol2/sol/usertype_metatable.hpp
+++ /dev/null
@@ -1,609 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_USERTYPE_METATABLE_HPP
-#define SOL_USERTYPE_METATABLE_HPP
-
-#include "wrapper.hpp"
-#include "call.hpp"
-#include "stack.hpp"
-#include "types.hpp"
-#include "stack_reference.hpp"
-#include "usertype_traits.hpp"
-#include "inheritance.hpp"
-#include "raii.hpp"
-#include "deprecate.hpp"
-#include <unordered_map>
-#include <cstdio>
-
-namespace sol {
- namespace usertype_detail {
- struct no_comp {
- template <typename A, typename B>
- bool operator()(A&&, B&&) const {
- return false;
- }
- };
-
- typedef void(*base_walk)(lua_State*, bool&, int&, string_detail::string_shim&);
- typedef int(*member_search)(lua_State*, void*);
-
- struct find_call_pair {
- member_search first;
- member_search second;
-
- find_call_pair(member_search first, member_search second) : first(first), second(second) {}
- };
-
- inline bool is_indexer(string_detail::string_shim s) {
- return s == name_of(meta_function::index) || s == name_of(meta_function::new_index);
- }
-
- inline bool is_indexer(meta_function mf) {
- return mf == meta_function::index || mf == meta_function::new_index;
- }
-
- inline bool is_indexer(call_construction) {
- return false;
- }
-
- inline bool is_indexer(base_classes_tag) {
- return false;
- }
-
- inline auto make_shim(string_detail::string_shim s) {
- return s;
- }
-
- inline auto make_shim(call_construction) {
- return string_detail::string_shim(name_of(meta_function::call_function));
- }
-
- inline auto make_shim(meta_function mf) {
- return string_detail::string_shim(name_of(mf));
- }
-
- inline auto make_shim(base_classes_tag) {
- return string_detail::string_shim(detail::base_class_cast_key());
- }
-
- template <typename Arg>
- inline std::string make_string(Arg&& arg) {
- string_detail::string_shim s = make_shim(arg);
- return std::string(s.c_str(), s.size());
- }
-
- template <typename N>
- inline luaL_Reg make_reg(N&& n, lua_CFunction f) {
- luaL_Reg l{ make_shim(std::forward<N>(n)).c_str(), f };
- return l;
- }
-
- struct registrar {
- virtual int push_um(lua_State* L) = 0;
- virtual ~registrar() {}
- };
-
- template <bool is_index>
- inline int indexing_fail(lua_State* L) {
- auto maybeaccessor = stack::get<optional<string_detail::string_shim>>(L, is_index ? -1 : -2);
- string_detail::string_shim accessor = maybeaccessor.value_or(string_detail::string_shim("(unknown)"));
- if (is_index)
- return luaL_error(L, "sol: attempt to index (get) lua_nil value \"%s\" on userdata (bad (misspelled?) key name or does not exist)", accessor.c_str());
- else
- return luaL_error(L, "sol: attempt to index (set) lua_nil value \"%s\" on userdata (bad (misspelled?) key name or does not exist)", accessor.c_str());
- }
-
- template <bool is_index, typename Base>
- static void walk_single_base(lua_State* L, bool& found, int& ret, string_detail::string_shim&) {
- if (found)
- return;
- const char* metakey = &usertype_traits<Base>::metatable()[0];
- const char* gcmetakey = &usertype_traits<Base>::gc_table()[0];
- const char* basewalkkey = is_index ? detail::base_class_index_propogation_key() : detail::base_class_new_index_propogation_key();
-
- luaL_getmetatable(L, metakey);
- if (type_of(L, -1) == type::lua_nil) {
- lua_pop(L, 1);
- return;
- }
-
- stack::get_field(L, basewalkkey);
- if (type_of(L, -1) == type::lua_nil) {
- lua_pop(L, 2);
- return;
- }
- lua_CFunction basewalkfunc = stack::pop<lua_CFunction>(L);
- lua_pop(L, 1);
-
- stack::get_field<true>(L, gcmetakey);
- int value = basewalkfunc(L);
- if (value > -1) {
- found = true;
- ret = value;
- }
- }
-
- template <bool is_index, typename... Bases>
- static void walk_all_bases(lua_State* L, bool& found, int& ret, string_detail::string_shim& accessor) {
- (void)L;
- (void)found;
- (void)ret;
- (void)accessor;
- (void)detail::swallow{ 0, (walk_single_base<is_index, Bases>(L, found, ret, accessor), 0)... };
- }
-
- template <typename T, typename Op>
- inline int operator_wrap(lua_State* L) {
- auto maybel = stack::check_get<T>(L, 1);
- if (maybel) {
- auto mayber = stack::check_get<T>(L, 2);
- if (mayber) {
- auto& l = *maybel;
- auto& r = *mayber;
- if (std::is_same<no_comp, Op>::value) {
- return stack::push(L, detail::ptr(l) == detail::ptr(r));
- }
- else {
- Op op;
- return stack::push(L, (detail::ptr(l) == detail::ptr(r)) || op(detail::deref(l), detail::deref(r)));
- }
- }
- }
- return stack::push(L, false);
- }
-
- template <typename T, typename Op, typename Supports, typename Regs, meta::enable<Supports> = meta::enabler>
- inline void make_reg_op(Regs& l, int& index, const char* name) {
- l[index] = { name, &operator_wrap<T, Op> };
- ++index;
- }
-
- template <typename T, typename Op, typename Supports, typename Regs, meta::disable<Supports> = meta::enabler>
- inline void make_reg_op(Regs&, int&, const char*) {
- // Do nothing if there's no support
- }
-
- struct add_destructor_tag {};
- struct check_destructor_tag {};
- struct verified_tag {} const verified{};
-
- template <typename T>
- struct is_non_factory_constructor : std::false_type {};
-
- template <typename... Args>
- struct is_non_factory_constructor<constructors<Args...>> : std::true_type {};
-
- template <typename... Args>
- struct is_non_factory_constructor<constructor_wrapper<Args...>> : std::true_type {};
-
- template <>
- struct is_non_factory_constructor<no_construction> : std::true_type {};
-
- template <typename T>
- struct is_constructor : is_non_factory_constructor<T> {};
-
- template <typename... Args>
- struct is_constructor<factory_wrapper<Args...>> : std::true_type {};
-
- template <typename... Args>
- using has_constructor = meta::any<is_constructor<meta::unqualified_t<Args>>...>;
-
- template <typename T>
- struct is_destructor : std::false_type {};
-
- template <typename Fx>
- struct is_destructor<destructor_wrapper<Fx>> : std::true_type {};
-
- template <typename... Args>
- using has_destructor = meta::any<is_destructor<meta::unqualified_t<Args>>...>;
-
- } // usertype_detail
-
- template <typename T>
- struct clean_type {
- typedef std::conditional_t<std::is_array<meta::unqualified_t<T>>::value, T&, std::decay_t<T>> type;
- };
-
- template <typename T>
- using clean_type_t = typename clean_type<T>::type;
-
- template <typename T, typename IndexSequence, typename... Tn>
- struct usertype_metatable : usertype_detail::registrar {};
-
- template <typename T, std::size_t... I, typename... Tn>
- struct usertype_metatable<T, std::index_sequence<I...>, Tn...> : usertype_detail::registrar {
- typedef std::make_index_sequence<sizeof...(I) * 2> indices;
- typedef std::index_sequence<I...> half_indices;
- typedef std::array<luaL_Reg, sizeof...(Tn) / 2 + 1 + 3> regs_t;
- typedef std::tuple<Tn...> RawTuple;
- typedef std::tuple<clean_type_t<Tn> ...> Tuple;
- template <std::size_t Idx>
- struct check_binding : is_variable_binding<meta::unqualified_tuple_element_t<Idx, Tuple>> {};
- typedef std::unordered_map<std::string, usertype_detail::find_call_pair> mapping_t;
- Tuple functions;
- mapping_t mapping;
- lua_CFunction indexfunc;
- lua_CFunction newindexfunc;
- lua_CFunction destructfunc;
- lua_CFunction callconstructfunc;
- lua_CFunction indexbase;
- lua_CFunction newindexbase;
- usertype_detail::base_walk indexbaseclasspropogation;
- usertype_detail::base_walk newindexbaseclasspropogation;
- void* baseclasscheck;
- void* baseclasscast;
- bool mustindex;
- bool secondarymeta;
- bool hasequals;
- bool hasless;
- bool haslessequals;
-
- template <std::size_t Idx, meta::enable<std::is_same<lua_CFunction, meta::unqualified_tuple_element<Idx + 1, RawTuple>>> = meta::enabler>
- inline lua_CFunction make_func() {
- return std::get<Idx + 1>(functions);
- }
-
- template <std::size_t Idx, meta::disable<std::is_same<lua_CFunction, meta::unqualified_tuple_element<Idx + 1, RawTuple>>> = meta::enabler>
- inline lua_CFunction make_func() {
- return call<Idx + 1>;
- }
-
- static bool contains_variable() {
- typedef meta::any<check_binding<(I * 2 + 1)>...> has_variables;
- return has_variables::value;
- }
-
- bool contains_index() const {
- bool idx = false;
- (void)detail::swallow{ 0, ((idx |= usertype_detail::is_indexer(std::get<I * 2>(functions))), 0) ... };
- return idx;
- }
-
- int finish_regs(regs_t& l, int& index) {
- if (!hasless) {
- const char* name = name_of(meta_function::less_than).c_str();
- usertype_detail::make_reg_op<T, std::less<>, meta::supports_op_less<T>>(l, index, name);
- }
- if (!haslessequals) {
- const char* name = name_of(meta_function::less_than_or_equal_to).c_str();
- usertype_detail::make_reg_op<T, std::less_equal<>, meta::supports_op_less_equal<T>>(l, index, name);
- }
- if (!hasequals) {
- const char* name = name_of(meta_function::equal_to).c_str();
- usertype_detail::make_reg_op<T, std::conditional_t<meta::supports_op_equal<T>::value, std::equal_to<>, usertype_detail::no_comp>, std::true_type>(l, index, name);
- }
- if (destructfunc != nullptr) {
- l[index] = { name_of(meta_function::garbage_collect).c_str(), destructfunc };
- ++index;
- }
- return index;
- }
-
- template <std::size_t Idx, typename F>
- void make_regs(regs_t&, int&, call_construction, F&&) {
- callconstructfunc = call<Idx + 1>;
- secondarymeta = true;
- }
-
- template <std::size_t, typename... Bases>
- void make_regs(regs_t&, int&, base_classes_tag, bases<Bases...>) {
- if (sizeof...(Bases) < 1) {
- return;
- }
- mustindex = true;
- (void)detail::swallow{ 0, ((detail::has_derived<Bases>::value = true), 0)... };
-
- static_assert(sizeof(void*) <= sizeof(detail::inheritance_check_function), "The size of this data pointer is too small to fit the inheritance checking function: file a bug report.");
- static_assert(sizeof(void*) <= sizeof(detail::inheritance_cast_function), "The size of this data pointer is too small to fit the inheritance checking function: file a bug report.");
- baseclasscheck = (void*)&detail::inheritance<T, Bases...>::type_check;
- baseclasscast = (void*)&detail::inheritance<T, Bases...>::type_cast;
- indexbaseclasspropogation = usertype_detail::walk_all_bases<true, Bases...>;
- newindexbaseclasspropogation = usertype_detail::walk_all_bases<false, Bases...>;
- }
-
- template <std::size_t Idx, typename N, typename F, typename = std::enable_if_t<!meta::any_same<meta::unqualified_t<N>, base_classes_tag, call_construction>::value>>
- void make_regs(regs_t& l, int& index, N&& n, F&&) {
- if (is_variable_binding<meta::unqualified_t<F>>::value) {
- return;
- }
- luaL_Reg reg = usertype_detail::make_reg(std::forward<N>(n), make_func<Idx>());
- // Returnable scope
- // That would be a neat keyword for C++
- // returnable { ... };
- if (reg.name == name_of(meta_function::equal_to)) {
- hasequals = true;
- }
- if (reg.name == name_of(meta_function::less_than)) {
- hasless = true;
- }
- if (reg.name == name_of(meta_function::less_than_or_equal_to)) {
- haslessequals = true;
- }
- if (reg.name == name_of(meta_function::garbage_collect)) {
- destructfunc = reg.func;
- return;
- }
- else if (reg.name == name_of(meta_function::index)) {
- indexfunc = reg.func;
- mustindex = true;
- return;
- }
- else if (reg.name == name_of(meta_function::new_index)) {
- newindexfunc = reg.func;
- mustindex = true;
- return;
- }
- l[index] = reg;
- ++index;
- }
-
- template <typename... Args, typename = std::enable_if_t<sizeof...(Args) == sizeof...(Tn)>>
- usertype_metatable(Args&&... args) : functions(std::forward<Args>(args)...),
- mapping(),
- indexfunc(usertype_detail::indexing_fail<true>), newindexfunc(usertype_detail::indexing_fail<false>),
- destructfunc(nullptr), callconstructfunc(nullptr),
- indexbase(&core_indexing_call<true>), newindexbase(&core_indexing_call<false>),
- indexbaseclasspropogation(usertype_detail::walk_all_bases<true>), newindexbaseclasspropogation(usertype_detail::walk_all_bases<false>),
- baseclasscheck(nullptr), baseclasscast(nullptr),
- mustindex(contains_variable() || contains_index()), secondarymeta(contains_variable()),
- hasequals(false), hasless(false), haslessequals(false) {
- std::initializer_list<typename mapping_t::value_type> ilist{ {
- std::pair<std::string, usertype_detail::find_call_pair>(
- usertype_detail::make_string(std::get<I * 2>(functions)),
- usertype_detail::find_call_pair(&usertype_metatable::real_find_call<I * 2, I * 2 + 1, false>,
- &usertype_metatable::real_find_call<I * 2, I * 2 + 1, true>)
- )
- }... };
- mapping.insert(ilist);
- }
-
- template <std::size_t I0, std::size_t I1, bool is_index>
- static int real_find_call(lua_State* L, void* um) {
- auto& f = *static_cast<usertype_metatable*>(um);
- if (is_variable_binding<decltype(std::get<I1>(f.functions))>::value) {
- return real_call_with<I1, is_index, true>(L, f);
- }
- return stack::push(L, c_closure(call<I1, is_index>, stack::push(L, light<usertype_metatable>(f))));
- }
-
- template <bool is_index, bool toplevel = false>
- static int core_indexing_call(lua_State* L) {
- usertype_metatable& f = toplevel ? stack::get<light<usertype_metatable>>(L, upvalue_index(1)) : stack::pop<light<usertype_metatable>>(L);
- static const int keyidx = -2 + static_cast<int>(is_index);
- if (toplevel && stack::get<type>(L, keyidx) != type::string) {
- return is_index ? f.indexfunc(L) : f.newindexfunc(L);
- }
- std::string name = stack::get<std::string>(L, keyidx);
- auto memberit = f.mapping.find(name);
- if (memberit != f.mapping.cend()) {
- auto& member = is_index ? memberit->second.second : memberit->second.first;
- return (member)(L, static_cast<void*>(&f));
- }
- string_detail::string_shim accessor = name;
- int ret = 0;
- bool found = false;
- // Otherwise, we need to do propagating calls through the bases
- if (is_index)
- f.indexbaseclasspropogation(L, found, ret, accessor);
- else
- f.newindexbaseclasspropogation(L, found, ret, accessor);
- if (found) {
- return ret;
- }
- return toplevel ? (is_index ? f.indexfunc(L) : f.newindexfunc(L)) : -1;
- }
-
- static int real_index_call(lua_State* L) {
- return core_indexing_call<true, true>(L);
- }
-
- static int real_new_index_call(lua_State* L) {
- return core_indexing_call<false, true>(L);
- }
-
- template <std::size_t Idx, bool is_index = true, bool is_variable = false>
- static int real_call(lua_State* L) {
- usertype_metatable& f = stack::get<light<usertype_metatable>>(L, upvalue_index(1));
- return real_call_with<Idx, is_index, is_variable>(L, f);
- }
-
- template <std::size_t Idx, bool is_index = true, bool is_variable = false>
- static int real_call_with(lua_State* L, usertype_metatable& um) {
- typedef meta::unqualified_tuple_element_t<Idx - 1, Tuple> K;
- typedef meta::unqualified_tuple_element_t<Idx, Tuple> F;
- static const int boost =
- !usertype_detail::is_non_factory_constructor<F>::value
- && std::is_same<K, call_construction>::value ?
- 1 : 0;
- auto& f = std::get<Idx>(um.functions);
- return call_detail::call_wrapped<T, is_index, is_variable, boost>(L, f);
- }
-
- template <std::size_t Idx, bool is_index = true, bool is_variable = false>
- static int call(lua_State* L) {
- return detail::static_trampoline<(&real_call<Idx, is_index, is_variable>)>(L);
- }
-
- template <std::size_t Idx, bool is_index = true, bool is_variable = false>
- static int call_with(lua_State* L) {
- return detail::static_trampoline<(&real_call_with<Idx, is_index, is_variable>)>(L);
- }
-
- static int index_call(lua_State* L) {
- return detail::static_trampoline<(&real_index_call)>(L);
- }
-
- static int new_index_call(lua_State* L) {
- return detail::static_trampoline<(&real_new_index_call)>(L);
- }
-
- virtual int push_um(lua_State* L) override {
- return stack::push(L, std::move(*this));
- }
-
- ~usertype_metatable() override {
-
- }
- };
-
- namespace stack {
-
- template <typename T, std::size_t... I, typename... Args>
- struct pusher<usertype_metatable<T, std::index_sequence<I...>, Args...>> {
- typedef usertype_metatable<T, std::index_sequence<I...>, Args...> umt_t;
- typedef typename umt_t::regs_t regs_t;
-
- static umt_t& make_cleanup(lua_State* L, umt_t&& umx) {
- // ensure some sort of uniqueness
- static int uniqueness = 0;
- std::string uniquegcmetakey = usertype_traits<T>::user_gc_metatable();
- // std::to_string doesn't exist in android still, with NDK, so this bullshit
- // is necessary
- // thanks, Android :v
- int appended = snprintf(nullptr, 0, "%d", uniqueness);
- std::size_t insertionpoint = uniquegcmetakey.length() - 1;
- uniquegcmetakey.append(appended, '\0');
- char* uniquetarget = &uniquegcmetakey[insertionpoint];
- snprintf(uniquetarget, uniquegcmetakey.length(), "%d", uniqueness);
- ++uniqueness;
-
- const char* gcmetakey = &usertype_traits<T>::gc_table()[0];
- // Make sure userdata's memory is properly in lua first,
- // otherwise all the light userdata we make later will become invalid
- stack::push_specific<user<umt_t>>(L, metatable_key, uniquegcmetakey, std::move(umx));
- // Create the top level thing that will act as our deleter later on
- stack_reference umt(L, -1);
- stack::set_field<true>(L, gcmetakey, umt);
- umt.pop();
-
- stack::get_field<true>(L, gcmetakey);
- return stack::pop<light<umt_t>>(L);
- }
-
- static int push(lua_State* L, umt_t&& umx) {
-
- umt_t& um = make_cleanup(L, std::move(umx));
- regs_t value_table{ {} };
- int lastreg = 0;
- (void)detail::swallow{ 0, (um.template make_regs<(I * 2)>(value_table, lastreg, std::get<(I * 2)>(um.functions), std::get<(I * 2 + 1)>(um.functions)), 0)... };
- um.finish_regs(value_table, lastreg);
- value_table[lastreg] = { nullptr, nullptr };
- regs_t ref_table = value_table;
- regs_t unique_table = value_table;
- bool hasdestructor = !value_table.empty() && name_of(meta_function::garbage_collect) == value_table[lastreg - 1].name;
- if (hasdestructor) {
- ref_table[lastreg - 1] = { nullptr, nullptr };
- unique_table[lastreg - 1] = { value_table[lastreg - 1].name, detail::unique_destruct<T> };
- }
-
- // Now use um
- const bool& mustindex = um.mustindex;
- for (std::size_t i = 0; i < 3; ++i) {
- // Pointer types, AKA "references" from C++
- const char* metakey = nullptr;
- luaL_Reg* metaregs = nullptr;
- switch (i) {
- case 0:
- metakey = &usertype_traits<T*>::metatable()[0];
- metaregs = ref_table.data();
- break;
- case 1:
- metakey = &usertype_traits<detail::unique_usertype<T>>::metatable()[0];
- metaregs = unique_table.data();
- break;
- case 2:
- default:
- metakey = &usertype_traits<T>::metatable()[0];
- metaregs = value_table.data();
- break;
- }
- luaL_newmetatable(L, metakey);
- stack_reference t(L, -1);
- stack::push(L, make_light(um));
- luaL_setfuncs(L, metaregs, 1);
-
- if (um.baseclasscheck != nullptr) {
- stack::set_field(L, detail::base_class_check_key(), um.baseclasscheck, t.stack_index());
- }
- if (um.baseclasscast != nullptr) {
- stack::set_field(L, detail::base_class_cast_key(), um.baseclasscast, t.stack_index());
- }
-
- stack::set_field(L, detail::base_class_index_propogation_key(), make_closure(um.indexbase, make_light(um)), t.stack_index());
- stack::set_field(L, detail::base_class_new_index_propogation_key(), make_closure(um.newindexbase, make_light(um)), t.stack_index());
-
- if (mustindex) {
- // Basic index pushing: specialize
- // index and newindex to give variables and stuff
- stack::set_field(L, meta_function::index, make_closure(umt_t::index_call, make_light(um)), t.stack_index());
- stack::set_field(L, meta_function::new_index, make_closure(umt_t::new_index_call, make_light(um)), t.stack_index());
- }
- else {
- // If there's only functions, we can use the fast index version
- stack::set_field(L, meta_function::index, t, t.stack_index());
- }
- // metatable on the metatable
- // for call constructor purposes and such
- lua_createtable(L, 0, 3);
- stack_reference metabehind(L, -1);
- if (um.callconstructfunc != nullptr) {
- stack::set_field(L, meta_function::call_function, make_closure(um.callconstructfunc, make_light(um)), metabehind.stack_index());
- }
- if (um.secondarymeta) {
- stack::set_field(L, meta_function::index, make_closure(umt_t::index_call, make_light(um)), metabehind.stack_index());
- stack::set_field(L, meta_function::new_index, make_closure(umt_t::new_index_call, make_light(um)), metabehind.stack_index());
- }
- stack::set_field(L, metatable_key, metabehind, t.stack_index());
- metabehind.pop();
- // We want to just leave the table
- // in the registry only, otherwise we return it
- t.pop();
- }
-
- // Now for the shim-table that actually gets assigned to the name
- luaL_newmetatable(L, &usertype_traits<T>::user_metatable()[0]);
- stack_reference t(L, -1);
- stack::push(L, make_light(um));
- luaL_setfuncs(L, value_table.data(), 1);
- {
- lua_createtable(L, 0, 3);
- stack_reference metabehind(L, -1);
- if (um.callconstructfunc != nullptr) {
- stack::set_field(L, meta_function::call_function, make_closure(um.callconstructfunc, make_light(um)), metabehind.stack_index());
- }
- if (um.secondarymeta) {
- stack::set_field(L, meta_function::index, make_closure(umt_t::index_call, make_light(um)), metabehind.stack_index());
- stack::set_field(L, meta_function::new_index, make_closure(umt_t::new_index_call, make_light(um)), metabehind.stack_index());
- }
- stack::set_field(L, metatable_key, metabehind, t.stack_index());
- metabehind.pop();
- }
-
- return 1;
- }
- };
-
- } // stack
-
-} // sol
-
-#endif // SOL_USERTYPE_METATABLE_HPP
diff --git a/3rdparty/sol2/sol/usertype_traits.hpp b/3rdparty/sol2/sol/usertype_traits.hpp
deleted file mode 100644
index a10ff082529..00000000000
--- a/3rdparty/sol2/sol/usertype_traits.hpp
+++ /dev/null
@@ -1,59 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_USERTYPE_TRAITS_HPP
-#define SOL_USERTYPE_TRAITS_HPP
-
-#include "demangle.hpp"
-
-namespace sol {
-
- template<typename T>
- struct usertype_traits {
- static const std::string& name() {
- static const std::string& n = detail::short_demangle<T>();
- return n;
- }
- static const std::string& qualified_name() {
- static const std::string& q_n = detail::demangle<T>();
- return q_n;
- }
- static const std::string& metatable() {
- static const std::string m = std::string("sol.").append(detail::demangle<T>());
- return m;
- }
- static const std::string& user_metatable() {
- static const std::string u_m = std::string("sol.").append(detail::demangle<T>()).append(".user");
- return u_m;
- }
- static const std::string& user_gc_metatable() {
- static const std::string u_g_m = std::string("sol.").append(detail::demangle<T>()).append(".user\xE2\x99\xBB");
- return u_g_m;
- }
- static const std::string& gc_table() {
- static const std::string g_t = std::string("sol.").append(detail::demangle<T>()).append(".\xE2\x99\xBB");
- return g_t;
- }
- };
-
-}
-
-#endif // SOL_USERTYPE_TRAITS_HPP
diff --git a/3rdparty/sol2/sol/variadic_args.hpp b/3rdparty/sol2/sol/variadic_args.hpp
deleted file mode 100644
index 38d258220e0..00000000000
--- a/3rdparty/sol2/sol/variadic_args.hpp
+++ /dev/null
@@ -1,243 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_VARIADIC_ARGS_HPP
-#define SOL_VARIADIC_ARGS_HPP
-
-#include "stack.hpp"
-#include "stack_proxy.hpp"
-#include <limits>
-#include <iterator>
-
-namespace sol {
- template <bool is_const>
- struct va_iterator : std::iterator<std::random_access_iterator_tag, std::conditional_t<is_const, const stack_proxy, stack_proxy>, std::ptrdiff_t, std::conditional_t<is_const, const stack_proxy*, stack_proxy*>, std::conditional_t<is_const, const stack_proxy, stack_proxy>> {
- typedef std::iterator<std::random_access_iterator_tag, std::conditional_t<is_const, const stack_proxy, stack_proxy>, std::ptrdiff_t, std::conditional_t<is_const, const stack_proxy*, stack_proxy*>, std::conditional_t<is_const, const stack_proxy, stack_proxy>> base_t;
- typedef typename base_t::reference reference;
- typedef typename base_t::pointer pointer;
- typedef typename base_t::value_type value_type;
- typedef typename base_t::difference_type difference_type;
- typedef typename base_t::iterator_category iterator_category;
- lua_State* L;
- int index;
- int stacktop;
- stack_proxy sp;
-
- va_iterator() : L(nullptr), index((std::numeric_limits<int>::max)()), stacktop((std::numeric_limits<int>::max)()) {}
- va_iterator(lua_State* luastate, int idx, int topidx) : L(luastate), index(idx), stacktop(topidx), sp(luastate, idx) {}
-
- reference operator*() {
- return stack_proxy(L, index);
- }
-
- pointer operator->() {
- sp = stack_proxy(L, index);
- return &sp;
- }
-
- va_iterator& operator++ () {
- ++index;
- return *this;
- }
-
- va_iterator operator++ (int) {
- auto r = *this;
- this->operator ++();
- return r;
- }
-
- va_iterator& operator-- () {
- --index;
- return *this;
- }
-
- va_iterator operator-- (int) {
- auto r = *this;
- this->operator --();
- return r;
- }
-
- va_iterator& operator+= (difference_type idx) {
- index += static_cast<int>(idx);
- return *this;
- }
-
- va_iterator& operator-= (difference_type idx) {
- index -= static_cast<int>(idx);
- return *this;
- }
-
- difference_type operator- (const va_iterator& r) const {
- return index - r.index;
- }
-
- va_iterator operator+ (difference_type idx) const {
- va_iterator r = *this;
- r += idx;
- return r;
- }
-
- reference operator[](difference_type idx) {
- return stack_proxy(L, index + static_cast<int>(idx));
- }
-
- bool operator==(const va_iterator& r) const {
- if (stacktop == (std::numeric_limits<int>::max)()) {
- return r.index == r.stacktop;
- }
- else if (r.stacktop == (std::numeric_limits<int>::max)()) {
- return index == stacktop;
- }
- return index == r.index;
- }
-
- bool operator != (const va_iterator& r) const {
- return !(this->operator==(r));
- }
-
- bool operator < (const va_iterator& r) const {
- return index < r.index;
- }
-
- bool operator > (const va_iterator& r) const {
- return index > r.index;
- }
-
- bool operator <= (const va_iterator& r) const {
- return index <= r.index;
- }
-
- bool operator >= (const va_iterator& r) const {
- return index >= r.index;
- }
- };
-
- template <bool is_const>
- inline va_iterator<is_const> operator+(typename va_iterator<is_const>::difference_type n, const va_iterator<is_const>& r) {
- return r + n;
- }
-
- struct variadic_args {
- private:
- lua_State* L;
- int index;
- int stacktop;
-
- public:
- typedef stack_proxy reference_type;
- typedef stack_proxy value_type;
- typedef stack_proxy* pointer;
- typedef std::ptrdiff_t difference_type;
- typedef std::size_t size_type;
- typedef va_iterator<false> iterator;
- typedef va_iterator<true> const_iterator;
- typedef std::reverse_iterator<iterator> reverse_iterator;
- typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-
- variadic_args() = default;
- variadic_args(lua_State* luastate, int stackindex = -1) : L(luastate), index(lua_absindex(luastate, stackindex)), stacktop(lua_gettop(luastate)) {}
- variadic_args(const variadic_args&) = default;
- variadic_args& operator=(const variadic_args&) = default;
- variadic_args(variadic_args&& o) : L(o.L), index(o.index), stacktop(o.stacktop) {
- // Must be manual, otherwise destructor will screw us
- // return count being 0 is enough to keep things clean
- // but will be thorough
- o.L = nullptr;
- o.index = 0;
- o.stacktop = 0;
- }
- variadic_args& operator=(variadic_args&& o) {
- L = o.L;
- index = o.index;
- stacktop = o.stacktop;
- // Must be manual, otherwise destructor will screw us
- // return count being 0 is enough to keep things clean
- // but will be thorough
- o.L = nullptr;
- o.index = 0;
- o.stacktop = 0;
- return *this;
- }
-
- iterator begin() { return iterator(L, index, stacktop + 1); }
- iterator end() { return iterator(L, stacktop + 1, stacktop + 1); }
- const_iterator begin() const { return const_iterator(L, index, stacktop + 1); }
- const_iterator end() const { return const_iterator(L, stacktop + 1, stacktop + 1); }
- const_iterator cbegin() const { return begin(); }
- const_iterator cend() const { return end(); }
-
- reverse_iterator rbegin() { return std::reverse_iterator<iterator>(begin()); }
- reverse_iterator rend() { return std::reverse_iterator<iterator>(end()); }
- const_reverse_iterator rbegin() const { return std::reverse_iterator<const_iterator>(begin()); }
- const_reverse_iterator rend() const { return std::reverse_iterator<const_iterator>(end()); }
- const_reverse_iterator crbegin() const { return std::reverse_iterator<const_iterator>(cbegin()); }
- const_reverse_iterator crend() const { return std::reverse_iterator<const_iterator>(cend()); }
-
- int push() const {
- return push(L);
- }
-
- int push(lua_State* target) const {
- int pushcount = 0;
- for (int i = index; i <= stacktop; ++i) {
- lua_pushvalue(L, i);
- pushcount += 1;
- }
- if (target != L) {
- lua_xmove(L, target, pushcount);
- }
- return pushcount;
- }
-
- template<typename T>
- decltype(auto) get(difference_type start = 0) const {
- return stack::get<T>(L, index + static_cast<int>(start));
- }
-
- stack_proxy operator[](difference_type start) const {
- return stack_proxy(L, index + static_cast<int>(start));
- }
-
- lua_State* lua_state() const { return L; };
- int stack_index() const { return index; };
- int leftover_count() const { return stacktop - (index - 1); }
- int top() const { return stacktop; }
- };
-
- namespace stack {
- template <>
- struct getter<variadic_args> {
- static variadic_args get(lua_State* L, int index, record& tracking) {
- tracking.last = 0;
- return variadic_args(L, index);
- }
- };
-
- template <>
- struct pusher<variadic_args> {
- static int push(lua_State* L, const variadic_args& ref) {
- return ref.push(L);
- }
- };
- } // stack
-} // sol
-
-#endif // SOL_VARIADIC_ARGS_HPP
diff --git a/3rdparty/sol2/sol/wrapper.hpp b/3rdparty/sol2/sol/wrapper.hpp
deleted file mode 100644
index 7e38d39f3fe..00000000000
--- a/3rdparty/sol2/sol/wrapper.hpp
+++ /dev/null
@@ -1,233 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2016 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_WRAPPER_HPP
-#define SOL_WRAPPER_HPP
-
-#include "types.hpp"
-
-namespace sol {
-
- template <typename F, typename = void>
- struct wrapper {
- typedef lua_bind_traits<F> traits_type;
- typedef typename traits_type::args_list args_list;
- typedef typename traits_type::args_list free_args_list;
- typedef typename traits_type::returns_list returns_list;
-
- template <typename... Args>
- static decltype(auto) call(F& f, Args&&... args) {
- return f(std::forward<Args>(args)...);
- }
-
- struct caller {
- template <typename... Args>
- decltype(auto) operator()(F& fx, Args&&... args) const {
- return call(fx, std::forward<Args>(args)...);
- }
- };
- };
-
- template <typename F>
- struct wrapper<F, std::enable_if_t<std::is_function<meta::unqualified_t<std::remove_pointer_t<F>>>::value>> {
- typedef lua_bind_traits<F> traits_type;
- typedef typename traits_type::args_list args_list;
- typedef typename traits_type::args_list free_args_list;
- typedef typename traits_type::returns_list returns_list;
-
- template <F fx, typename... Args>
- static decltype(auto) invoke(Args&&... args) {
- return fx(std::forward<Args>(args)...);
- }
-
- template <typename... Args>
- static decltype(auto) call(F& fx, Args&&... args) {
- return fx(std::forward<Args>(args)...);
- }
-
- struct caller {
- template <typename... Args>
- decltype(auto) operator()(F& fx, Args&&... args) const {
- return call(fx, std::forward<Args>(args)...);
- }
- };
-
- template <F fx>
- struct invoker {
- template <typename... Args>
- decltype(auto) operator()(Args&&... args) const {
- return invoke<fx>(std::forward<Args>(args)...);
- }
- };
- };
-
- template <typename F>
- struct wrapper<F, std::enable_if_t<std::is_member_object_pointer<meta::unqualified_t<F>>::value>> {
- typedef lua_bind_traits<F> traits_type;
- typedef typename traits_type::object_type object_type;
- typedef typename traits_type::return_type return_type;
- typedef typename traits_type::args_list args_list;
- typedef types<object_type&, return_type> free_args_list;
- typedef typename traits_type::returns_list returns_list;
-
- template <F fx, typename... Args>
- static decltype(auto) invoke(object_type& mem, Args&&... args) {
- return (mem.*fx)(std::forward<Args>(args)...);
- }
-
- template <typename Fx>
- static decltype(auto) call(Fx&& fx, object_type& mem) {
- return (mem.*fx);
- }
-
- template <typename Fx, typename Arg, typename... Args>
- static void call(Fx&& fx, object_type& mem, Arg&& arg, Args&&...) {
- (mem.*fx) = std::forward<Arg>(arg);
- }
-
- struct caller {
- template <typename Fx, typename... Args>
- decltype(auto) operator()(Fx&& fx, object_type& mem, Args&&... args) const {
- return call(std::forward<Fx>(fx), mem, std::forward<Args>(args)...);
- }
- };
-
- template <F fx>
- struct invoker {
- template <typename... Args>
- decltype(auto) operator()(Args&&... args) const {
- return invoke<fx>(std::forward<Args>(args)...);
- }
- };
- };
-
- template <typename F, typename R, typename O, typename... FArgs>
- struct member_function_wrapper {
- typedef O object_type;
- typedef lua_bind_traits<F> traits_type;
- typedef typename traits_type::args_list args_list;
- typedef types<object_type&, FArgs...> free_args_list;
- typedef meta::tuple_types<R> returns_list;
-
- template <F fx, typename... Args>
- static R invoke(O& mem, Args&&... args) {
- return (mem.*fx)(std::forward<Args>(args)...);
- }
-
- template <typename Fx, typename... Args>
- static R call(Fx&& fx, O& mem, Args&&... args) {
- return (mem.*fx)(std::forward<Args>(args)...);
- }
-
- struct caller {
- template <typename Fx, typename... Args>
- decltype(auto) operator()(Fx&& fx, O& mem, Args&&... args) const {
- return call(std::forward<Fx>(fx), mem, std::forward<Args>(args)...);
- }
- };
-
- template <F fx>
- struct invoker {
- template <typename... Args>
- decltype(auto) operator()(O& mem, Args&&... args) const {
- return invoke<fx>(mem, std::forward<Args>(args)...);
- }
- };
- };
-
- template <typename R, typename O, typename... Args>
- struct wrapper<R(O:: *)(Args...)> : public member_function_wrapper<R(O:: *)(Args...), R, O, Args...> {
-
- };
-
- template <typename R, typename O, typename... Args>
- struct wrapper<R(O:: *)(Args...) const> : public member_function_wrapper<R(O:: *)(Args...) const, R, O, Args...> {
-
- };
-
- template <typename R, typename O, typename... Args>
- struct wrapper<R(O:: *)(Args...) const volatile> : public member_function_wrapper<R(O:: *)(Args...) const volatile, R, O, Args...> {
-
- };
-
- template <typename R, typename O, typename... Args>
- struct wrapper<R(O:: *)(Args...) &> : public member_function_wrapper<R(O:: *)(Args...) &, R, O, Args...> {
-
- };
-
- template <typename R, typename O, typename... Args>
- struct wrapper<R(O:: *)(Args...) const &> : public member_function_wrapper<R(O:: *)(Args...) const &, R, O, Args...> {
-
- };
-
- template <typename R, typename O, typename... Args>
- struct wrapper<R(O:: *)(Args...) const volatile &> : public member_function_wrapper<R(O:: *)(Args...) const volatile &, R, O, Args...> {
-
- };
-
- template <typename R, typename O, typename... Args>
- struct wrapper<R(O:: *)(Args..., ...) &> : public member_function_wrapper<R(O:: *)(Args..., ...) &, R, O, Args...> {
-
- };
-
- template <typename R, typename O, typename... Args>
- struct wrapper<R(O:: *)(Args..., ...) const &> : public member_function_wrapper<R(O:: *)(Args..., ...) const &, R, O, Args...> {
-
- };
-
- template <typename R, typename O, typename... Args>
- struct wrapper<R(O:: *)(Args..., ...) const volatile &> : public member_function_wrapper<R(O:: *)(Args..., ...) const volatile &, R, O, Args...> {
-
- };
-
- template <typename R, typename O, typename... Args>
- struct wrapper<R(O:: *)(Args...) && > : public member_function_wrapper<R(O:: *)(Args...) &, R, O, Args...> {
-
- };
-
- template <typename R, typename O, typename... Args>
- struct wrapper<R(O:: *)(Args...) const &&> : public member_function_wrapper<R(O:: *)(Args...) const &, R, O, Args...> {
-
- };
-
- template <typename R, typename O, typename... Args>
- struct wrapper<R(O:: *)(Args...) const volatile &&> : public member_function_wrapper<R(O:: *)(Args...) const volatile &, R, O, Args...> {
-
- };
-
- template <typename R, typename O, typename... Args>
- struct wrapper<R(O:: *)(Args..., ...) && > : public member_function_wrapper<R(O:: *)(Args..., ...) &, R, O, Args...> {
-
- };
-
- template <typename R, typename O, typename... Args>
- struct wrapper<R(O:: *)(Args..., ...) const &&> : public member_function_wrapper<R(O:: *)(Args..., ...) const &, R, O, Args...> {
-
- };
-
- template <typename R, typename O, typename... Args>
- struct wrapper<R(O:: *)(Args..., ...) const volatile &&> : public member_function_wrapper<R(O:: *)(Args..., ...) const volatile &, R, O, Args...> {
-
- };
-
-} // sol
-
-#endif // SOL_WRAPPER_HPP