Merge pull request #381 from ruby-rice/dev

Run tests with stress GC on and see what happens.

Author: cfis

Rice.cmake

@@ -4,8 +4,8 @@ if(NOT TARGET Rice)
   add_library(Rice INTERFACE)
 
   target_include_directories(Rice INTERFACE
-    $<BUILD_INTERFACE:$<$<CONFIG:Debug>:${CMAKE_CURRENT_SOURCE_DIR}>>
-    $<BUILD_INTERFACE:$<$<CONFIG:Release>:${CMAKE_CURRENT_SOURCE_DIR}/include>>
+    $<BUILD_INTERFACE:$<$<CONFIG:Debug>:${CMAKE_CURRENT_LIST_DIR}>>
+    $<BUILD_INTERFACE:$<$<CONFIG:Release>:${CMAKE_CURRENT_LIST_DIR}/include>>
     $<INSTALL_INTERFACE:include>
   )
 

rice/Pin.hpp

@@ -18,21 +18,19 @@ namespace Rice
   class Pin
   {
   public:
-    //! Construct a strong pin for a Ruby VALUE.
-    explicit Pin(VALUE value);
+    //! Construct a pin from a Ruby VALUE.
+    Pin(VALUE value);
 
-    // Shared-anchor semantics.
+    // Copying
     Pin(const Pin&) = default;
     Pin& operator=(const Pin&) = default;
 
+    // Moving
     Pin(Pin&&) noexcept = default;
     Pin& operator=(Pin&&) noexcept = default;
 
-    //! Replace the pinned Ruby VALUE.
-    void set(VALUE value);
-
     //! Retrieve the pinned Ruby VALUE.
-    VALUE get() const;
+    VALUE value() const;
 
   private:
     //! Shared ownership of the internal GC anchor.

rice/Pin.ipp

@@ -5,12 +5,7 @@ namespace Rice
   {
   }
 
-  inline void Pin::set(VALUE value)
-  {
-    this->anchor_->set(value);
-  }
-
-  inline VALUE Pin::get() const
+  inline VALUE Pin::value() const
   {
     return this->anchor_->get();
   }

rice/cpp_api/Module.hpp

@@ -24,7 +24,7 @@ namespace Rice
     //! Construct a Module from an existing Module object.
     Module(VALUE v);
 
-    //! Construct a Module from an string that references a Module
+    //! Construct a Module from a string that references a Module
     Module(std::string name, Object under = rb_cObject);
 
     //! Return the name of the module.

rice/cpp_api/Module.ipp

@@ -16,7 +16,7 @@ namespace Rice
     }
   }
 
-  //! Construct a Module from an string that references a Module
+  //! Construct a Module from a string that references a Module
   inline Module::Module(std::string name, Object under)
   {
     VALUE result = under.const_get(name);

rice/cpp_api/Object.hpp

@@ -39,20 +39,20 @@ namespace Rice
     // Having this conversion also prevents accidental conversion to
     // undesired integral types (e.g. long or int) by making the
     // conversion ambiguous.
-    bool test() const { return RTEST(value_); }
+    bool test() const;
 
     //! Returns false if the object is nil or false; returns true
     //! otherwise.
-    operator bool() const { return test(); }
+    operator bool() const;
 
     //! Returns true if the object is nil, false otherwise.
-    bool is_nil() const { return NIL_P(value_); }
+    bool is_nil() const;
 
     //! Implicit conversion to VALUE.
-    operator VALUE() const { return value_; }
+    operator VALUE() const;
 
     //! Explicitly get the encapsulated VALUE.
-    VALUE value() const { return value_; }
+    VALUE value() const;
 
     //! Get the class of an object.
     /*! \return the object's Class.
@@ -254,7 +254,7 @@ namespace Rice
 
   protected:
     //! Set the encapsulated value.
-    void set_value(VALUE v);
+    void set_value(VALUE value);
 
   private:
     volatile VALUE value_;

rice/cpp_api/Object.ipp

@@ -27,6 +27,31 @@ namespace Rice
     return *this;
   }
 
+  inline bool Object::test() const
+  {
+    return RTEST(this->value());
+  }
+
+  inline Object::operator bool() const
+  {
+    return this->test();
+  }
+
+  inline bool Object::is_nil() const
+  {
+    return NIL_P(this->value());
+  }
+
+  inline Object::operator VALUE() const
+  {
+    return this->value();
+  }
+
+  inline VALUE Object::value() const
+  {
+    return this->value_;
+  }
+
   template<typename ...Parameter_Ts>
   inline Object Object::call(Identifier id, Parameter_Ts... args) const
   {
@@ -63,13 +88,13 @@ namespace Rice
 
   inline bool Object::is_equal(const Object& other) const
   {
-    VALUE result = detail::protect(rb_equal, this->value_, other.value_);
+    VALUE result = detail::protect(rb_equal, this->value(), other.value());
     return RB_TEST(result);
   }
 
   inline bool Object::is_eql(const Object& other) const
   {
-    VALUE result = detail::protect(rb_eql, this->value_, other.value_);
+    VALUE result = detail::protect(rb_eql, this->value(), other.value());
     return RB_TEST(result);
   }
 
@@ -125,9 +150,9 @@ namespace Rice
     return detail::protect(rb_attr_get, this->value(), name.id());
   }
 
-  inline void Object::set_value(VALUE v)
+  inline void Object::set_value(VALUE value)
   {
-    value_ = v;
+    value_ = value;
   }
 
   inline Object Object::const_get(Identifier name) const

rice/detail/Anchor.hpp

@@ -51,7 +51,7 @@ namespace Rice
 
     private:
       //! GC-visible Ruby VALUE slot.
-      VALUE value_;
+      VALUE value_ = Qnil;
     };
   }
 }

rice/detail/Anchor.ipp

@@ -4,16 +4,21 @@ namespace Rice
   {
     inline Anchor::Anchor(VALUE value) : value_(value)
     {
-      Anchor::registerExitHandler();
-      detail::protect(rb_gc_register_address, &this->value_);
+      if (value != Qnil)
+      {
+        Anchor::registerExitHandler();
+        detail::protect(rb_gc_register_address, &this->value_);
+      }
     }
 
     inline Anchor::~Anchor()
     {
-      if (Anchor::enabled_)
+      if (Anchor::enabled_ && this->value_ != Qnil)
       {
         detail::protect(rb_gc_unregister_address, &this->value_);
       }
+      // Ruby auto detects VALUEs in the stack, so make sure up in case this object is on the stack
+      this->value_ = Qnil;
     }
 
     inline VALUE Anchor::get() const

rice/detail/NativeCallback.ipp

@@ -221,7 +221,7 @@ namespace Rice::detail
                convertToRuby(args)... };
 
     static Identifier id("call");
-    VALUE result = detail::protect(rb_funcallv, this->proc_.get(), id.id(), (int)sizeof...(Parameter_Ts), values.data());
+    VALUE result = detail::protect(rb_funcallv, this->proc_.value(), id.id(), (int)sizeof...(Parameter_Ts), values.data());
     if constexpr (!std::is_void_v<Return_T>)
     {
       return this->fromRuby_.convert(result);