From dc2493e7525bb7633f697ef10f72b72b46222249 Mon Sep 17 00:00:00 2001 From: Andy Belle-Isle Date: Fri, 30 Aug 2019 00:45:36 -0400 Subject: Forget what I said, I just need to change git attributes to mark for vendor --- .../include/sol/stack_check_get_unqualified.hpp | 196 +++++++++++++++++++++ 1 file changed, 196 insertions(+) create mode 100644 lib/sol2/include/sol/stack_check_get_unqualified.hpp (limited to 'lib/sol2/include/sol/stack_check_get_unqualified.hpp') diff --git a/lib/sol2/include/sol/stack_check_get_unqualified.hpp b/lib/sol2/include/sol/stack_check_get_unqualified.hpp new file mode 100644 index 0000000..d552c08 --- /dev/null +++ b/lib/sol2/include/sol/stack_check_get_unqualified.hpp @@ -0,0 +1,196 @@ +// 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_CHECK_UNQUALIFIED_GET_HPP +#define SOL_STACK_CHECK_UNQUALIFIED_GET_HPP + +#include "stack_core.hpp" +#include "stack_get.hpp" +#include "stack_check.hpp" +#include "optional.hpp" + +#include +#include +#if defined(SOL_CXX17_FEATURES) && SOL_CXX17_FEATURES +#include +#if defined(SOL_STD_VARIANT) && SOL_STD_VARIANT +#include +#endif // variant +#endif // C++17 + + + +namespace sol { +namespace stack { + template + struct unqualified_check_getter { + typedef decltype(stack_detail::unchecked_unqualified_get(nullptr, -1, std::declval())) R; + + template + static optional get(lua_State* L, int index, Handler&& handler, record& tracking) { + if constexpr (!meta::meta_detail::is_adl_sol_lua_check_v && !meta::meta_detail::is_adl_sol_lua_get_v) { + if constexpr (is_lua_reference_v) { + // actually check if it's none here, otherwise + // we'll have a none object inside an optional! + bool success = lua_isnoneornil(L, index) == 0 && stack::check(L, index, no_panic); + if (!success) { + // expected type, actual type + tracking.use(static_cast(success)); + handler(L, index, type::poly, type_of(L, index), ""); + return nullopt; + } + return stack_detail::unchecked_get(L, index, tracking); + } + else if constexpr ((std::is_integral_v || std::is_same_v) && !std::is_same_v) { +#if SOL_LUA_VERSION >= 503 + if (lua_isinteger(L, index) != 0) { + tracking.use(1); + return static_cast(lua_tointeger(L, index)); + } +#endif + int isnum = 0; + const lua_Number value = lua_tonumberx(L, index, &isnum); + if (isnum != 0) { +#if (defined(SOL_SAFE_NUMERICS) && SOL_SAFE_NUMERICS) && !(defined(SOL_NO_CHECK_NUMBER_PRECISION) && SOL_NO_CHECK_NUMBER_PRECISION) + const auto integer_value = llround(value); + if (static_cast(integer_value) == value) { + tracking.use(1); + return static_cast(integer_value); + } +#else + tracking.use(1); + return static_cast(value); +#endif + } + const type t = type_of(L, index); + tracking.use(static_cast(t != type::none)); + handler(L, index, type::number, t, "not an integer"); + return nullopt; + } + else if constexpr (std::is_floating_point_v || std::is_same_v) { + int isnum = 0; + lua_Number value = lua_tonumberx(L, index, &isnum); + if (isnum == 0) { + type t = type_of(L, index); + tracking.use(static_cast(t != type::none)); + handler(L, index, type::number, t, "not a valid floating point number"); + return nullopt; + } + tracking.use(1); + return static_cast(value); + } + else if constexpr (std::is_enum_v && !meta::any_same_v) { + int isnum = 0; + lua_Integer value = lua_tointegerx(L, index, &isnum); + if (isnum == 0) { + type t = type_of(L, index); + tracking.use(static_cast(t != type::none)); + handler(L, index, type::number, t, "not a valid enumeration value"); + return nullopt; + } + tracking.use(1); + return static_cast(value); + } + else { + if (!unqualified_check(L, index, std::forward(handler))) { + tracking.use(static_cast(!lua_isnone(L, index))); + return nullopt; + } + return stack_detail::unchecked_unqualified_get(L, index, tracking); + } + } + else { + if (!unqualified_check(L, index, std::forward(handler))) { + tracking.use(static_cast(!lua_isnone(L, index))); + return nullopt; + } + return stack_detail::unchecked_unqualified_get(L, index, tracking); + } + } + }; + + template + struct unqualified_getter> { + static decltype(auto) get(lua_State* L, int index, record& tracking) { + return stack::unqualified_check_get(L, index, no_panic, tracking); + } + }; + +#if defined(SOL_CXX17_FEATURES) && SOL_CXX17_FEATURES + template + struct unqualified_getter> { + static std::optional get(lua_State* L, int index, record& tracking) { + if (!unqualified_check(L, index, no_panic)) { + tracking.use(static_cast(!lua_isnone(L, index))); + return std::nullopt; + } + return stack_detail::unchecked_unqualified_get(L, index, tracking); + } + }; + +#if defined(SOL_STD_VARIANT) && SOL_STD_VARIANT + template + struct unqualified_check_getter, C> { + typedef std::variant V; + typedef std::variant_size V_size; + typedef std::integral_constant V_is_empty; + + template + static optional get_empty(std::true_type, lua_State*, int, Handler&&, record&) { + return nullopt; + } + + template + static optional get_empty(std::false_type, lua_State* L, int index, Handler&& handler, record&) { + // This should never be reached... + // please check your code and understand what you did to bring yourself here + // maybe file a bug report, or 5 + handler(L, index, type::poly, type_of(L, index), "this variant code should never be reached: if it has, you have done something so terribly wrong"); + return nullopt; + } + + template + static optional get_one(std::integral_constant, lua_State* L, int index, Handler&& handler, record& tracking) { + return get_empty(V_is_empty(), L, index, std::forward(handler), tracking); + } + + template + static optional get_one(std::integral_constant, lua_State* L, int index, Handler&& handler, record& tracking) { + typedef std::variant_alternative_t T; + if (stack::check(L, index, no_panic, tracking)) { + return V(std::in_place_index, stack::get(L, index)); + } + return get_one(std::integral_constant(), L, index, std::forward(handler), tracking); + } + + template + static optional get(lua_State* L, int index, Handler&& handler, record& tracking) { + return get_one(std::integral_constant(), L, index, std::forward(handler), tracking); + } + }; +#endif // SOL_STD_VARIANT +#endif // SOL_CXX17_FEATURES +} +} // namespace sol::stack + +#endif // SOL_STACK_CHECK_UNQUALIFIED_GET_HPP -- cgit v1.2.3