rbxx 0.1.0

data/include/rbxx/data_object.hpp

@@ -0,0 +1,221 @@
+#pragma once
+
+#include <rbxx/policies.hpp>
+#include <rbxx/registry.hpp>
+
+#include <memory>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+namespace rbxx {
+
+/// @brief A Ruby VALUE member that remains marked and compaction-safe inside a C++ object.
+/// @code rbxx::member_value child{ruby_child}; @endcode
+class member_value {
+public:
+  member_value() noexcept { rb_gc_register_address(&stored_); }
+  explicit member_value(value initial) noexcept : stored_(initial.raw()) {
+    rb_gc_register_address(&stored_);
+  }
+  explicit member_value(VALUE initial) noexcept : stored_(initial) {
+    rb_gc_register_address(&stored_);
+  }
+  member_value(const member_value& other) noexcept : stored_(other.stored_) {
+    rb_gc_register_address(&stored_);
+  }
+  member_value(member_value&& other) noexcept : stored_(other.stored_) {
+    rb_gc_register_address(&stored_);
+    other.stored_ = Qnil;
+  }
+  member_value& operator=(const member_value& other) noexcept {
+    stored_ = other.stored_;
+    return *this;
+  }
+  member_value& operator=(member_value&& other) noexcept {
+    stored_ = other.stored_;
+    other.stored_ = Qnil;
+    return *this;
+  }
+  ~member_value() noexcept { rb_gc_unregister_address(&stored_); }
+
+  [[nodiscard]] value get() const noexcept { return value{stored_}; }
+  void set(value updated) noexcept { stored_ = updated.raw(); }
+
+private:
+  VALUE stored_ = Qnil;
+};
+
+namespace detail {
+
+template <typename T> struct is_non_bindable_class : std::false_type {};
+template <typename T> struct is_non_bindable_class<std::unique_ptr<T>> : std::true_type {};
+template <typename T> struct is_non_bindable_class<std::shared_ptr<T>> : std::true_type {};
+
+enum class ownership { owned, borrowed, shared };
+
+template <typename T> struct data_wrapper {
+  T* pointer = nullptr;
+  ownership mode = ownership::borrowed;
+  std::shared_ptr<T> shared_owner;
+
+  ~data_wrapper() noexcept {
+    if (mode == ownership::owned) {
+      delete pointer;
+    }
+  }
+};
+
+template <typename T> void data_mark(void*) noexcept {}
+template <typename T> void data_compact(void*) noexcept {}
+
+template <typename T> void data_free(void* raw) noexcept {
+  delete static_cast<data_wrapper<T>*>(raw);
+}
+
+template <typename T> std::size_t data_size(const void* raw) noexcept {
+  const auto* wrapper = static_cast<const data_wrapper<T>*>(raw);
+  return sizeof(data_wrapper<T>) +
+         (wrapper != nullptr && wrapper->pointer != nullptr ? sizeof(T) : 0U);
+}
+
+template <typename T> rb_data_type_t& typed_data_type() {
+  static auto* name = new std::string("rbxx::" + std::string(type_name<T>()));
+  static rb_data_type_t type = {
+      name->c_str(),
+      {data_mark<T>, data_free<T>, data_size<T>, data_compact<T>, {nullptr}},
+      nullptr,
+      nullptr,
+      RUBY_TYPED_FREE_IMMEDIATELY,
+  };
+  return type;
+}
+
+template <typename T> value wrap_data(std::unique_ptr<data_wrapper<T>> wrapper) {
+  class_info& information = registered_class<T>();
+  VALUE result = protect(rb_data_typed_object_wrap, information.ruby_class,
+                         static_cast<void*>(wrapper.get()), information.data_type);
+  wrapper.release();
+  return value{result};
+}
+
+template <typename T> value wrap_copy(const T& input) {
+  auto wrapper = std::make_unique<data_wrapper<T>>();
+  wrapper->pointer = new T(input);
+  wrapper->mode = ownership::owned;
+  return wrap_data(std::move(wrapper));
+}
+
+template <typename T> value wrap_move(T&& input) {
+  auto wrapper = std::make_unique<data_wrapper<T>>();
+  wrapper->pointer = new T(std::move(input));
+  wrapper->mode = ownership::owned;
+  return wrap_data(std::move(wrapper));
+}
+
+template <typename T> value wrap_reference(T* input) {
+  if (input == nullptr) {
+    return value{Qnil};
+  }
+  auto wrapper = std::make_unique<data_wrapper<T>>();
+  wrapper->pointer = input;
+  wrapper->mode = ownership::borrowed;
+  return wrap_data(std::move(wrapper));
+}
+
+template <typename T> value wrap_take(std::unique_ptr<T> input) {
+  if (!input) {
+    return value{Qnil};
+  }
+  auto wrapper = std::make_unique<data_wrapper<T>>();
+  wrapper->pointer = input.release();
+  wrapper->mode = ownership::owned;
+  return wrap_data(std::move(wrapper));
+}
+
+template <typename T> value wrap_shared(std::shared_ptr<T> input) {
+  if (!input) {
+    return value{Qnil};
+  }
+  auto wrapper = std::make_unique<data_wrapper<T>>();
+  wrapper->pointer = input.get();
+  wrapper->mode = ownership::shared;
+  wrapper->shared_owner = std::move(input);
+  return wrap_data(std::move(wrapper));
+}
+
+template <typename T, typename Base = void>
+void register_data_class(VALUE ruby_class,
+                         std::source_location location = std::source_location::current()) {
+  rb_data_type_t& type = typed_data_type<T>();
+  if constexpr (!std::is_void_v<Base>) {
+    type.parent = &typed_data_type<Base>();
+  }
+  type_registry::instance().add<T, Base>(ruby_class, &type, location);
+  type_registry::instance().set_native_pointer<T>(
+      [](void* raw) { return static_cast<void*>(static_cast<data_wrapper<T>*>(raw)->pointer); });
+}
+
+template <typename T> VALUE allocate_data_object(VALUE klass) {
+  VALUE result = Qnil;
+  VALUE pending = Qnil;
+  try {
+    auto wrapper = std::make_unique<data_wrapper<T>>();
+    result = protect(rb_data_typed_object_wrap, klass, static_cast<void*>(wrapper.get()),
+                     &typed_data_type<T>());
+    wrapper.release();
+  } catch (...) {
+    pending = translate_current_exception();
+  }
+  if (!NIL_P(pending)) {
+    rb_exc_raise(pending);
+  }
+  return result;
+}
+
+template <typename T> data_wrapper<T>& exact_wrapper(value self) {
+  if (!RB_TYPE_P(self.raw(), T_DATA) || !RTYPEDDATA_P(self.raw()) ||
+      RTYPEDDATA_TYPE(self.raw()) != &typed_data_type<T>()) {
+    throw ruby_error(make_exception(rb_eTypeError, "rbxx: unexpected TypedData class"));
+  }
+  return *static_cast<data_wrapper<T>*>(RTYPEDDATA_DATA(self.raw()));
+}
+
+} // namespace detail
+
+template <typename T>
+struct type_caster<T, std::enable_if_t<std::is_class_v<T> && !std::is_same_v<T, object> &&
+                                       !detail::is_non_bindable_class<T>::value>> {
+  static constexpr std::string_view name = "bound C++ object";
+  static T& load(value input) { return detail::load_registered<T>(input); }
+  static value dump(const T& input) { return detail::wrap_copy(input); }
+  static value dump(T&& input) { return detail::wrap_move(std::move(input)); }
+  static bool matches(value input) noexcept { return detail::registered_matches<T>(input); }
+};
+
+template <typename T> struct type_caster<T*> {
+  static constexpr std::string_view name = "bound C++ object or nil";
+  static T* load(value input) {
+    return input.is_nil() ? nullptr : std::addressof(detail::load_registered<T>(input));
+  }
+  static value dump(T* input) { return detail::wrap_reference(input); }
+  static bool matches(value input) noexcept {
+    return input.is_nil() || detail::registered_matches<T>(input);
+  }
+};
+
+template <typename T> struct type_caster<std::unique_ptr<T>> {
+  static constexpr std::string_view name = "owned C++ object";
+  static value dump(std::unique_ptr<T> input) { return detail::wrap_take(std::move(input)); }
+  static bool matches(value) noexcept { return false; }
+};
+
+template <typename T> struct type_caster<std::shared_ptr<T>> {
+  static constexpr std::string_view name = "shared C++ object";
+  static value dump(std::shared_ptr<T> input) { return detail::wrap_shared(std::move(input)); }
+  static bool matches(value input) noexcept {
+    return RB_TYPE_P(input.raw(), T_DATA) && RTYPEDDATA_P(input.raw());
+  }
+};
+
+} // namespace rbxx

data/include/rbxx/detail/ruby_include.hpp

@@ -0,0 +1,36 @@
+#pragma once
+
+#if defined(_MSC_VER)
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#pragma warning(push)
+#pragma warning(disable : 4127 4244 4267 4996)
+#else
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
+
+#include <ruby.h>
+#include <ruby/thread.h>
+#include <ruby/version.h>
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#else
+#pragma GCC diagnostic pop
+#endif
+
+#define RBXX_RUBY_VERSION_MAJOR RUBY_API_VERSION_MAJOR
+#define RBXX_RUBY_VERSION_MINOR RUBY_API_VERSION_MINOR
+#define RBXX_RUBY_VERSION_TEENY RUBY_API_VERSION_TEENY
+
+#if RUBY_API_VERSION_MAJOR < 4
+// CRuby exports this debug helper before 4.0 but does not declare it in ruby/thread.h.
+extern "C" int ruby_thread_has_gvl_p(void);
+#endif
+
+static_assert(RUBY_API_VERSION_MAJOR >= 3, "rbxx requires CRuby 3.1 or newer");

data/include/rbxx/exception.hpp

@@ -0,0 +1,116 @@
+#pragma once
+
+#include <rbxx/object.hpp>
+
+#include <exception>
+#include <new>
+#include <stdexcept>
+#include <string>
+
+namespace rbxx {
+
+/// @brief A C++ exception that preserves the original Ruby exception object.
+/// @code catch (const rbxx::ruby_error& error) { error.reraise(); } @endcode
+class ruby_error : public std::exception {
+public:
+  /// @brief Pins a Ruby exception for propagation through C++ frames.
+  explicit ruby_error(value exception) : exception_(exception) {}
+  explicit ruby_error(VALUE exception) : exception_(exception) {}
+
+  /// @brief Returns a stable description for C++ diagnostics.
+  [[nodiscard]] const char* what() const noexcept override { return "Ruby exception"; }
+
+  /// @brief Returns the preserved Ruby exception.
+  [[nodiscard]] value exception() const noexcept { return exception_.get(); }
+
+  /// @brief Returns the Ruby exception class name.
+  [[nodiscard]] std::string ruby_class_name() const;
+
+  /// @brief Returns the Ruby exception message.
+  [[nodiscard]] std::string message() const;
+
+  /// @brief Throws a copy so the outer Ruby boundary can transparently re-raise it.
+  [[noreturn]] void reraise() const { throw *this; }
+
+private:
+  object exception_;
+};
+
+namespace detail {
+
+inline VALUE exception_class_name(VALUE exception) { return rb_class_name(CLASS_OF(exception)); }
+
+inline VALUE exception_message(VALUE exception) {
+  VALUE message = rb_funcall(exception, rb_intern("message"), 0);
+  return rb_obj_as_string(message);
+}
+
+inline std::string protected_exception_string(VALUE exception, VALUE (*function)(VALUE)) {
+  int state = 0;
+  VALUE string = rb_protect(function, exception, &state);
+  if (state != 0) {
+    VALUE nested = rb_errinfo();
+    rb_set_errinfo(Qnil);
+    throw ruby_error(nested);
+  }
+  return std::string(RSTRING_PTR(string), static_cast<std::size_t>(RSTRING_LEN(string)));
+}
+
+struct exception_creation {
+  VALUE klass;
+  const char* message;
+};
+
+inline VALUE create_exception(VALUE opaque) {
+  auto* creation = reinterpret_cast<exception_creation*>(opaque);
+  return rb_exc_new_cstr(creation->klass, creation->message);
+}
+
+inline VALUE make_exception(VALUE klass, const char* message) noexcept {
+  exception_creation creation{klass, message};
+  int state = 0;
+  VALUE result = rb_protect(create_exception, reinterpret_cast<VALUE>(&creation), &state);
+  if (state == 0) {
+    return result;
+  }
+
+  result = rb_errinfo();
+  rb_set_errinfo(Qnil);
+  return result;
+}
+
+/// @brief Converts the active C++ exception into a Ruby exception VALUE without raising it.
+/// @code catch (...) { pending = rbxx::detail::translate_current_exception(); } @endcode
+inline VALUE translate_current_exception() noexcept {
+  try {
+    throw;
+  } catch (const ruby_error& error) {
+    return error.exception().raw();
+  } catch (const std::invalid_argument& error) {
+    return make_exception(rb_eArgError, error.what());
+  } catch (const std::out_of_range& error) {
+    return make_exception(rb_eRangeError, error.what());
+  } catch (const std::range_error& error) {
+    return make_exception(rb_eRangeError, error.what());
+  } catch (const std::bad_alloc& error) {
+    return make_exception(rb_eNoMemError, error.what());
+  } catch (const std::domain_error& error) {
+    return make_exception(rb_eMathDomainError, error.what());
+  } catch (const std::exception& error) {
+    return make_exception(rb_eRuntimeError, error.what());
+  } catch (...) {
+    return make_exception(rb_eRuntimeError, "unknown C++ exception");
+  }
+}
+
+} // namespace detail
+
+inline std::string ruby_error::ruby_class_name() const {
+  return detail::protected_exception_string(exception_.raw(), detail::exception_class_name);
+}
+
+inline std::string ruby_error::message() const {
+  return detail::protected_exception_string(exception_.raw(), detail::exception_message);
+}
+
+} // namespace rbxx

data/include/rbxx/extension.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <rbxx/exception.hpp>
+
+#if defined(_WIN32)
+#define RBXX_EXPORT __declspec(dllexport)
+#else
+#define RBXX_EXPORT __attribute__((visibility("default")))
+#endif
+
+#define RBXX_EXTENSION(name)                                                                       \
+  static void rbxx_init_body_##name();                                                             \
+  extern "C" RBXX_EXPORT void Init_##name() {                                                      \
+    VALUE rbxx_pending_exception = Qnil;                                                           \
+    try {                                                                                          \
+      rbxx_init_body_##name();                                                                     \
+      return;                                                                                      \
+    } catch (...) {                                                                                \
+      rbxx_pending_exception = ::rbxx::detail::translate_current_exception();                      \
+    }                                                                                              \
+    rb_exc_raise(rbxx_pending_exception);                                                          \
+  }                                                                                                \
+  static void rbxx_init_body_##name()