// The MIT License (MIT) // Copyright (c) 2013-2016 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 "stack.hpp" #include "function_result.hpp" #include "thread.hpp" namespace sol { class coroutine : public reference { private: call_status stats = call_status::yielded; void luacall(std::ptrdiff_t argcount, std::ptrdiff_t) { #if SOL_LUA_VERSION < 502 stats = static_cast(lua_resume(lua_state(), static_cast(argcount))); #else stats = static_cast(lua_resume(lua_state(), nullptr, static_cast(argcount))); #endif // Lua 5.1 compat } 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 stacksize = lua_gettop(lua_state()); int firstreturn = (std::max)(1, stacksize - static_cast(n)); luacall(n, LUA_MULTRET); int poststacksize = lua_gettop(lua_state()); int returncount = poststacksize - (firstreturn - 1); if (error()) { return protected_function_result(lua_state(), lua_absindex(lua_state(), -1), 1, returncount, status()); } return protected_function_result(lua_state(), firstreturn, returncount, returncount, status()); } public: coroutine() noexcept = default; coroutine(const coroutine&) noexcept = default; coroutine(coroutine&&) noexcept = default; coroutine& operator=(const coroutine&) noexcept = default; coroutine& operator=(coroutine&&) noexcept = default; template , coroutine>>, std::is_base_of>> = meta::enabler> coroutine(T&& r) : reference(std::forward(r)) {} coroutine(lua_nil_t r) : reference(r) {} coroutine(const stack_reference& r) noexcept : coroutine(r.lua_state(), r.stack_index()) {} coroutine(stack_reference&& r) noexcept : coroutine(r.lua_state(), r.stack_index()) {} template >>, meta::neg>> = meta::enabler> coroutine(lua_State* L, T&& r) : coroutine(L, sol::ref_index(r.registry_index())) {} coroutine(lua_State* L, int index = -1) : reference(L, index) { #ifdef SOL_CHECK_ARGUMENTS stack::check(L, index, type_panic); #endif // Safety } coroutine(lua_State* L, ref_index index) : reference(L, index) { #ifdef SOL_CHECK_ARGUMENTS auto pp = stack::push_pop(*this); stack::check(L, -1, type_panic); #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 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) { push(); int pushcount = stack::multi_push(lua_state(), std::forward(args)...); return invoke(types(), std::make_index_sequence(), pushcount); } }; } // sol #endif // SOL_COUROUTINE_HPP