lua.h

Go to the documentation of this file.

 
#ifndef NNGN_LUA_LUA_H
#define NNGN_LUA_LUA_H
 
#include <numeric>
#include <optional>
 
#include <lua.hpp>
 
#include "utils/concepts.h"
#include "utils/fixed_string.h"
#include "utils/fn.h"
#include "utils/ranges.h"
#include "utils/utils.h"
 
struct lua_State;
 
namespace nngn::lua {
 
class global_table;
class state_view;
struct table;
struct value;
class value_view;
 
#define NNGN_LUA_TYPES(X) \
    X(none, LUA_TNONE) \
    X(nil, LUA_TNIL) \
    X(boolean, LUA_TBOOLEAN) \
    X(light_user_data, LUA_TLIGHTUSERDATA) \
    X(number, LUA_TNUMBER) \
    X(string, LUA_TSTRING) \
    X(table, LUA_TTABLE) \
    X(function, LUA_TFUNCTION) \
    X(user_data, LUA_TUSERDATA) \
    X(thread, LUA_TTHREAD)
 
enum class type : int {
#define X(n, v) n = v,
    NNGN_LUA_TYPES(X)
#undef X
};
 
inline constexpr struct nil_type {} nil;
 
template<typename T> struct error { T e; };
 
// XXX clang
template<typename T> error(T) -> error<T>;
 
inline constexpr std::array types = [] {
    using U = std::underlying_type_t<type>;
    constexpr auto f = to_underlying<type>;
    constexpr auto b = f(type::none), e = f(type::thread) + 1;
    constexpr auto n = e - b;
    std::array<U, n> u = {};
    std::array<type, n> ret = {};
    std::iota(begin(u), end(u), b);
    std::transform(
        std::ranges::begin(u), std::ranges::end(u),
        std::ranges::begin(ret), to<type>{});
    return ret;
}();
static_assert(is_sequence(types, to_underlying<type>));
 
inline constexpr type type_from_lua(int t) {
    assert(to_underlying(type::nil) <= t);
    assert(t <= to_underlying(types.back()));
    constexpr auto b = std::find(begin(types), end(types), type::nil);
    static_assert(b != end(types));
    return b[t];
}
 
template<typename> struct stack_get;
template<typename = void> struct stack_push;
 
// Note: a function template would remove the need for the `stack_push<>::push`
// circumlocution, but non dependent names (e.g. `stack_push(L, x)`) are bound
// when a template is defined, not instantiated:
//
// https://en.cppreference.com/w/cpp/language/dependent_name#Binding_rules
//
// This meant any members of the overload set defined after a particular use of
// \ref stack_push would not be seen.
template<>
struct stack_push<void> {
    template<typename T>
    static int push(lua_State *L, T &&t) {
        return stack_push<std::decay_t<T>>::push(L, FWD(t));
    }
};
 
template<typename T> inline constexpr auto is_user_type = false;
 
template<typename T> concept user_type = is_user_type<std::decay_t<T>>;
 
template<typename T> inline constexpr empty metatable_name = {};
 
template<typename R, typename ...Args>
R call(lua_State *L, R(*f)(Args...), int i = 1);
template<typename R, typename T, typename ...Args>
R call(lua_State *L, R(T::*f)(Args...), int i = 1);
template<typename R, typename T, typename ...Args>
R call(lua_State *L, R(T::*f)(Args...) const, int i = 1);
template<stateless_lambda T>
decltype(auto) call(lua_State *L, T, int i = 1);
 
namespace detail {
 
template<typename CRTP, typename T> class table_iter_base;
template<typename T> class table_iter;
template<typename T> class table_seq_iter;
 
enum op_mode { normal, raw };
 
struct table_base_tag {};
 
struct table_proxy_tag {};
 
template<typename T>
inline constexpr bool can_get = requires(lua_State *L) {
    stack_get<T>::get(L, 0);
};
 
template<typename T>
inline constexpr bool can_push = requires(lua_State *L, T t) {
    stack_push<T>::push(L, t);
};
 
template<typename T>
concept stack_value = can_get<T> && can_push<T>;
 
template<typename T>
concept stack_type = requires(lua_State *L, int i, T t) {
    { T{L, i} };
    { t.state() } -> std::same_as<state_view>;
    { t.push() } -> std::same_as<int>;
};
 
template<typename T>
concept integer = convertible_to_strict<T, lua_Integer>;
 
template<typename T>
concept number = convertible_to_strict<T, lua_Number>;
 
template<typename T> inline constexpr bool is_optional = false;
template<typename T> inline constexpr bool is_optional<std::optional<T>> = true;
 
}
 
template<typename T> inline constexpr bool is_stack_ref = false;
 
template<typename T>
inline constexpr bool is_stack_ref<std::optional<T>> = is_stack_ref<T>;
 
template<typename T> concept stack_ref = is_stack_ref<std::decay_t<T>>;
 
std::string_view type_str(type t);
int msgh(lua_State *L);
void print_stack(lua_State *L);
void print_traceback(lua_State *L);
 
inline std::string_view type_str(type t) {
    switch(t) {
#define X(n, _) case type::n: return #n;
    NNGN_LUA_TYPES(X)
#undef X
    default: return "unknown";
    }
}
 
}
 
#endif