diff --git a/.gitignore b/.gitignore index 9c836821..55ca734b 100644 --- a/.gitignore +++ b/.gitignore @@ -82,6 +82,10 @@ main2.cpp main.cpp # Local Lua Testbeds +lua-5.4.0-cxx/ +lua-5.4.0/ +lua-5.4.0-work1-cxx/ +lua-5.4.0-work1/ lua-5.3.4-cxx/ lua-5.3.4/ lua-5.3.2/ diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md new file mode 100644 index 00000000..52f4e0f9 --- /dev/null +++ b/CONTRIBUTORS.md @@ -0,0 +1,9 @@ +# Donators! ♥ + +Thank you to all patrons, donators and contributors who help keep sol2 amazing. + +Robert Salvet +Ορφέας Ζαφείρης - 2x Donations! +Michael Wallar +Johannes Schultz +Dailidzionak Ilya diff --git a/README.md b/README.md index 439f3e47..3e901803 100644 --- a/README.md +++ b/README.md @@ -47,6 +47,17 @@ int main() { More examples are given in the examples directory [here](https://github.com/ThePhD/sol2/tree/develop/examples). +## Supporting + +You can [donate to support Sol and the project](https://www.paypal.me/LMeneide), which is always appreciated! This is a time-consuming effort, so individuals who donate get to: + +- steer the direction and time spent on sol +- get a role on the Discord server +- get their name put up in the CONTRIBUTORS list +- put something of their choice on sol2's README or the documentation's front page + +You can also help out the library by submitting pull requests to fix anything or add anything you think would be helpful! This includes making small, useful examples of something you haven't seen, or fixing typos and bad code in the documentation. + ## Presentations "A Sun For the Moon - A Zero-Overhead Lua Abstraction using C++" @@ -118,12 +129,6 @@ Testing on Travis-CI and Appveyor use CMake. You can generate the tests by runni You will need any flavor of python3 and an available compiler. The testing suite will build its own version of Lua and LuaJIT, so you do not have to. -## Supporting - -You can help out the library by submitting pull requests to fix anything or add anything you think would be helpful! This includes making small, useful examples of something you haven't seen, or fixing typos and bad code in the documentation. - -You can also [donate to support me and my family](https://www.paypal.me/LMeneide), which is always appreciated! - ## License Sol is distributed with an MIT License. You can see LICENSE.txt for more info. diff --git a/docs/source/api/overload.rst b/docs/source/api/overload.rst index 5fc64a09..8817aab8 100644 --- a/docs/source/api/overload.rst +++ b/docs/source/api/overload.rst @@ -19,6 +19,9 @@ The actual class produced by ``sol::overload`` is essentially a type-wrapper aro Please note that default parameters in a function (e.g., ``int func(int a = 20)``) do not exist beyond C++'s compile-time fun. When that function gets bound or serialized into Lua's framework, it is bound as a function taking 1 argument, not 2 functions taking either 0 or 1 argument. If you want to achieve the same effect, then you need to use overloading and explicitly call the version of the function you want. There is no magic in C++ that allows me to retrieve default parameters and set this up automatically. +.. note:: + + Overload resolution can be affected by configuration defines in the :doc:`safety pages<../safety>`. For example, it is impossible to differentiate between integers (uint8_t, in32_t, etc.) versus floating-point types (float, double, half) when ``SOL_SAFE_NUMERICS`` is not turned on. Its use is simple: wherever you can pass a function type to Lua, whether its on a :doc:`usertype` or if you are just setting any kind of function with ``set`` or ``set_function`` (for :doc:`table` or :doc:`state(_view)`), simply wrap up the functions you wish to be considered for overload resolution on one function like so: diff --git a/docs/source/api/resolve.rst b/docs/source/api/resolve.rst index 091204e3..6c79f171 100644 --- a/docs/source/api/resolve.rst +++ b/docs/source/api/resolve.rst @@ -63,3 +63,7 @@ It can also be used with :doc:`sol::c_call`: lua.script("f(1, 2)"); + +.. note:: + + You cannot use ``sol::resolve<...>(...)`` when one function is templated and it has a non-templated overload: it will always fail in this case. To resolve this, please use a manual ``static_cast( &func )`` or ``static_cast( &T::overloaded_member_func )`` (with the right const-ness and volatile-ness and r-value/l-value qualifiers if necessary). diff --git a/docs/source/containers.rst b/docs/source/containers.rst index eae61b1d..41a85cb4 100644 --- a/docs/source/containers.rst +++ b/docs/source/containers.rst @@ -110,7 +110,7 @@ Below are the many container operations and their override points for ``containe +-----------+-------------------------------------------+--------------------------------------------------+----------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | at | ``v = c:at(key)`` | ``static int at(lua_State*);`` | 1 self | - can return multiple values | | | | | 2 index | - default implementation increments iterators linearly for non-random-access | -| | | | 2 index | - if the type does not have random-access iterators, **do not use this in a for loop** ! | +| | | | | - if the type does not have random-access iterators, **do not use this in a for loop** ! | +-----------+-------------------------------------------+--------------------------------------------------+----------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | get | ``v = c:get(key)`` | ``static int get(lua_State*);`` | 1 self | - can return multiple values | | | | | 2 key | - default implementation increments iterators linearly for non-random-access | @@ -142,9 +142,11 @@ Below are the many container operations and their override points for ``containe +-----------+-------------------------------------------+--------------------------------------------------+----------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | offset | n/a | ``static int index_adjustment(lua_State*, T&);`` | n/a | - returns an index that adds to the passed-in numeric index for array acces (default implementation is ``return -1`` to simulate 1-based indexing from Lua) | +-----------+-------------------------------------------+--------------------------------------------------+----------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| begin | n/a | ``static int begin(lua_State*, T&);`` | n/a | - called by default implementation | +| begin | n/a | ``static iterator begin(lua_State*, T&);`` | n/a | - called by default implementation | +| | | | | - is not the regular raw function: must return an iterator from second "T&" argument, which is self | +-----------+-------------------------------------------+--------------------------------------------------+----------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ -| end | n/a | ``static int end(lua_State*, T&);`` | n/a | - called by default implementation | +| end | n/a | ``static iterator end(lua_State*, T&);`` | n/a | - called by default implementation | +| | | | | - is not the regular raw function: must return an iterator from second "T&" argument, which is self | +-----------+-------------------------------------------+--------------------------------------------------+----------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | next | | ``static int next(lua_State*);`` | 1 self | - implement if advanced user only that understands caveats | | | | | | - is used as 'iteration function' dispatched with pairs() call | diff --git a/docs/source/functions.rst b/docs/source/functions.rst index be28337f..5bb2ea32 100644 --- a/docs/source/functions.rst +++ b/docs/source/functions.rst @@ -13,6 +13,7 @@ There are a number of examples dealing with functions and how they can be bound - using :doc:`sol::variadic_results` * :doc:`Overload function calls with different argument types and count on a single name` (first-bound, first-serve overloading) - Note: because of this feature, automatic number to string conversion from Lua is not permitted for overloads and does not work when safeties are turned on + - int/float overloads must have ``SOL_SAFE_NUMERICS`` turned on to differentiate between the two - Use C++ captures and lambdas to bind member functions tied to a single object / * You can work with **transparent arguments** that provide you with special information, such as - :doc:`sol::variadic_args`, for handling variable number of arguments at runtime diff --git a/docs/source/index.rst b/docs/source/index.rst index e9de95bf..e751847c 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -69,12 +69,16 @@ the basics: helping out ----------- -You can support the library by submitting pull requests to fix anything (the code, typos, even contribute your own examples). +You can support sol2 development by `donating here`_. This is a time-consuming effort, so individuals who donate get to: -You can support me and my family by `donating a little something here`_. +- steer the direction and time spent on sol +- get a role on the Discord server +- get their name put up in the CONTRIBUTORS list +- put something of their choice on sol2's README or the documentation's front page -Thank you for using sol2! +You can also help out the library by submitting pull requests to fix anything or add anything you think would be helpful! This includes making small, useful examples of something you haven't seen, or fixing typos and bad code in the documentation. +Finally, `come join in Discord`_! Indices and tables ================== @@ -85,4 +89,5 @@ Indices and tables .. _Sol: https://github.com/ThePhD/sol2 .. _issues: https://github.com/ThePhD/sol2/issues .. _examples directory: https://github.com/ThePhD/sol2/tree/develop/examples -.. _donating a little something here: https://www.paypal.me/LMeneide +.. _donating here: https://www.paypal.me/LMeneide +.. _come join in Discord: https://discord.gg/buxkYNT diff --git a/docs/source/safety.rst b/docs/source/safety.rst index 79e51e67..ff6b2396 100644 --- a/docs/source/safety.rst +++ b/docs/source/safety.rst @@ -39,6 +39,7 @@ Safety Config ``SOL_SAFE_NUMERICS`` triggers the following changes: * Numbers will also be checked to see if they fit within a ``lua_Number`` if there is no ``lua_Integer`` type available that can fit your signed or unsigned number * You can opt-out of this behavior with ``SOL_NO_CHECK_NUMBER_PRECISION`` + * **This option is required to differentiate between floats/ints in overloads** * **Not** turned on by default under any settings: *this MUST be turned on manually* ``SOL_SAFE_GETTER`` triggers the following changes: diff --git a/single/sol/sol.hpp b/single/sol/sol.hpp index 5abaa9c4..38614733 100644 --- a/single/sol/sol.hpp +++ b/single/sol/sol.hpp @@ -1,21598 +1,21598 @@ -// The MIT License (MIT) - -// Copyright (c) 2013-2018 Rapptz, ThePhD and contributors - -// Permission is hereby granted, free of charge, to any person obtaining a copy of -// this software and associated documentation files (the "Software"), to deal in -// the Software without restriction, including without limitation the rights to -// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of -// the Software, and to permit persons to whom the Software is furnished to do so, -// subject to the following conditions: - -// The above copyright notice and this permission notice shall be included in all -// copies or substantial portions of the Software. - -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS -// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR -// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER -// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN -// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - -// This file was generated with a script. -// Generated 2018-05-22 19:42:19.603781 UTC -// This header was generated with sol v2.20.2 (revision d67c5b7) -// https://github.com/ThePhD/sol2 - -#ifndef SOL_SINGLE_INCLUDE_HPP -#define SOL_SINGLE_INCLUDE_HPP - -// beginning of sol.hpp - -#ifndef SOL_HPP -#define SOL_HPP - -#if defined(UE_BUILD_DEBUG) || defined(UE_BUILD_DEVELOPMENT) || defined(UE_BUILD_TEST) || defined(UE_BUILD_SHIPPING) || defined(UE_SERVER) -#define SOL_INSIDE_UNREAL 1 -#endif // Unreal Engine 4 bullshit - -#if defined(SOL_INSIDE_UNREAL) && SOL_INSIDE_UNREAL -#ifdef check -#define SOL_INSIDE_UNREAL_REMOVED_CHECK -#undef check -#endif -#endif // Unreal Engine 4 Bullshit - -#if defined(__GNUC__) -#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 defined(__clang__) -#elif defined _MSC_VER -#pragma warning( push ) -#pragma warning( disable : 4324 ) // structure was padded due to alignment specifier -#pragma warning( disable : 4503 ) // decorated name horse shit -#pragma warning( disable : 4702 ) // unreachable code -#pragma warning( disable: 4127 ) // 'conditional expression is constant' yeah that's the point your old compilers don't have `if constexpr` you jerk -#pragma warning( disable: 4505 ) // some other nonsense warning -#endif // clang++ vs. g++ vs. VC++ - -// beginning of sol/forward.hpp - -// beginning of sol/feature_test.hpp - -#if (defined(__cplusplus) && __cplusplus == 201703L) || (defined(_MSC_VER) && _MSC_VER > 1900 && ((defined(_HAS_CXX17) && _HAS_CXX17 == 1) || (defined(_MSVC_LANG) && (_MSVC_LANG > 201402L)))) -#ifndef SOL_CXX17_FEATURES -#define SOL_CXX17_FEATURES 1 -#endif // C++17 features macro -#endif // C++17 features check - -#if defined(SOL_CXX17_FEATURES) && SOL_CXX17_FEATURES -#if defined(__cpp_noexcept_function_type) || ((defined(_MSC_VER) && _MSC_VER > 1911) && (defined(_MSVC_LANG) && ((_MSVC_LANG >= 201403L)))) -#ifndef SOL_NOEXCEPT_FUNCTION_TYPE -#define SOL_NOEXCEPT_FUNCTION_TYPE 1 -#endif // noexcept is part of a function's type -#endif // compiler-specific checks -#if defined(__clang__) && defined(__APPLE__) -#if defined(__has_include) -#if __has_include() -#define SOL_STD_VARIANT 1 -#endif // has include nonsense -#endif // __has_include -#else -#define SOL_STD_VARIANT 1 -#endif // Clang screws up variant -#endif // C++17 only - -// beginning of sol/config.hpp - -#ifdef _MSC_VER - #if defined(_DEBUG) && !defined(NDEBUG) - - #ifndef SOL_IN_DEBUG_DETECTED - #define SOL_IN_DEBUG_DETECTED 1 - #endif - - #endif // VC++ Debug macros - - #ifndef _CPPUNWIND - #ifndef SOL_NO_EXCEPTIONS - #define SOL_NO_EXCEPTIONS 1 - #endif - #endif // Automatic Exceptions - - #ifndef _CPPRTTI - #ifndef SOL_NO_RTTI - #define SOL_NO_RTTI 1 - #endif - #endif // Automatic RTTI -#elif defined(__GNUC__) || defined(__clang__) - - #if !defined(NDEBUG) && !defined(__OPTIMIZE__) - - #ifndef SOL_IN_DEBUG_DETECTED - #define SOL_IN_DEBUG_DETECTED 1 - #endif - - #endif // Not Debug && g++ optimizer flag - - #ifndef __EXCEPTIONS - #ifndef SOL_NO_EXCEPTIONS - #define SOL_NO_EXCEPTIONS 1 - #endif - #endif // No Exceptions - - #ifndef __GXX_RTTI - #ifndef SOL_NO_RTII - #define SOL_NO_RTTI 1 - #endif - #endif // No RTTI - -#endif // vc++ || clang++/g++ - -#if defined(SOL_CHECK_ARGUMENTS) && SOL_CHECK_ARGUMENTS - - // Checks low-level getter function - // (and thusly, affects nearly entire framework) - #if !defined(SOL_SAFE_GETTER) - #define SOL_SAFE_GETTER 1 - #endif - - // Checks access on usertype functions - // local my_obj = my_type.new() - // my_obj.my_member_function() - // -- bad syntax and crash - #if !defined(SOL_SAFE_USERTYPE) - #define SOL_SAFE_USERTYPE 1 - #endif - - // Checks sol::reference derived boundaries - // sol::function ref(L, 1); - // sol::userdata sref(L, 2); - #if !defined(SOL_SAFE_REFERENCES) - #define SOL_SAFE_REFERENCES 1 - #endif - - // Changes all typedefs of sol::function to point to the - // protected_function version, instead of unsafe_function - #if !defined(SOL_SAFE_FUNCTION) - #define SOL_SAFE_FUNCTION 1 - #endif - - // Checks function parameters and - // returns upon call into/from Lua - // local a = 1 - // local b = "woof" - // my_c_function(a, b) - #if !defined(SOL_SAFE_FUNCTION_CALLS) - #define SOL_SAFE_FUNCTION_CALLS 1 - #endif - - // Checks conversions - // int v = lua["bark"]; - // int v2 = my_sol_function(); - #if !defined(SOL_SAFE_PROXIES) - #define SOL_SAFE_PROXIES 1 - #endif - - // Check overflowing number conversions - // for things like 64 bit integers that don't fit in a typical lua_Number - // for Lua 5.1 and 5.2 - #if !defined(SOL_SAFE_NUMERICS) - #define SOL_SAFE_NUMERICS 1 - #endif - - // Turn off Number Precision Checks - // if this is defined, we do not do range - // checks on integers / unsigned integers that might - // be bigger than what Lua can represent - #if !defined(SOL_NO_CHECK_NUMBER_PRECISION) - // off by default - #define SOL_NO_CHECK_NUMBER_PRECISION 0 - #endif - -#endif // Turn on Safety for all if top-level macro is defined - -#if defined(SOL_IN_DEBUG_DETECTED) && SOL_IN_DEBUG_DETECTED - - #if !defined(SOL_SAFE_REFERENCES) - // Ensure that references are forcefully type-checked upon construction - #define SOL_SAFE_REFERENCES 1 - #endif - - // Safe usertypes checks for errors such as - // obj = my_type.new() - // obj.f() -- note the '.' instead of ':' - // usertypes should be safe no matter what - #if !defined(SOL_SAFE_USERTYPE) - #define SOL_SAFE_USERTYPE 1 - #endif - - #if !defined(SOL_SAFE_FUNCTION_CALLS) - // Function calls from Lua should be automatically safe in debug mode - #define SOL_SAFE_FUNCTION_CALLS 1 - #endif - - // Print any exceptions / errors that occur - // in debug mode to the default error stream / console - #if !defined(SOL_PRINT_ERRORS) - #define SOL_PRINT_ERRORS 1 - #endif - -#endif // DEBUG: Turn on all debug safety features for VC++ / g++ / clang++ and similar - -#if !defined(SOL_PRINT_ERRORS) -#define SOL_PRINT_ERRORS 0 -#endif - -#if !defined(SOL_DEFAULT_PASS_ON_ERROR) -#define SOL_DEFAULT_PASS_ON_ERROR 0 -#endif - -#if !defined(SOL_ENABLE_INTEROP) -#define SOL_ENABLE_INTEROP 0 -#endif - -#if defined(__MAC_OS_X_VERSION_MAX_ALLOWED) || defined(__OBJC__) || defined(nil) -#if !defined(SOL_NO_NIL) -#define SOL_NO_NIL 1 -#endif -#endif // avoiding nil defines / keywords - -#if defined(SOL_USE_BOOST) && SOL_USE_BOOST -#ifndef SOL_UNORDERED_MAP_COMPATIBLE_HASH -#define SOL_UNORDERED_MAP_COMPATIBLE_HASH 1 -#endif // SOL_UNORDERED_MAP_COMPATIBLE_HASH -#endif - -#ifndef SOL_STACK_STRING_OPTIMIZATION_SIZE -#define SOL_STACK_STRING_OPTIMIZATION_SIZE 1024 -#endif // Optimized conversion routines using a KB or so off the stack - -// end of sol/config.hpp - -// end of sol/feature_test.hpp - -namespace sol { - - template - class basic_reference; - using reference = basic_reference; - using main_reference = basic_reference; - class stack_reference; - - struct proxy_base_tag; - template - struct proxy_base; - template - struct proxy; - - template - class usertype; - template - class simple_usertype; - template - class basic_table_core; - template - using table_core = basic_table_core; - template - using main_table_core = basic_table_core; - template - using stack_table_core = basic_table_core; - template - using basic_table = basic_table_core; - typedef table_core table; - typedef table_core global_table; - typedef main_table_core main_table; - typedef main_table_core main_global_table; - typedef stack_table_core stack_table; - typedef stack_table_core stack_global_table; - template - struct basic_environment; - using environment = basic_environment; - using main_environment = basic_environment; - using stack_environment = basic_environment; - template - class basic_function; - template - class basic_protected_function; - using unsafe_function = basic_function; - using safe_function = basic_protected_function; - using main_unsafe_function = basic_function; - using main_safe_function = basic_protected_function; - using stack_unsafe_function = basic_function; - using stack_safe_function = basic_protected_function; - using stack_aligned_unsafe_function = basic_function; - using stack_aligned_safe_function = basic_protected_function; - 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 defined(SOL_SAFE_FUNCTION) && SOL_SAFE_FUNCTION - using function = protected_function; - using main_function = main_protected_function; - using stack_function = stack_protected_function; -#else - using function = unsafe_function; - using main_function = main_unsafe_function; - using stack_function = stack_unsafe_function; -#endif - using stack_aligned_function = stack_aligned_unsafe_function; - using stack_aligned_stack_handler_function = basic_protected_function; - - struct unsafe_function_result; - struct protected_function_result; - using safe_function_result = protected_function_result; -#if defined(SOL_SAFE_FUNCTION) && SOL_SAFE_FUNCTION - using function_result = safe_function_result; -#else - using function_result = unsafe_function_result; -#endif - - template - class basic_object; - template - class basic_userdata; - template - class basic_lightuserdata; - template - class basic_coroutine; - template - class basic_thread; - - using object = basic_object; - using userdata = basic_userdata; - using lightuserdata = basic_lightuserdata; - using thread = basic_thread; - using coroutine = basic_coroutine; - using main_object = basic_object; - using main_userdata = basic_userdata; - using main_lightuserdata = basic_lightuserdata; - using main_coroutine = basic_coroutine; - using stack_object = basic_object; - using stack_userdata = basic_userdata; - using stack_lightuserdata = basic_lightuserdata; - using stack_thread = basic_thread; - using stack_coroutine = basic_coroutine; - - 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; - - template - struct as_table_t; - template - struct as_container_t; - template - struct nested; - template - struct light; - template - struct user; - template - struct as_args_t; - template - struct protect_t; - template - struct filter_wrapper; -} // namespace sol - -// end of sol/forward.hpp - -// beginning of sol/state.hpp - -// beginning of sol/state_view.hpp - -// beginning of sol/error.hpp - -#include -#include - -namespace sol { - namespace detail { - struct direct_error_tag {}; - const auto direct_error = direct_error_tag{}; - } // namespace detail - - class error : public std::runtime_error { - private: - // Because VC++ is upsetting, most of the time! - std::string w; - - public: - error(const std::string& str) - : error(detail::direct_error, "lua: error: " + str) { - } - error(std::string&& str) - : error(detail::direct_error, "lua: error: " + std::move(str)) { - } - error(detail::direct_error_tag, const std::string& str) - : std::runtime_error(""), w(str) { - } - error(detail::direct_error_tag, std::string&& str) - : std::runtime_error(""), w(std::move(str)) { - } - - error(const error& e) = default; - error(error&& e) = default; - error& operator=(const error& e) = default; - error& operator=(error&& e) = default; - - virtual const char* what() const noexcept override { - return w.c_str(); - } - }; - -} // namespace sol - -// end of sol/error.hpp - -// beginning of sol/table.hpp - -// beginning of sol/table_core.hpp - -// beginning of sol/proxy.hpp - -// beginning of sol/traits.hpp - -// beginning of sol/tuple.hpp - -#include -#include - -namespace sol { - namespace detail { - using swallow = std::initializer_list; - } // namespace detail - - template - struct types { - typedef std::make_index_sequence indices; - static constexpr std::size_t size() { - return sizeof...(Args); - } - }; - namespace meta { - namespace detail { - template - struct tuple_types_ { typedef types type; }; - - template - struct tuple_types_> { typedef types type; }; - } // namespace detail - - template - using unqualified = std::remove_cv>; - - template - using unqualified_t = typename unqualified::type; - - template - using tuple_types = typename detail::tuple_types_::type; - - template - struct pop_front_type; - - template - using pop_front_type_t = typename pop_front_type::type; - - template - struct pop_front_type> { - typedef void front_type; - typedef types type; - }; - - template - struct pop_front_type> { - typedef Arg front_type; - typedef types type; - }; - - template - using tuple_element = std::tuple_element>; - - template - using tuple_element_t = std::tuple_element_t>; - - template - using unqualified_tuple_element = unqualified>; - - template - using unqualified_tuple_element_t = unqualified_t>; - - } // namespace meta -} // namespace sol - -// end of sol/tuple.hpp - -// beginning of sol/bind_traits.hpp - -namespace sol { -namespace meta { - namespace meta_detail { - - template - struct check_deducible_signature { - struct nat {}; - template - static auto test(int) -> decltype(&G::operator(), void()); - template - static auto test(...) -> nat; - - using type = std::is_void(0))>; - }; - } // namespace meta_detail - - template - struct has_deducible_signature : meta_detail::check_deducible_signature::type {}; - - namespace meta_detail { - - template - struct void_tuple_element : meta::tuple_element {}; - - template - struct void_tuple_element> { typedef void type; }; - - template - using void_tuple_element_t = typename void_tuple_element::type; - - template - struct basic_traits { - private: - typedef std::conditional_t::value, int, T>& first_type; - - public: - static const bool is_noexcept = it_is_noexcept; - static const bool is_member_function = std::is_void::value; - static const bool has_c_var_arg = has_c_variadic; - static const std::size_t arity = sizeof...(Args); - static const std::size_t free_arity = sizeof...(Args) + static_cast(!std::is_void::value); - typedef types args_list; - typedef std::tuple args_tuple; - typedef T object_type; - typedef R return_type; - typedef tuple_types returns_list; - typedef R(function_type)(Args...); - typedef std::conditional_t::value, args_list, types> free_args_list; - typedef std::conditional_t::value, R(Args...), R(first_type, Args...)> free_function_type; - typedef std::conditional_t::value, R (*)(Args...), R (*)(first_type, Args...)> free_function_pointer_type; - typedef std::remove_pointer_t signature_type; - template - using arg_at = void_tuple_element_t; - }; - - template ::value> - struct fx_traits : basic_traits {}; - - // Free Functions - template - struct fx_traits : basic_traits { - typedef R (*function_pointer_type)(Args...); - }; - - template - struct fx_traits : basic_traits { - typedef R (*function_pointer_type)(Args...); - }; - - template - struct fx_traits : basic_traits { - typedef R (*function_pointer_type)(Args..., ...); - }; - - template - struct fx_traits : basic_traits { - typedef R (*function_pointer_type)(Args..., ...); - }; - - // Member Functions - /* C-Style Variadics */ - template - struct fx_traits : basic_traits { - typedef R (T::*function_pointer_type)(Args...); - }; - - template - struct fx_traits : basic_traits { - typedef R (T::*function_pointer_type)(Args..., ...); - }; - - /* Const Volatile */ - template - struct fx_traits : basic_traits { - typedef R (T::*function_pointer_type)(Args...) const; - }; - - template - struct fx_traits : basic_traits { - typedef R (T::*function_pointer_type)(Args..., ...) const; - }; - - template - struct fx_traits : basic_traits { - typedef R (T::*function_pointer_type)(Args...) const volatile; - }; - - template - struct fx_traits : basic_traits { - typedef R (T::*function_pointer_type)(Args..., ...) const volatile; - }; - - /* Member Function Qualifiers */ - template - struct fx_traits : basic_traits { - typedef R (T::*function_pointer_type)(Args...) &; - }; - - template - struct fx_traits : basic_traits { - typedef R (T::*function_pointer_type)(Args..., ...) &; - }; - - template - struct fx_traits : basic_traits { - typedef R (T::*function_pointer_type)(Args...) const&; - }; - - template - struct fx_traits : basic_traits { - typedef R (T::*function_pointer_type)(Args..., ...) const&; - }; - - template - struct fx_traits : basic_traits { - typedef R (T::*function_pointer_type)(Args...) const volatile&; - }; - - template - struct fx_traits : basic_traits { - typedef R (T::*function_pointer_type)(Args..., ...) const volatile&; - }; - - template - struct fx_traits : basic_traits { - typedef R (T::*function_pointer_type)(Args...) &&; - }; - - template - struct fx_traits : basic_traits { - typedef R (T::*function_pointer_type)(Args..., ...) &&; - }; - - template - struct fx_traits : basic_traits { - typedef R (T::*function_pointer_type)(Args...) const&&; - }; - - template - struct fx_traits : basic_traits { - typedef R (T::*function_pointer_type)(Args..., ...) const&&; - }; - - template - struct fx_traits : basic_traits { - typedef R (T::*function_pointer_type)(Args...) const volatile&&; - }; - - template - struct fx_traits : basic_traits { - typedef R (T::*function_pointer_type)(Args..., ...) const volatile&&; - }; - -#if defined(SOL_NOEXCEPT_FUNCTION_TYPE) && SOL_NOEXCEPT_FUNCTION_TYPE - - template - struct fx_traits : basic_traits { - typedef R (*function_pointer_type)(Args...) noexcept; - }; - - template - struct fx_traits : basic_traits { - typedef R (*function_pointer_type)(Args...) noexcept; - }; - - template - struct fx_traits : basic_traits { - typedef R (*function_pointer_type)(Args..., ...) noexcept; - }; - - template - struct fx_traits : basic_traits { - typedef R (*function_pointer_type)(Args..., ...) noexcept; - }; - - template - struct fx_traits : basic_traits { - typedef R (T::*function_pointer_type)(Args...) noexcept; - }; - - template - struct fx_traits : basic_traits { - typedef R (T::*function_pointer_type)(Args..., ...) noexcept; - }; - - /* Const Volatile */ - template - struct fx_traits : basic_traits { - typedef R (T::*function_pointer_type)(Args...) const noexcept; - }; - - template - struct fx_traits : basic_traits { - typedef R (T::*function_pointer_type)(Args..., ...) const noexcept; - }; - - template - struct fx_traits : basic_traits { - typedef R (T::*function_pointer_type)(Args...) const volatile noexcept; - }; - - template - struct fx_traits : basic_traits { - typedef R (T::*function_pointer_type)(Args..., ...) const volatile noexcept; - }; - - template - struct fx_traits : basic_traits { - typedef R (T::*function_pointer_type)(Args...) & noexcept; - }; - - template - struct fx_traits : basic_traits { - typedef R (T::*function_pointer_type)(Args..., ...) & noexcept; - }; - - template - struct fx_traits : basic_traits { - typedef R (T::*function_pointer_type)(Args...) const& noexcept; - }; - - template - struct fx_traits : basic_traits { - typedef R (T::*function_pointer_type)(Args..., ...) const& noexcept; - }; - - template - struct fx_traits : basic_traits { - typedef R (T::*function_pointer_type)(Args...) const volatile& noexcept; - }; - - template - struct fx_traits : basic_traits { - typedef R (T::*function_pointer_type)(Args..., ...) const volatile& noexcept; - }; - - template - struct fx_traits : basic_traits { - typedef R (T::*function_pointer_type)(Args...) && noexcept; - }; - - template - struct fx_traits : basic_traits { - typedef R (T::*function_pointer_type)(Args..., ...) && noexcept; - }; - - template - struct fx_traits : basic_traits { - typedef R (T::*function_pointer_type)(Args...) const&& noexcept; - }; - - template - struct fx_traits : basic_traits { - typedef R (T::*function_pointer_type)(Args..., ...) const&& noexcept; - }; - - template - struct fx_traits : basic_traits { - typedef R (T::*function_pointer_type)(Args...) const volatile&& noexcept; - }; - - template - struct fx_traits : basic_traits { - typedef R (T::*function_pointer_type)(Args..., ...) const volatile&& noexcept; - }; - -#endif // noexcept is part of a function's type - -#if defined(_MSC_VER) && defined(_M_IX86) - template - struct fx_traits : basic_traits { - typedef R(__stdcall* function_pointer_type)(Args...); - }; - - template - struct fx_traits : basic_traits { - typedef R(__stdcall* function_pointer_type)(Args...); - }; - - template - struct fx_traits : basic_traits { - typedef R (__stdcall T::*function_pointer_type)(Args...); - }; - - /* Const Volatile */ - template - struct fx_traits : basic_traits { - typedef R (__stdcall T::*function_pointer_type)(Args...) const; - }; - - template - struct fx_traits : basic_traits { - typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile; - }; - - /* Member Function Qualifiers */ - template - struct fx_traits : basic_traits { - typedef R (__stdcall T::*function_pointer_type)(Args...) &; - }; - - template - struct fx_traits : basic_traits { - typedef R (__stdcall T::*function_pointer_type)(Args...) const&; - }; - - template - struct fx_traits : basic_traits { - typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile&; - }; - - template - struct fx_traits : basic_traits { - typedef R (__stdcall T::*function_pointer_type)(Args...) &&; - }; - - template - struct fx_traits : basic_traits { - typedef R (__stdcall T::*function_pointer_type)(Args...) const&&; - }; - - template - struct fx_traits : basic_traits { - typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile&&; - }; - -#if defined(SOL_NOEXCEPT_FUNCTION_TYPE) && SOL_NOEXCEPT_FUNCTION_TYPE - - template - struct fx_traits : basic_traits { - typedef R(__stdcall* function_pointer_type)(Args...) noexcept; - }; - - template - struct fx_traits : basic_traits { - typedef R(__stdcall* function_pointer_type)(Args...) noexcept; - }; - - /* __stdcall cannot be applied to functions with varargs*/ - /*template - struct fx_traits<__stdcall R(Args..., ...) noexcept, false> : basic_traits { - typedef R(__stdcall* function_pointer_type)(Args..., ...) noexcept; - }; - - template - struct fx_traits : basic_traits { - typedef R(__stdcall* function_pointer_type)(Args..., ...) noexcept; - };*/ - - template - struct fx_traits : basic_traits { - typedef R (__stdcall T::*function_pointer_type)(Args...) noexcept; - }; - - /* __stdcall does not work with varargs */ - /*template - struct fx_traits : basic_traits { - typedef R (__stdcall T::*function_pointer_type)(Args..., ...) noexcept; - };*/ - - /* Const Volatile */ - template - struct fx_traits : basic_traits { - typedef R (__stdcall T::*function_pointer_type)(Args...) const noexcept; - }; - - /* __stdcall does not work with varargs */ - /*template - struct fx_traits : basic_traits { - typedef R (__stdcall T::*function_pointer_type)(Args..., ...) const noexcept; - };*/ - - template - struct fx_traits : basic_traits { - typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile noexcept; - }; - - /* __stdcall does not work with varargs */ - /*template - struct fx_traits : basic_traits { - typedef R (__stdcall T::*function_pointer_type)(Args..., ...) const volatile noexcept; - };*/ - - template - struct fx_traits : basic_traits { - typedef R (__stdcall T::*function_pointer_type)(Args...) & noexcept; - }; - - /* __stdcall does not work with varargs */ - /*template - struct fx_traits : basic_traits { - typedef R (__stdcall T::*function_pointer_type)(Args..., ...) & noexcept; - };*/ - - template - struct fx_traits : basic_traits { - typedef R (__stdcall T::*function_pointer_type)(Args...) const& noexcept; - }; - - /* __stdcall does not work with varargs */ - /*template - struct fx_traits : basic_traits { - typedef R (__stdcall T::*function_pointer_type)(Args..., ...) const& noexcept; - };*/ - - template - struct fx_traits : basic_traits { - typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile& noexcept; - }; - - /* __stdcall does not work with varargs */ - /*template - struct fx_traits : basic_traits { - typedef R (__stdcall T::*function_pointer_type)(Args..., ...) const volatile& noexcept; - };*/ - - template - struct fx_traits : basic_traits { - typedef R (__stdcall T::*function_pointer_type)(Args...) && noexcept; - }; - - /* __stdcall does not work with varargs */ - /*template - struct fx_traits : basic_traits { - typedef R (__stdcall T::*function_pointer_type)(Args..., ...) && noexcept; - };*/ - - template - struct fx_traits : basic_traits { - typedef R (__stdcall T::*function_pointer_type)(Args...) const&& noexcept; - }; - - /* __stdcall does not work with varargs */ - /*template - struct fx_traits : basic_traits { - typedef R (__stdcall T::*function_pointer_type)(Args..., ...) const&& noexcept; - };*/ - - template - struct fx_traits : basic_traits { - typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile&& noexcept; - }; - - /* __stdcall does not work with varargs */ - /*template - struct fx_traits : basic_traits { - 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 - struct fx_traits : fx_traits::function_type, false> {}; - - template ::value> - struct callable_traits : fx_traits> { - }; - - template - struct callable_traits { - typedef std::conditional_t::value, std::add_lvalue_reference_t, R> return_type; - typedef return_type Arg; - typedef T object_type; - using signature_type = R(T::*); - static const bool is_noexcept = false; - static const bool is_member_function = false; - static const std::size_t arity = 1; - static const std::size_t free_arity = 2; - typedef std::tuple args_tuple; - typedef types args_list; - typedef types free_args_list; - typedef meta::tuple_types 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 - using arg_at = void_tuple_element_t; - }; - - } // namespace meta_detail - - template - struct bind_traits : meta_detail::callable_traits {}; - - template - using function_args_t = typename bind_traits::args_list; - - template - using function_signature_t = typename bind_traits::signature_type; - - template - using function_return_t = typename bind_traits::return_type; -} -} // namespace sol::meta - -// end of sol/bind_traits.hpp - -// beginning of sol/string_view.hpp - -#if defined(SOL_CXX17_FEATURES) && SOL_CXX17_FEATURES -#include -#endif // C++17 features -#include -#if defined(SOL_USE_BOOST) && SOL_USE_BOOST -#include -#endif - -namespace sol { -#if defined(SOL_CXX17_FEATURES) && SOL_CXX17_FEATURES - template > - using basic_string_view = std::basic_string_view; - 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 string_view_hash; -#else - template > - struct basic_string_view { - std::size_t s; - const Char* p; - - basic_string_view(const std::string& r) - : basic_string_view(r.data(), r.size()) { - } - basic_string_view(const Char* ptr) - : basic_string_view(ptr, Traits::length(ptr)) { - } - basic_string_view(const Char* ptr, std::size_t sz) - : s(sz), p(ptr) { - } - - static int compare(const Char* lhs_p, std::size_t lhs_sz, const Char* rhs_p, std::size_t rhs_sz) { - int result = Traits::compare(lhs_p, rhs_p, lhs_sz < rhs_sz ? lhs_sz : rhs_sz); - if (result != 0) - return result; - if (lhs_sz < rhs_sz) - return -1; - if (lhs_sz > rhs_sz) - return 1; - return 0; - } - - const Char* begin() const { - return p; - } - - const Char* end() const { - return p + s; - } - - const Char* cbegin() const { - return p; - } - - const Char* cend() const { - return p + s; - } - - const Char* data() const { - return p; - } - - std::size_t size() const { - return s; - } - - std::size_t length() const { - return size(); - } - - operator std::basic_string() const { - return std::basic_string(data(), size()); - } - - bool operator==(const basic_string_view& r) const { - return compare(p, s, r.data(), r.size()) == 0; - } - - bool operator==(const Char* r) const { - return compare(r, Traits::length(r), p, s) == 0; - } - - bool operator==(const std::basic_string& r) const { - return compare(r.data(), r.size(), p, s) == 0; - } - - bool operator!=(const basic_string_view& r) const { - return !(*this == r); - } - - bool operator!=(const char* r) const { - return !(*this == r); - } - - bool operator!=(const std::basic_string& r) const { - return !(*this == r); - } - }; - - template > - struct basic_string_view_hash { - typedef basic_string_view argument_type; - typedef std::size_t result_type; - - template - result_type operator()(const std::basic_string& r) const { - return (*this)(argument_type(r.c_str(), r.size())); - } - - result_type operator()(const argument_type& r) const { -#if defined(SOL_USE_BOOST) && SOL_USE_BOOST - return boost::hash_range(r.begin(), r.end()); -#else - // Modified, from libstdc++ - // An implementation attempt at Fowler No Voll, 1a. - // Supposedly, used in MSVC, - // GCC (libstdc++) uses MurmurHash of some sort for 64-bit though...? - // But, well. Can't win them all, right? - // This should normally only apply when NOT using boost, - // so this should almost never be tapped into... - std::size_t hash = 0; - const unsigned char* cptr = reinterpret_cast(r.data()); - for (std::size_t sz = r.size(); sz != 0; --sz) { - hash ^= static_cast(*cptr++); - hash *= static_cast(1099511628211ULL); - } - return hash; -#endif - } - }; -} // namespace sol - -namespace std { - template - struct hash< ::sol::basic_string_view > : ::sol::basic_string_view_hash {}; -} // namespace std - -namespace sol { - using string_view = basic_string_view; - using wstring_view = basic_string_view; - using u16string_view = basic_string_view; - using u32string_view = basic_string_view; - using string_view_hash = std::hash; -#endif // C++17 Support -} // namespace sol - -// end of sol/string_view.hpp - -#include -#include -#include -#include -#include - -namespace sol { - template - using index_value = std::integral_constant; - - namespace meta { - template - struct identity { typedef T type; }; - - template - using identity_t = typename identity::type; - - template - struct is_tuple : std::false_type {}; - - template - struct is_tuple> : std::true_type {}; - - template - struct is_builtin_type : std::integral_constant::value || std::is_pointer::value || std::is_array::value> {}; - - template - struct unwrapped { - typedef T type; - }; - - template - struct unwrapped> { - typedef T type; - }; - - template - using unwrapped_t = typename unwrapped::type; - - template - struct unwrap_unqualified : unwrapped> {}; - - template - using unwrap_unqualified_t = typename unwrap_unqualified::type; - - template - struct remove_member_pointer; - - template - struct remove_member_pointer { - typedef R type; - }; - - template - struct remove_member_pointer { - typedef R type; - }; - - template - using remove_member_pointer_t = remove_member_pointer; - - namespace meta_detail { - template class Templ> - struct is_specialization_of : std::false_type {}; - template class Templ> - struct is_specialization_of, Templ> : std::true_type {}; - } - - template class Templ> - using is_specialization_of = meta_detail::is_specialization_of, Templ>; - - template - struct all_same : std::true_type {}; - - template - struct all_same : std::integral_constant::value && all_same::value> {}; - - template - struct any_same : std::false_type {}; - - template - struct any_same : std::integral_constant::value || any_same::value> {}; - - template - using boolean = std::integral_constant; - - template - using invoke_t = typename T::type; - - template - using invoke_b = boolean; - - template - using neg = boolean; - - template - using condition = std::conditional_t; - - template - struct all : boolean {}; - - template - struct all : condition, boolean> {}; - - template - struct any : boolean {}; - - template - struct any : condition, any> {}; - - enum class enable_t { - _ - }; - - constexpr const auto enabler = enable_t::_; - - template - using disable_if_t = std::enable_if_t; - - template - using enable = std::enable_if_t::value, enable_t>; - - template - using disable = std::enable_if_t>::value, enable_t>; - - template - using enable_any = std::enable_if_t::value, enable_t>; - - template - using disable_any = std::enable_if_t>::value, enable_t>; - - template - struct find_in_pack_v : boolean {}; - - template - struct find_in_pack_v : any, find_in_pack_v> {}; - - namespace meta_detail { - template - struct index_in_pack : std::integral_constant {}; - - template - struct index_in_pack : std::conditional_t::value, std::integral_constant, index_in_pack> {}; - } // namespace meta_detail - - template - struct index_in_pack : meta_detail::index_in_pack<0, T, Args...> {}; - - template - struct index_in : meta_detail::index_in_pack<0, T, List> {}; - - template - struct index_in> : meta_detail::index_in_pack<0, T, Args...> {}; - - template - struct at_in_pack {}; - - template - using at_in_pack_t = typename at_in_pack::type; - - template - struct at_in_pack : std::conditional> {}; - - template - struct at_in_pack<0, Arg, Args...> { typedef Arg type; }; - - namespace meta_detail { - template class Pred, typename... Ts> - struct count_for_pack : std::integral_constant {}; - template class Pred, typename T, typename... Ts> - struct count_for_pack : std::conditional_t < sizeof...(Ts) - == 0 - || Limit<2, - std::integral_constant(Limit != 0 && Pred::value)>, - count_for_pack(Pred::value), Pred, Ts...>> {}; - template class Pred, typename... Ts> - struct count_2_for_pack : std::integral_constant {}; - template class Pred, typename T, typename U, typename... Ts> - struct count_2_for_pack : std::conditional_t(Pred::value)>, - count_2_for_pack(Pred::value), Pred, Ts...>> {}; - } // namespace meta_detail - - template