diff options
Diffstat (limited to 'deps/sol2/include/sol/stack_get_unqualified.hpp')
| -rw-r--r-- | deps/sol2/include/sol/stack_get_unqualified.hpp | 1021 |
1 files changed, 1021 insertions, 0 deletions
diff --git a/deps/sol2/include/sol/stack_get_unqualified.hpp b/deps/sol2/include/sol/stack_get_unqualified.hpp new file mode 100644 index 0000000..375cc36 --- /dev/null +++ b/deps/sol2/include/sol/stack_get_unqualified.hpp @@ -0,0 +1,1021 @@ +// sol3 + +// The MIT License (MIT) + +// Copyright (c) 2013-2019 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_UNQUALIFIED_GET_HPP +#define SOL_STACK_UNQUALIFIED_GET_HPP + +#include "stack_core.hpp" +#include "usertype_traits.hpp" +#include "inheritance.hpp" +#include "overload.hpp" +#include "error.hpp" +#include "unicode.hpp" + +#include <memory> +#include <functional> +#include <utility> +#include <cstdlib> +#include <cmath> +#if defined(SOL_CXX17_FEATURES) && SOL_CXX17_FEATURES +#include <string_view> +#if defined(SOL_STD_VARIANT) && SOL_STD_VARIANT +#include <variant> +#endif // Apple clang screwed up +#endif // C++17 + +namespace sol { namespace stack { + + namespace stack_detail { + template <typename Ch> + struct count_code_units_utf { + std::size_t needed_size; + + count_code_units_utf() : needed_size(0) { + } + + void operator()(const unicode::encoded_result<Ch> er) { + needed_size += er.code_units_size; + } + }; + + template <typename Ch, typename ErCh> + struct copy_code_units_utf { + Ch* target_; + + copy_code_units_utf(Ch* target) : target_(target) { + } + + void operator()(const unicode::encoded_result<ErCh> er) { + std::memcpy(target_, er.code_units.data(), er.code_units_size * sizeof(ErCh)); + target_ += er.code_units_size; + } + }; + + template <typename Ch, typename F> + inline void convert(const char* strb, const char* stre, F&& f) { + char32_t cp = 0; + for (const char* strtarget = strb; strtarget < stre;) { + auto dr = unicode::utf8_to_code_point(strtarget, stre); + if (dr.error != unicode::error_code::ok) { + cp = unicode::unicode_detail::replacement; + ++strtarget; + } + else { + cp = dr.codepoint; + strtarget = dr.next; + } + if constexpr(std::is_same_v<Ch, char32_t>) { + auto er = unicode::code_point_to_utf32(cp); + f(er); + } + else { + auto er = unicode::code_point_to_utf16(cp); + f(er); + } + } + } + + template <typename BaseCh, typename S> + inline S get_into(lua_State* L, int index, record& tracking) { + using Ch = typename S::value_type; + tracking.use(1); + size_t len; + auto utf8p = lua_tolstring(L, index, &len); + if (len < 1) + return S(); + const char* strb = utf8p; + const char* stre = utf8p + len; + stack_detail::count_code_units_utf<BaseCh> count_units; + convert<BaseCh>(strb, stre, count_units); + S r(count_units.needed_size, static_cast<Ch>(0)); + r.resize(count_units.needed_size); + Ch* target = &r[0]; + stack_detail::copy_code_units_utf<Ch, BaseCh> copy_units(target); + convert<BaseCh>(strb, stre, copy_units); + return r; + } + } // namespace stack_detail + + template <typename T, typename> + struct unqualified_getter { + static decltype(auto) get(lua_State* L, int index, record& tracking) { + if constexpr (std::is_same_v<T, bool>) { + tracking.use(1); + return lua_toboolean(L, index) != 0; + } + else if constexpr (std::is_enum_v<T>) { + tracking.use(1); + return static_cast<T>(lua_tointegerx(L, index, nullptr)); + } + else if constexpr (std::is_integral_v<T> || std::is_same_v<T, lua_Integer>) { + tracking.use(1); +#if SOL_LUA_VERSION >= 503 + if (lua_isinteger(L, index) != 0) { + return static_cast<T>(lua_tointeger(L, index)); + } +#endif + return static_cast<T>(llround(lua_tonumber(L, index))); + } + else if constexpr (std::is_floating_point_v<T> || std::is_same_v<T, lua_Number>) { + tracking.use(1); + return static_cast<T>(lua_tonumber(L, index)); + } + else if constexpr (is_lua_reference_v<T>) { + tracking.use(1); + return T(L, index); + } + else if constexpr (is_unique_usertype_v<T>) { + using Real = typename unique_usertype_traits<T>::actual_type; + + tracking.use(1); + void* memory = lua_touserdata(L, index); + memory = detail::align_usertype_unique<Real>(memory); + Real* mem = static_cast<Real*>(memory); + return *mem; + } + else { + return stack_detail::unchecked_unqualified_get<detail::as_value_tag<T>>(L, index, tracking); + } + } + }; + + template <typename X, typename> + struct qualified_getter { + static decltype(auto) get(lua_State* L, int index, record& tracking) { + using Tu = meta::unqualified_t<X>; + static constexpr bool is_userdata_of_some_kind + = !std::is_reference_v<X> && is_container_v<Tu> && std::is_default_constructible_v<Tu> && !is_lua_primitive_v<Tu> && !is_transparent_argument_v<Tu>; + if constexpr (is_userdata_of_some_kind) { + if (type_of(L, index) == type::userdata) { + return static_cast<Tu>(stack_detail::unchecked_unqualified_get<Tu>(L, index, tracking)); + } + else { + return stack_detail::unchecked_unqualified_get<sol::nested<Tu>>(L, index, tracking); + } + } + else if constexpr (!std::is_reference_v<X> && is_unique_usertype_v<Tu> && !is_base_rebindable_non_void_v<unique_usertype_traits<Tu>>) { + using u_traits = unique_usertype_traits<Tu>; + using T = typename u_traits::type; + using Real = typename u_traits::actual_type; + tracking.use(1); + void* memory = lua_touserdata(L, index); + memory = detail::align_usertype_unique_destructor(memory); + detail::unique_destructor& pdx = *static_cast<detail::unique_destructor*>(memory); + if (&detail::usertype_unique_alloc_destroy<T, X> == pdx) { + memory = detail::align_usertype_unique_tag<true, false>(memory); + memory = detail::align_usertype_unique<Real, true, false>(memory); + Real* mem = static_cast<Real*>(memory); + return static_cast<Real>(*mem); + } + Real r(nullptr); + if constexpr (!derive<T>::value) { + // TODO: abort / terminate, maybe only in debug modes? + return static_cast<Real>(std::move(r)); + } + else { + memory = detail::align_usertype_unique_tag<true, false>(memory); + detail::unique_tag& ic = *reinterpret_cast<detail::unique_tag*>(memory); + memory = detail::align_usertype_unique<Real, true, false>(memory); + string_view ti = usertype_traits<T>::qualified_name(); + int cast_operation; + if constexpr (is_base_rebindable_v<u_traits>) { + using rebind_t = typename u_traits::template rebind_base<void>; + string_view rebind_ti = usertype_traits<rebind_t>::qualified_name(); + cast_operation = ic(memory, &r, ti, rebind_ti); + } + else { + string_view rebind_ti(""); + cast_operation = ic(memory, &r, ti, rebind_ti); + } + switch (cast_operation) { + case 1: { + // it's a perfect match, + // alias memory directly + Real* mem = static_cast<Real*>(memory); + return static_cast<Real>(*mem); + } + case 2: + // it's a base match, return the + // aliased creation + return static_cast<Real>(std::move(r)); + default: + // uh oh.. + break; + } + // TODO: abort / terminate, maybe only in debug modes? + return static_cast<Real>(r); + } + } + else { + return stack_detail::unchecked_unqualified_get<Tu>(L, index, tracking); + } + } + }; + + template <typename T> + struct unqualified_getter<as_table_t<T>> { + using Tu = meta::unqualified_t<T>; + + template <typename V> + static void push_back_at_end(std::true_type, types<V>, lua_State* L, T& cont, std::size_t) { + cont.push_back(stack::get<V>(L, -lua_size<V>::value)); + } + + template <typename V> + static void push_back_at_end(std::false_type, types<V> t, lua_State* L, T& cont, std::size_t idx) { + insert_at_end(meta::has_insert<Tu>(), t, L, cont, idx); + } + + template <typename V> + static void insert_at_end(std::true_type, types<V>, lua_State* L, T& cont, std::size_t) { + using std::cend; + cont.insert(cend(cont), stack::get<V>(L, -lua_size<V>::value)); + } + + template <typename V> + static void insert_at_end(std::false_type, types<V>, lua_State* L, T& cont, std::size_t idx) { + cont[idx] = stack::get<V>(L, -lua_size<V>::value); + } + + static bool max_size_check(std::false_type, T&, std::size_t) { + return false; + } + + static bool max_size_check(std::true_type, T& cont, std::size_t idx) { + return idx >= cont.max_size(); + } + + static T get(lua_State* L, int relindex, record& tracking) { + return get(meta::is_associative<Tu>(), L, relindex, tracking); + } + + static T get(std::false_type, lua_State* L, int relindex, record& tracking) { + typedef typename Tu::value_type V; + return get(types<V>(), L, relindex, tracking); + } + + template <typename V> + static T get(types<V> t, lua_State* L, int relindex, record& tracking) { + tracking.use(1); + + // the W4 flag is really great, + // so great that it can tell my for loops (twice nested) + // below never actually terminate + // without hitting where the gotos have infested + + // so now I would get the error W4XXX unreachable + // me that the return cont at the end of this function + // which is fair until other compilers complain + // that there isn't a return and that based on + // SOME MAGICAL FORCE + // control flow falls off the end of a non-void function + // so it needs to be there for the compilers that are + // too flimsy to analyze the basic blocks... + // (I'm sure I should file a bug but those compilers are already + // in the wild; it doesn't matter if I fix them, + // someone else is still going to get some old-ass compiler + // and then bother me about the unclean build for the 30th + // time) + + // "Why not an IIFE?" + // Because additional lambdas / functions which serve as + // capture-all-and-then-invoke bloat binary sizes + // by an actually detectable amount + // (one user uses sol2 pretty heavily and 22 MB of binary size + // was saved by reducing reliance on lambdas in templates) + + // This would really be solved by having break N; + // be a real, proper thing... + // but instead, we have to use labels and gotos + // and earn the universal vitriol of the dogmatic + // programming community + + // all in all: W4 is great!~ + + int index = lua_absindex(L, relindex); + T cont; + std::size_t idx = 0; +#if SOL_LUA_VERSION >= 503 + // This method is HIGHLY performant over regular table iteration + // thanks to the Lua API changes in 5.3 + // Questionable in 5.4 + for (lua_Integer i = 0;; i += lua_size<V>::value) { + if (max_size_check(meta::has_max_size<Tu>(), cont, idx)) { + // see above comment + goto done; + } + bool isnil = false; + for (int vi = 0; vi < lua_size<V>::value; ++vi) { +#if defined(LUA_NILINTABLE) && LUA_NILINTABLE && SOL_LUA_VERSION >= 600 +#if defined(SOL_SAFE_STACK_CHECK) && SOL_SAFE_STACK_CHECK + luaL_checkstack(L, 1, detail::not_enough_stack_space_generic); +#endif // make sure stack doesn't overflow + lua_pushinteger(L, static_cast<lua_Integer>(i + vi)); + if (lua_keyin(L, index) == 0) { + // it's time to stop + isnil = true; + } + else { + // we have a key, have to get the value + lua_geti(L, index, i + vi); + } +#else + type vt = static_cast<type>(lua_geti(L, index, i + vi)); + isnil = vt == type::none || vt == type::lua_nil; +#endif + if (isnil) { + if (i == 0) { + break; + } +#if defined(LUA_NILINTABLE) && LUA_NILINTABLE && SOL_LUA_VERSION >= 600 + lua_pop(L, vi); +#else + lua_pop(L, (vi + 1)); +#endif + // see above comment + goto done; + } + } + if (isnil) { +#if defined(LUA_NILINTABLE) && LUA_NILINTABLE && SOL_LUA_VERSION >= 600 +#else + lua_pop(L, lua_size<V>::value); +#endif + continue; + } + + push_back_at_end(meta::has_push_back<Tu>(), t, L, cont, idx); + ++idx; + lua_pop(L, lua_size<V>::value); + } +#else + // Zzzz slower but necessary thanks to the lower version API and missing functions qq + for (lua_Integer i = 0;; i += lua_size<V>::value, lua_pop(L, lua_size<V>::value)) { + if (idx >= cont.max_size()) { + // see above comment + goto done; + } +#if defined(SOL_SAFE_STACK_CHECK) && SOL_SAFE_STACK_CHECK + luaL_checkstack(L, 2, detail::not_enough_stack_space_generic); +#endif // make sure stack doesn't overflow + bool isnil = false; + for (int vi = 0; vi < lua_size<V>::value; ++vi) { + lua_pushinteger(L, i); + lua_gettable(L, index); + type vt = type_of(L, -1); + isnil = vt == type::lua_nil; + if (isnil) { + if (i == 0) { + break; + } + lua_pop(L, (vi + 1)); + // see above comment + goto done; + } + } + if (isnil) + continue; + push_back_at_end(meta::has_push_back<Tu>(), t, L, cont, idx); + ++idx; + } +#endif + done: + return cont; + } + + static T get(std::true_type, lua_State* L, int index, record& tracking) { + typedef typename Tu::value_type P; + typedef typename P::first_type K; + typedef typename P::second_type V; + return get(types<K, V>(), L, index, tracking); + } + + template <typename K, typename V> + static T get(types<K, V>, lua_State* L, int relindex, record& tracking) { + tracking.use(1); + +#if defined(SOL_SAFE_STACK_CHECK) && SOL_SAFE_STACK_CHECK + luaL_checkstack(L, 3, detail::not_enough_stack_space_generic); +#endif // make sure stack doesn't overflow + + T associative; + int index = lua_absindex(L, relindex); + lua_pushnil(L); + while (lua_next(L, index) != 0) { + decltype(auto) key = stack::check_get<K>(L, -2); + if (!key) { + lua_pop(L, 1); + continue; + } + associative.emplace(std::forward<decltype(*key)>(*key), stack::get<V>(L, -1)); + lua_pop(L, 1); + } + return associative; + } + }; + + template <typename T, typename Al> + struct unqualified_getter<as_table_t<std::forward_list<T, Al>>> { + typedef std::forward_list<T, Al> C; + + static C get(lua_State* L, int relindex, record& tracking) { + return get(meta::has_key_value_pair<C>(), L, relindex, tracking); + } + + static C get(std::true_type, lua_State* L, int index, record& tracking) { + typedef typename T::value_type P; + typedef typename P::first_type K; + typedef typename P::second_type V; + return get(types<K, V>(), L, index, tracking); + } + + static C get(std::false_type, lua_State* L, int relindex, record& tracking) { + typedef typename C::value_type V; + return get(types<V>(), L, relindex, tracking); + } + + template <typename V> + static C get(types<V>, lua_State* L, int relindex, record& tracking) { + tracking.use(1); +#if defined(SOL_SAFE_STACK_CHECK) && SOL_SAFE_STACK_CHECK + luaL_checkstack(L, 3, detail::not_enough_stack_space_generic); +#endif // make sure stack doesn't overflow + + int index = lua_absindex(L, relindex); + C cont; + auto at = cont.cbefore_begin(); + std::size_t idx = 0; +#if SOL_LUA_VERSION >= 503 + // This method is HIGHLY performant over regular table iteration thanks to the Lua API changes in 5.3 + for (lua_Integer i = 0;; i += lua_size<V>::value, lua_pop(L, lua_size<V>::value)) { + if (idx >= cont.max_size()) { + goto done; + } + bool isnil = false; + for (int vi = 0; vi < lua_size<V>::value; ++vi) { + type t = static_cast<type>(lua_geti(L, index, i + vi)); + isnil = t == type::lua_nil; + if (isnil) { + if (i == 0) { + break; + } + lua_pop(L, (vi + 1)); + goto done; + } + } + if (isnil) + continue; + at = cont.insert_after(at, stack::get<V>(L, -lua_size<V>::value)); + ++idx; + } +#else + // Zzzz slower but necessary thanks to the lower version API and missing functions qq + for (lua_Integer i = 0;; i += lua_size<V>::value, lua_pop(L, lua_size<V>::value)) { + if (idx >= cont.max_size()) { + goto done; + } + bool isnil = false; + for (int vi = 0; vi < lua_size<V>::value; ++vi) { + lua_pushinteger(L, i); + lua_gettable(L, index); + type t = type_of(L, -1); + isnil = t == type::lua_nil; + if (isnil) { + if (i == 0) { + break; + } + lua_pop(L, (vi + 1)); + goto done; + } + } + if (isnil) + continue; + at = cont.insert_after(at, stack::get<V>(L, -lua_size<V>::value)); + ++idx; + } +#endif + done: + return cont; + } + + template <typename K, typename V> + static C get(types<K, V>, lua_State* L, int relindex, record& tracking) { + tracking.use(1); + +#if defined(SOL_SAFE_STACK_CHECK) && SOL_SAFE_STACK_CHECK + luaL_checkstack(L, 3, detail::not_enough_stack_space_generic); +#endif // make sure stack doesn't overflow + + C associative; + auto at = associative.cbefore_begin(); + int index = lua_absindex(L, relindex); + lua_pushnil(L); + while (lua_next(L, index) != 0) { + decltype(auto) key = stack::check_get<K>(L, -2); + if (!key) { + lua_pop(L, 1); + continue; + } + at = associative.emplace_after(at, std::forward<decltype(*key)>(*key), stack::get<V>(L, -1)); + lua_pop(L, 1); + } + return associative; + } + }; + + template <typename T> + struct unqualified_getter<nested<T>> { + static T get(lua_State* L, int index, record& tracking) { + using Tu = meta::unqualified_t<T>; + if constexpr (is_container_v<Tu>) { + if constexpr (meta::is_associative<Tu>::value) { + typedef typename T::value_type P; + typedef typename P::first_type K; + typedef typename P::second_type V; + unqualified_getter<as_table_t<T>> g; + // VC++ has a bad warning here: shut it up + (void)g; + return g.get(types<K, nested<V>>(), L, index, tracking); + } + else { + typedef typename T::value_type V; + unqualified_getter<as_table_t<T>> g; + // VC++ has a bad warning here: shut it up + (void)g; + return g.get(types<nested<V>>(), L, index, tracking); + } + } + else { + unqualified_getter<Tu> g; + // VC++ has a bad warning here: shut it up + (void)g; + return g.get(L, index, tracking); + } + } + }; + + template <typename T> + struct unqualified_getter<as_container_t<T>> { + static decltype(auto) get(lua_State* L, int index, record& tracking) { + return stack::unqualified_get<T>(L, index, tracking); + } + }; + + template <typename T> + struct unqualified_getter<as_container_t<T>*> { + static decltype(auto) get(lua_State* L, int index, record& tracking) { + return stack::unqualified_get<T*>(L, index, tracking); + } + }; + + template <> + struct unqualified_getter<userdata_value> { + static userdata_value get(lua_State* L, int index, record& tracking) { + tracking.use(1); + return userdata_value(lua_touserdata(L, index)); + } + }; + + template <> + struct unqualified_getter<lightuserdata_value> { + static lightuserdata_value get(lua_State* L, int index, record& tracking) { + tracking.use(1); + return lightuserdata_value(lua_touserdata(L, index)); + } + }; + + template <typename T> + struct unqualified_getter<light<T>> { + static light<T> get(lua_State* L, int index, record& tracking) { + tracking.use(1); + void* memory = lua_touserdata(L, index); + return light<T>(static_cast<T*>(memory)); + } + }; + + template <typename T> + struct unqualified_getter<user<T>> { + static std::add_lvalue_reference_t<T> get(lua_State* L, int index, record& tracking) { + tracking.use(1); + void* memory = lua_touserdata(L, index); + memory = detail::align_user<T>(memory); + return *static_cast<std::remove_reference_t<T>*>(memory); + } + }; + + template <typename T> + struct unqualified_getter<user<T*>> { + static T* get(lua_State* L, int index, record& tracking) { + tracking.use(1); + void* memory = lua_touserdata(L, index); + memory = detail::align_user<T*>(memory); + return static_cast<T*>(memory); + } + }; + + template <> + struct unqualified_getter<type> { + static type get(lua_State* L, int index, record& tracking) { + tracking.use(1); + return static_cast<type>(lua_type(L, index)); + } + }; + + template <> + struct unqualified_getter<std::string> { + static std::string get(lua_State* L, int index, record& tracking) { + tracking.use(1); + std::size_t len; + auto str = lua_tolstring(L, index, &len); + return std::string(str, len); + } + }; + + template <> + struct unqualified_getter<const char*> { + static const char* get(lua_State* L, int index, record& tracking) { + tracking.use(1); + size_t sz; + return lua_tolstring(L, index, &sz); + } + }; + + template <> + struct unqualified_getter<char> { + static char get(lua_State* L, int index, record& tracking) { + tracking.use(1); + size_t len; + auto str = lua_tolstring(L, index, &len); + return len > 0 ? str[0] : '\0'; + } + }; + + template <typename Traits> + struct unqualified_getter<basic_string_view<char, Traits>> { + static string_view get(lua_State* L, int index, record& tracking) { + tracking.use(1); + size_t sz; + const char* str = lua_tolstring(L, index, &sz); + return basic_string_view<char, Traits>(str, sz); + } + }; + + template <typename Traits, typename Al> + struct unqualified_getter<std::basic_string<wchar_t, Traits, Al>> { + using S = std::basic_string<wchar_t, Traits, Al>; + static S get(lua_State* L, int index, record& tracking) { + using Ch = meta::conditional_t<sizeof(wchar_t) == 2, char16_t, char32_t>; + return stack_detail::get_into<Ch, S>(L, index, tracking); + } + }; + + template <typename Traits, typename Al> + struct unqualified_getter<std::basic_string<char16_t, Traits, Al>> { + static std::basic_string<char16_t, Traits, Al> get(lua_State* L, int index, record& tracking) { + return stack_detail::get_into<char16_t, std::basic_string<char16_t, Traits, Al>>(L, index, tracking); + } + }; + + template <typename Traits, typename Al> + struct unqualified_getter<std::basic_string<char32_t, Traits, Al>> { + static std::basic_string<char32_t, Traits, Al> get(lua_State* L, int index, record& tracking) { + return stack_detail::get_into<char32_t, std::basic_string<char32_t, Traits, Al>>(L, index, tracking); + } + }; + + template <> + struct unqualified_getter<char16_t> { + static char16_t get(lua_State* L, int index, record& tracking) { + string_view utf8 = stack::get<string_view>(L, index, tracking); + const char* strb = utf8.data(); + const char* stre = utf8.data() + utf8.size(); + char32_t cp = 0; + auto dr = unicode::utf8_to_code_point(strb, stre); + if (dr.error != unicode::error_code::ok) { + cp = unicode::unicode_detail::replacement; + } + else { + cp = dr.codepoint; + } + auto er = unicode::code_point_to_utf16(cp); + return er.code_units[0]; + } + }; + + template <> + struct unqualified_getter<char32_t> { + static char32_t get(lua_State* L, int index, record& tracking) { + string_view utf8 = stack::get<string_view>(L, index, tracking); + const char* strb = utf8.data(); + const char* stre = utf8.data() + utf8.size(); + char32_t cp = 0; + auto dr = unicode::utf8_to_code_point(strb, stre); + if (dr.error != unicode::error_code::ok) { + cp = unicode::unicode_detail::replacement; + } + else { + cp = dr.codepoint; + } + auto er = unicode::code_point_to_utf32(cp); + return er.code_units[0]; + } + }; + + template <> + struct unqualified_getter<wchar_t> { + static wchar_t get(lua_State* L, int index, record& tracking) { + typedef meta::conditional_t<sizeof(wchar_t) == 2, char16_t, char32_t> Ch; + unqualified_getter<Ch> g; + (void)g; + auto c = g.get(L, index, tracking); + return static_cast<wchar_t>(c); + } + }; + + template <> + struct unqualified_getter<meta_function> { + static meta_function get(lua_State* L, int index, record& tracking) { + tracking.use(1); + const char* name = unqualified_getter<const char*>{}.get(L, index, tracking); + const auto& mfnames = meta_function_names(); + for (std::size_t i = 0; i < mfnames.size(); ++i) + if (mfnames[i] == name) + return static_cast<meta_function>(i); + return meta_function::construct; + } + }; + + template <> + struct unqualified_getter<lua_nil_t> { + static lua_nil_t get(lua_State*, int, record& tracking) { + tracking.use(1); + return lua_nil; + } + }; + + template <> + struct unqualified_getter<std::nullptr_t> { + static std::nullptr_t get(lua_State*, int, record& tracking) { + tracking.use(1); + return nullptr; + } + }; + + template <> + struct unqualified_getter<nullopt_t> { + static nullopt_t get(lua_State*, int, record& tracking) { + tracking.use(1); + return nullopt; + } + }; + + template <> + struct unqualified_getter<this_state> { + static this_state get(lua_State* L, int, record& tracking) { + tracking.use(0); + return this_state(L); + } + }; + + template <> + struct unqualified_getter<this_main_state> { + static this_main_state get(lua_State* L, int, record& tracking) { + tracking.use(0); + return this_main_state(main_thread(L, L)); + } + }; + + template <> + struct unqualified_getter<lua_CFunction> { + static lua_CFunction get(lua_State* L, int index, record& tracking) { + tracking.use(1); + return lua_tocfunction(L, index); + } + }; + + template <> + struct unqualified_getter<c_closure> { + static c_closure get(lua_State* L, int index, record& tracking) { + tracking.use(1); + return c_closure(lua_tocfunction(L, index), -1); + } + }; + + template <> + struct unqualified_getter<error> { + static error get(lua_State* L, int index, record& tracking) { + tracking.use(1); + size_t sz = 0; + const char* err = lua_tolstring(L, index, &sz); + if (err == nullptr) { + return error(detail::direct_error, ""); + } + return error(detail::direct_error, std::string(err, sz)); + } + }; + + template <> + struct unqualified_getter<void*> { + static void* get(lua_State* L, int index, record& tracking) { + tracking.use(1); + return lua_touserdata(L, index); + } + }; + + template <> + struct unqualified_getter<const void*> { + static const void* get(lua_State* L, int index, record& tracking) { + tracking.use(1); + return lua_touserdata(L, index); + } + }; + + template <typename T> + struct unqualified_getter<detail::as_value_tag<T>> { + static T* get_no_lua_nil(lua_State* L, int index, record& tracking) { + void* memory = lua_touserdata(L, index); +#if defined(SOL_ENABLE_INTEROP) && SOL_ENABLE_INTEROP + auto ugr = stack_detail::interop_get<T>(L, index, memory, tracking); + if (ugr.first) { + return ugr.second; + } +#endif // interop extensibility + tracking.use(1); + void* rawdata = detail::align_usertype_pointer(memory); + void** pudata = static_cast<void**>(rawdata); + void* udata = *pudata; + return get_no_lua_nil_from(L, udata, index, tracking); + } + + static T* get_no_lua_nil_from(lua_State* L, void* udata, int index, record&) { + bool has_derived = derive<T>::value || weak_derive<T>::value; + if (has_derived) { + if (lua_getmetatable(L, index) == 1) { + lua_getfield(L, -1, &detail::base_class_cast_key()[0]); + if (type_of(L, -1) != type::lua_nil) { + void* basecastdata = lua_touserdata(L, -1); + detail::inheritance_cast_function ic + = reinterpret_cast<detail::inheritance_cast_function>(basecastdata); + // use the casting function to properly adjust the pointer for the desired T + udata = ic(udata, usertype_traits<T>::qualified_name()); + } + lua_pop(L, 2); + } + } + T* obj = static_cast<T*>(udata); + return obj; + } + + static T& get(lua_State* L, int index, record& tracking) { + return *get_no_lua_nil(L, index, tracking); + } + }; + + template <typename T> + struct unqualified_getter<detail::as_pointer_tag<T>> { + static T* get(lua_State* L, int index, record& tracking) { + type t = type_of(L, index); + if (t == type::lua_nil) { + tracking.use(1); + return nullptr; + } + unqualified_getter<detail::as_value_tag<T>> g; + // Avoid VC++ warning + (void)g; + return g.get_no_lua_nil(L, index, tracking); + } + }; + + template <typename T> + struct unqualified_getter<non_null<T*>> { + static T* get(lua_State* L, int index, record& tracking) { + unqualified_getter<detail::as_value_tag<T>> g; + // Avoid VC++ warning + (void)g; + return g.get_no_lua_nil(L, index, tracking); + } + }; + + template <typename T> + struct unqualified_getter<T&> { + static T& get(lua_State* L, int index, record& tracking) { + unqualified_getter<detail::as_value_tag<T>> g; + // Avoid VC++ warning + (void)g; + return g.get(L, index, tracking); + } + }; + + template <typename T> + struct unqualified_getter<std::reference_wrapper<T>> { + static T& get(lua_State* L, int index, record& tracking) { + unqualified_getter<T&> g; + // Avoid VC++ warning + (void)g; + return g.get(L, index, tracking); + } + }; + + template <typename T> + struct unqualified_getter<T*> { + static T* get(lua_State* L, int index, record& tracking) { + unqualified_getter<detail::as_pointer_tag<T>> g; + // Avoid VC++ warning + (void)g; + return g.get(L, index, tracking); + } + }; + + template <typename... Tn> + struct unqualified_getter<std::tuple<Tn...>> { + typedef std::tuple<decltype(stack::get<Tn>(nullptr, 0))...> R; + + template <typename... Args> + static R apply(std::index_sequence<>, lua_State*, int, record&, Args&&... args) { + // Fuck you too, VC++ + return R{ std::forward<Args>(args)... }; + } + + template <std::size_t I, std::size_t... Ix, typename... Args> + static R apply(std::index_sequence<I, Ix...>, lua_State* L, int index, record& tracking, Args&&... args) { + // Fuck you too, VC++ + typedef std::tuple_element_t<I, std::tuple<Tn...>> T; + return apply(std::index_sequence<Ix...>(), L, index, tracking, std::forward<Args>(args)..., + stack::get<T>(L, index + tracking.used, tracking)); + } + + static R get(lua_State* L, int index, record& tracking) { + return apply(std::make_index_sequence<sizeof...(Tn)>(), L, index, tracking); + } + }; + + template <typename A, typename B> + struct unqualified_getter<std::pair<A, B>> { + static decltype(auto) get(lua_State* L, int index, record& tracking) { + return std::pair<decltype(stack::get<A>(L, index)), decltype(stack::get<B>(L, index))>{ + stack::get<A>(L, index, tracking), stack::get<B>(L, index + tracking.used, tracking) + }; + } + }; + +#if defined(SOL_CXX17_FEATURES) && SOL_CXX17_FEATURES +#if defined(SOL_STD_VARIANT) && SOL_STD_VARIANT + template <typename... Tn> + struct unqualified_getter<std::variant<Tn...>> { + using V = std::variant<Tn...>; + + static V get_one(std::integral_constant<std::size_t, std::variant_size_v<V>>, lua_State* L, int index, record& tracking) { + (void)L; + (void)index; + (void)tracking; + if constexpr (std::variant_size_v<V> == 0) { + return V(); + } + else { + //using T = std::variant_alternative_t<0, V>; + std::abort(); + //return V(std::in_place_index<0>, stack::get<T>(L, index, tracking)); + } + } + + template <std::size_t I> + static V get_one(std::integral_constant<std::size_t, I>, lua_State* L, int index, record& tracking) { + typedef std::variant_alternative_t<I, V> T; + record temp_tracking = tracking; + if (stack::check<T>(L, index, no_panic, temp_tracking)) { + tracking = temp_tracking; + return V(std::in_place_index<I>, stack::get<T>(L, index)); + } + return get_one(std::integral_constant<std::size_t, I + 1>(), L, index, tracking); + } + + static V get(lua_State* L, int index, record& tracking) { + return get_one(std::integral_constant<std::size_t, 0>(), L, index, tracking); + } + }; +#endif // SOL_STD_VARIANT +#endif // SOL_CXX17_FEATURES + +}} // namespace sol::stack + +#endif // SOL_STACK_UNQUALIFIED_GET_HPP |