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 --- lib/sol2/include/sol/coroutine.hpp | 248 +++++++++++++++++++++++++++++++++++++ 1 file changed, 248 insertions(+) create mode 100644 lib/sol2/include/sol/coroutine.hpp (limited to 'lib/sol2/include/sol/coroutine.hpp') diff --git a/lib/sol2/include/sol/coroutine.hpp b/lib/sol2/include/sol/coroutine.hpp new file mode 100644 index 0000000..b4c845d --- /dev/null +++ b/lib/sol2/include/sol/coroutine.hpp @@ -0,0 +1,248 @@ +// 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_COROUTINE_HPP +#define SOL_COROUTINE_HPP + +#include "reference.hpp" +#include "object.hpp" +#include "stack.hpp" +#include "function_result.hpp" +#include "thread.hpp" +#include "protected_handler.hpp" + +namespace sol { + template + class basic_coroutine : public basic_object { + private: + using base_t = basic_object; + + public: + typedef reference handler_t; + handler_t error_handler; + + private: + call_status stats = call_status::yielded; + + void luacall(std::ptrdiff_t argcount, std::ptrdiff_t) { +#if SOL_LUA_VERSION >= 504 + int nresults; + stats = static_cast(lua_resume(lua_state(), nullptr, static_cast(argcount), &nresults)); +#else + stats = static_cast(lua_resume(lua_state(), nullptr, static_cast(argcount))); +#endif + } + + template + auto invoke(types, std::index_sequence, std::ptrdiff_t n) { + luacall(n, sizeof...(Ret)); + return stack::pop>(lua_state()); + } + + template + Ret invoke(types, std::index_sequence, std::ptrdiff_t n) { + luacall(n, 1); + return stack::pop(lua_state()); + } + + template + void invoke(types, std::index_sequence, std::ptrdiff_t n) { + luacall(n, 0); + } + + protected_function_result invoke(types<>, std::index_sequence<>, std::ptrdiff_t n) { + int firstreturn = 1; + luacall(n, LUA_MULTRET); + int poststacksize = lua_gettop(this->lua_state()); + int returncount = poststacksize - (firstreturn - 1); + if (error()) { + if (error_handler.valid()) { + string_view err = stack::get(this->lua_state(), poststacksize); + error_handler.push(); + stack::push(this->lua_state(), err); + lua_call(lua_state(), 1, 1); + } + return protected_function_result(this->lua_state(), lua_absindex(this->lua_state(), -1), 1, returncount, status()); + } + return protected_function_result(this->lua_state(), firstreturn, returncount, returncount, status()); + } + + public: + using base_t::lua_state; + + basic_coroutine() = default; + template , basic_coroutine>>, meta::neg>>, meta::neg>, meta::neg>>, is_lua_reference>> = meta::enabler> + basic_coroutine(T&& r) noexcept + : base_t(std::forward(r)), error_handler(detail::get_default_handler::value>(r.lua_state())) { +#if defined(SOL_SAFE_REFERENCES) && SOL_SAFE_REFERENCES + if (!is_function>::value) { + auto pp = stack::push_pop(*this); + constructor_handler handler{}; + stack::check(lua_state(), -1, handler); + } +#endif // Safety + } + basic_coroutine(const basic_coroutine&) = default; + basic_coroutine& operator=(const basic_coroutine&) = default; + basic_coroutine(basic_coroutine&&) = default; + basic_coroutine& operator=(basic_coroutine&&) = default; + basic_coroutine(const basic_function& b) + : basic_coroutine(b, detail::get_default_handler::value>(b.lua_state())) { + } + basic_coroutine(basic_function&& b) + : basic_coroutine(std::move(b), detail::get_default_handler::value>(b.lua_state())) { + } + basic_coroutine(const basic_function& b, handler_t eh) + : base_t(b), error_handler(std::move(eh)) { + } + basic_coroutine(basic_function&& b, handler_t eh) + : base_t(std::move(b)), error_handler(std::move(eh)) { + } + basic_coroutine(const stack_reference& r) + : basic_coroutine(r.lua_state(), r.stack_index(), detail::get_default_handler::value>(r.lua_state())) { + } + basic_coroutine(stack_reference&& r) + : basic_coroutine(r.lua_state(), r.stack_index(), detail::get_default_handler::value>(r.lua_state())) { + } + basic_coroutine(const stack_reference& r, handler_t eh) + : basic_coroutine(r.lua_state(), r.stack_index(), std::move(eh)) { + } + basic_coroutine(stack_reference&& r, handler_t eh) + : basic_coroutine(r.lua_state(), r.stack_index(), std::move(eh)) { + } + + template + basic_coroutine(const proxy_base& p) + : basic_coroutine(p, detail::get_default_handler::value>(p.lua_state())) { + } + template + basic_coroutine(proxy_base&& p) + : basic_coroutine(std::move(p), detail::get_default_handler::value>(p.lua_state())) { + } + template >, meta::neg>>> = meta::enabler> + basic_coroutine(Proxy&& p, Handler&& eh) + : basic_coroutine(detail::force_cast(p), std::forward(eh)) { + } + + template >> = meta::enabler> + basic_coroutine(lua_State* L, T&& r) + : basic_coroutine(L, std::forward(r), detail::get_default_handler::value>(L)) { + } + template >> = meta::enabler> + basic_coroutine(lua_State* L, T&& r, handler_t eh) + : base_t(L, std::forward(r)), error_handler(std::move(eh)) { +#if defined(SOL_SAFE_REFERENCES) && SOL_SAFE_REFERENCES + auto pp = stack::push_pop(*this); + constructor_handler handler{}; + stack::check(lua_state(), -1, handler); +#endif // Safety + } + + basic_coroutine(lua_nil_t n) + : base_t(n), error_handler(n) { + } + + basic_coroutine(lua_State* L, int index = -1) + : basic_coroutine(L, index, detail::get_default_handler::value>(L)) { + } + basic_coroutine(lua_State* L, int index, handler_t eh) + : base_t(L, index), error_handler(std::move(eh)) { +#ifdef SOL_SAFE_REFERENCES + constructor_handler handler{}; + stack::check(L, index, handler); +#endif // Safety + } + basic_coroutine(lua_State* L, absolute_index index) + : basic_coroutine(L, index, detail::get_default_handler::value>(L)) { + } + basic_coroutine(lua_State* L, absolute_index index, handler_t eh) + : base_t(L, index), error_handler(std::move(eh)) { +#if defined(SOL_SAFE_REFERENCES) && SOL_SAFE_REFERENCES + constructor_handler handler{}; + stack::check(L, index, handler); +#endif // Safety + } + basic_coroutine(lua_State* L, raw_index index) + : basic_coroutine(L, index, detail::get_default_handler::value>(L)) { + } + basic_coroutine(lua_State* L, raw_index index, handler_t eh) + : base_t(L, index), error_handler(std::move(eh)) { +#if defined(SOL_SAFE_REFERENCES) && SOL_SAFE_REFERENCES + constructor_handler handler{}; + stack::check(L, index, handler); +#endif // Safety + } + basic_coroutine(lua_State* L, ref_index index) + : basic_coroutine(L, index, detail::get_default_handler::value>(L)) { + } + basic_coroutine(lua_State* L, ref_index index, handler_t eh) + : base_t(L, index), error_handler(std::move(eh)) { +#if defined(SOL_SAFE_REFERENCES) && SOL_SAFE_REFERENCES + auto pp = stack::push_pop(*this); + constructor_handler handler{}; + stack::check(lua_state(), -1, handler); +#endif // Safety + } + + call_status status() const noexcept { + return stats; + } + + bool error() const noexcept { + call_status cs = status(); + return cs != call_status::ok && cs != call_status::yielded; + } + + bool runnable() const noexcept { + return base_t::valid() + && (status() == call_status::yielded); + } + + explicit operator bool() const noexcept { + return runnable(); + } + + template + protected_function_result operator()(Args&&... args) { + return call<>(std::forward(args)...); + } + + template + decltype(auto) operator()(types, Args&&... args) { + return call(std::forward(args)...); + } + + template + decltype(auto) call(Args&&... args) { + // some users screw up coroutine.create + // and try to use it with sol::coroutine without ever calling the first resume in Lua + // this makes the stack incompatible with other kinds of stacks: protect against this + // make sure coroutines don't screw us over + base_t::push(); + int pushcount = stack::multi_push_reference(lua_state(), std::forward(args)...); + return invoke(types(), std::make_index_sequence(), pushcount); + } + }; +} // namespace sol + +#endif // SOL_COUROUTINE_HPP -- cgit v1.2.3