rice 4.0.4 → 4.2.0

data/rice/detail/Wrapper.ipp

@@ -1,4 +1,5 @@
 #include <memory>
+#include "InstanceRegistry.hpp"
 
 namespace Rice::detail
 {
@@ -23,6 +24,11 @@ namespace Rice::detail
     {
     }
 
+    ~WrapperValue()
+    {
+      Registries::instance.instances.remove(this->get());
+    }
+
     void* get() override
     {
       return (void*)&this->data_;
@@ -36,8 +42,13 @@ namespace Rice::detail
   class WrapperReference : public Wrapper
   {
   public:
-    WrapperReference(const T& data): data_(data)
+    WrapperReference(T& data): data_(data)
+    {
+    }
+
+    ~WrapperReference()
     {
+      Registries::instance.instances.remove(this->get());
     }
 
     void* get() override
@@ -46,7 +57,7 @@ namespace Rice::detail
     }
 
   private:
-    const T& data_;
+    T& data_;
   };
 
   template <typename T>
@@ -59,6 +70,8 @@ namespace Rice::detail
 
     ~WrapperPointer()
     {
+      Registries::instance.instances.remove(this->get());
+
       if (this->isOwner_)
       {
         delete this->data_;
@@ -79,53 +92,76 @@ namespace Rice::detail
   template <typename T, typename Wrapper_T>
   inline VALUE wrap(VALUE klass, rb_data_type_t* rb_type, T& data, bool isOwner)
   {
+    VALUE result = Registries::instance.instances.lookup(&data);
+
+    if (result != Qnil)
+      return result;
+
+    Wrapper* wrapper = nullptr;
+
     if constexpr (!std::is_void_v<Wrapper_T>)
     {
-      Wrapper_T* wrapper = new Wrapper_T(data);
-      return TypedData_Wrap_Struct(klass, rb_type, wrapper);
+      wrapper = new Wrapper_T(data);
+      result = TypedData_Wrap_Struct(klass, rb_type, wrapper);
     }
     else if (isOwner)
     {
-      WrapperValue<T>* wrapper = new WrapperValue<T>(data);
-      return TypedData_Wrap_Struct(klass, rb_type, wrapper);
+      wrapper = new WrapperValue<T>(data);
+      result = TypedData_Wrap_Struct(klass, rb_type, wrapper);
     }
     else
     {
-      WrapperReference<T>* wrapper = new WrapperReference<T>(data);
-      return TypedData_Wrap_Struct(klass, rb_type, wrapper);
+      wrapper = new WrapperReference<T>(data);
+      result = TypedData_Wrap_Struct(klass, rb_type, wrapper);
     }
+
+    Registries::instance.instances.add(wrapper->get(), result);
+
+    return result;
   };
 
   template <typename T, typename Wrapper_T>
   inline VALUE wrap(VALUE klass, rb_data_type_t* rb_type, T* data, bool isOwner)
   {
+    VALUE result = Registries::instance.instances.lookup(data);
+
+    if (result != Qnil)
+      return result;
+
+    Wrapper* wrapper = nullptr;
+
     if constexpr (!std::is_void_v<Wrapper_T>)
     {
-      Wrapper_T* wrapper = new Wrapper_T(data);
-      return TypedData_Wrap_Struct(klass, rb_type, wrapper);
+      wrapper = new Wrapper_T(data);
+      result = TypedData_Wrap_Struct(klass, rb_type, wrapper);
     }
     else
     {
-      WrapperPointer<T>* wrapper = new WrapperPointer<T>(data, isOwner);
-      return TypedData_Wrap_Struct(klass, rb_type, wrapper);
+      wrapper = new WrapperPointer<T>(data, isOwner);
+      result = TypedData_Wrap_Struct(klass, rb_type, wrapper);
     }
+
+    Registries::instance.instances.add(wrapper->get(), result);
+    return result;
   };
 
   template <typename T>
   inline T* unwrap(VALUE value, rb_data_type_t* rb_type)
   {
     Wrapper* wrapper = getWrapper(value, rb_type);
-    TypedData_Get_Struct(value, Wrapper, rb_type, wrapper);
-    return static_cast<T*>(wrapper->get());
-  }
 
-  inline void* unwrap(VALUE value)
-  {
-    // Direct access to avoid any type checking
-    Wrapper* wrapper = (Wrapper*)RTYPEDDATA_DATA(value);
-    return wrapper->get();
-  }
+    if (wrapper == nullptr)
+    {
+      std::string message = "Wrapped C++ object is nil. Did you override " + 
+                            std::string(detail::protect(rb_obj_classname, value)) + 
+                            "#initialize and forget to call super?";
 
+      throw std::runtime_error(message);
+    }
+
+    return static_cast<T*>(wrapper->get());
+  }
+    
   inline Wrapper* getWrapper(VALUE value, rb_data_type_t* rb_type)
   {
     Wrapper* wrapper = nullptr;
@@ -138,14 +174,28 @@ namespace Rice::detail
   {
     WrapperPointer<T>* wrapper = nullptr;
     TypedData_Get_Struct(value, WrapperPointer<T>, rb_type, wrapper);
-    delete wrapper;
+    if (wrapper)
+    {
+      Registries::instance.instances.remove(wrapper->get());
+      delete wrapper;
+    }
 
-    wrapper = new WrapperPointer<T>(data, true);
+    wrapper = new WrapperPointer<T>(data, isOwner);
     RTYPEDDATA_DATA(value) = wrapper;
+
+    Registries::instance.instances.add(data, value);
   }
 
   inline Wrapper* getWrapper(VALUE value)
   {
-    return static_cast<Wrapper*>(RTYPEDDATA_DATA(value));
+    // Turn off spurious warning on g++ 12
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Warray-bounds"
+#endif
+    return RTYPEDDATA_P(value) ? static_cast<Wrapper*>(RTYPEDDATA_DATA(value)) : nullptr;
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
   }
 } // namespace

data/rice/detail/cpp_protect.hpp

@@ -0,0 +1,93 @@
+#ifndef Rice__detail__cpp_protect__hpp_
+#define Rice__detail__cpp_protect__hpp_
+
+#include <regex>
+#include <filesystem>
+#include <stdexcept>
+
+#include "Jump_Tag.hpp"
+#include "../Exception_defn.hpp"
+
+namespace Rice::detail
+{
+  template <typename Callable_T>
+  auto cpp_protect(Callable_T&& func)
+  {
+    try
+    {
+      return func();
+    }
+    catch (...)
+    {
+      try
+      {
+        detail::Registries::instance.handlers.handler()->handle();
+      }
+      catch (::Rice::Exception const& ex)
+      {
+        rb_exc_raise(ex.value());
+      }
+      catch (::Rice::Jump_Tag const& ex)
+      {
+        rb_jump_tag(ex.tag);
+      }
+      catch (std::bad_alloc const& ex)
+      {
+        /* This won't work quite right if the rb_exc_new2 fails; not
+           much we can do about that, since Ruby doesn't give us access
+           to a pre-allocated NoMemoryError object */
+        rb_exc_raise(rb_exc_new2(rb_eNoMemError, ex.what()));
+      }
+      catch (std::domain_error const& ex)
+      {
+        rb_exc_raise(rb_exc_new2(rb_eFloatDomainError, ex.what()));
+      }
+      catch (std::invalid_argument const& ex)
+      {
+        rb_exc_raise(rb_exc_new2(rb_eArgError, ex.what()));
+      }
+      catch (std::filesystem::filesystem_error const& ex)
+      {
+        rb_exc_raise(rb_exc_new2(rb_eIOError, ex.what()));
+      }
+      catch (std::length_error const& ex)
+      {
+        rb_exc_raise(rb_exc_new2(rb_eRuntimeError, ex.what()));
+      }
+      catch (std::out_of_range const& ex)
+      {
+        rb_exc_raise(rb_exc_new2(rb_eRangeError, ex.what()));
+      }
+      catch (std::overflow_error const& ex)
+      {
+        rb_exc_raise(rb_exc_new2(rb_eRangeError, ex.what()));
+      }
+      catch (std::range_error const& ex)
+      {
+        rb_exc_raise(rb_exc_new2(rb_eRangeError, ex.what()));
+      }
+      catch (std::regex_error const& ex)
+      {
+        rb_exc_raise(rb_exc_new2(rb_eRegexpError, ex.what()));
+      }
+      catch (std::system_error const& ex)
+      {
+        rb_exc_raise(rb_exc_new2(rb_eSystemCallError, ex.what()));
+      }
+      catch (std::underflow_error const& ex)
+      {
+        rb_exc_raise(rb_exc_new2(rb_eRangeError, ex.what()));
+      }
+      catch (std::exception const& ex)
+      {
+        rb_exc_raise(rb_exc_new2(rb_eRuntimeError, ex.what()));
+      }
+      catch (...)
+      {
+        rb_exc_raise(rb_exc_new2(rb_eRuntimeError, "Unknown C++ exception thrown"));
+      }
+      throw std::runtime_error("Should never get here - just making compilers happy");
+    }
+  }
+}
+#endif // Rice__detail__cpp_protect__hpp_

data/rice/detail/default_allocation_func.ipp

@@ -7,6 +7,6 @@ namespace Rice::detail
   {
     // Create a new Ruby object but since we do not yet have a C++ object
     // just pass a nullptr. It will be set via the Constructor call
-    return TypedData_Wrap_Struct(klass, Data_Type<T>::rb_type(), nullptr);
+    return TypedData_Wrap_Struct(klass, Data_Type<T>::ruby_data_type(), nullptr);
   }
 }