state.h

Go to the documentation of this file.

 
#ifndef NNGN_LUA_STATE_H
#define NNGN_LUA_STATE_H
 
#include <tuple>
#include <utility>
#include <vector>
 
#include "math/math.h"
#include "utils/fixed_string.h"
#include "utils/pp.h"
#include "utils/utils.h"
 
#include "lua.h"
#include "utils.h"
 
struct lua_State;
 
namespace nngn::lua {
 
struct alloc_info;
 
class state_view {
public:
    state_view(void) = default;
    state_view(lua_State *L_) : L{L_} {}
    operator lua_State*(void) const { return this->L; }
    bool init(alloc_info *i = nullptr);
    /* Disowns the current reference and returns a non-owning view to it. */
    state_view release(void) { return std::exchange(this->L, {}); }
    void destroy(void);
    int top(void) const { return lua_gettop(*this); }
    type get_type(int i) const;
    template<typename T = lua_Integer> T len(int i) const;
    std::pair<lua_Alloc, void*> allocator(void) const;
    global_table globals(void) const;
    void set_top(int i) const { lua_settop(*this, i); }
    void set_meta_table(auto &&mt, int i);
    void print_stack(void) const { nngn::lua::print_stack(*this); }
    void print_traceback(void) const { nngn::lua::print_traceback(*this); }
    bool doarg(std::string_view s) const;
    bool dofile(std::string_view filename) const;
    bool dostring(std::string_view src) const;
    bool dofunction(std::string_view f) const;
    template<typename T> T *new_user_data(int nv = 0) const;
    template<typename T> table new_user_type(void) const;
    table create_table(void) const;
    table create_table(int narr, int nrec) const;
    template<typename T = value_view> T get(int i) const;
    template<typename T = value_view> T push(auto &&x) const;
    void pop(int n = 1) const { lua_pop(*this, n); }
    void remove(int i) const { lua_remove(*this, i); }
    void call(auto &&f, auto &&...args) const;
    int pcall(auto &&h, auto &&f, auto &&...args) const;
    std::pair<value, std::string_view> to_string(int i) const;
    bool heartbeat(void) const;
protected:
    lua_State *L = nullptr;
};
 
struct state : state_view {
    NNGN_NO_COPY(state)
    state(void) = default;
    explicit state(lua_State *L_) : state_view{L_} {}
    state(state &&rhs) noexcept { *this = std::move(rhs); }
    state &operator=(state &&rhs) noexcept;
    ~state(void) { this->destroy(); }
};
 
template<typename T>
T get(nngn::lua::state_view L, int i) {
    return stack_get<T>::get(L, i);
}
 
template<typename T = value_view>
T push(nngn::lua::state_view lua, auto &&v) {
    [[maybe_unused]] const auto i = lua.top() + 1;
    stack_push<>::push(lua, FWD(v));
    if constexpr(!std::is_void_v<T>)
        return lua.get<T>(i);
}
 
inline type state_view::get_type(int i) const {
    const auto ret = static_cast<type>(lua_type(*this, i));
    if constexpr(Platform::debug)
        if(std::find(begin(types), end(types), ret) == end(types)) {
            NNGN_LOG_CONTEXT_CF(state_view);
            Log::l() << "invalid type at index " << i << '\n';
        }
    return ret;
}
 
template<typename T>
T state_view::len(int i) const {
    lua_len(*this, i);
    NNGN_ANON_DECL(defer_pop(*this));
    return this->get<T>(this->top());
}
 
inline std::pair<lua_Alloc, void*> state_view::allocator(void) const {
    void *p = nullptr;
    auto *const f = lua_getallocf(*this, &p);
    return {f, p};
}
 
void state_view::set_meta_table(auto &&mt, int i) {
    this->push(FWD(mt));
    lua_setmetatable(*this, i);
}
 
template<typename T>
T *state_view::new_user_data(int nv) const {
    return static_cast<T*>(
        Math::align_ptr(
            lua_newuserdatauv(*this, sizeof(T) + alignof(T), nv),
            alignof(T)));
}
 
template<typename T>
T state_view::get(int i) const {
    return lua::get<T>(*this, i);
}
 
template<typename T>
T state_view::push(auto &&x) const {
    return lua::push<T>(*this, FWD(x));
}
 
void state_view::call(auto &&f, auto &&...args) const {
    [[maybe_unused]] const int i = this->top() + 1;
    if constexpr(Platform::debug)
        lua_pushcfunction(*this, msgh);
    lua::push(*this, FWD(f));
    (..., lua::push(*this, FWD(args)));
    constexpr auto n_args = static_cast<int>(sizeof...(args));
    if constexpr(Platform::debug) {
        lua_pcall(*this, n_args, LUA_MULTRET, i);
        lua_remove(*this, i);
    } else
        lua_call(*this, n_args, LUA_MULTRET);
}
 
int state_view::pcall(auto &&h, auto &&f, auto &&...args) const {
    const int h_idx = h.index();
    assert(h_idx <= this->top());
    lua::push(*this, FWD(f));
    (..., lua::push(*this, FWD(args)));
    constexpr auto n_args = static_cast<int>(sizeof...(args));
    return lua_pcall(*this, n_args, LUA_MULTRET, h_idx);
}
 
inline state &state::operator=(state &&rhs) noexcept {
    state_view::operator=(std::move(rhs).release());
    return *this;
}
 
template<>
struct stack_get<state_view> {
    static state_view get(lua_State *L, int) { return L; }
};
 
}
 
#endif