zekexiao/mrubypp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix failed bind method in gcc/clang
All checks were successful
ubuntu / Explore-Gitea-Actions (push) Successful in 1m39s
Details

Browse Source
This commit is contained in:
zekexiao
2025-10-22 22:11:58 +08:00
parent 4cc759347f
commit 72db94928c
4 changed files with 102 additions and 80 deletions
Download Patch File Download Diff File Expand all files Collapse all files

157
mrubypp_bind_class.h
View File

@@ -15,16 +15,16 @@
#include <mruby/data.h>
#include <mruby/proc.h>
template <typename... Args, size_t... Is>
template<typename... Args, size_t... Is>
std::tuple<Args...> mrubypp_get_args_helper_impl(mrb_state *mrb,
const mrb_value *argv,
std::index_sequence<Is...>) {
return std::make_tuple(
mrubypp_converter<typename std::decay<Args>::type>::from_mrb(
mrb, argv[Is])...);
mrubypp_converter<typename std::decay<Args>::type>::from_mrb(
mrb, argv[Is])...);
}
template <typename... Args>
template<typename... Args>
std::tuple<typename std::decay<Args>::type...>
mrubypp_get_args_helper(mrb_state *mrb) {
mrubypp_arena_guard guard(mrb);
@@ -36,24 +36,37 @@ mrubypp_get_args_helper(mrb_state *mrb) {
}
return mrubypp_get_args_helper_impl<typename std::decay<Args>::type...>(
mrb, argv, std::index_sequence_for<Args...>{});
mrb, argv, std::index_sequence_for<Args...>{});
}
template <typename T, typename Ret, typename... MethodArgs>
template<typename T, typename Ret, typename... MethodArgs>
struct mrubypp_method_wrapper {
using MethodType = Ret (T::*)(MethodArgs...);
// TODO, fix memory leak
static void *method_to_ptr(MethodType method) {
auto ptr = malloc(sizeof(MethodType));
memcpy(ptr, &method, sizeof(MethodType));
return ptr;
}
static MethodType ptr_to_method(void *ptr) {
MethodType method;
memcpy(&method, ptr, sizeof(MethodType));
return method;
}
static mrb_value wrapper(mrb_state *mrb, mrb_value self) {
auto args = mrubypp_get_args_helper<MethodArgs...>(mrb);
T *instance = static_cast<T *>(DATA_PTR(self));
if (!instance) {
mrb_raise(mrb, E_RUNTIME_ERROR, "invalid instance");
}
union {
Ret (T::*method)(MethodArgs...);
void *ptr;
} converter;
converter.ptr = mrb_cptr(mrb_cfunc_env_get(mrb, 0));
auto method = converter.method;
void *method_ptr = mrb_cptr(mrb_cfunc_env_get(mrb, 0));
auto method = ptr_to_method(method_ptr);
if constexpr (std::is_same_v<Ret, void>) {
std::apply(method, std::tuple_cat(std::make_tuple(instance), args));
return mrb_nil_value();
@@ -65,25 +78,36 @@ struct mrubypp_method_wrapper {
}
};
template <typename T, typename Ret, typename... MethodArgs>
template<typename T, typename Ret, typename... MethodArgs>
struct mrubypp_const_method_wrapper {
using MethodType = Ret (T::*)(MethodArgs...) const;
// TODO, fix memory leak
static void *method_to_ptr(MethodType method) {
auto ptr = malloc(sizeof(MethodType));
memcpy(ptr, &method, sizeof(MethodType));
return ptr;
}
static MethodType ptr_to_method(void *ptr) {
MethodType method;
memcpy(&method, ptr, sizeof(MethodType));
return method;
}
static mrb_value wrapper(mrb_state *mrb, mrb_value self) {
auto args = mrubypp_get_args_helper<MethodArgs...>(mrb);
T *instance = static_cast<T *>(DATA_PTR(self));
if (!instance) {
mrb_raise(mrb, E_RUNTIME_ERROR, "invalid instance");
}
union {
Ret (T::*method)(MethodArgs...) const;
void *ptr;
} converter;
converter.ptr = mrb_cptr(mrb_cfunc_env_get(mrb, 0));
auto method = converter.method;
void *method_ptr = mrb_cptr(mrb_cfunc_env_get(mrb, 0));
auto method = ptr_to_method(method_ptr);
if constexpr (std::is_same_v<Ret, void>) {
std::apply(method, std::tuple_cat(std::make_tuple(instance), args));
return mrb_nil_value();
} else {
Ret result =
std::apply(method, std::tuple_cat(std::make_tuple(instance), args));
@@ -92,16 +116,12 @@ struct mrubypp_const_method_wrapper {
}
};
template <typename T, typename Ret, typename... FuncArgs>
template<typename T, typename Ret, typename... FuncArgs>
struct mrubypp_function_wrapper {
static mrb_value wrapper(mrb_state *mrb, mrb_value self) {
union {
Ret (*func)(FuncArgs...);
void *ptr;
} converter;
using FunctionType = Ret (*)(FuncArgs...);
converter.ptr = mrb_cptr(mrb_cfunc_env_get(mrb, 0));
auto func = converter.func;
static mrb_value wrapper(mrb_state *mrb, mrb_value self) {
auto func = (FunctionType) mrb_cptr(mrb_cfunc_env_get(mrb, 0));
auto args = mrubypp_get_args_helper<FuncArgs...>(mrb);
if constexpr (std::is_same_v<Ret, void>) {
std::apply(func, args);
@@ -113,9 +133,11 @@ struct mrubypp_function_wrapper {
}
};
template <typename T> class mrubypp_class_builder;
template<typename T>
class mrubypp_class_builder;
template <typename T, typename... Args> struct mrubypp_constructor_wrapper {
template<typename T, typename... Args>
struct mrubypp_constructor_wrapper {
static mrb_value wrapper(mrb_state *mrb, mrb_value self) {
auto args = mrubypp_get_args_helper<Args...>(mrb);
T *instance = std::apply([](Args... args) { return new T(args...); }, args);
@@ -126,49 +148,47 @@ template <typename T, typename... Args> struct mrubypp_constructor_wrapper {
}
};
template <typename T> class mrubypp_class_builder {
template<typename T>
class mrubypp_class_builder {
public:
static const struct mrb_data_type data_type;
mrubypp_class_builder(mrb_state *mrb, std::string name)
: mrb_(mrb), name_(std::move(name)) {
: mrb_(mrb), name_(std::move(name)) {
rclass_ = mrb_define_class(mrb_, name_.c_str(), mrb_->object_class);
MRB_SET_INSTANCE_TT(rclass_, MRB_TT_DATA);
mrb_define_method(
mrb_, rclass_, "initialize",
[](mrb_state *mrb, mrb_value self) -> mrb_value {
mrb_raise(mrb, E_NOTIMP_ERROR,
"initialize must be defined explicitly");
return self;
},
MRB_ARGS_ANY());
mrb_, rclass_, "initialize",
[](mrb_state *mrb, mrb_value self) -> mrb_value {
mrb_raise(mrb, E_NOTIMP_ERROR,
"initialize must be defined explicitly");
return self;
},
MRB_ARGS_ANY());
}
template <typename... Args> mrubypp_class_builder &def_constructor() {
template<typename... Args>
mrubypp_class_builder &def_constructor() {
mrb_define_method(mrb_, rclass_, "initialize",
&mrubypp_constructor_wrapper<T, Args...>::wrapper,
MRB_ARGS_REQ(sizeof...(Args)));
return *this;
}
template <typename Ret, typename... MethodArgs>
template<typename Ret, typename... MethodArgs>
mrubypp_class_builder &def_method(const std::string &name,
Ret (T::*method)(MethodArgs...)) {
mrb_sym method_sym = mrb_intern_cstr(mrb_, name.c_str());
union {
Ret (T::*method_ptr)(MethodArgs...);
void *ptr;
} converter;
converter.method_ptr = method;
using wrap = mrubypp_method_wrapper<T, Ret, MethodArgs...>;
auto ptr = wrap::method_to_ptr(method);
mrb_value env[] = {
mrb_cptr_value(mrb_, converter.ptr),
mrb_cptr_value(mrb_, ptr),
};
struct RProc *p = mrb_proc_new_cfunc_with_env(
mrb_, &mrubypp_method_wrapper<T, Ret, MethodArgs...>::wrapper, 1, env);
mrb_, &wrap::wrapper, 1, env);
mrb_method_t m;
MRB_METHOD_FROM_PROC(m, p);
mrb_define_method_raw(mrb_, rclass_, method_sym, m);
@@ -176,45 +196,39 @@ public:
return *this;
}
template <typename Ret, typename... MethodArgs>
template<typename Ret, typename... MethodArgs>
mrubypp_class_builder &def_method(const std::string &name,
Ret (T::*method)(MethodArgs...) const) {
mrb_sym method_sym = mrb_intern_cstr(mrb_, name.c_str());
union {
Ret (T::*method_ptr)(MethodArgs...) const;
void *ptr;
} converter;
using wrap = mrubypp_const_method_wrapper<T, Ret, MethodArgs...>;
converter.method_ptr = method;
auto ptr = wrap::method_to_ptr(method);
auto obj = mrb_cptr_value(mrb_, ptr);
mrb_gc_protect(mrb_, obj);
mrb_value env[] = {
mrb_cptr_value(mrb_, converter.ptr),
obj
};
struct RProc *p = mrb_proc_new_cfunc_with_env(
mrb_, &mrubypp_const_method_wrapper<T, Ret, MethodArgs...>::wrapper, 1,
env);
mrb_, &wrap::wrapper, 1,
env);
mrb_method_t m;
MRB_METHOD_FROM_PROC(m, p);
mrb_define_method_raw(mrb_, rclass_, method_sym, m);
return *this;
}
template <typename Ret, typename... FuncArgs>
template<typename Ret, typename... FuncArgs>
mrubypp_class_builder &def_class_method(const std::string &name,
Ret (*func)(FuncArgs...)) {
union {
Ret (*funcPtr)(FuncArgs...);
void *ptr;
} converter;
converter.funcPtr = func;
using wrap = mrubypp_function_wrapper<T, Ret, FuncArgs...>;
mrb_value env[] = {
mrb_cptr_value(mrb_, converter.ptr),
mrb_cptr_value(mrb_, (void *) func),
};
mrb_sym func_sym = mrb_intern_cstr(mrb_, name.c_str());
struct RProc *p = mrb_proc_new_cfunc_with_env(
mrb_, &mrubypp_function_wrapper<T, Ret, FuncArgs...>::wrapper, 1, env);
mrb_, &wrap::wrapper, 1, env);
mrb_method_t m;
MRB_METHOD_FROM_PROC(m, p);
@@ -225,11 +239,10 @@ public:
}
// get set
template <typename Ret>
template<typename Ret>
mrubypp_class_builder &def_property(const std::string &name,
Ret (T::*getter)() const,
void (T::*setter)(Ret)) {
def_method(name, getter);
def_method(name + "=", setter);
return *this;
@@ -258,14 +271,14 @@ private:
delete instance;
}
}
static std::map<std::string, mrb_method_t> method_map;
mrb_state *mrb_;
struct RClass *rclass_;
std::string name_;
};
template <typename T>
template<typename T>
const struct mrb_data_type mrubypp_class_builder<T>::data_type = {
typeid(T).name(), mrubypp_class_builder<T>::free_instance
};