fflua_lua.h

//
//  fflua_lua.h
//  RGPLua
//
//  Created by Robert Patterson on 4/3/23.
//
 
#ifndef fflua_luabridge_h
#define fflua_luabridge_h
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
 
#include "lua.hpp"
 
//#ifndef __OBJC__
 
// LuaBridge 2 headers do not compile in objective-c++, so this directive was used
// to mask them. But it is much safer to compile all code with the same headers,
// so now that we are using LuaBridge 3, this is effectively the same as PDK_FRAMEWORK_LUAFRIENDLY
#define PDK_FRAMEWORK_LUAFRIENDLY_CPP
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdocumentation"
#endif
 
#include "LuaBridge/LuaBridge.h"
#include "LuaBridge/Vector.h"
#include "LuaBridge/Map.h"
 
#if LUABRIDGE_MAJOR_VERSION >= 3
namespace luabridge
{
template<class T>
using RefCountedPtr = std::shared_ptr<T>;
}
template<class T>
static std::shared_ptr<T> makeLuaSharedPtr(T *p) { return std::shared_ptr<T>(p, [](T* p){ delete p; }); }
#else
#include "LuaBridge/RefCountedPtr.h"
template<class T>
static luabridge::RefCountedPtr<T> makeLuaSharedPtr(T *p) { return luabridge::RefCountedPtr<T>(p); }
#endif
 
#if LUABRIDGE_MAJOR_VERSION >= 3
#define LB3(C) C
#define LB3_PARM(C) , C
#define LB2(C)
#else
#define LB3(C)
#define LB3_PARM(C)
#define LB2(C) C
#endif
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
 
#if LUABRIDGE_MAJOR_VERSION < 3
namespace luabridge
{
template <typename T>
struct Enum {
    static inline
    typename std::enable_if<std::is_enum<T>::value, void>::type
    push(lua_State* L, T value) {
        lua_pushnumber(L, static_cast<std::size_t>(value));
    }
    
    static inline
    typename std::enable_if<std::is_enum<T>::value, T>::type
    get(lua_State* L, int index) {
        return static_cast<T>(lua_tointeger(L, index));
    }
};
}
#endif // LUABRIDGE_MAJOR_VERSION < 3
 
// Lua coroutines use a different state than the main execution path,
// so the Lua connector should insert the base state at this key:
constexpr char LUARUN_BASE_STATE_KEY[] = "___LuaRun_BaseStateKey$$$___";
 
inline lua_State* _GetBaseLuaState(lua_State *L)
{
    lua_pushstring(L, LUARUN_BASE_STATE_KEY);
    lua_gettable(L, LUA_REGISTRYINDEX);
    lua_State* baseState = lua_tothread(L, -1);
    lua_pop(L, 1);
    assert(baseState); // assert should never fail if _CreateLuaState is used to create the state
    return baseState;
}
 
inline lua_State* _CreateLuaState()
{
    lua_State* L = luaL_newstate();
    // push the base-state key into the registry, so we can retrieve it in coroutines
    lua_pushstring(L, LUARUN_BASE_STATE_KEY);
    lua_pushthread(L);
    lua_settable(L, LUA_REGISTRYINDEX);
    return L;
}
 
template<class FC, typename OPT>
FC* _OneOptionalParamLuaConstructor(void* ptr, lua_State *L)
{
    const int numArgs = lua_gettop(L);
    if (numArgs <= 2) return new(ptr) FC();
    OPT optParam = luabridge::Stack<OPT>::get(L, 2) LB3(.value());
    return new(ptr) FC(optParam);
}
 
template <class C, typename RT, RT (C::*func)() const>
int _CFunctionProxyGetter(lua_State* L)
{
    const C* instance = luabridge::Stack<const C*>::get(L, 1) LB3(.value());
    RT result = (instance->*func)();
    luabridge::Stack<RT>::push(L, result) LB3(.throw_on_error());
    return 1;
}
 
template <class C, typename RT, void (C::*func)(RT)>
int _CFunctionProxySetter(lua_State* L)
{
    C* instance = luabridge::Stack<C*>::get(L, 1) LB3(.value());
    luabridge::LuaRef ref = luabridge::Stack<luabridge::LuaRef>::get(L, 2) LB3(.value());
    if constexpr(std::is_same<RT, const char *>::value)
    {
        // if the input is a string:
        //    - nil is converted to ""
        //    - luaL_checkstring automatically converts numbers to decimal strings
        //    - other types throw type errors
        if (! ref.isString())
        {
            (instance->*func)(lua_isnil(L, 2) ? "" : luaL_checkstring(L, 2));
            return 0;
        }
    }
    (instance->*func)(ref.cast<RT>() LB3(.value()));
    return 0;
}
 
template <class C, typename RT, typename PT, typename F, typename I>
int _CFunctionOneOptionalParameterImpl(lua_State *L, F func, I instance, PT default_value)
{
    const int numArgs = lua_gettop(L);
    // argument 1 is `this`
    int retval = 0;
    PT param = (numArgs < 2) ? default_value : luabridge::Stack<PT>::get(L, 2) LB3(.value());
    if constexpr(std::is_void<RT>::value)
        ((*instance).*func)(param);
    else
    {
        luabridge::Stack<RT>::push(L, ((*instance).*func)(param)) LB3(.throw_on_error());
        retval++;
    }
    return retval;
}
 
template <class C, typename RT, typename PT, RT (C::*func)(PT)>
int _CFunctionOneOptionalParameter(lua_State *L, PT default_value)
{
    C* instance = luabridge::Stack<C*>::get(L, 1) LB3(.value());
    return _CFunctionOneOptionalParameterImpl<C, RT, PT, decltype(func), C*>(L, func, instance, default_value);
}
 
template <class C, typename RT, typename PT, RT (C::*func)(PT) const>
int _CFunctionOneOptionalParameter(lua_State *L, PT default_value)
{
    const C* instance = luabridge::Stack<const C*>::get(L, 1) LB3(.value());
    return _CFunctionOneOptionalParameterImpl<C, RT, PT, decltype(func), const C*>(L, func, instance, default_value);
}
 
template <class C, typename RT, typename PT, RT (C::*func)(PT, lua_State*)>
int _CFunctionOneOptionalParameterWithState(lua_State* L, PT default_value)
{
    const int numArgs = lua_gettop(L);
    assert(numArgs >= 1);
    C* instance = luabridge::Stack<C*>::get(L, 1) LB3(.value());
    PT param = (numArgs < 2) ? default_value : luabridge::Stack<PT>::get(L, 2) LB3(.value());
    luabridge::Stack<RT>::push(L, ((*instance).*func)(param, L)) LB3(.throw_on_error());
    return 1;
}
 
 
extern lua_CFunction LuaRun_ErrorFunction;
 
//#endif // #ifndef __OBJC__
 
#endif // DOXYGEN_SHOULD_IGNORE_THIS
 
 
#endif /* fflua_luabridge_h */