mirror of
https://github.com/scp-fs2open/fs2open.github.com.git
synced 2026-11-09 04:49:39 -10:00
asarium
ebcf686cf7
This adds a Lua API for representing asynchronous operations and running coroutines based on those operations comfortably. This is very similar to features other languages have introduced such as C# or JavaScript. In fact, the whole "promise" thing is derived from how JavaScript represents these operations. This is the initial and very basic system for supporting async coroutines in Lua. There is no native support for running these operations at specific points (they run whenever the awaited promise resolved) or making sure they do not leak through different game states.
125 lines
2.4 KiB
C++
125 lines
2.4 KiB
C++
#include "LuaValue.h"
|
|
#include "LuaException.h"
|
|
|
|
namespace {
|
|
using namespace luacpp;
|
|
|
|
ValueType luaToEnumType(int luaType) {
|
|
switch (luaType) {
|
|
case LUA_TNONE:
|
|
return ValueType::NONE;
|
|
case LUA_TNIL:
|
|
return ValueType::NIL;
|
|
case LUA_TBOOLEAN:
|
|
return ValueType::BOOLEAN;
|
|
case LUA_TLIGHTUSERDATA:
|
|
return ValueType::LIGHTUSERDATA;
|
|
case LUA_TNUMBER:
|
|
return ValueType::NUMBER;
|
|
case LUA_TSTRING:
|
|
return ValueType::STRING;
|
|
case LUA_TTABLE:
|
|
return ValueType::TABLE;
|
|
case LUA_TFUNCTION:
|
|
return ValueType::FUNCTION;
|
|
case LUA_TUSERDATA:
|
|
return ValueType::USERDATA;
|
|
case LUA_TTHREAD:
|
|
return ValueType::THREAD;
|
|
|
|
default:
|
|
return ValueType::NONE;
|
|
}
|
|
}
|
|
}
|
|
|
|
namespace luacpp {
|
|
LuaValue LuaValue::createNil(lua_State* L)
|
|
{
|
|
lua_pushnil(L);
|
|
|
|
LuaValue val(L);
|
|
|
|
val.setReference(UniqueLuaReference::create(L));
|
|
|
|
return val;
|
|
}
|
|
|
|
LuaValue::LuaValue() = default;
|
|
|
|
LuaValue::LuaValue(lua_State* state) : _luaState(state)
|
|
{
|
|
Assertion(state != nullptr, "Lua state pointer is not valid!");
|
|
}
|
|
|
|
LuaValue::LuaValue(const LuaValue&) = default;
|
|
LuaValue& LuaValue::operator=(const LuaValue&) = default;
|
|
|
|
LuaValue::LuaValue(LuaValue&&) noexcept = default;
|
|
LuaValue& LuaValue::operator=(LuaValue&&) noexcept = default;
|
|
|
|
LuaValue::~LuaValue() = default;
|
|
|
|
void LuaValue::setReference(const LuaReference& ref)
|
|
{
|
|
this->_reference = ref;
|
|
this->_luaState = ref->getState();
|
|
|
|
if (isValid()) {
|
|
this->_reference->pushValue(_luaState);
|
|
|
|
this->_luaType = luaToEnumType(lua_type(_luaState, -1));
|
|
|
|
lua_pop(_luaState, 1);
|
|
} else {
|
|
_luaType = ValueType::NONE;
|
|
}
|
|
}
|
|
|
|
const LuaReference LuaValue::getReference() const {
|
|
return _reference;
|
|
}
|
|
|
|
ValueType LuaValue::getValueType() const {
|
|
return _luaType;
|
|
}
|
|
|
|
bool LuaValue::isValid() const {
|
|
return _reference && _reference->isValid();
|
|
}
|
|
|
|
bool LuaValue::pushValue(lua_State* thread) const
|
|
{
|
|
if (this->_reference->isValid()) {
|
|
this->_reference->pushValue(thread);
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
lua_State* LuaValue::getLuaState() const { return _luaState; }
|
|
|
|
namespace convert {
|
|
|
|
void pushValue(lua_State* luaState, const LuaValue& value) { value.pushValue(luaState); }
|
|
|
|
bool popValue(lua_State* luaState, LuaValue& target, int stackposition, bool remove)
|
|
{
|
|
if (!internal::isValidIndex(luaState, stackposition)) {
|
|
return false;
|
|
}
|
|
|
|
target.setReference(UniqueLuaReference::create(luaState, stackposition));
|
|
|
|
if (remove) {
|
|
lua_remove(luaState, stackposition);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
}
|
|
|
|
}
|