From bd3fe0cac583739bc0d7c4b5c8f301bb350abca0 Mon Sep 17 00:00:00 2001
From: Andy Belle-Isle <drumsetmonkey@gmail.com>
Date: Fri, 30 Aug 2019 00:19:31 -0400
Subject: Renamed lib to deps so github will ignore it for language stats
---
deps/sol2/include/sol/stack_get_unqualified.hpp | 1021 +++++++++++++++++++++++
1 file changed, 1021 insertions(+)
create mode 100644 deps/sol2/include/sol/stack_get_unqualified.hpp
(limited to 'deps/sol2/include/sol/stack_get_unqualified.hpp')
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
--
cgit v1.2.3