mirror
/
openmw
mirror of https://github.com/OpenMW/openmw.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Update sol. Replace combined sol.hpp with loose files.

Browse Source
openmw-fix_osx_build_maybe
Petr Mikheev 3 years ago
parent d16fa553c8
commit 7cd4222647
115 changed files with 32108 additions and 26678 deletions
Show Stats Download Patch File Download Diff File

2
CMakeLists.txt
Unescape Escape View File

@ -449,7 +449,7 @@ else(USE_LUAJIT)
endif(USE_LUAJIT)
# C++ library binding to Lua
set(SOL_INCLUDE_DIR ${OpenMW_SOURCE_DIR}/extern/sol3.2.2)
set(SOL_INCLUDE_DIR ${OpenMW_SOURCE_DIR}/extern/sol3)
set(SOL_CONFIG_DIR ${OpenMW_SOURCE_DIR}/extern/sol_config)
include_directories(

3
extern/sol3.2.2/README.md vendored
Unescape Escape View File

@ -1,3 +0,0 @@
sol/sol.hpp is downloaded from https://github.com/ThePhD/sol2/releases/download/v3.2.2/sol.hpp
License: MIT

26674
extern/sol3.2.2/sol/sol.hpp vendored
View File

File diff suppressed because it is too large Load Diff

3
extern/sol3/README.md vendored
Unescape Escape View File

@ -0,0 +1,3 @@
The code in this directory is copied from https://github.com/ThePhD/sol2.git (64096348465b980e2f1d0e5ba9cbeea8782e8f27)
License: MIT

54
extern/sol3/sol/as_args.hpp vendored
Unescape Escape View File

@ -0,0 +1,54 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 Spermission 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_AS_ARGS_HPP
#define SOL_AS_ARGS_HPP
#include <sol/stack.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
#endif // SOL_AS_ARGS_HPP

62
extern/sol3/sol/as_returns.hpp vendored
Unescape Escape View File

@ -0,0 +1,62 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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_AS_RETURNS_HPP
#define SOL_AS_RETURNS_HPP
#include <sol/traits.hpp>
#include <sol/stack.hpp>
#include <sol/ebco.hpp>
namespace sol {
template <typename T>
struct as_returns_t : private detail::ebco<T> {
private:
using base_t = detail::ebco<T>;
public:
using base_t::base_t;
using base_t::value;
};
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.value());
int p = 0;
for (const auto& i : src) {
p += stack::push(L, i);
}
return p;
}
};
} // namespace stack
} // namespace sol
#endif // SOL_AS_RETURNS_HPP

99
extern/sol3/sol/assert.hpp vendored
Unescape Escape View File

@ -0,0 +1,99 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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.
#pragma once
#ifndef SOL_ASSERT_HPP
#define SOL_ASSERT_HPP
#include <sol/forward.hpp>
#if SOL_IS_ON(SOL2_CI_I_)
struct pre_main {
pre_main() {
#ifdef _MSC_VER
_set_abort_behavior(0, _WRITE_ABORT_MSG);
#endif
}
} inline sol2_ci_dont_lock_ci_please = {};
#endif // Prevent lockup when doing Continuous Integration
// clang-format off
#if SOL_IS_ON(SOL_USER_C_ASSERT_I_)
#define sol_c_assert(...) SOL_C_ASSERT(__VA_ARGS__)
#else
#if SOL_IS_ON(SOL_DEBUG_BUILD_I_)
#include <exception>
#include <iostream>
#include <cstdlib>
#define sol_c_assert(...) \
do { \
if (!(__VA_ARGS__)) { \
std::cerr << "Assertion `" #__VA_ARGS__ "` failed in " << __FILE__ << " line " << __LINE__ << std::endl; \
std::terminate(); \
} \
} while (false)
#else
#define sol_c_assert(...) \
do { \
if (false) { \
(void)(__VA_ARGS__); \
} \
} while (false)
#endif
#endif
#if SOL_IS_ON(SOL_USER_M_ASSERT_I_)
#define sol_m_assert(message, ...) SOL_M_ASSERT(message, __VA_ARGS__)
#else
#if SOL_IS_ON(SOL_DEBUG_BUILD_I_)
#include <exception>
#include <iostream>
#include <cstdlib>
#define sol_m_assert(message, ...) \
do { \
if (!(__VA_ARGS__)) { \
std::cerr << "Assertion `" #__VA_ARGS__ "` failed in " << __FILE__ << " line " << __LINE__ << ": " << message << std::endl; \
std::terminate(); \
} \
} while (false)
#else
#define sol_m_assert(message, ...) \
do { \
if (false) { \
(void)(__VA_ARGS__); \
(void)sizeof(message); \
} \
} while (false)
#endif
#endif
// clang-format on
#endif // SOL_ASSERT_HPP

123
extern/sol3/sol/base_traits.hpp vendored
Unescape Escape View File

@ -0,0 +1,123 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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_BASE_TRAITS_HPP
#define 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...>
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_detail {
template <typename T, typename = void>
struct has_internal_marker_impl : std::false_type { };
template <typename T>
struct has_internal_marker_impl<T, void_t<typename T::SOL_INTERNAL_UNSPECIALIZED_MARKER_>> : 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 meta_detail
} // namespace meta
} // namespace sol
#endif // SOL_BASE_TRAITS_HPP

553
extern/sol3/sol/bind_traits.hpp vendored
Unescape Escape View File

@ -0,0 +1,553 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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_BIND_TRAITS_HPP
#define SOL_BIND_TRAITS_HPP
#include <sol/forward.hpp>
#include <sol/base_traits.hpp>
#include <sol/tuple.hpp>
namespace sol { namespace meta {
namespace meta_detail {
template <typename F>
using detect_deducible_signature = decltype(&F::operator(), void());
} // namespace meta_detail
template <typename F>
using call_operator_deducible = typename is_detected<meta_detail::detect_deducible_signature, F>::type;
template <typename F>
constexpr inline bool call_operator_deducible_v = call_operator_deducible<F>::value;
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 = call_operator_deducible<Signature>::value>
struct fx_traits : public basic_traits<false, false, void, void> { };
// Free Functions
template <typename R, typename... Args>
struct fx_traits<R(Args...), false> : public basic_traits<false, false, void, R, Args...> {
typedef R (*function_pointer_type)(Args...);
};
template <typename R, typename... Args>
struct fx_traits<R (*)(Args...), false> : public basic_traits<false, false, void, R, Args...> {
typedef R (*function_pointer_type)(Args...);
};
template <typename R, typename... Args>
struct fx_traits<R(Args..., ...), false> : public basic_traits<false, true, void, R, Args...> {
typedef R (*function_pointer_type)(Args..., ...);
};
template <typename R, typename... Args>
struct fx_traits<R (*)(Args..., ...), false> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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> : public 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>
using bind_traits = meta_detail::callable_traits<Signature>;
namespace meta_detail {
template <typename, bool>
struct is_probably_stateless_lambda : std::false_type { };
template <typename T>
struct is_probably_stateless_lambda<T, true> : std::is_convertible<T, typename bind_traits<T>::function_type*>::type { };
} // namespace meta_detail
template <typename T>
using is_probably_stateless_lambda = typename meta_detail::is_probably_stateless_lambda<T, std::is_empty_v<T> && call_operator_deducible_v<T>>::type;
template <typename T>
inline constexpr bool is_probably_stateless_lambda_v = is_probably_stateless_lambda<T>::value;
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
#endif // SOL_BIND_TRAITS_HPP

121
extern/sol3/sol/bytecode.hpp vendored
Unescape Escape View File

@ -0,0 +1,121 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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_BYTECODE_HPP
#define SOL_BYTECODE_HPP
#include <sol/compatibility.hpp>
#include <sol/string_view.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_pointer) {
using storage_t = Container;
const std::byte* p_code = static_cast<const std::byte*>(memory);
storage_t& bc = *static_cast<storage_t*>(userdata_pointer);
#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
#endif // SOL_BYTECODE_HPP

961
extern/sol3/sol/call.hpp vendored
Unescape Escape View File

@ -0,0 +1,961 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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.
#pragma once
#ifndef SOL_CALL_HPP
#define SOL_CALL_HPP
#include <sol/property.hpp>
#include <sol/protect.hpp>
#include <sol/wrapper.hpp>
#include <sol/trampoline.hpp>
#include <sol/policies.hpp>
#include <sol/stack.hpp>
#include <sol/unique_usertype_traits.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_;
reference* obj_lua_ref_;
stack::stack_detail::undefined_metatable* p_umf_;
constructor_match(T* obj_ptr, reference& obj_lua_ref, stack::stack_detail::undefined_metatable& umf)
: obj_(obj_ptr), obj_lua_ref_(&obj_lua_ref), p_umf_(&umf) {
}
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 {};
int result = stack::call_into_lua<checked, clean_stack>(r, a, L, start, func, this->obj_);
// construct userdata table
// SPECIFICALLY, after we've created it successfully.
// If the constructor exits for any reason we have to break things down...
if constexpr (clean_stack) {
obj_lua_ref_->push();
(*this->p_umf_)();
obj_lua_ref_->pop();
}
else {
(*this->p_umf_)();
}
return result;
}
};
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>);
// put userdata at the first index
lua_insert(L, 1);
construct_match<T, TypeLists...>(constructor_match<T, checked, clean_stack>(obj, userdataref, umf), 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>);
// put userdata at the first index
lua_insert(L, 1);
// Because of the way constructors work,
// we have to kill the data, but only if the cosntructor is successfulyl invoked...
// if it's not successfully invoked and we panic,
// we cannot actually deallcoate/delete the data.
construct_match<T, Args...>(
constructor_match<T, checked, clean_stack>(obj, userdataref, umf), 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_destroy<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>(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
#endif // SOL_CALL_HPP

51
extern/sol3/sol/compatibility.hpp vendored
Unescape Escape View File

@ -0,0 +1,51 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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.3
// but has been modified in many places for use with sol and luajit,
// though the core abstractions remain the same
#include <sol/version.hpp>
#include <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
#include <sol/compatibility/compat-5.3.h>
#include <sol/compatibility/compat-5.4.h>
#endif
#endif // SOL_COMPATIBILITY_HPP

900
extern/sol3/sol/compatibility/compat-5.3.c.h vendored
Unescape Escape View File

@ -0,0 +1,900 @@
#include <sol/compatibility/compat-5.3.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);
}
COMPAT53_API void lua_arith(lua_State* L, int op) {
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";
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);
}
COMPAT53_API int lua_compare(lua_State* L, int idx1, int idx2, int op) {
static const char compat53_compare_code[]
= "local a,b=...\n"
"return a<=b\n";
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");
#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 504
newptr = (char*)lua_newuserdatauv(B->L2, newcap, 0);
#else
newptr = (char*)lua_newuserdata(B->L2, newcap);
#endif
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.
*********************************************************************/

424
extern/sol3/sol/compatibility/compat-5.3.h vendored
Unescape Escape View File

@ -0,0 +1,424 @@
#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
# include "compat-5.3.c.h"
#endif
#endif /* KEPLER_PROJECT_COMPAT53_H_ */

25
extern/sol3/sol/compatibility/compat-5.4.h vendored
Unescape Escape View File

@ -0,0 +1,25 @@
#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_

218
extern/sol3/sol/compatibility/lua_version.hpp vendored
Unescape Escape View File

@ -0,0 +1,218 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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_VERSION_HPP
#define SOL_COMPATIBILITY_VERSION_HPP
#include <sol/version.hpp>
// clang-format off
#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_ON
#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(SOL_LUAJIT_FFI_DISABLED)
#define SOL_LUAJIT_FFI_DISABLED_I_ SOL_ON
#elif defined(LUAJIT_DISABLE_FFI)
#define SOL_LUAJIT_FFI_DISABLED_I_ SOL_ON
#else
#define SOL_LUAJIT_FFI_DISABLED_I_ SOL_DEFAULT_OFF
#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_VERSION_I_ SOL_LUA_VERSION
#else
#define SOL_LUA_VERSION_I_ 504
#endif
// Exception safety / propagation, according to Lua information
// and user defines. Note this can sometimes change based on version information...
#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
// Some configurations work with exceptions,
// but cannot catch-all everything...
#if defined(SOL_EXCEPTIONS_CATCH_ALL)
#if (SOL_EXCEPTIONS_CATCH_ALL != 0)
#define SOL_EXCEPTIONS_CATCH_ALL_I_ SOL_ON
#else
#define SOL_EXCEPTIONS_CATCH_ALL_I_ SOL_OFF
#endif
#else
#if SOL_IS_ON(SOL_USE_LUAJIT_I_)
#define SOL_EXCEPTIONS_CATCH_ALL_I_ SOL_DEFAULT_OFF
#elif SOL_IS_ON(SOL_USE_CXX_LUAJIT_I_)
#define SOL_EXCEPTIONS_CATCH_ALL_I_ SOL_DEFAULT_OFF
#elif SOL_IS_ON(SOL_USE_CXX_LUA_I_)
#define SOL_EXCEPTIONS_CATCH_ALL_I_ SOL_DEFAULT_OFF
#else
#define SOL_EXCEPTIONS_CATCH_ALL_I_ SOL_DEFAULT_ON
#endif
#endif
#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
#if defined (SOL_LUA_BIT32_LIB)
#if SOL_LUA_BIT32_LIB != 0
#define SOL_LUA_BIT32_LIB_I_ SOL_ON
#else
#define SOL_LUA_BIT32_LIB_I_ SOL_OFF
#endif
#else
// Lua 5.2 only (deprecated in 5.3 (503)) (Can be turned on with Compat flags)
// Lua 5.2, or other versions of Lua with the compat flag, or Lua that is not 5.2 with the specific define (5.4.1 either removed it entirely or broke it)
#if (SOL_LUA_VERSION_I_ == 502) || (defined(LUA_COMPAT_BITLIB) && (LUA_COMPAT_BITLIB != 0)) || (SOL_LUA_VERSION_I_ < 504 && (defined(LUA_COMPAT_5_2) && (LUA_COMPAT_5_2 != 0)))
#define SOL_LUA_BIT32_LIB_I_ SOL_ON
#else
#define SOL_LUA_BIT32_LIB_I_ SOL_DEFAULT_OFF
#endif
#endif
#if defined (SOL_LUA_NIL_IN_TABLES)
#if SOL_LUA_NIL_IN_TABLES != 0
#define SOL_LUA_NIL_IN_TABLES_I_ SOL_ON
#else
#define SOL_LUA_NIL_IN_TABLES_I_ SOL_OFF
#endif
#else
#if defined(LUA_NILINTABLE) && (LUA_NILINTABLE != 0)
#define SOL_LUA_NIL_IN_TABLES_I_ SOL_DEFAULT_ON
#else
#define SOL_LUA_NIL_IN_TABLES_I_ SOL_DEFAULT_OFF
#endif
#endif
// clang-format on
#endif // SOL_COMPATIBILITY_VERSION_HPP

251
extern/sol3/sol/coroutine.hpp vendored
Unescape Escape View File

@ -0,0 +1,251 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/reference.hpp>
#include <sol/object.hpp>
#include <sol/stack.hpp>
#include <sol/function_result.hpp>
#include <sol/thread.hpp>
#include <sol/protected_handler.hpp>
namespace sol {
template <typename Reference>
class basic_coroutine : public basic_object<Reference> {
private:
using base_t = basic_object<Reference>;
using handler_t = reference;
private:
call_status stats = call_status::yielded;
void luacall(std::ptrdiff_t argcount, std::ptrdiff_t) {
#if SOL_LUA_VERSION_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 (m_error_handler.valid()) {
string_view err = stack::get<string_view>(this->lua_state(), poststacksize);
m_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)), m_error_handler(detail::get_default_handler<reference, is_main_threaded<base_t>::value>(r.lua_state())) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
if (!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& other) = default;
basic_coroutine& operator=(const basic_coroutine&) = default;
basic_coroutine(basic_coroutine&& other) noexcept : base_t(std::move(other)), m_error_handler(this->lua_state(), std::move(other.m_error_handler)) {
}
basic_coroutine& operator=(basic_coroutine&& other) noexcept {
base_t::operator=(std::move(other));
// must change the state, since it could change on the coroutine type
m_error_handler = handler_t(this->lua_state(), std::move(other.m_error_handler));
return *this;
}
basic_coroutine(const basic_function<base_t>& b) noexcept
: basic_coroutine(b, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(b.lua_state())) {
}
basic_coroutine(basic_function<base_t>&& b) noexcept
: 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) noexcept : base_t(b), m_error_handler(std::move(eh)) {
}
basic_coroutine(basic_function<base_t>&& b, handler_t eh) noexcept : base_t(std::move(b)), m_error_handler(std::move(eh)) {
}
basic_coroutine(const stack_reference& r) noexcept
: 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) noexcept
: 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) noexcept : basic_coroutine(r.lua_state(), r.stack_index(), std::move(eh)) {
}
basic_coroutine(stack_reference&& r, handler_t eh) noexcept : 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 HandlerReference,
meta::enable<std::is_base_of<proxy_base_tag, meta::unqualified_t<Proxy>>,
meta::neg<is_lua_index<meta::unqualified_t<HandlerReference>>>> = meta::enabler>
basic_coroutine(Proxy&& p, HandlerReference&& eh) : basic_coroutine(detail::force_cast<base_t>(p), std::forward<HandlerReference>(eh)) {
}
template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
basic_coroutine(lua_State* L, T&& r) noexcept
: 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)), m_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), m_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), m_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), m_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), m_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), m_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);
}
private:
handler_t m_error_handler;
};
} // namespace sol
#endif // SOL_COUROUTINE_HPP

52
extern/sol3/sol/debug.hpp vendored
Unescape Escape View File

@ -0,0 +1,52 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/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;
}
}}} // namespace sol::detail::debug
#endif // SOL_DEBUG_HPP

192
extern/sol3/sol/demangle.hpp vendored
Unescape Escape View File

@ -0,0 +1,192 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/string_view.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::size_t idx = 0;
for (idx = static_cast<std::size_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::size_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
#endif // SOL_DEMANGLE_HPP

44
extern/sol3/sol/deprecate.hpp vendored
Unescape Escape View File

@ -0,0 +1,44 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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;
};
}} // namespace sol::detail
#endif // SOL_DEPRECATE_HPP

232
extern/sol3/sol/detail/build_version.hpp vendored
Unescape Escape View File

@ -0,0 +1,232 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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.
#pragma once
#ifndef SOL_DETAIL_BUILD_VERSION_HPP
#define SOL_DETAIL_BUILD_VERSION_HPP
#include <sol/version.hpp>
// clang-format off
#if defined(SOL_DLL)
#if (SOL_DLL != 0)
#define SOL_DLL_I_ SOL_ON
#else
#define SOL_DLL_I_ SOL_OFF
#endif
#elif SOL_IS_ON(SOL_COMPILER_VCXX_I_) && (defined(DLL_) || defined(_DLL))
#define SOL_DLL_I_ SOL_DEFAULT_ON
#else
#define SOL_DLL_I_ SOL_DEFAULT_OFF
#endif // DLL definition
#if defined(SOL_HEADER_ONLY)
#if (SOL_HEADER_ONLY != 0)
#define SOL_HEADER_ONLY_I_ SOL_ON
#else
#define SOL_HEADER_ONLY_I_ SOL_OFF
#endif
#else
#define SOL_HEADER_ONLY_I_ SOL_DEFAULT_OFF
#endif // Header only library
#if defined(SOL_BUILD)
#if (SOL_BUILD != 0)
#define SOL_BUILD_I_ SOL_ON
#else
#define SOL_BUILD_I_ SOL_OFF
#endif
#elif SOL_IS_ON(SOL_HEADER_ONLY_I_)
#define SOL_BUILD_I_ SOL_DEFAULT_OFF
#else
#define SOL_BUILD_I_ SOL_DEFAULT_ON
#endif
#if defined(SOL_UNITY_BUILD)
#if (SOL_UNITY_BUILD != 0)
#define SOL_UNITY_BUILD_I_ SOL_ON
#else
#define SOL_UNITY_BUILD_I_ SOL_OFF
#endif
#else
#define SOL_UNITY_BUILD_I_ SOL_DEFAULT_OFF
#endif // Header only library
#if defined(SOL_C_FUNCTION_LINKAGE)
#define SOL_C_FUNCTION_LINKAGE_I_ SOL_C_FUNCTION_LINKAGE
#else
#if SOL_IS_ON(SOL_BUILD_CXX_MODE_I_)
// C++
#define SOL_C_FUNCTION_LINKAGE_I_ extern "C"
#else
// normal
#define SOL_C_FUNCTION_LINKAGE_I_
#endif // C++ or not
#endif // Linkage specification for C functions
#if defined(SOL_API_LINKAGE)
#define SOL_API_LINKAGE_I_ SOL_API_LINKAGE
#else
#if SOL_IS_ON(SOL_DLL_I_)
#if SOL_IS_ON(SOL_COMPILER_VCXX_I_) || SOL_IS_ON(SOL_PLATFORM_WINDOWS_I_) || SOL_IS_ON(SOL_PLATFORM_CYGWIN_I_)
// MSVC Compiler; or, Windows, or Cygwin platforms
#if SOL_IS_ON(SOL_BUILD_I_)
// Building the library
#if SOL_IS_ON(SOL_COMPILER_GCC_I_)
// Using GCC
#define SOL_API_LINKAGE_I_ __attribute__((dllexport))
#else
// Using Clang, MSVC, etc...
#define SOL_API_LINKAGE_I_ __declspec(dllexport)
#endif
#else
#if SOL_IS_ON(SOL_COMPILER_GCC_I_)
#define SOL_API_LINKAGE_I_ __attribute__((dllimport))
#else
#define SOL_API_LINKAGE_I_ __declspec(dllimport)
#endif
#endif
#else
// extern if building normally on non-MSVC
#define SOL_API_LINKAGE_I_ extern
#endif
#elif SOL_IS_ON(SOL_UNITY_BUILD_I_)
// Built-in library, like how stb typical works
#if SOL_IS_ON(SOL_HEADER_ONLY_I_)
// Header only, so functions are defined "inline"
#define SOL_API_LINKAGE_I_ inline
#else
// Not header only, so seperately compiled files
#define SOL_API_LINKAGE_I_ extern
#endif
#else
// Normal static library
#if SOL_IS_ON(SOL_BUILD_CXX_MODE_I_)
#define SOL_API_LINKAGE_I_
#else
#define SOL_API_LINKAGE_I_ extern
#endif
#endif // DLL or not
#endif // Build definitions
#if defined(SOL_PUBLIC_FUNC_DECL)
#define SOL_PUBLIC_FUNC_DECL_I_ SOL_PUBLIC_FUNC_DECL
#else
#define SOL_PUBLIC_FUNC_DECL_I_ SOL_API_LINKAGE_I_
#endif
#if defined(SOL_INTERNAL_FUNC_DECL_)
#define SOL_INTERNAL_FUNC_DECL_I_ SOL_INTERNAL_FUNC_DECL_
#else
#define SOL_INTERNAL_FUNC_DECL_I_ SOL_API_LINKAGE_I_
#endif
#if defined(SOL_PUBLIC_FUNC_DEF)
#define SOL_PUBLIC_FUNC_DEF_I_ SOL_PUBLIC_FUNC_DEF
#else
#define SOL_PUBLIC_FUNC_DEF_I_ SOL_API_LINKAGE_I_
#endif
#if defined(SOL_INTERNAL_FUNC_DEF)
#define SOL_INTERNAL_FUNC_DEF_I_ SOL_INTERNAL_FUNC_DEF
#else
#define SOL_INTERNAL_FUNC_DEF_I_ SOL_API_LINKAGE_I_
#endif
#if defined(SOL_FUNC_DECL)
#define SOL_FUNC_DECL_I_ SOL_FUNC_DECL
#elif SOL_IS_ON(SOL_HEADER_ONLY_I_)
#define SOL_FUNC_DECL_I_
#elif SOL_IS_ON(SOL_DLL_I_)
#if SOL_IS_ON(SOL_COMPILER_VCXX_I_)
#if SOL_IS_ON(SOL_BUILD_I_)
#define SOL_FUNC_DECL_I_ extern __declspec(dllexport)
#else
#define SOL_FUNC_DECL_I_ extern __declspec(dllimport)
#endif
#elif SOL_IS_ON(SOL_COMPILER_GCC_I_) || SOL_IS_ON(SOL_COMPILER_CLANG_I_)
#define SOL_FUNC_DECL_I_ extern __attribute__((visibility("default")))
#else
#define SOL_FUNC_DECL_I_ extern
#endif
#endif
#if defined(SOL_FUNC_DEFN)
#define SOL_FUNC_DEFN_I_ SOL_FUNC_DEFN
#elif SOL_IS_ON(SOL_HEADER_ONLY_I_)
#define SOL_FUNC_DEFN_I_ inline
#elif SOL_IS_ON(SOL_DLL_I_)
#if SOL_IS_ON(SOL_COMPILER_VCXX_I_)
#if SOL_IS_ON(SOL_BUILD_I_)
#define SOL_FUNC_DEFN_I_ __declspec(dllexport)
#else
#define SOL_FUNC_DEFN_I_ __declspec(dllimport)
#endif
#elif SOL_IS_ON(SOL_COMPILER_GCC_I_) || SOL_IS_ON(SOL_COMPILER_CLANG_I_)
#define SOL_FUNC_DEFN_I_ __attribute__((visibility("default")))
#else
#define SOL_FUNC_DEFN_I_
#endif
#endif
#if defined(SOL_HIDDEN_FUNC_DECL)
#define SOL_HIDDEN_FUNC_DECL_I_ SOL_HIDDEN_FUNC_DECL
#elif SOL_IS_ON(SOL_HEADER_ONLY_I_)
#define SOL_HIDDEN_FUNC_DECL_I_
#elif SOL_IS_ON(SOL_DLL_I_)
#if SOL_IS_ON(SOL_COMPILER_VCXX_I_)
#if SOL_IS_ON(SOL_BUILD_I_)
#define SOL_HIDDEN_FUNC_DECL_I_ extern __declspec(dllexport)
#else
#define SOL_HIDDEN_FUNC_DECL_I_ extern __declspec(dllimport)
#endif
#elif SOL_IS_ON(SOL_COMPILER_GCC_I_) || SOL_IS_ON(SOL_COMPILER_CLANG_I_)
#define SOL_HIDDEN_FUNC_DECL_I_ extern __attribute__((visibility("default")))
#else
#define SOL_HIDDEN_FUNC_DECL_I_ extern
#endif
#endif
#if defined(SOL_HIDDEN_FUNC_DEFN)
#define SOL_HIDDEN_FUNC_DEFN_I_ SOL_HIDDEN_FUNC_DEFN
#elif SOL_IS_ON(SOL_HEADER_ONLY_I_)
#define SOL_HIDDEN_FUNC_DEFN_I_ inline
#elif SOL_IS_ON(SOL_DLL_I_)
#if SOL_IS_ON(SOL_COMPILER_VCXX_I_)
#if SOL_IS_ON(SOL_BUILD_I_)
#define SOL_HIDDEN_FUNC_DEFN_I_
#else
#define SOL_HIDDEN_FUNC_DEFN_I_
#endif
#elif SOL_IS_ON(SOL_COMPILER_GCC_I_) || SOL_IS_ON(SOL_COMPILER_CLANG_I_)
#define SOL_HIDDEN_FUNC_DEFN_I_ __attribute__((visibility("hidden")))
#else
#define SOL_HIDDEN_FUNC_DEFN_I_
#endif
#endif
// clang-format on
#endif // SOL_DETAIL_BUILD_VERSION_HPP

77
extern/sol3/sol/dump_handler.hpp vendored
Unescape Escape View File

@ -0,0 +1,77 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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_DUMP_HANDLER_HPP
#define SOL_DUMP_HANDLER_HPP
#include <sol/compatibility.hpp>
#include <cstdint>
#include <exception>
namespace sol {
class dump_error : public error {
private:
int m_ec;
public:
dump_error(int error_code_) : error("dump returned non-zero error of " + std::to_string(error_code_)), m_ec(error_code_) {
}
int error_code() const {
return m_ec;
}
};
inline int dump_pass_on_error(lua_State* L_, int result_code, lua_Writer writer_function, void* userdata_pointer_, bool strip) {
(void)L_;
(void)writer_function;
(void)userdata_pointer_;
(void)strip;
return result_code;
}
inline int dump_panic_on_error(lua_State* L_, int result_code, lua_Writer writer_function, void* userdata_pointer_, bool strip) {
(void)L_;
(void)writer_function;
(void)userdata_pointer_;
(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_pointer_, bool strip) {
#if SOL_IS_OFF(SOL_EXCEPTIONS_I_)
return dump_panic_on_error(L_, result_code, writer_function, userdata_pointer_, strip);
#else
(void)L_;
(void)writer_function;
(void)userdata_pointer_;
(void)strip;
throw dump_error(result_code);
#endif // no exceptions stuff
}
} // namespace sol
#endif // SOL_DUMP_HANDLER_HPP

160
extern/sol3/sol/ebco.hpp vendored
Unescape Escape View File

@ -0,0 +1,160 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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_EBCO_HPP
#define 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 m_value;
ebco() = default;
ebco(const ebco&) = default;
ebco(ebco&&) = default;
ebco& operator=(const ebco&) = default;
ebco& operator=(ebco&&) = default;
ebco(const T& v) noexcept(std::is_nothrow_copy_constructible_v<T>) : m_value(v) {};
ebco(T&& v) noexcept(std::is_nothrow_move_constructible_v<T>) : m_value(std::move(v)) {};
ebco& operator=(const T& v) noexcept(std::is_nothrow_copy_assignable_v<T>) {
m_value = v;
return *this;
}
ebco& operator=(T&& v) noexcept(std::is_nothrow_move_assignable_v<T>) {
m_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> && (sizeof...(Args) > 0 || !std::is_convertible_v<Arg, T>)>>
ebco(Arg&& arg, Args&&... args) noexcept(std::is_nothrow_constructible_v<T, Arg, Args...>)
: m_value(std::forward<Arg>(arg), std::forward<Args>(args)...) {
}
T& value() & noexcept {
return m_value;
}
T const& value() const& noexcept {
return m_value;
}
T&& value() && noexcept {
return std::move(m_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) noexcept(std::is_nothrow_copy_constructible_v<T>) : T(v) {};
ebco(T&& v) noexcept(std::is_nothrow_move_constructible_v<T>) : 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> && (sizeof...(Args) > 0 || !std::is_convertible_v<Arg, T>)>>
ebco(Arg&& arg, Args&&... args) noexcept(std::is_nothrow_constructible_v<T, Arg, Args...>) : T(std::forward<Arg>(arg), std::forward<Args>(args)...) {
}
ebco& operator=(const ebco&) = default;
ebco& operator=(ebco&&) = default;
ebco& operator=(const T& v) noexcept(std::is_nothrow_copy_assignable_v<T>) {
static_cast<T&>(*this) = v;
return *this;
}
ebco& operator=(T&& v) noexcept(std::is_nothrow_move_assignable_v<T>) {
static_cast<T&>(*this) = std::move(v);
return *this;
};
T& value() & noexcept {
return static_cast<T&>(*this);
}
T const& value() const& noexcept {
return static_cast<T const&>(*this);
}
T&& value() && noexcept {
return std::move(static_cast<T&>(*this));
}
};
template <typename T, std::size_t tag>
struct ebco<T&, tag> {
private:
T* m_ref;
public:
ebco() = default;
ebco(const ebco&) = default;
ebco(ebco&&) = default;
ebco(T& v) noexcept : m_ref(std::addressof(v)) {};
ebco& operator=(const ebco&) = default;
ebco& operator=(ebco&&) = default;
ebco& operator=(T& v) noexcept {
m_ref = std::addressof(v);
return *this;
}
T& value() const noexcept {
return *(const_cast<ebco<T&, tag>&>(*this).m_ref);
}
};
template <typename T, std::size_t tag>
struct ebco<T&&, tag> {
T&& ref;
ebco() = default;
ebco(const ebco&) = delete;
ebco(ebco&&) = default;
ebco(T&& v) noexcept : ref(v) {};
ebco& operator=(const ebco&) = delete;
ebco& operator=(ebco&&) = delete;
T& value() & noexcept {
return ref;
}
const T& value() const& noexcept {
return ref;
}
T&& value() && noexcept {
return std::move(ref);
}
};
}} // namespace sol::detail
#endif // SOL_EBCO_HPP

261
extern/sol3/sol/environment.hpp vendored
Unescape Escape View File

@ -0,0 +1,261 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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_ENVIRONMENT_HPP
#define SOL_ENVIRONMENT_HPP
#include <sol/table.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>
bool set_on(const T& target) const {
lua_State* L = target.lua_state();
auto pp = stack::push_pop(target);
int target_index = pp.index_of(target);
#if SOL_LUA_VERSION_I_ < 502
// Use lua_setfenv
this->push();
int success_result = lua_setfenv(L, target_index);
return success_result != 0;
#else
// If this is a C function, the environment is always placed in
// the first value, as is expected of sol2 (all upvalues have an empty name, "")
if (lua_iscfunction(L, target_index) != 0) {
const char* maybe_upvalue_name = lua_getupvalue(L, target_index, 1);
if (maybe_upvalue_name == nullptr) {
return false;
}
string_view upvalue_name(maybe_upvalue_name);
if (upvalue_name == "") {
this->push();
const char* success = lua_setupvalue(L, target_index, 1);
if (success == nullptr) {
// left things alone on the stack, pop them off
lua_pop(L, 1);
return false;
}
return true;
}
return false;
}
else {
// Must search for the right upvalue target on index
for (int upvalue_index = 1;; ++upvalue_index) {
const char* maybe_upvalue_name = lua_getupvalue(L, target_index, upvalue_index);
if (maybe_upvalue_name == nullptr) {
break;
}
string_view upvalue_name(maybe_upvalue_name);
if (upvalue_name == "_ENV") {
this->push();
const char* success = lua_setupvalue(L, target_index, upvalue_index);
if (success == nullptr) {
// left things alone on the stack, pop them off
lua_pop(L, 1);
break;
}
// whether or not we succeeded, we found _ENV
// so we need to break
return true;
}
lua_pop(L, 1);
}
// if we get here,
// we did not find an _ENV here...
return false;
}
#endif
}
};
template <typename T, typename E>
bool set_environment(const basic_environment<E>& env, const T& target) {
return 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
#endif // SOL_ENVIRONMENT_HPP

39
extern/sol3/sol/epilogue.hpp vendored
Unescape Escape View File

@ -0,0 +1,39 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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.
#pragma once
// clang-format off
#if !defined(SOL_PROLOGUE_I_)
#error "[sol2] Library Prologue is missing from this translation unit."
#else
#undef SOL_PROLOGUE_I_
#endif
#if SOL_IS_ON(SOL_BUILD_CXX_MODE_I_)
#undef _FWD
#undef _MOVE
#endif
// clang-format on

89
extern/sol3/sol/error.hpp vendored
Unescape Escape View File

@ -0,0 +1,89 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/compatibility.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> argument_strings;
error_result() : results(0), format_string(nullptr) {
}
error_result(int results_) : results(results_), format_string(nullptr) {
}
error_result(const char* format_string_, const char* first_message_) : results(0), format_string(format_string_), argument_strings() {
argument_strings[0] = first_message_;
}
};
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.argument_strings[0], er.argument_strings[1], er.argument_strings[2], er.argument_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
#endif // SOL_ERROR_HPP

175
extern/sol3/sol/error_handler.hpp vendored
Unescape Escape View File

@ -0,0 +1,175 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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_HANDLER_HPP
#define SOL_ERROR_HANDLER_HPP
#include <sol/types.hpp>
#include <sol/demangle.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 sol2 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
#endif // SOL_ERROR_HANDLER_HPP

266
extern/sol3/sol/forward.hpp vendored
Unescape Escape View File

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

56
extern/sol3/sol/forward_detail.hpp vendored
Unescape Escape View File

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

142
extern/sol3/sol/function.hpp vendored
Unescape Escape View File

@ -0,0 +1,142 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/stack.hpp>
#include <sol/unsafe_function.hpp>
#include <sol/protected_function.hpp>
#include <sol/bytecode.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
#endif // SOL_FUNCTION_HPP

78
extern/sol3/sol/function_result.hpp vendored
Unescape Escape View File

@ -0,0 +1,78 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/protected_function_result.hpp>
#include <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(), fr.stack_index() + static_cast<int>(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(), fr.stack_index() + static_cast<int>(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(), fr.stack_index() + static_cast<int>(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
#endif // SOL_FUNCTION_RESULT_HPP

769
extern/sol3/sol/function_types.hpp vendored
Unescape Escape View File

@ -0,0 +1,769 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/function_types_core.hpp>
#include <sol/function_types_templated.hpp>
#include <sol/function_types_stateless.hpp>
#include <sol/function_types_stateful.hpp>
#include <sol/function_types_overloaded.hpp>
#include <sol/resolve.hpp>
#include <sol/call.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, bool no_trampoline, 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 ? function_detail::call<meta::unqualified_t<Fx>, 2, is_yielding>
: detail::static_trampoline<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, bool no_trampoline, 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, no_trampoline>(L, std::move(fxptr), std::forward<Args>(args)...);
}
else {
using F = function_detail::functor_function<dFx, false, true>;
select_set_fx<is_yielding, no_trampoline, F>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
}
}
template <bool is_yielding, bool no_trampoline, 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, no_trampoline>(types<Sig>(), L, std::forward<Fx>(fx), std::forward<Args>(args)...);
}
template <bool is_yielding, bool no_trampoline, 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>::template call<is_yielding, no_trampoline>;
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>::template call<is_yielding, no_trampoline>;
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>>::template call<is_yielding, no_trampoline>;
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, no_trampoline>;
select_set_fx<is_yielding, no_trampoline, 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, no_trampoline>;
select_set_fx<is_yielding, no_trampoline, F>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
}
}
template <bool is_yielding, bool no_trampoline, 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>::template call<is_yielding, no_trampoline>;
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>::template call<is_yielding, no_trampoline>;
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, no_trampoline>;
select_set_fx<is_yielding, no_trampoline, F>(L, std::forward<Fx>(fx), std::forward<T>(obj), std::forward<Args>(args)...);
}
}
}
template <bool is_yielding, bool no_trampoline, 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>::template call<is_yielding, no_trampoline>;
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, no_trampoline>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
}
}
template <bool is_yielding, bool no_trampoline, 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>) {
if constexpr (no_trampoline) {
if (is_yielding) {
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<true>;
lua_pushcclosure(L, reinterpret_cast<lua_CFunction>(cf), upvalues);
}
else
#endif
{
lua_CFunction cf = &function_detail::lua_c_wrapper<true>;
lua_pushcclosure(L, cf, upvalues);
}
}
else {
lua_pushcclosure(L, std::forward<Fx>(fx), 0);
}
}
else {
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), upvalues);
}
else {
lua_CFunction cf = &function_detail::lua_c_wrapper<is_yielding>;
lua_pushcclosure(L, cf, upvalues);
}
#else
lua_CFunction cf = &function_detail::lua_c_wrapper<is_yielding>;
lua_pushcclosure(L, cf, upvalues);
#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>::template call<is_yielding, no_trampoline>;
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, no_trampoline>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
}
else if constexpr (meta::is_member_object_v<uFx>) {
select_member_variable<is_yielding, no_trampoline>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
}
else {
select_convertible<is_yielding, no_trampoline>(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_yielding(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, false>(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_yielding<true>(L, std::forward<Args>(args)...);
}
else if constexpr (meta::is_specialization_of_v<meta::unqualified_t<Arg0>, yielding_t>) {
push_yielding<true>(L, std::forward<Arg0>(arg0).func, std::forward<Args>(args)...);
}
else {
push_yielding<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, false>(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, false>(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>> {
using TargetFunctor = function_detail::functor_function<std::function<Signature>, false, true>;
static int push(lua_State* L, detail::yield_tag_t, const std::function<Signature>& fx) {
if (fx) {
function_detail::select_set_fx<true, false, TargetFunctor>(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_set_fx<true, false, TargetFunctor>(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_set_fx<false, false, TargetFunctor>(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_set_fx<false, false, TargetFunctor>(L, std::move(fx));
return 1;
}
return stack::push(L, lua_nil);
}
};
template <typename Signature>
struct unqualified_pusher<Signature, std::enable_if_t<meta::is_member_object_or_function_v<Signature>>> {
template <typename... Args>
static int push(lua_State* L, Args&&... args) {
function_detail::select<false, 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, true>(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, function_detail::call_indicator) {
lua_CFunction cf = &function_detail::no_construction_error;
return stack::push(L, cf);
}
};
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_destroy<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
(void)L;
(void)index;
(void)handler;
(void)tracking;
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
(void)L;
(void)index;
(void)tracking;
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
#endif // SOL_FUNCTION_TYPES_HPP

46
extern/sol3/sol/function_types_core.hpp vendored
Unescape Escape View File

@ -0,0 +1,46 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/stack.hpp>
#include <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
#endif // SOL_FUNCTION_TYPES_CORE_HPP

65
extern/sol3/sol/function_types_overloaded.hpp vendored
Unescape Escape View File

@ -0,0 +1,65 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/overload.hpp>
#include <sol/call.hpp>
#include <sol/function_types_core.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;
}
struct on_success {
template <typename... Args>
int operator()(Args&&... args) const {
return call(std::forward<Args>(args)...);
}
};
int operator()(lua_State* L) {
on_success call_obj {};
return call_detail::overload_match<Functions...>(call_obj, L, 1 + start_skew, overloads);
}
};
}} // namespace sol::function_detail
#endif // SOL_FUNCTION_TYPES_OVERLOAD_HPP

158
extern/sol3/sol/function_types_stateful.hpp vendored
Unescape Escape View File

@ -0,0 +1,158 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/function_types_core.hpp>
#include <sol/call.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 invocation;
template <typename... Args>
functor_function(function_type f, Args&&... args) noexcept(std::is_nothrow_constructible_v<function_type, function_type, Args...>)
: invocation(std::move(f), std::forward<Args>(args)...) {
}
static int call(lua_State* L, functor_function& self) noexcept(noexcept(call_detail::call_wrapped<void, true, false>(L, self.invocation))) {
int nr = call_detail::call_wrapped<void, true, false>(L, self.invocation);
if (is_yielding) {
return lua_yield(L, nr);
}
else {
return nr;
}
}
int operator()(lua_State* L) noexcept(noexcept(call_detail::call_wrapped<void, true, false>(L, invocation))) {
if constexpr (no_trampoline) {
return call(L, *this);
}
else {
return detail::trampoline(L, &call, *this);
}
}
};
template <typename T, typename Function, bool is_yielding, bool no_trampoline>
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;
using traits_type = meta::bind_traits<function_type>;
function_type invocation;
T member;
template <typename... Args>
member_function(function_type f, Args&&... args) noexcept(
std::is_nothrow_constructible_v<function_type, function_type>&& std::is_nothrow_constructible_v<T, Args...>)
: invocation(std::move(f)), member(std::forward<Args>(args)...) {
}
static int call(lua_State* L, member_function& self)
#if SOL_IS_ON(SOL_COMPILER_VCXX_I_)
// MSVC is broken, what a surprise...
#else
noexcept(traits_type::is_noexcept)
#endif
{
int nr = call_detail::call_wrapped<T, true, false, -1>(L, self.invocation, detail::unwrap(detail::deref(self.member)));
if (is_yielding) {
return lua_yield(L, nr);
}
else {
return nr;
}
}
int operator()(lua_State* L)
#if SOL_IS_ON(SOL_COMPILER_VCXX_I_)
// MSVC is broken, what a surprise...
#else
noexcept(traits_type::is_noexcept)
#endif
{
if constexpr (no_trampoline) {
return call(L, *this);
}
else {
return detail::trampoline(L, &call, *this);
}
}
};
template <typename T, typename Function, bool is_yielding, bool no_trampoline>
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) noexcept(
std::is_nothrow_constructible_v<function_type, function_type>&& std::is_nothrow_constructible_v<T, Args...>)
: var(std::move(v)), member(std::forward<Args>(args)...) {
}
static int call(lua_State* L, member_variable& self) noexcept(std::is_nothrow_copy_assignable_v<T>) {
int nr;
{
M mem = detail::unwrap(detail::deref(self.member));
switch (lua_gettop(L)) {
case 0:
nr = call_detail::call_wrapped<T, true, false, -1>(L, self.var, mem);
break;
case 1:
nr = call_detail::call_wrapped<T, false, false, -1>(L, self.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) noexcept(std::is_nothrow_copy_assignable_v<T>) {
if constexpr (no_trampoline) {
return call(L, *this);
}
else {
return detail::trampoline(L, &call, *this);
}
}
};
}} // namespace sol::function_detail
#endif // SOL_FUNCTION_TYPES_STATEFUL_HPP

385
extern/sol3/sol/function_types_stateless.hpp vendored
Unescape Escape View File

@ -0,0 +1,385 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/stack.hpp>
#include <sol/call.hpp>
#include <sol/bind_traits.hpp>
namespace sol { namespace function_detail {
template <typename Function>
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);
}
template <bool is_yielding, bool no_trampoline>
static int call(lua_State* L) {
int nr;
if constexpr (no_trampoline) {
nr = real_call(L);
}
else {
nr = detail::typed_static_trampoline<decltype(&real_call), (&real_call)>(L);
}
if (is_yielding) {
return lua_yield(L, nr);
}
else {
return nr;
}
}
};
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)
#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);
}
template <bool is_yielding, bool no_trampoline>
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;
if constexpr (no_trampoline) {
nr = real_call(L);
}
else {
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)
#if SOL_IS_ON(SOL_COMPILER_VCXX_I_)
// MSVC is broken, what a surprise...
#else
noexcept(traits_type::is_noexcept)
#endif
{
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)
#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");
}
}
template <bool is_yielding, bool no_trampoline>
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;
if constexpr (no_trampoline) {
nr = real_call(L);
}
else {
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)
#if SOL_IS_ON(SOL_COMPILER_VCXX_I_)
// MSVC is broken, what a surprise...
#else
noexcept(traits_type::is_noexcept)
#endif
{
return call(L);
}
};
template <typename T, typename Function>
struct upvalue_member_variable<T, readonly_wrapper<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
// 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");
}
}
template <bool is_yielding, bool no_trampoline>
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;
if constexpr (no_trampoline) {
nr = real_call(L);
}
else {
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)
#if SOL_IS_ON(SOL_COMPILER_VCXX_I_)
// MSVC is broken, what a surprise...
#else
noexcept(traits_type::is_noexcept)
#endif
{
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)
#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);
}
template <bool is_yielding, bool no_trampoline>
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;
if constexpr (no_trampoline) {
nr = real_call(L);
}
else {
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)
#if SOL_IS_ON(SOL_COMPILER_VCXX_I_)
// MSVC is broken, what a surprise...
#else
noexcept(traits_type::is_noexcept)
#endif
{
return call(L);
}
};
template <typename T, typename Function>
struct upvalue_this_member_variable {
typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
static int real_call(lua_State* L) noexcept(std::is_nothrow_copy_assignable_v<T>) {
// 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");
}
}
template <bool is_yielding, bool no_trampoline>
static int call(lua_State* L) noexcept(std::is_nothrow_copy_assignable_v<T>) {
int nr;
if constexpr (no_trampoline) {
nr = real_call(L);
}
else {
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) noexcept(std::is_nothrow_copy_assignable_v<T>) {
return call(L);
}
};
template <typename T, typename Function>
struct upvalue_this_member_variable<T, readonly_wrapper<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) noexcept(std::is_nothrow_copy_assignable_v<T>) {
// 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");
}
}
template <bool is_yielding, bool no_trampoline>
static int call(lua_State* L) noexcept(std::is_nothrow_copy_assignable_v<T>) {
int nr;
if constexpr (no_trampoline) {
nr = real_call(L);
}
else {
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) noexcept(std::is_nothrow_copy_assignable_v<T>) {
return call(L);
}
};
}} // namespace sol::function_detail
#endif // SOL_FUNCTION_TYPES_STATELESS_HPP

154
extern/sol3/sol/function_types_templated.hpp vendored
Unescape Escape View File

@ -0,0 +1,154 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <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) noexcept(noexcept(c_call<type, f>(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
#endif // SOL_FUNCTION_TYPES_TEMPLATED_HPP

48
extern/sol3/sol/in_place.hpp vendored
Unescape Escape View File

@ -0,0 +1,48 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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
#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
#endif // SOL_IN_PLACE_HPP

195
extern/sol3/sol/inheritance.hpp vendored
Unescape Escape View File

@ -0,0 +1,195 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/types.hpp>
#include <sol/usertype_traits.hpp>
#include <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_actual_type<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) {
if constexpr (is_actual_type_rebindable_for_v<U>) {
using rebound_actual_type = unique_usertype_rebind_actual_t<U>;
using maybe_bases_or_empty = meta::conditional_t<std::is_void_v<rebound_actual_type>, types<>, bases_t>;
string_view this_rebind_ti = usertype_traits<rebound_actual_type>::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>(maybe_bases_or_empty(), 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...>;
if constexpr (is_actual_type_rebindable_for_v<U>) {
using rebound_actual_type = unique_usertype_rebind_actual_t<U>;
using cond_bases_t = meta::conditional_t<std::is_void_v<rebound_actual_type>, types<>, uc_bases_t>;
string_view this_rebind_ti = usertype_traits<rebound_actual_type>::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
#endif // SOL_INHERITANCE_HPP

150
extern/sol3/sol/load_result.hpp vendored
Unescape Escape View File

@ -0,0 +1,150 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/stack.hpp>
#include <sol/function.hpp>
#include <sol/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;
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) {
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);
}
};
} // namespace sol
#endif // SOL_LOAD_RESULT_HPP

95
extern/sol3/sol/lua_table.hpp vendored
Unescape Escape View File

@ -0,0 +1,95 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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_LUA_TABLE_HPP
#define SOL_LUA_TABLE_HPP
#include <sol/table_core.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) {
}
};
} // namespace sol
#endif // SOL_LUA_TABLE_HPP

162
extern/sol3/sol/lua_value.hpp vendored
Unescape Escape View File

@ -0,0 +1,162 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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_LUA_VALUE_HPP
#define SOL_LUA_VALUE_HPP
#include <sol/stack.hpp>
#include <sol/reference.hpp>
#include <sol/make_reference.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
#endif // SOL_LUA_VALUE_HPP

74
extern/sol3/sol/make_reference.hpp vendored
Unescape Escape View File

@ -0,0 +1,74 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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_MAKE_REFERENCE_HPP
#define SOL_MAKE_REFERENCE_HPP
#include <sol/reference.hpp>
#include <sol/stack.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
#endif // SOL_MAKE_REFERENCE_HPP

203
extern/sol3/sol/metatable.hpp vendored
Unescape Escape View File

@ -0,0 +1,203 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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_METATABLE_HPP
#define SOL_METATABLE_HPP
#include <sol/table_core.hpp>
#include <sol/usertype.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)) {
}
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:
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>
basic_metatable<base_type>& set(Key&& key, Value&& value);
template <typename Sig, typename Key, typename... Args>
basic_metatable& 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_metatable& set_function(Key&& key, Args&&... args) {
set_fx(types<>(), std::forward<Key>(key), std::forward<Args>(args)...);
return *this;
}
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) {
lua_settop(L, top);
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) {
lua_settop(L, top);
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
#endif // SOL_METATABLE_HPP

150
extern/sol3/sol/object.hpp vendored
Unescape Escape View File

@ -0,0 +1,150 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/make_reference.hpp>
#include <sol/reference.hpp>
#include <sol/stack.hpp>
#include <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(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_State* L_, global_tag_t t) : base_t(L_, t) {
}
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
#endif // SOL_OBJECT_HPP

86
extern/sol3/sol/object_base.hpp vendored
Unescape Escape View File

@ -0,0 +1,86 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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_BASE_HPP
#define SOL_OBJECT_BASE_HPP
#include <sol/reference.hpp>
#include <sol/stack.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
#endif // SOL_OBJECT_BASE_HPP

83
extern/sol3/sol/optional.hpp vendored
Unescape Escape View File

@ -0,0 +1,83 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/forward.hpp>
#include <sol/in_place.hpp>
#include <sol/traits.hpp>
#if SOL_IS_ON(SOL_USE_BOOST_I_)
#include <boost/optional.hpp>
#else
#include <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;
SOL_BOOST_NONE_CONSTEXPR_I_ 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 SOL_BOOST_NONE_CONSTEXPR_I_ boost::none_t value = boost::none;
};
#endif // Boost nullopt
#if SOL_IS_ON(SOL_USE_BOOST_I_)
template <typename T>
inline SOL_BOOST_NONE_CONSTEXPR_I_ auto associated_nullopt_v = associated_nullopt<T>::value;
#else
template <typename T>
inline constexpr auto associated_nullopt_v = associated_nullopt<T>::value;
#endif // Boost continues to lag behind, to not many people's surprise...
} // namespace detail
} // namespace sol
#if SOL_IS_ON(SOL_USE_BOOST_I_)
#undef SOL_BOOST_NONE_CONSTEXPR_I_
#endif
#endif // SOL_OPTIONAL_HPP

2303
extern/sol3/sol/optional_implementation.hpp vendored
View File

File diff suppressed because it is too large Load Diff

49
extern/sol3/sol/overload.hpp vendored
Unescape Escape View File

@ -0,0 +1,49 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/traits.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
#endif // SOL_OVERLOAD_HPP

262
extern/sol3/sol/packaged_coroutine.hpp vendored
Unescape Escape View File

@ -0,0 +1,262 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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_PACKAGED_COROUTINE_HPP
#define SOL_PACKAGED_COROUTINE_HPP
#include <sol/reference.hpp>
#include <sol/object.hpp>
#include <sol/stack.hpp>
#include <sol/function_result.hpp>
#include <sol/thread.hpp>
#include <sol/protected_handler.hpp>
#include <sol/coroutine.hpp>
namespace sol {
#if 0
class packaged_coroutine {
private:
lua_State* m_L;
sol::stateless_reference m_coroutine_reference;
sol::stateless_reference m_error_handler;
sol::thread m_thread_reference;
void luacall(std::ptrdiff_t argcount, std::ptrdiff_t) {
#if SOL_LUA_VERSION_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 (m_error_handler.valid()) {
string_view err = stack::get<string_view>(this->lua_state(), poststacksize);
m_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_packaged_coroutine() = default;
template <typename T,
meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_packaged_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_packaged_coroutine(T&& r) noexcept
: base_t(std::forward<T>(r)), m_error_handler(detail::get_default_handler<reference, is_main_threaded<base_t>::value>(r.lua_state())) {
#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_packaged_coroutine>(lua_state(), -1, handler);
}
#endif // Safety
}
basic_packaged_coroutine(const basic_packaged_coroutine& other) = default;
basic_packaged_coroutine& operator=(const basic_packaged_coroutine&) = default;
basic_packaged_coroutine(basic_packaged_coroutine&& other) noexcept
: base_t(std::move(other)), m_error_handler(this->lua_state(), std::move(other.m_error_handler)) {
}
basic_packaged_coroutine& operator=(basic_packaged_coroutine&& other) noexcept {
base_t::operator=(std::move(other));
// must change the state, since it could change on the coroutine type
m_error_handler.abandon();
m_error_handler = handler_t(this->lua_state(), std::move(other.m_error_handler));
return *this;
}
basic_packaged_coroutine(const basic_function<base_t>& b) noexcept
: basic_packaged_coroutine(b, detail::get_default_handler<reference, is_main_threaded_v<base_t>>(b.lua_state())) {
}
basic_packaged_coroutine(basic_function<base_t>&& b) noexcept
: basic_packaged_coroutine(std::move(b), detail::get_default_handler<reference, is_main_threaded_v<base_t>>(b.lua_state())) {
}
basic_packaged_coroutine(const basic_function<base_t>& b, handler_t eh) noexcept : base_t(b), m_error_handler(std::move(eh)) {
}
basic_packaged_coroutine(basic_function<base_t>&& b, handler_t eh) noexcept : base_t(std::move(b)), m_error_handler(std::move(eh)) {
}
basic_packaged_coroutine(const stack_reference& r) noexcept
: basic_packaged_coroutine(r.lua_state(), r.stack_index(), detail::get_default_handler<reference, is_main_threaded<base_t>::value>(r.lua_state())) {
}
basic_packaged_coroutine(stack_reference&& r) noexcept
: basic_packaged_coroutine(r.lua_state(), r.stack_index(), detail::get_default_handler<reference, is_main_threaded<base_t>::value>(r.lua_state())) {
}
basic_packaged_coroutine(const stack_reference& r, handler_t eh) noexcept : basic_packaged_coroutine(r.lua_state(), r.stack_index(), std::move(eh)) {
}
basic_packaged_coroutine(stack_reference&& r, handler_t eh) noexcept : basic_packaged_coroutine(r.lua_state(), r.stack_index(), std::move(eh)) {
}
template <typename Super>
basic_packaged_coroutine(const proxy_base<Super>& p)
: basic_packaged_coroutine(p, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(p.lua_state())) {
}
template <typename Super>
basic_packaged_coroutine(proxy_base<Super>&& p)
: basic_packaged_coroutine(std::move(p), detail::get_default_handler<reference, is_main_threaded<base_t>::value>(p.lua_state())) {
}
template <typename Proxy, typename HandlerReference,
meta::enable<std::is_base_of<proxy_base_tag, meta::unqualified_t<Proxy>>, meta::neg<is_lua_index<meta::unqualified_t<HandlerReference>>>> = meta::enabler>
basic_packaged_coroutine(Proxy&& p, HandlerReference&& eh) : basic_packaged_coroutine(detail::force_cast<base_t>(p), std::forward<HandlerReference>(eh)) {
}
template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
basic_packaged_coroutine(lua_State* L, T&& r) noexcept
: basic_packaged_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_packaged_coroutine(lua_State* L, T&& r, handler_t eh) : base_t(L, std::forward<T>(r)), m_error_handler(std::move(eh)) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
auto pp = stack::push_pop(*this);
constructor_handler handler {};
stack::check<basic_packaged_coroutine>(lua_state(), -1, handler);
#endif // Safety
}
basic_packaged_coroutine(lua_nil_t n) : base_t(n), m_error_handler(n) {
}
basic_packaged_coroutine(lua_State* L, int index = -1)
: basic_packaged_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
}
basic_packaged_coroutine(lua_State* L, int index, handler_t eh) : base_t(L, index), m_error_handler(std::move(eh)) {
#ifdef SOL_SAFE_REFERENCES
constructor_handler handler {};
stack::check<basic_packaged_coroutine>(L, index, handler);
#endif // Safety
}
basic_packaged_coroutine(lua_State* L, absolute_index index)
: basic_packaged_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
}
basic_packaged_coroutine(lua_State* L, absolute_index index, handler_t eh) : base_t(L, index), m_error_handler(std::move(eh)) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
constructor_handler handler {};
stack::check<basic_packaged_coroutine>(L, index, handler);
#endif // Safety
}
basic_packaged_coroutine(lua_State* L, raw_index index)
: basic_packaged_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
}
basic_packaged_coroutine(lua_State* L, raw_index index, handler_t eh) : base_t(L, index), m_error_handler(std::move(eh)) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
constructor_handler handler {};
stack::check<basic_packaged_coroutine>(L, index, handler);
#endif // Safety
}
basic_packaged_coroutine(lua_State* L, ref_index index)
: basic_packaged_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
}
basic_packaged_coroutine(lua_State* L, ref_index index, handler_t eh) : base_t(L, index), m_error_handler(std::move(eh)) {
#if SOL_IS_ON(SOL_SAFE_REFERENCES_I_)
auto pp = stack::push_pop(*this);
constructor_handler handler {};
stack::check<basic_packaged_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);
}
reference error_handler() const noexcept {
return reference(m_L, registry_index(m_error_handler.index));
}
set_error_handler(reference new_error_handler) noexcept {
this->m_error_handler = stateless_reference(this->m_L, std::move(new_error_handler));
}
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);
}
};
#endif
} // namespace sol
#endif // SOL_PACKAGED_COROUTINE_HPP

275
extern/sol3/sol/pairs_iterator.hpp vendored
Unescape Escape View File

@ -0,0 +1,275 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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_PAIRS_ITERATOR_HPP
#define SOL_PAIRS_ITERATOR_HPP
#include <sol/version.hpp>
#include <sol/reference.hpp>
#include <sol/stack_reference.hpp>
#include <sol/table_iterator.hpp>
#include <sol/protected_function.hpp>
#include <sol/stack/detail/pairs.hpp>
namespace sol {
struct pairs_sentinel { };
class pairs_iterator {
private:
inline static constexpr int empty_key_index = -1;
public:
using key_type = object;
using mapped_type = object;
using value_type = std::pair<object, object>;
using iterator_category = std::input_iterator_tag;
using difference_type = std::ptrdiff_t;
using pointer = value_type*;
using const_pointer = value_type const*;
using reference = value_type&;
using const_reference = const value_type&;
pairs_iterator() noexcept
: m_L(nullptr)
, m_next_function_ref(lua_nil)
, m_table_ref(lua_nil)
, m_cached_key_value_pair({ lua_nil, lua_nil })
, m_key_index(empty_key_index)
, m_iteration_index(0) {
}
pairs_iterator(const pairs_iterator&) = delete;
pairs_iterator& operator=(const pairs_iterator&) = delete;
pairs_iterator(pairs_iterator&& right) noexcept
: m_L(right.m_L)
, m_next_function_ref(std::move(right.m_next_function_ref))
, m_table_ref(std::move(right.m_table_ref))
, m_cached_key_value_pair(std::move(right.m_cached_key_value_pair))
, m_key_index(right.m_key_index)
, m_iteration_index(right.m_iteration_index) {
right.m_key_index = empty_key_index;
}
pairs_iterator& operator=(pairs_iterator&& right) noexcept {
m_L = right.m_L;
m_next_function_ref = std::move(right.m_next_function_ref);
m_table_ref = std::move(right.m_table_ref);
m_cached_key_value_pair = std::move(right.m_cached_key_value_pair);
m_key_index = right.m_key_index;
m_iteration_index = right.m_iteration_index;
right.m_key_index = empty_key_index;
return *this;
}
template <typename Source>
pairs_iterator(const Source& source_) noexcept : m_L(source_.lua_state()), m_key_index(empty_key_index), m_iteration_index(0) {
if (m_L == nullptr || !source_.valid()) {
m_key_index = empty_key_index;
return;
}
int source_index = -source_.push(m_L);
int abs_source_index = lua_absindex(m_L, source_index);
int metatable_exists = lua_getmetatable(m_L, abs_source_index);
lua_remove(m_L, abs_source_index);
if (metatable_exists == 1) {
// just has a metatable, but does it have __pairs ?
stack_reference metatable(m_L, raw_index(abs_source_index));
stack::get_field<is_global_table_v<Source>, true>(m_L, meta_function::pairs, metatable.stack_index());
optional<protected_function> maybe_pairs_function = stack::pop<optional<protected_function>>(m_L);
if (maybe_pairs_function.has_value()) {
protected_function& pairs_function = *maybe_pairs_function;
protected_function_result next_fn_and_table_and_first_key = pairs_function(source_);
if (next_fn_and_table_and_first_key.valid()) {
m_next_function_ref = next_fn_and_table_and_first_key.get<protected_function>(0);
m_table_ref = next_fn_and_table_and_first_key.get<sol::reference>(1);
m_key_index = next_fn_and_table_and_first_key.stack_index() - 1;
// remove next function and table
lua_remove(m_L, m_key_index);
lua_remove(m_L, m_key_index);
next_fn_and_table_and_first_key.abandon();
lua_remove(m_L, abs_source_index);
this->operator++();
m_iteration_index = 0;
return;
}
}
}
{
auto maybe_next = stack::stack_detail::find_lua_next_function(m_L);
if (maybe_next.has_value()) {
m_next_function_ref = std::move(*maybe_next);
m_table_ref = source_;
stack::push(m_L, lua_nil);
m_key_index = lua_gettop(m_L);
this->operator++();
m_iteration_index = 0;
return;
}
}
// okay, so none of the above worked and now we need to create
// a shim / polyfill instead
stack::push(m_L, &stack::stack_detail::c_lua_next);
m_next_function_ref = stack::pop<protected_function>(m_L);
m_table_ref = source_;
stack::push(m_L, lua_nil);
m_key_index = lua_gettop(m_L);
this->operator++();
m_iteration_index = 0;
}
pairs_iterator& operator++() {
if (m_key_index == empty_key_index) {
return *this;
}
{
sol::protected_function_result next_results = m_next_function_ref(m_table_ref, stack_reference(m_L, m_key_index));
if (!next_results.valid()) {
// TODO: abort, or throw an error?
m_clear();
m_key_index = empty_key_index;
return *this;
}
int next_results_count = next_results.return_count();
if (next_results_count < 2) {
// iteration is over!
next_results.abandon();
lua_settop(m_L, m_key_index - 1);
m_key_index = empty_key_index;
++m_iteration_index;
return *this;
}
else {
lua_remove(m_L, m_key_index);
m_key_index = next_results.stack_index() - 1;
m_cached_key_value_pair.first = stack::get<object>(m_L, m_key_index);
m_cached_key_value_pair.second = stack::get<object>(m_L, m_key_index + 1);
lua_settop(m_L, m_key_index);
next_results.abandon();
}
}
++m_iteration_index;
return *this;
}
std::ptrdiff_t index() const {
return static_cast<std::ptrdiff_t>(m_iteration_index);
}
const_reference operator*() const noexcept {
return m_cached_key_value_pair;
}
reference operator*() noexcept {
return m_cached_key_value_pair;
}
friend bool operator==(const pairs_iterator& left, const pairs_iterator& right) noexcept {
return left.m_table_ref == right.m_table_ref && left.m_iteration_index == right.m_iteration_index;
}
friend bool operator!=(const pairs_iterator& left, const pairs_iterator& right) noexcept {
return left.m_table_ref != right.m_table_ref || left.m_iteration_index != right.m_iteration_index;
}
friend bool operator==(const pairs_iterator& left, const pairs_sentinel&) noexcept {
return left.m_key_index == empty_key_index;
}
friend bool operator!=(const pairs_iterator& left, const pairs_sentinel&) noexcept {
return left.m_key_index != empty_key_index;
}
friend bool operator==(const pairs_sentinel&, const pairs_iterator& left) noexcept {
return left.m_key_index == empty_key_index;
}
friend bool operator!=(const pairs_sentinel&, const pairs_iterator& left) noexcept {
return left.m_key_index != empty_key_index;
}
~pairs_iterator() {
if (m_key_index != empty_key_index) {
m_clear();
}
}
private:
void m_clear() noexcept {
lua_remove(m_L, m_key_index);
}
lua_State* m_L;
protected_function m_next_function_ref;
sol::reference m_table_ref;
std::pair<object, object> m_cached_key_value_pair;
int m_key_index;
int m_iteration_index;
};
template <typename Source>
class basic_pairs_range {
private:
using source_t = std::add_lvalue_reference_t<Source>;
source_t m_source;
public:
using iterator = pairs_iterator;
using const_iterator = pairs_iterator;
basic_pairs_range(source_t source_) noexcept : m_source(source_) {
}
iterator begin() noexcept {
return iterator(m_source);
}
iterator begin() const noexcept {
return iterator(m_source);
}
const_iterator cbegin() const noexcept {
return const_iterator(m_source);
}
pairs_sentinel end() noexcept {
return {};
}
pairs_sentinel end() const noexcept {
return {};
}
pairs_sentinel cend() const noexcept {
return {};
}
};
} // namespace sol
#endif // SOL_PAIRS_ITERATOR_HPP

102
extern/sol3/sol/pointer_like.hpp vendored
Unescape Escape View File

@ -0,0 +1,102 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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_POINTER_LIKE_HPP
#define SOL_POINTER_LIKE_HPP
#include <sol/base_traits.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*());
} // namespace meta_detail
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
#endif // SOL_POINTER_LIKE_HPP

98
extern/sol3/sol/policies.hpp vendored
Unescape Escape View File

@ -0,0 +1,98 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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_FILTERS_HPP
#define SOL_FILTERS_HPP
#include <sol/traits.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
#endif // SOL_FILTERS_HPP

47
extern/sol3/sol/prologue.hpp vendored
Unescape Escape View File

@ -0,0 +1,47 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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.
#pragma once
// clang-format off
#if defined(SOL_PROLOGUE_I_)
#error "[sol2] Library Prologue was already included in translation unit and not properly ended with an epilogue."
#endif
#define SOL_PROLOGUE_I_ 1
#if SOL_IS_ON(SOL_BUILD_CXX_MODE_I_)
#define _FWD(...) static_cast<decltype( __VA_ARGS__ )&&>( __VA_ARGS__ )
#if SOL_IS_ON(SOL_COMPILER_GCC_I_) || SOL_IS_ON(SOL_COMPILER_CLANG_I_)
#define _MOVE(...) static_cast<__typeof( __VA_ARGS__ )&&>( __VA_ARGS__ )
#else
#include <type_traits>
#define _MOVE(...) static_cast<::std::remove_reference_t<( __VA_ARGS__ )>&&>( __VA_OPT__(,) )
#endif
#endif
// clang-format on

151
extern/sol3/sol/property.hpp vendored
Unescape Escape View File

@ -0,0 +1,151 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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
#include <sol/types.hpp>
#include <sol/ebco.hpp>
#include <type_traits>
#include <utility>
namespace sol {
namespace detail {
struct no_prop { };
} // namespace detail
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>
using is_member_object = std::integral_constant<bool, std::is_member_object_pointer_v<T> || is_specialization_of_v<T, readonly_wrapper>>;
template <typename T>
inline constexpr bool is_member_object_v = is_member_object<T>::value;
template <typename T>
using is_member_object_or_function = std::integral_constant<bool, is_member_object_v<T> || std::is_member_pointer_v<T>>;
template <typename T>
inline constexpr bool is_member_object_or_function_v = is_member_object_or_function<T>::value;
} // namespace meta
} // namespace sol
#endif // SOL_PROPERTY_HPP

53
extern/sol3/sol/protect.hpp vendored
Unescape Escape View File

@ -0,0 +1,53 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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_PROTECT_HPP
#define SOL_PROTECT_HPP
#include <sol/traits.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
#endif // SOL_PROTECT_HPP

385
extern/sol3/sol/protected_function.hpp vendored
Unescape Escape View File

@ -0,0 +1,385 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/reference.hpp>
#include <sol/object.hpp>
#include <sol/stack.hpp>
#include <sol/protected_function_result.hpp>
#include <sol/unsafe_function.hpp>
#include <sol/protected_handler.hpp>
#include <sol/bytecode.hpp>
#include <sol/dump_handler.hpp>
#include <cstdint>
#include <algorithm>
namespace sol {
namespace detail {
template <bool ShouldPush_, typename Handler_>
inline void handle_protected_exception(
lua_State* L_, optional<const std::exception&> maybe_ex, const char* error, detail::protected_handler<ShouldPush_, Handler_>& handler_) {
handler_.stack_index = 0;
if (ShouldPush_) {
handler_.target.push(L_);
detail::call_exception_handler(L_, maybe_ex, error);
lua_call(L_, 1, 1);
}
else {
detail::call_exception_handler(L_, maybe_ex, error);
}
}
} // namespace detail
template <typename Reference, bool Aligned = false, typename Handler = reference>
class basic_protected_function : public basic_object<Reference> {
private:
using base_t = basic_object<Reference>;
using handler_t = Handler;
inline static constexpr bool is_stack_handler_v = is_stack_based_v<handler_t>;
basic_protected_function(std::true_type, const basic_protected_function& other_) noexcept
: base_t(other_), m_error_handler(other_.m_error_handler.copy(lua_state())) {
}
basic_protected_function(std::false_type, const basic_protected_function& other_) noexcept : base_t(other_), m_error_handler(other_.m_error_handler) {
}
public:
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)), m_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& other_) noexcept
: basic_protected_function(meta::boolean<is_stateless_lua_reference_v<Handler>>(), other_) {
}
basic_protected_function& operator=(const basic_protected_function& other_) {
base_t::operator=(other_);
if constexpr (is_stateless_lua_reference_v<Handler>) {
m_error_handler.copy_assign(lua_state(), other_.m_error_handler);
}
else {
m_error_handler = other_.m_error_handler;
}
return *this;
}
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), m_error_handler(std::move(eh)) {
}
basic_protected_function(basic_function<base_t>&& b, handler_t eh) : base_t(std::move(b)), m_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 HandlerReference,
meta::enable<std::is_base_of<proxy_base_tag, meta::unqualified_t<Proxy>>,
meta::neg<is_lua_index<meta::unqualified_t<HandlerReference>>>> = meta::enabler>
basic_protected_function(Proxy&& p, HandlerReference&& eh)
: basic_protected_function(detail::force_cast<base_t>(p), make_reference<handler_t>(p.lua_state(), std::forward<HandlerReference>(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)), m_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), m_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_), m_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_), m_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_), m_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_), m_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
}
using base_t::lua_state;
template <typename Fx>
int dump(lua_Writer writer, void* userdata_pointer_, 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_pointer_, strip ? 1 : 0);
if (r != 0) {
return on_error(this->lua_state(), r, writer, userdata_pointer_, strip);
}
return r;
}
int dump(lua_Writer writer, void* userdata_pointer_, bool strip = false) const {
return dump(writer, userdata_pointer_, 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 (m_error_handler.valid(lua_state())) {
detail::protected_handler<true, handler_t> h(lua_state(), m_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(lua_state(), m_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 (m_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_v) {
// 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(lua_state(), m_error_handler);
if constexpr (!is_stack_handler_v) {
lua_replace(lua_state(), -3);
h.stack_index = 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(lua_state(), m_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);
}
}
}
~basic_protected_function() {
if constexpr (is_stateless_lua_reference_v<handler_t>) {
this->m_error_handler.reset(lua_state());
}
}
static handler_t get_default_handler(lua_State* L_) {
return detail::get_default_handler<handler_t, is_main_threaded_v<base_t>>(L_);
}
template <typename T>
static void set_default_handler(const T& ref) {
detail::set_default_handler(ref.lua_state(), ref);
}
auto get_error_handler() const noexcept {
if constexpr (is_stateless_lua_reference_v<handler_t>) {
if constexpr (is_stack_based_v<handler_t>) {
return stack_reference(lua_state(), m_error_handler.stack_index());
}
else {
return basic_reference<is_main_threaded_v<base_t>>(lua_state(), ref_index(m_error_handler.registry_index()));
}
}
else {
return m_error_handler;
}
}
template <typename ErrorHandler_>
void set_error_handler(ErrorHandler_&& error_handler_) noexcept {
static_assert(!is_stack_based_v<handler_t> || is_stack_based_v<ErrorHandler_>,
"A stack-based error handler can only be set from a parameter that is also stack-based.");
if constexpr (std::is_rvalue_reference_v<ErrorHandler_>) {
m_error_handler = std::forward<ErrorHandler_>(error_handler_);
}
else {
m_error_handler.copy_assign(lua_state(), std::forward<ErrorHandler_>(error_handler_));
}
}
void abandon () noexcept {
this->m_error_handler.abandon();
base_t::abandon();
}
private:
handler_t m_error_handler;
template <bool b>
call_status luacall(std::ptrdiff_t argcount, std::ptrdiff_t result_count_, detail::protected_handler<b, handler_t>& h) const {
return static_cast<call_status>(lua_pcall(lua_state(), static_cast<int>(argcount), static_cast<int>(result_count_), h.stack_index));
}
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 SOL_IS_ON(SOL_EXCEPTIONS_I_) && SOL_IS_OFF(SOL_PROPAGATE_EXCEPTIONS_I_)
try {
#endif // No Exceptions
firstreturn = (std::max)(1, static_cast<int>(stacksize - n - static_cast<int>(h.valid() && !is_stack_handler_v)));
code = luacall(n, LUA_MULTRET, h);
poststacksize = lua_gettop(lua_state()) - static_cast<int>(h.valid() && !is_stack_handler_v);
returncount = poststacksize - (firstreturn - 1);
#if SOL_IS_ON(SOL_EXCEPTIONS_I_) && SOL_IS_OFF(SOL_PROPAGATE_EXCEPTIONS_I_)
}
// 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 SOL_IS_ON(SOL_EXCEPTIONS_CATCH_ALL_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 (...) {
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 // Always catch edge case
#else
// do not handle exceptions: they can be propogated into C++ and keep all type information / rich information
#endif // Exceptions vs. No Exceptions
return protected_function_result(lua_state(), firstreturn, returncount, returncount, code);
}
};
} // namespace sol
#endif // SOL_FUNCTION_HPP

233
extern/sol3/sol/protected_function_result.hpp vendored
Unescape Escape View File

@ -0,0 +1,233 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/reference.hpp>
#include <sol/tuple.hpp>
#include <sol/stack.hpp>
#include <sol/proxy_base.hpp>
#include <sol/stack_iterator.hpp>
#include <sol/stack_proxy.hpp>
#include <sol/error.hpp>
#include <sol/stack.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() {
if (L == nullptr)
return;
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
#endif // SOL_PROTECTED_FUNCTION_RESULT_HPP

108
extern/sol3/sol/protected_handler.hpp vendored
Unescape Escape View File

@ -0,0 +1,108 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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_HANDLER_HPP
#define SOL_PROTECTED_HANDLER_HPP
#include <sol/reference.hpp>
#include <sol/stack.hpp>
#include <sol/protected_function_result.hpp>
#include <sol/unsafe_function.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 ShouldPush, typename Target = reference>
struct protected_handler {
lua_State* m_L;
const Target& target;
int stack_index;
protected_handler(std::false_type, lua_State* L_, const Target& target_) : m_L(L_), target(target_), stack_index(0) {
if (ShouldPush) {
stack_index = lua_gettop(L_) + 1;
target.push(L_);
}
}
protected_handler(std::true_type, lua_State* L_, const Target& target_) : m_L(L_), target(target_), stack_index(0) {
if (ShouldPush) {
stack_index = target.stack_index();
}
}
protected_handler(lua_State* L_, const Target& target_) : protected_handler(meta::boolean<is_stack_based_v<Target>>(), L_, target_) {
}
bool valid() const noexcept {
return ShouldPush;
}
~protected_handler() {
if constexpr (!is_stack_based_v<Target>) {
if (stack_index != 0) {
lua_remove(m_L, stack_index);
}
}
}
};
template <typename Base, typename T>
inline basic_function<Base> force_cast(T& p) {
return p;
}
template <typename Reference, bool IsMainReference = false>
inline Reference get_default_handler(lua_State* L_) {
if (is_stack_based_v<Reference> || L_ == nullptr)
return Reference(L_, lua_nil);
L_ = IsMainReference ? 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>
inline 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 sol::detail
#endif // SOL_PROTECTED_HANDLER_HPP

68
extern/sol3/sol/proxy_base.hpp vendored
Unescape Escape View File

@ -0,0 +1,68 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/reference.hpp>
#include <sol/tuple.hpp>
#include <sol/stack.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 : public proxy_base_tag {
lua_State* lua_state() const {
const Super& super = *static_cast<const Super*>(static_cast<const void*>(this));
return super.lua_state();
}
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&>();
}
};
} // namespace sol
#endif // SOL_PROXY_BASE_HPP

162
extern/sol3/sol/raii.hpp vendored
Unescape Escape View File

@ -0,0 +1,162 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/traits.hpp>
#include <sol/compatibility.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_destroy {
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
#endif // SOL_RAII_HPP

900
extern/sol3/sol/reference.hpp vendored
Unescape Escape View File

@ -0,0 +1,900 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/types.hpp>
#include <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* L_, int index_ = -1, int count_ = 1) : L(L_), index(index_), count(count_) {
}
~push_popper_at() {
remove(L, index, count);
}
};
template <bool top_level>
struct push_popper_n {
lua_State* L;
int pop_count;
push_popper_n(lua_State* L_, int pop_count_) : L(L_), pop_count(pop_count_) {
}
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, pop_count);
}
};
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 m_object;
int m_index;
push_popper(T object_) noexcept : m_object(object_), m_index(lua_absindex(m_object.lua_state(), -m_object.push())) {
}
int index_of(const Tu&) const noexcept {
return m_index;
}
~push_popper() {
m_object.pop();
}
};
template <typename T, typename C>
struct push_popper<true, T, C> {
using Tu = meta::unqualified_t<T>;
push_popper(T) noexcept {
}
int index_of(const Tu&) const noexcept {
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) noexcept {
}
int index_of(const Tu& object_) const noexcept {
return object_.stack_index();
}
~push_popper() {
}
};
template <bool, typename T, typename = void>
struct stateless_push_popper {
using Tu = meta::unqualified_t<T>;
lua_State* m_L;
T m_object;
int m_index;
stateless_push_popper(lua_State* L_, T object_) noexcept : m_L(L_), m_object(object_), m_index(lua_absindex(m_L, -m_object.push(m_L))) {
}
int index_of(const Tu&) const noexcept {
return m_index;
}
~stateless_push_popper() {
m_object.pop(m_L);
}
};
template <typename T, typename C>
struct stateless_push_popper<true, T, C> {
using Tu = meta::unqualified_t<T>;
stateless_push_popper(lua_State*, T) noexcept {
}
int index_of(lua_State*, const Tu&) const noexcept {
return -1;
}
~stateless_push_popper() {
}
};
template <typename T>
struct stateless_push_popper<false, T, std::enable_if_t<is_stack_based_v<meta::unqualified_t<T>>>> {
using Tu = meta::unqualified_t<T>;
lua_State* m_L;
stateless_push_popper(lua_State* L_, T) noexcept : m_L(L_) {
}
int index_of(const Tu& object_) const noexcept {
return object_.stack_index();
}
~stateless_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, typename T>
stateless_push_popper<top_level, T> push_pop(lua_State* L_, T&& object_) {
return stateless_push_popper<top_level, T>(L_, std::forward<T>(object_));
}
template <typename T>
push_popper_at push_pop_at(T&& object_) {
int push_count = object_.push();
lua_State* L = object_.lua_state();
return push_popper_at(L, lua_absindex(L, -push_count), push_count);
}
template <bool top_level = false>
push_popper_n<top_level> pop_n(lua_State* L_, int pop_count_) {
return push_popper_n<top_level>(L_, pop_count_);
}
} // namespace stack
inline lua_State* main_thread(lua_State* L_, lua_State* backup_if_unsupported_ = nullptr) {
#if SOL_LUA_VERSION_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 no_safety_tag {
} inline constexpr 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_ref(lua_State* L_) const noexcept {
if (ref == LUA_NOREF)
return LUA_NOREF;
push(L_);
return luaL_ref(L_, LUA_REGISTRYINDEX);
}
lua_State* copy_assign_ref(lua_State* L_, lua_State* rL, const stateless_reference& r) {
if (valid(L_)) {
deref(L_);
}
ref = r.copy_ref(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_, global_tag_t) 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_ref(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_, const stateless_stack_reference& r) noexcept : stateless_reference(L_, r.stack_index()) {
}
stateless_reference(lua_State* L_, int index = -1) 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_pushvalue(L_, index);
ref = luaL_ref(L_, LUA_REGISTRYINDEX);
}
stateless_reference(lua_State* L_, absolute_index index_) noexcept : stateless_reference(L_, index_.index) {
}
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;
}
void reset(lua_State* L_) noexcept {
if (valid(L_)) {
deref(L_);
}
ref = LUA_NOREF;
}
void reset(lua_State* L_, int index_) noexcept {
reset(L_);
#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);
}
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);
}
stateless_reference copy(lua_State* L_) const noexcept {
if (!valid(L_)) {
return {};
}
return stateless_reference(copy_ref(L_));
}
void copy_assign(lua_State* L_, const stateless_reference& right) noexcept {
if (valid(L_)) {
deref(L_);
}
if (!right.valid(L_)) {
return;
}
ref = right.copy_ref(L_);
}
bool equals(lua_State* L_, const stateless_reference& r) const noexcept {
auto ppl = stack::push_pop(L_, *this);
auto ppr = stack::push_pop(L_, r);
return lua_compare(L_, -1, -2, LUA_OPEQ) == 1;
}
bool equals(lua_State* L_, const stateless_stack_reference& r) const noexcept {
auto ppl = stack::push_pop(L_, *this);
return lua_compare(L_, -1, r.stack_index(), LUA_OPEQ) == 1;
}
bool equals(lua_State* L_, lua_nil_t) const noexcept {
return valid(L_);
}
};
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_complex(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_ref();
}
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_, global_tag_t) noexcept : basic_reference(detail::pick_main_thread<main_only>(L_, L_), global_tag, global_tag) {
}
basic_reference(lua_State* L_, global_tag_t, global_tag_t) noexcept : stateless_reference(L_, global_tag), 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_ref() const noexcept {
return copy_ref(lua_state());
}
int copy_ref(lua_State* L_) const noexcept {
return stateless_reference::copy_ref(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_ref();
}
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_ref()), 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_complex(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_complex(r);
return *this;
}
basic_reference& operator=(const lua_nil_t&) noexcept {
reset();
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());
}
void reset() noexcept {
stateless_reference::reset(luastate);
luastate = nullptr;
}
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());
}
bool valid(lua_State* L_) const noexcept {
return stateless_reference::valid(L_);
}
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) noexcept {
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) noexcept {
return !operator==(l, r);
}
template <bool lb>
inline bool operator==(const basic_reference<lb>& l, const stack_reference& r) noexcept {
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) noexcept {
return !operator==(l, r);
}
template <bool rb>
inline bool operator==(const stack_reference& l, const basic_reference<rb>& r) noexcept {
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) noexcept {
return !operator==(l, r);
}
template <bool lb>
inline bool operator==(const basic_reference<lb>& lhs, const lua_nil_t&) noexcept {
return !lhs.valid();
}
template <bool rb>
inline bool operator==(const lua_nil_t&, const basic_reference<rb>& rhs) noexcept {
return !rhs.valid();
}
template <bool lb>
inline bool operator!=(const basic_reference<lb>& lhs, const lua_nil_t&) noexcept {
return lhs.valid();
}
template <bool rb>
inline bool operator!=(const lua_nil_t&, const basic_reference<rb>& rhs) noexcept {
return rhs.valid();
}
inline bool operator==(const stateless_reference& l, const stateless_reference& r) noexcept {
return l.registry_index() == r.registry_index();
}
inline bool operator!=(const stateless_reference& l, const stateless_reference& r) noexcept {
return l.registry_index() != r.registry_index();
}
inline bool operator==(const stateless_reference& lhs, const lua_nil_t&) noexcept {
return lhs.registry_index() == LUA_REFNIL;
}
inline bool operator==(const lua_nil_t&, const stateless_reference& rhs) noexcept {
return rhs.registry_index() == LUA_REFNIL;
}
inline bool operator!=(const stateless_reference& lhs, const lua_nil_t&) noexcept {
return lhs.registry_index() != LUA_REFNIL;
}
inline bool operator!=(const lua_nil_t&, const stateless_reference& rhs) noexcept {
return rhs.registry_index() != LUA_REFNIL;
}
struct stateless_reference_equals : public stateless_stack_reference_equals {
using is_transparent = std::true_type;
stateless_reference_equals(lua_State* L_) noexcept : stateless_stack_reference_equals(L_) {
}
bool operator()(const lua_nil_t& lhs, const stateless_reference& rhs) const noexcept {
return rhs.equals(lua_state(), lhs);
}
bool operator()(const stateless_reference& lhs, const lua_nil_t& rhs) const noexcept {
return lhs.equals(lua_state(), rhs);
}
bool operator()(const stateless_reference& lhs, const stateless_reference& rhs) const noexcept {
return lhs.equals(lua_state(), rhs);
}
};
struct reference_equals : public stack_reference_equals {
using is_transparent = std::true_type;
template <bool rb>
bool operator()(const lua_nil_t& lhs, const basic_reference<rb>& rhs) const noexcept {
return lhs == rhs;
}
template <bool lb>
bool operator()(const basic_reference<lb>& lhs, const lua_nil_t& rhs) const noexcept {
return lhs == rhs;
}
template <bool lb, bool rb>
bool operator()(const basic_reference<lb>& lhs, const basic_reference<rb>& rhs) const noexcept {
return lhs == rhs;
}
template <bool lb>
bool operator()(const basic_reference<lb>& lhs, const stack_reference& rhs) const noexcept {
return lhs == rhs;
}
template <bool rb>
bool operator()(const stack_reference& lhs, const basic_reference<rb>& rhs) const noexcept {
return lhs == rhs;
}
};
struct stateless_reference_hash : public stateless_stack_reference_hash {
using argument_type = stateless_reference;
using result_type = std::size_t;
using is_transparent = std::true_type;
stateless_reference_hash(lua_State* L_) noexcept : stateless_stack_reference_hash(L_) {
}
result_type operator()(const stateless_reference& lhs) const noexcept {
std::hash<const void*> h;
return h(lhs.pointer(lua_state()));
}
};
struct reference_hash : public stack_reference_hash {
using argument_type = reference;
using result_type = std::size_t;
using is_transparent = std::true_type;
template <bool lb>
result_type operator()(const basic_reference<lb>& lhs) const noexcept {
std::hash<const void*> h;
return h(lhs.pointer());
}
};
} // namespace sol
#endif // SOL_REFERENCE_HPP

173
extern/sol3/sol/resolve.hpp vendored
Unescape Escape View File

@ -0,0 +1,173 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/traits.hpp>
#include <sol/tuple.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::call_operator_deducible_v<F>, "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::call_operator_deducible<U>(), std::forward<F>(f))) {
return resolve_f(meta::call_operator_deducible<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::call_operator_deducible_v<F>, "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::call_operator_deducible<U>(), std::forward<F>(f))) {
return resolve_f(meta::call_operator_deducible<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
#endif // SOL_RESOLVE_HPP

79
extern/sol3/sol/sol.hpp vendored
Unescape Escape View File

@ -0,0 +1,79 @@
// The MIT License (MIT)
// Copyright (c) 2013-2021 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_HPP
#define SOL_HPP
#include <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_)
// we'll just let this alone for now
#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++
#include <sol/forward.hpp>
#include <sol/forward_detail.hpp>
#include <sol/assert.hpp>
#include <sol/bytecode.hpp>
#include <sol/stack.hpp>
#include <sol/object.hpp>
#include <sol/function.hpp>
#include <sol/protected_function.hpp>
#include <sol/usertype.hpp>
#include <sol/table.hpp>
#include <sol/state.hpp>
#include <sol/coroutine.hpp>
#include <sol/thread.hpp>
#include <sol/userdata.hpp>
#include <sol/metatable.hpp>
#include <sol/as_args.hpp>
#include <sol/variadic_args.hpp>
#include <sol/variadic_results.hpp>
#include <sol/lua_value.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

351
extern/sol3/sol/stack.hpp vendored
Unescape Escape View File

@ -0,0 +1,351 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/trampoline.hpp>
#include <sol/stack_core.hpp>
#include <sol/stack_reference.hpp>
#include <sol/stack_check.hpp>
#include <sol/stack_get.hpp>
#include <sol/stack_check_get.hpp>
#include <sol/stack_push.hpp>
#include <sol/stack_pop.hpp>
#include <sol/stack_field.hpp>
#include <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 <bool checked, typename Handler, typename Fx, typename... Args>
static decltype(auto) eval(types<>, std::index_sequence<>, lua_State*, int, Handler&&, record&, Fx&& fx, Args&&... args) {
return std::forward<Fx>(fx)(std::forward<Args>(args)...);
}
template <bool checked, typename Arg, typename... Args, std::size_t I, std::size_t... Is, typename Handler, typename Fx, typename... FxArgs>
static decltype(auto) eval(types<Arg, Args...>, std::index_sequence<I, Is...>, lua_State* L_, int start_index_, Handler&& handler_,
record& tracking_, Fx&& fx_, FxArgs&&... fxargs_) {
#if SOL_IS_ON(SOL_PROPAGATE_EXCEPTIONS_I_)
// We can save performance/time by letting errors unwind produced arguments
// rather than checking everything once, and then potentially re-doing work
if constexpr (checked) {
return eval<checked>(types<Args...>(),
std::index_sequence<Is...>(),
L_,
start_index_,
std::forward<Handler>(handler_),
tracking_,
std::forward<Fx>(fx_),
std::forward<FxArgs>(fxargs_)...,
*stack_detail::check_get_arg<Arg>(L_, start_index_ + tracking_.used, handler_, tracking_));
}
else
#endif
{
return eval<checked>(types<Args...>(),
std::index_sequence<Is...>(),
L_,
start_index_,
std::forward<Handler>(handler_),
tracking_,
std::forward<Fx>(fx_),
std::forward<FxArgs>(fxargs_)...,
stack_detail::unchecked_get_arg<Arg>(L_, start_index_ + 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...> argument_types_, std::index_sequence<I...> argument_indices_, lua_State* L_,
int start_index_, Fx&& fx_, FxArgs&&... args_) {
static_assert(meta::all_v<meta::is_not_move_only<Args>...>,
"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.");
argument_handler<types<R, Args...>> handler {};
record tracking {};
#if SOL_IS_OFF(SOL_PROPAGATE_EXCEPTIONS_I_)
if constexpr (checkargs) {
multi_check<Args...>(L_, start_index_, handler);
}
#endif
if constexpr (std::is_void_v<R>) {
eval<checkargs>(
argument_types_, argument_indices_, L_, start_index_, handler, tracking, std::forward<Fx>(fx_), std::forward<FxArgs>(args_)...);
}
else {
return eval<checkargs>(
argument_types_, argument_indices_, L_, start_index_, handler, 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
#endif // SOL_STACK_HPP

98
extern/sol3/sol/stack/detail/pairs.hpp vendored
Unescape Escape View File

@ -0,0 +1,98 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 Spermission 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_DETAIL_PAIRS_HPP
#define SOL_DETAIL_PAIRS_HPP
#include <sol/version.hpp>
#include <sol/stack.hpp>
#include <sol/stack_reference.hpp>
#include <sol/protected_function.hpp>
#include <sol/assert.hpp>
#include <optional>
namespace sol { namespace stack { namespace stack_detail {
inline bool maybe_push_lua_next_function(lua_State* L_) {
stack::get_field<true, false>(L_, "next");
bool is_next = stack::check<protected_function>(L_);
if (is_next) {
return true;
}
stack::get_field<true, false>(L_, "table");
stack::record tracking{};
if (!stack::loose_table_check(L_, -1, &no_panic, tracking)) {
return false;
}
lua_getfield(L_, -1, "next");
bool is_table_next_func = stack::check<protected_function>(L_, -1);
if (is_table_next_func) {
return true;
}
lua_pop(L_, 1);
return false;
}
inline std::optional<protected_function> find_lua_next_function(lua_State* L_) {
if (maybe_push_lua_next_function(L_)) {
return stack::pop<protected_function>(L_);
}
return std::nullopt;
}
inline int c_lua_next(lua_State* L_) noexcept {
stack_reference table_stack_ref(L_, raw_index(1));
stateless_stack_reference key_stack_ref(L_, raw_index(2));
int result = lua_next(table_stack_ref.lua_state(), table_stack_ref.stack_index());
if (result == 0) {
stack::push(L_, lua_nil);
return 1;
}
return 2;
}
inline int readonly_pairs(lua_State* L_) noexcept {
int pushed = 0;
if (!maybe_push_lua_next_function(L_)) {
// we do not have the "next" function in the global namespace
// from the "table" global entiry, use our own
pushed += stack::push(L_, &c_lua_next);
}
else {
pushed += 1;
}
int metatable_exists = lua_getmetatable(L_, 1);
sol_c_assert(metatable_exists == 1);
const auto& index_key = to_string(sol::meta_function::index);
lua_getfield(L_, lua_gettop(L_), index_key.c_str());
lua_remove(L_, -2);
pushed += 1;
pushed += stack::push(L_, lua_nil);
return pushed;
}
}}} // sol::stack::stack_detail
#endif // SOL_DETAIL_PAIRS_HPP

30
extern/sol3/sol/stack_check.hpp vendored
Unescape Escape View File

@ -0,0 +1,30 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/stack_check_unqualified.hpp>
#include <sol/stack_check_qualified.hpp>
#endif // SOL_STACK_CHECK_HPP

30
extern/sol3/sol/stack_check_get.hpp vendored
Unescape Escape View File

@ -0,0 +1,30 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/stack_check_get_unqualified.hpp>
#include <sol/stack_check_get_qualified.hpp>
#endif // SOL_STACK_CHECK_GET_HPP

139
extern/sol3/sol/stack_check_get_qualified.hpp vendored
Unescape Escape View File

@ -0,0 +1,139 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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_QUALIFIED_GET_HPP
#define SOL_STACK_CHECK_QUALIFIED_GET_HPP
#include <sol/stack_core.hpp>
#include <sol/stack_check_get_unqualified.hpp>
#include <sol/optional.hpp>
namespace sol { namespace stack {
namespace stack_detail {
template <typename OptionalType, typename T, typename Handler>
OptionalType get_optional(lua_State* L, int index, Handler&& handler, record& tracking) {
using Tu = meta::unqualified_t<T>;
if constexpr (is_lua_reference_v<T>) {
if constexpr (is_global_table_v<Tu>) {
(void)L;
(void)index;
(void)handler;
tracking.use(1);
return true;
}
else {
// 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 {};
}
return OptionalType(stack_detail::unchecked_get<T>(L, index, tracking));
}
}
else if constexpr (!std::is_reference_v<T> && is_unique_usertype_v<Tu> && !is_actual_type_rebindable_for_v<Tu>) {
// we can take shortcuts here to save on separate checking, and just return nullopt!
using element = unique_usertype_element_t<Tu>;
using actual = unique_usertype_actual_t<Tu>;
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<element, Tu> == pdx) {
memory = detail::align_usertype_unique_tag<true, false>(memory);
memory = detail::align_usertype_unique<actual, true, false>(memory);
actual* mem = static_cast<actual*>(memory);
return static_cast<actual>(*mem);
}
actual r {};
if constexpr (!derive<element>::value) {
return {};
}
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<actual, true, false>(memory);
string_view ti = usertype_traits<element>::qualified_name();
int cast_operation;
if constexpr (is_actual_type_rebindable_for_v<Tu>) {
using rebound_actual_type = unique_usertype_rebind_actual_t<Tu, void>;
string_view rebind_ti = usertype_traits<rebound_actual_type>::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
actual* mem = static_cast<actual*>(memory);
return OptionalType(*mem);
}
case 2:
// it's a base match, return the
// aliased creation
return OptionalType(std::move(r));
default:
break;
}
return {};
}
}
else {
if (!check<T>(L, index, std::forward<Handler>(handler))) {
tracking.use(static_cast<int>(!lua_isnone(L, index)));
return {};
}
return OptionalType(stack_detail::unchecked_get<T>(L, index, tracking));
}
}
} // namespace stack_detail
template <typename T, typename>
struct qualified_check_getter {
typedef decltype(stack_detail::unchecked_get<T>(nullptr, -1, std::declval<record&>())) R;
template <typename Handler>
optional<R> get(lua_State* L, int index, Handler&& handler, record& tracking) {
return stack_detail::get_optional<optional<R>, T>(L, index, std::forward<Handler>(handler), tracking);
}
};
template <typename Optional>
struct qualified_getter<Optional, std::enable_if_t<meta::is_optional_v<Optional>>> {
static Optional get(lua_State* L, int index, record& tracking) {
using T = typename meta::unqualified_t<Optional>::value_type;
return stack_detail::get_optional<Optional, T>(L, index, &no_panic, tracking);
}
};
}} // namespace sol::stack
#endif // SOL_STACK_CHECK_QUALIFIED_GET_HPP

186
extern/sol3/sol/stack_check_get_unqualified.hpp vendored
Unescape Escape View File

@ -0,0 +1,186 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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_UNQUALIFIED_GET_HPP
#define SOL_STACK_CHECK_UNQUALIFIED_GET_HPP
#include <sol/stack_core.hpp>
#include <sol/stack_get.hpp>
#include <sol/stack_check.hpp>
#include <sol/optional.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>) {
if constexpr (is_global_table_v<T>) {
(void)L;
(void)index;
(void)handler;
tracking.use(1);
return true;
}
else {
// 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_VERSION_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
#endif // SOL_STACK_CHECK_UNQUALIFIED_GET_HPP

89
extern/sol3/sol/stack_check_qualified.hpp vendored
Unescape Escape View File

@ -0,0 +1,89 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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_QUALIFIED_HPP
#define SOL_STACK_CHECK_QUALIFIED_HPP
#include <sol/stack_check_unqualified.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) {
using no_cv_X = meta::unqualified_t<X>;
if constexpr (!std::is_reference_v<X> && is_unique_usertype_v<no_cv_X>) {
using element = unique_usertype_element_t<no_cv_X>;
if constexpr (is_actual_type_rebindable_for_v<no_cv_X>) {
using rebound_actual_type = unique_usertype_rebind_actual_t<no_cv_X>;
// 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<element, no_cv_X> == pdx) {
return true;
}
if constexpr (derive<element>::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<element>::qualified_name();
string_view rebind_ti = usertype_traits<rebound_actual_type>::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<no_cv_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
#endif // SOL_STACK_CHECK_HPP

639
extern/sol3/sol/stack_check_unqualified.hpp vendored
Unescape Escape View File

@ -0,0 +1,639 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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_UNQUALIFIED_HPP
#define SOL_STACK_CHECK_UNQUALIFIED_HPP
#include <sol/stack_core.hpp>
#include <sol/usertype_traits.hpp>
#include <sol/inheritance.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 {
template <typename Handler>
bool loose_table_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::table, t, "value is not a table or a userdata that can behave like one");
return false;
}
return true;
}
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
#if SOL_IS_ON(SOL_CHAR8_T_I_)
,
char8_t
#endif
,
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_VERSION_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 element = unique_usertype_element_t<T>;
using actual = unique_usertype_actual_t<T>;
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<d::u<element>>(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<element, actual> == pdx;
if (!success) {
memory = detail::align_usertype_unique_tag<true>(memory);
#if 0
// New version, one day
#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) {
return stack::loose_table_check(L_, index, std::forward<Handler>(handler), tracking);
}
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 SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE_I_)
if (lua_iscfunction(L_, index) != 0) {
// a potential match...
return true;
}
#endif
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<d::u<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
#endif // SOL_STACK_CHECK_UNQUALIFIED_HPP

1456
extern/sol3/sol/stack_core.hpp vendored
View File

File diff suppressed because it is too large Load Diff

279
extern/sol3/sol/stack_field.hpp vendored
Unescape Escape View File

@ -0,0 +1,279 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/stack_core.hpp>
#include <sol/stack_push.hpp>
#include <sol/stack_get.hpp>
#include <sol/stack_check_get.hpp>
namespace sol { namespace stack {
namespace stack_detail {
template <typename T, bool global, bool raw>
inline constexpr bool is_get_direct_tableless_v = (global && !raw && meta::is_c_str_or_string_v<T>);
template <typename T, bool global, bool raw>
inline constexpr bool is_get_direct_v = (is_get_direct_tableless_v<T, global, raw>) // cf-hack
|| (!global && !raw && (meta::is_c_str_or_string_v<T> || meta::is_string_of_v<T, char>)) // cf-hack
|| (!global && raw && (std::is_integral_v<T> && !std::is_same_v<T, bool>))
#if SOL_LUA_VERSION_I_ >= 503
|| (!global && !raw && (std::is_integral_v<T> && !std::is_same_v<T, bool>))
#endif // integer keys 5.3 or better
#if SOL_LUA_VERSION_I_ >= 502
|| (!global && raw && std::is_pointer_v<T> && std::is_void_v<std::remove_pointer_t<T>>)
#endif // void pointer keys 5.2 or better
;
template <typename T, bool global, bool raw>
inline constexpr bool is_set_direct_tableless_v = (global && !raw && meta::is_c_str_or_string_v<T>);
template <typename T, bool global, bool raw>
inline constexpr bool is_set_direct_v = (is_set_direct_tableless_v<T, global, raw>) // cf-hack
|| (!global && !raw && (meta::is_c_str_or_string_v<T> || meta::is_string_of_v<T, char>)) // cf-hack
|| (!global && raw && (std::is_integral_v<T> && !std::is_same_v<T, bool>)) // cf-hack
#if SOL_LUA_VERSION_I_ >= 503
|| (!global && !raw && (std::is_integral_v<T> && !std::is_same_v<T, bool>))
#endif // integer keys 5.3 or better
#if SOL_LUA_VERSION_I_ >= 502
|| (!global && raw && (std::is_pointer_v<T> && std::is_void_v<std::remove_pointer_t<T>>))
#endif // void pointer keys 5.2 or better
;
} // namespace stack_detail
template <typename T, bool global, bool raw, typename>
struct field_getter {
static inline constexpr int default_table_index
= meta::conditional_t<stack_detail::is_get_direct_v<T, global, raw>, 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_VERSION_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_VERSION_I_ >= 502
else if constexpr (std::is_pointer_v<T> && 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_or_string_v<T>) {
if constexpr (global) {
(void)tableindex;
lua_getglobal(L, &key[0]);
}
else {
lua_getfield(L, tableindex, &key[0]);
}
}
else if constexpr (std::is_same_v<T, meta_function>) {
const auto& real_key = to_string(key);
lua_getfield(L, tableindex, &real_key[0]);
}
#if SOL_LUA_VERSION_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<stack_detail::is_set_direct_v<T, global, raw>, 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_VERSION_I_ >= 502
else if constexpr (std::is_pointer_v<T> && 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_or_string_v<T>) {
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_VERSION_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
#endif // SOL_STACK_FIELD_HPP

30
extern/sol3/sol/stack_get.hpp vendored
Unescape Escape View File

@ -0,0 +1,30 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/stack_get_unqualified.hpp>
#include <sol/stack_get_qualified.hpp>
#endif // SOL_STACK_GET_HPP

37
extern/sol3/sol/stack_get_qualified.hpp vendored
Unescape Escape View File

@ -0,0 +1,37 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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_QUALIFIED_GET_HPP
#define SOL_STACK_QUALIFIED_GET_HPP
#include <sol/stack_get_unqualified.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
#endif // SOL_STACK_QUALIFIED_GET_HPP

1064
extern/sol3/sol/stack_get_unqualified.hpp vendored
View File

File diff suppressed because it is too large Load Diff

67
extern/sol3/sol/stack_guard.hpp vendored
Unescape Escape View File

@ -0,0 +1,67 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/compatibility/lua_version.hpp>
#include <sol/error.hpp>
#include <functional>
namespace sol {
namespace detail {
inline void stack_fail(int, int) {
#if SOL_IS_OFF(SOL_EXCEPTIONS_I_)
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
#endif // SOL_STACK_GUARD_HPP

153
extern/sol3/sol/stack_iterator.hpp vendored
Unescape Escape View File

@ -0,0 +1,153 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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_ITERATOR_HPP
#define SOL_STACK_ITERATOR_HPP
#include <sol/stack.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
#endif // SOL_STACK_ITERATOR_HPP

51
extern/sol3/sol/stack_pop.hpp vendored
Unescape Escape View File

@ -0,0 +1,51 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/stack_core.hpp>
#include <sol/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) {
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
#endif // SOL_STACK_POP_HPP

94
extern/sol3/sol/stack_probe.hpp vendored
Unescape Escape View File

@ -0,0 +1,94 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/stack_core.hpp>
#include <sol/stack_field.hpp>
#include <sol/stack_check.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
#endif // SOL_STACK_PROBE_HPP

64
extern/sol3/sol/stack_proxy.hpp vendored
Unescape Escape View File

@ -0,0 +1,64 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <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
#endif // SOL_STACK_PROXY_HPP

96
extern/sol3/sol/stack_proxy_base.hpp vendored
Unescape Escape View File

@ -0,0 +1,96 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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_BASE_HPP
#define SOL_STACK_PROXY_BASE_HPP
#include <sol/stack.hpp>
#include <sol/proxy_base.hpp>
namespace sol {
struct stack_proxy_base : public proxy_base<stack_proxy_base> {
private:
lua_State* m_L;
int m_index;
public:
stack_proxy_base() : m_L(nullptr), m_index(0) {
}
stack_proxy_base(lua_State* L_, int index_) : m_L(L_), m_index(index_) {
}
template <typename T>
decltype(auto) get() const {
return stack::get<T>(m_L, stack_index());
}
template <typename T>
bool is() const {
return stack::check<T>(m_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(m_L);
}
int push(lua_State* L_) const {
lua_pushvalue(L_, m_index);
return 1;
}
lua_State* lua_state() const {
return m_L;
}
int stack_index() const {
return m_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& proxy_reference) {
return proxy_reference.push();
}
};
} // namespace stack
} // namespace sol
#endif // SOL_STACK_PROXY_BASE_HPP

1382
extern/sol3/sol/stack_push.hpp vendored
View File

File diff suppressed because it is too large Load Diff

314
extern/sol3/sol/stack_reference.hpp vendored
Unescape Escape View File

@ -0,0 +1,314 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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
#include <sol/types.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 m_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 index_) noexcept : stateless_stack_reference(absolute_index(L_, index_)) {
}
stateless_stack_reference(lua_State*, absolute_index index_) noexcept : stateless_stack_reference(index_) {
}
stateless_stack_reference(lua_State*, raw_index index_) noexcept : stateless_stack_reference(index_) {
}
stateless_stack_reference(absolute_index index_) noexcept : m_index(index_) {
}
stateless_stack_reference(raw_index index_) noexcept : m_index(index_) {
}
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_, m_index);
return 1;
}
void pop(lua_State* L_, int pop_count = 1) const noexcept {
lua_pop(L_, pop_count);
}
int stack_index() const noexcept {
return m_index;
}
const void* pointer(lua_State* L_) const noexcept {
const void* pointer_id = lua_topointer(L_, stack_index());
return pointer_id;
}
type get_type(lua_State* L_) const noexcept {
int untyped_value = lua_type(L_, stack_index());
return static_cast<type>(untyped_value);
}
bool valid(lua_State* L) const noexcept {
type t = get_type(L);
return t != type::lua_nil && t != type::none;
}
void reset(lua_State*) noexcept {
m_index = 0;
}
void reset(lua_State* L_, int index_) noexcept {
m_index = absolute_index(L_, index_);
}
void abandon(lua_State* = nullptr) noexcept {
m_index = 0;
}
stateless_stack_reference copy(lua_State* L_) const noexcept {
return stateless_stack_reference(L_, raw_index(m_index));
}
void copy_assign(lua_State*, const stateless_stack_reference& right) noexcept {
m_index = right.m_index;
}
bool equals(lua_State* L_, const stateless_stack_reference& r) const noexcept {
return lua_compare(L_, this->stack_index(), r.stack_index(), LUA_OPEQ) == 1;
}
bool equals(lua_State* L_, lua_nil_t) const noexcept {
return valid(L_);
}
};
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()) {
m_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.stack_index());
lua_xmove(r.lua_state(), luastate, 1);
i = absolute_index(luastate, -1);
}
m_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* L_) const noexcept {
return stateless_stack_reference::push(L_);
}
void pop() const noexcept {
pop(lua_state());
}
void pop(lua_State* L_, int pop_count_ = 1) const noexcept {
stateless_stack_reference::pop(L_, pop_count_);
}
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) == 1;
}
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();
}
inline bool operator==(const stateless_stack_reference& l, const stateless_stack_reference& r) {
return l.stack_index() == r.stack_index();
}
inline bool operator!=(const stateless_stack_reference& l, const stateless_stack_reference& r) {
return l.stack_index() != r.stack_index();
}
struct stateless_stack_reference_equals {
using is_transparent = std::true_type;
stateless_stack_reference_equals(lua_State* L_) noexcept : m_L(L_) {
}
lua_State* lua_state() const noexcept {
return m_L;
}
bool operator()(const stateless_stack_reference& lhs, const stateless_stack_reference& rhs) const {
return lhs.equals(lua_state(), rhs);
}
bool operator()(lua_nil_t lhs, const stateless_stack_reference& rhs) const {
return rhs.equals(lua_state(), lhs);
}
bool operator()(const stateless_stack_reference& lhs, lua_nil_t rhs) const {
return lhs.equals(lua_state(), rhs);
}
private:
lua_State* m_L;
};
struct stack_reference_equals {
using is_transparent = std::true_type;
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 stateless_stack_reference_hash {
using argument_type = stateless_stack_reference;
using result_type = std::size_t;
using is_transparent = std::true_type;
stateless_stack_reference_hash(lua_State* L_) noexcept : m_L(L_) {
}
lua_State* lua_state() const noexcept {
return m_L;
}
result_type operator()(const argument_type& lhs) const noexcept {
std::hash<const void*> h;
return h(lhs.pointer(lua_state()));
}
private:
lua_State* m_L;
};
struct stack_reference_hash {
using argument_type = stack_reference;
using result_type = std::size_t;
using is_transparent = std::true_type;
result_type operator()(const argument_type& lhs) const noexcept {
std::hash<const void*> h;
return h(lhs.pointer());
}
};
} // namespace sol
#endif // SOL_STACK_REFERENCE_HPP

62
extern/sol3/sol/state.hpp vendored
Unescape Escape View File

@ -0,0 +1,62 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/state_view.hpp>
#include <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
#endif // SOL_STATE_HPP

194
extern/sol3/sol/state_handling.hpp vendored
Unescape Escape View File

@ -0,0 +1,194 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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_DEFAULT_HPP
#define SOL_STATE_DEFAULT_HPP
#include <sol/trampoline.hpp>
#include <sol/stack.hpp>
#include <sol/error.hpp>
#include <sol/function.hpp>
#include <sol/object.hpp>
#include <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_VERSION_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 << "[sol2] 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 << "[sol2] 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 = static_cast<std::size_t>(lua_gc(L, LUA_GCCOUNT, 0));
kb *= 1024;
kb += static_cast<std::size_t>(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 << "[sol2] 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
#endif // SOL_STATE_DEFAULT_HPP

874
extern/sol3/sol/state_view.hpp vendored
Unescape Escape View File

@ -0,0 +1,874 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/error.hpp>
#include <sol/table.hpp>
#include <sol/environment.hpp>
#include <sol/load_result.hpp>
#include <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_VERSION_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_VERSION_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);
int before = lua_gettop(L);
action();
int after = lua_gettop(L);
if (before == after) {
// I mean, you were supposed to return
// something, ANYTHING, from your requires script. I guess I'll just
// but some trash in here, it's on you after that?
ensure_package(key, static_cast<void*>(L));
return object(L, lua_nil);
}
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, global_tag) {
}
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_VERSION_I_ <= 501 && SOL_IS_ON(SOL_USE_LUAJIT_I_)
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 SOL_IS_OFF(SOL_USE_LUAJIT_I_)
case lib::coroutine:
#if SOL_LUA_VERSION_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:
#if SOL_IS_ON(SOL_USE_LUAJIT_I_)
luaL_requiref(L, "bit32", luaopen_bit, 1);
lua_pop(L, 1);
#elif SOL_IS_ON(SOL_LUA_BIT32_LIB_I_)
luaL_requiref(L, "bit32", luaopen_bit32, 1);
lua_pop(L, 1);
#else
#endif
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_I_ > 502 && SOL_IS_OFF(SOL_USE_LUAJIT_I_)
luaL_requiref(L, "utf8", luaopen_utf8, 1);
lua_pop(L, 1);
#endif // Lua 5.3+ only
break;
case lib::ffi:
#if SOL_IS_ON(SOL_USE_LUAJIT_I_) && SOL_IS_OFF(SOL_LUAJIT_FFI_DISABLED_I_)
luaL_requiref(L, "ffi", luaopen_ffi, 1);
lua_pop(L, 1);
#endif // LuaJIT only
break;
case lib::jit:
#if SOL_IS_ON(SOL_USE_LUAJIT_I_)
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_VERSION_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_VERSION_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_VERSION_I_ >= 504
// supports all modes
(void)mode;
return true;
#endif
return mode == gc_mode::default_value;
}
bool is_gc_on() const {
#if SOL_LUA_VERSION_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_VERSION_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_VERSION_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_VERSION_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;
}
#else
(void)minor_multiplier;
(void)major_multiplier;
#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(Args&&... args) {
return global.new_usertype<Class>(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
#endif // SOL_STATE_VIEW_HPP

45
extern/sol3/sol/string_view.hpp vendored
Unescape Escape View File

@ -0,0 +1,45 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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_VIEW_HPP
#define SOL_STRING_VIEW_HPP
#include <sol/version.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
#endif // SOL_STRING_VIEW_HPP

116
extern/sol3/sol/table.hpp vendored
Unescape Escape View File

@ -0,0 +1,116 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/table_core.hpp>
#include <sol/lua_table.hpp>
#include <sol/usertype.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) {
constant_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, automagic_flags enrollment_flags>
usertype<Class> basic_table_core<is_global, base_type>::new_usertype(Key&& key, constant_automagic_enrollments<enrollment_flags> enrollments) {
int mt_index = u_detail::register_usertype<Class, enrollment_flags>(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>
usertype<Class> basic_table_core<is_global, base_type>::new_usertype(Key&& key, automagic_enrollments enrollments) {
int mt_index = u_detail::register_usertype<Class, automagic_flags::all>(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) {
constexpr automagic_flags enrollment_flags = meta::any_same_v<no_construction, meta::unqualified_t<Arg>, meta::unqualified_t<Args>...>
? clear_flags(automagic_flags::all, automagic_flags::default_constructor)
: automagic_flags::all;
constant_automagic_enrollments<enrollment_flags> 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>
basic_metatable<base_type>& 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 = nullopt;
maybe_uts = u_detail::maybe_get_usertype_storage_base(L, target);
if (maybe_uts) {
u_detail::usertype_storage_base& uts = *maybe_uts;
uts.set(L, std::forward<Key>(key), std::forward<Value>(value));
return *this;
}
else {
base_t::set(std::forward<Key>(key), std::forward<Value>(value));
}
this->pop();
return *this;
}
namespace stack {
template <>
struct unqualified_getter<metatable_key_t> {
static metatable get(lua_State* L, int index = -1) {
if (lua_getmetatable(L, index) == 0) {
return metatable(L, ref_index(LUA_REFNIL));
}
return metatable(L, -1);
}
};
} // namespace stack
} // namespace sol
#endif // SOL_TABLE_HPP

733
extern/sol3/sol/table_core.hpp vendored
Unescape Escape View File

@ -0,0 +1,733 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/table_proxy.hpp>
#include <sol/stack.hpp>
#include <sol/function_types.hpp>
#include <sol/table_iterator.hpp>
#include <sol/pairs_iterator.hpp>
#include <sol/types.hpp>
#include <sol/object.hpp>
#include <sol/usertype.hpp>
#include <sol/optional.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& pop_count;
ref_clean(lua_State* L_, int& pop_count_) noexcept : L(L_), pop_count(pop_count_) {
}
~ref_clean() {
lua_pop(L, static_cast<int>(pop_count));
}
};
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 <typename T>
using is_get_direct_tableless = meta::boolean<stack::stack_detail::is_get_direct_tableless_v<T, top_level, false>>;
template <typename T>
using is_raw_get_direct_tableless = std::false_type;
template <typename T>
using is_set_direct_tableless = meta::boolean<stack::stack_detail::is_set_direct_tableless_v<T, top_level, false>>;
template <typename T>
using is_raw_set_direct_tableless = std::false_type;
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 = (meta::count_for_to_pack_v < 1, is_get_direct_tableless, 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 = (meta::count_even_for_pack_v < is_set_direct_tableless,
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)...);
}
}
}
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) {
}
basic_table_core(lua_State* L, global_tag_t t) noexcept : base_t(L, t) {
}
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();
}
basic_pairs_range<basic_table_core> pairs() noexcept {
return basic_pairs_range<basic_table_core>(*this);
}
basic_pairs_range<const basic_table_core> pairs() const noexcept {
return basic_pairs_range<const basic_table_core>(*this);
}
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>, is_get_direct_tableless<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 = (meta::count_for_to_pack_v < 1, is_get_direct_tableless, 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
= (meta::count_when_for_to_pack_v < detail::is_not_insert_mode, 1, is_set_direct_tableless, 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 = (meta::count_for_to_pack_v < 1, is_raw_get_direct_tableless, 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 = (meta::count_for_to_pack_v < 1, is_raw_get_direct_tableless, 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 = (meta::count_for_to_pack_v < 1, is_raw_set_direct_tableless, 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, automagic_flags enrollment_flags>
usertype<Class> new_usertype(Key&& key, constant_automagic_enrollments<enrollment_flags> enrollment);
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_base_of_v<automagic_enrollments, meta::unqualified_t<Arg>>>>
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 constexpr (read_only) {
// Need to create a special iterator to handle this
table x
= create_with(meta_function::new_index, detail::fail_on_newindex, meta_function::index, target, meta_function::pairs, stack::stack_detail::readonly_pairs);
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
#endif // SOL_TABLE_CORE_HPP

114
extern/sol3/sol/table_iterator.hpp vendored
Unescape Escape View File

@ -0,0 +1,114 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/object.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() noexcept : keyidx(-1), idx(-1) {
}
basic_table_iterator(reference_type x) noexcept : 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++() noexcept {
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) noexcept {
auto saved = *this;
this->operator++();
return saved;
}
reference operator*() const noexcept {
return const_cast<reference>(kvp);
}
bool operator==(const basic_table_iterator& right) const noexcept {
return idx == right.idx;
}
bool operator!=(const basic_table_iterator& right) const noexcept {
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
#endif // SOL_TABLE_ITERATOR_HPP

337
extern/sol3/sol/table_proxy.hpp vendored
Unescape Escape View File

@ -0,0 +1,337 @@
// sol3
// The MIT License (MIT)
// Copyright (c) 2013-2021 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_PROXY_HPP
#define SOL_TABLE_PROXY_HPP
#include <sol/traits.hpp>
#include <sol/function.hpp>
#include <sol/protected_function.hpp>
#include <sol/proxy_base.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) && {
std::move(*this).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_invocable_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_invocable_v<Tu> && !detail::is_msvc_callable_rigged_v<T>) {
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
#endif // SOL_TABLE_PROXY_HPP

189
extern/sol3/sol/thread.hpp vendored
Unescape Escape View File

@ -0,0 +1,189 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/reference.hpp>
#include <sol/object.hpp>
#include <sol/stack.hpp>
#include <sol/state_view.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
#endif // SOL_THREAD_HPP

98
extern/sol3/sol/tie.hpp vendored
Unescape Escape View File

@ -0,0 +1,98 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/traits.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
#endif // SOL_TIE_HPP

739
extern/sol3/sol/traits.hpp vendored
Unescape Escape View File

@ -0,0 +1,739 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/tuple.hpp>
#include <sol/bind_traits.hpp>
#include <sol/pointer_like.hpp>
#include <sol/base_traits.hpp>
#include <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... Args>
constexpr inline bool all_v = all<Args...>::value;
template <typename... Args>
constexpr inline bool any_v = any<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_invocable : std::is_function<std::remove_pointer_t<T>> { };
template <typename T>
struct is_invocable<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_invocable<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_invocable<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_with_iterator_test {
private:
template <typename C>
static sfinae_yes_t test(decltype(std::declval<C>().insert(
std::declval<std::add_rvalue_reference_t<typename C::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_no_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::value_type>>()))*);
template <typename C>
static sfinae_no_t test(...);
public:
static constexpr bool value = !std::is_same_v<decltype(test<T>(0)), sfinae_no_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,
#if SOL_IS_ON(SOL_STD_VARIANT_I_)
!is_specialization_of_v<unqualified_t<T>, std::variant> && !is_specialization_of_v<unqualified_t<U>, std::variant>
#else
true
#endif
> {
};
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,
#if SOL_IS_ON(SOL_STD_VARIANT_I_)
!is_specialization_of_v<unqualified_t<T>, std::variant> && !is_specialization_of_v<unqualified_t<U>, std::variant>
#else
true
#endif
> {
};
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,
#if SOL_IS_ON(SOL_STD_VARIANT_I_)
!is_specialization_of_v<unqualified_t<T>, std::variant> && !is_specialization_of_v<unqualified_t<U>, std::variant>
#else
true
#endif
> {
};
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_invocable = boolean<meta_detail::is_invocable<T>::value>;
template <typename T>
constexpr inline bool is_invocable_v = is_invocable<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_with_iterator = meta::boolean<meta_detail::has_insert_with_iterator_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,
#if SOL_IS_ON(SOL_CHAR8_T_I_)
char8_t,
#endif
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> || std::is_null_pointer_v<T>>;
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_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, typename Char>
using is_c_str_or_string_of = any<is_c_str_of<T, Char>, is_string_of<T, Char>>;
template <typename T, typename Char>
constexpr inline bool is_c_str_or_string_of_v = is_c_str_or_string_of<T, Char>::value;
template <typename T>
using is_c_str_or_string = is_c_str_or_string_of<T, char>;
template <typename T>
constexpr inline bool is_c_str_or_string_v = is_c_str_or_string<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
#endif // SOL_TRAITS_HPP

214
extern/sol3/sol/trampoline.hpp vendored
Unescape Escape View File

@ -0,0 +1,214 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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_TRAMPOLINE_HPP
#define SOL_TRAMPOLINE_HPP
#include <sol/types.hpp>
#include <sol/traits.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 << "[sol2] An exception occurred: ";
std::cerr.write(what.data(), static_cast<std::streamsize>(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_ON(SOL_EXCEPTIONS_CATCH_ALL_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_ON(SOL_EXCEPTIONS_CATCH_ALL_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 0
// TODO: you must evaluate the get/check_get of every
// argument, to ensure it doesn't throw
// (e.g., for the sol_lua_check_access extension point!)
// This incluudes properly noexcept-ing all the above
// trampolines / safety nets
if constexpr (meta::bind_traits<F>::is_noexcept) {
return static_trampoline_noexcept<fx>(L);
}
else
#endif
{ 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
#endif // SOL_TRAMPOLINE_HPP

93
extern/sol3/sol/tuple.hpp vendored
Unescape Escape View File

@ -0,0 +1,93 @@
// sol2
// The MIT License (MIT)
// Copyright (c) 2013-2021 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 <sol/forward.hpp>
#include <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
#endif // SOL_TUPLE_HPP

1496
extern/sol3/sol/types.hpp vendored
View File

File diff suppressed because it is too large Load Diff

308
extern/sol3/sol/unicode.hpp vendored
Unescape Escape View File

@ -0,0 +1,308 @@
#pragma once
#include <sol/string_view.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 (static_cast<char32_t>((b0 & 0x1Fu) << 6u) | static_cast<char32_t>(b1 & 0x3Fu));
}
static constexpr char32_t decode(unsigned char b0, unsigned char b1, unsigned char b2) {
return static_cast<char32_t>((b0 & 0x0Fu) << 12u) | static_cast<char32_t>((b1 & 0x3Fu) << 6u) | static_cast<char32_t>(b2 & 0x3Fu);
}
static constexpr char32_t decode(unsigned char b0, unsigned char b1, unsigned char b2, unsigned char b3) {
return static_cast<char32_t>(static_cast<char32_t>((b0 & 0x07u) << 18u) | static_cast<char32_t>((b1 & 0x3F) << 12)
| static_cast<char32_t>((b2 & 0x3Fu) << 6u) | static_cast<char32_t>(b3 & 0x3Fu));
}
// 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 = static_cast<unsigned char>(*it);
std::size_t length = static_cast<std::size_t>(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] = static_cast<unsigned char>(*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;
}
} // namespace unicode
} // namespace sol

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

Write Preview
Loading…
Cancel
Save