rice 4.3.3 → 4.5.0

data/lib/mkmf-rice.rb

@@ -1,93 +1,8 @@
 require 'mkmf'
 
-IS_MSWIN = !RbConfig::CONFIG['host_os'].match(/mswin/).nil?
-IS_MINGW = !RbConfig::CONFIG['host_os'].match(/mingw/).nil?
-IS_DARWIN = !RbConfig::CONFIG['host_os'].match(/darwin/).nil?
-
-# If we are on versions of Ruby before 2.7 then we need to copy in the experimental C++ support
-# added in Ruby 2.7
-unless MakeMakefile.methods.include?(:[])
-
-  # Ruby 2.6 makes this declaration which is not valid with C++17
-  # void rb_mem_clear(register VALUE*, register long);
-  if !IS_MSWIN
-    $CXXFLAGS += " " << "-Wno-register"
-  end
-
-  MakeMakefile::CONFTEST_C = "#{CONFTEST}.cc"
-
-  MakeMakefile.module_eval do
-    CONFTEST_C = "#{CONFTEST}.cc"
-    def cc_config(opt="")
-      conf = RbConfig::CONFIG.merge('hdrdir' => $hdrdir.quote, 'srcdir' => $srcdir.quote,
-                                    'arch_hdrdir' => $arch_hdrdir.quote,
-                                    'top_srcdir' => $top_srcdir.quote)
-      conf
-    end
-
-    def link_config(ldflags, opt="", libpath=$DEFLIBPATH|$LIBPATH)
-      librubyarg = $extmk ? $LIBRUBYARG_STATIC : "$(LIBRUBYARG)"
-      conf = RbConfig::CONFIG.merge('hdrdir' => $hdrdir.quote,
-                                    'src' => "#{conftest_source}",
-                                    'arch_hdrdir' => $arch_hdrdir.quote,
-                                    'top_srcdir' => $top_srcdir.quote,
-                                    'INCFLAGS' => "#$INCFLAGS",
-                                    'CPPFLAGS' => "#$CPPFLAGS",
-                                    'CFLAGS' => "#$CFLAGS",
-                                    'ARCH_FLAG' => "#$ARCH_FLAG",
-                                    'LDFLAGS' => "#$LDFLAGS #{ldflags}",
-                                    'LOCAL_LIBS' => "#$LOCAL_LIBS #$libs",
-                                    'LIBS' => "#{librubyarg} #{opt} #$LIBS")
-      conf['LIBPATH'] = libpathflag(libpath.map {|s| RbConfig::expand(s.dup, conf)})
-      conf
-    end
-
-    @lang = Hash.new(self)
-
-    def self.[](name)
-      @lang.fetch(name)
-    end
-
-    def self.[]=(name, mod)
-      @lang[name] = mod
-    end
-
-    MakeMakefile["C++"] = Module.new do
-      include MakeMakefile
-      extend self
-
-      CONFTEST_CXX = "#{CONFTEST}.#{config_string('CXX_EXT') || CXX_EXT[0]}"
-
-      TRY_LINK_CXX = config_string('TRY_LINK_CXX') ||
-        ((cmd = TRY_LINK.gsub(/\$\(C(?:C|(FLAGS))\)/, '$(CXX\1)')) != TRY_LINK && cmd) ||
-        "$(CXX) #{OUTFLAG}#{CONFTEST}#{$EXEEXT} $(INCFLAGS) $(CPPFLAGS) " \
-                     "$(CXXFLAGS) $(src) $(LIBPATH) $(LDFLAGS) $(ARCH_FLAG) $(LOCAL_LIBS) $(LIBS)"
-
-      def have_devel?
-        unless defined? @have_devel
-          @have_devel = true
-          @have_devel = try_link(MAIN_DOES_NOTHING)
-        end
-        @have_devel
-      end
-
-      def conftest_source
-        CONFTEST_CXX
-      end
-
-      def cc_command(opt="")
-        conf = cc_config(opt)
-        RbConfig::expand("$(CXX) #$INCFLAGS #$CPPFLAGS #$CXXFLAGS #$ARCH_FLAG #{opt} -c #{CONFTEST_CXX}",
-                         conf)
-      end
-
-      def link_command(ldflags, *opts)
-        conf = link_config(ldflags, *opts)
-        RbConfig::expand(TRY_LINK_CXX.dup, conf)
-      end
-    end
-  end
-end
+IS_MSWIN = /mswin/ =~ RUBY_PLATFORM
+IS_MINGW = /mingw/ =~ RUBY_PLATFORM
+IS_DARWIN = RbConfig::CONFIG['host_os'].match?(/darwin/)
 
 # The cpp_command is not overwritten in the experimental mkmf C++ support.
 # See https://bugs.ruby-lang.org/issues/17578
@@ -107,7 +22,7 @@ include MakeMakefile['C++']
 
 # Rice needs c++17.
 if IS_MSWIN
-  $CXXFLAGS += " /std:c++17 /EHsc /permissive- /bigobj"
+  $CXXFLAGS += " /std:c++17 /EHs /permissive- /bigobj /utf-8"
   $CPPFLAGS += " -D_ALLOW_KEYWORD_MACROS -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE"
 elsif IS_MINGW
   $CXXFLAGS += " -std=c++17 -Wa,-mbig-obj"
@@ -123,10 +38,37 @@ unless find_header('rice/rice.hpp', path)
   raise("Could not find rice/rice.hpp header")
 end
 
-if IS_DARWIN
-  have_library('c++')
-elsif !IS_MSWIN
-  if !have_library('stdc++fs')
-    have_library('stdc++')
+if !IS_DARWIN && !IS_MSWIN && !have_library('stdc++fs')
+  have_library('stdc++')
+end
+
+# Copied from Ruby FFI bindings - see
+# https://github.com/ffi/ffi/blob/1715332d553d53fae13fd9fcbbd9d2c1982a5c2f/ext/ffi_c/extconf.rb#L7C1-L27C6
+def system_libffi_usable?
+  # We need pkg_config or ffi.h
+  libffi_ok = pkg_config("libffi") ||
+      have_header("ffi.h") ||
+      find_header("ffi.h", "/usr/local/include", "/usr/include/ffi",
+                  "/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/include/ffi",
+                  "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/include/ffi") ||
+      (find_header("ffi.h", `xcrun --sdk macosx --show-sdk-path`.strip + "/usr/include/ffi") rescue false)
+
+  # Ensure we can link to ffi_prep_closure_loc
+  libffi_ok &&= have_library("ffi", "ffi_prep_closure_loc", [ "ffi.h" ]) ||
+                have_library("libffi", "ffi_prep_closure_loc", [ "ffi.h" ]) ||
+                have_library("libffi-8", "ffi_prep_closure_loc", [ "ffi.h" ])
+
+  if RbConfig::CONFIG['host_os'] =~ /mswin/
+    have_library('libffi_convenience')
+    have_library('shlwapi')
   end
-end
+
+  libffi_ok
+end
+
+def have_libffi
+  # Check for libffi to support C style callacks.
+  libffi_usable = system_libffi_usable?
+  $CPPFLAGS += " -DHAVE_LIBFFI" if libffi_usable
+  libffi_usable
+end

data/rice/Address_Registration_Guard.hpp

@@ -1,7 +1,76 @@
 #ifndef Rice__Address_Registration_Guard__hpp_
 #define Rice__Address_Registration_Guard__hpp_
 
-#include "Address_Registration_Guard_defn.hpp"
-#include "Address_Registration_Guard.ipp"
+namespace Rice
+{
+  //! A guard to register a given address with the GC.
+  /*! Calls rb_gc_register_address upon construction and
+   *  rb_gc_unregister_address upon destruction.
+   *  For example:
+   *  \code
+   *    Class Foo
+   *    {
+   *    public:
+   *      Foo()
+   *        : string_(rb_str_new2())
+   *        , guard_(&string_);
+   *
+   *    private:
+   *      VALUE string_;
+   *      Address_Registration_Guard guard_;
+   *    };
+   *  \endcode
+   */
+  class Address_Registration_Guard
+  {
+  public:
+    //! Register an address with the GC.
+    /*  \param address The address to register with the GC.  The address
+     *  must point to a valid ruby object (RObject).
+     */
+    Address_Registration_Guard(VALUE* address);
 
-#endif // Rice__Address_Registration_Guard__hpp_
+    //! Register an Object with the GC.
+    /*! \param object The Object to register with the GC.  The object must
+     *  not be destroyed before the Address_Registration_Guard is
+     *  destroyed.
+     */
+    Address_Registration_Guard(Object* object);
+
+    //! Unregister an address/Object with the GC.
+    /*! Destruct an Address_Registration_Guard.  The address registered
+     *  with the Address_Registration_Guard when it was constructed will
+     *  be unregistered from the GC.
+     */
+    ~Address_Registration_Guard();
+
+    // Disable copying
+    Address_Registration_Guard(Address_Registration_Guard const& other) = delete;
+    Address_Registration_Guard& operator=(Address_Registration_Guard const& other) = delete;
+
+    // Enable moving
+    Address_Registration_Guard(Address_Registration_Guard&& other);
+    Address_Registration_Guard& operator=(Address_Registration_Guard&& other);
+
+    //! Get the address that is registered with the GC.
+    VALUE* address() const;
+
+    /** Called during Ruby's exit process since we should not call
+     * rb_gc unregister_address there
+     */
+    static void disable();
+
+  private:
+    inline static bool enabled = true;
+    inline static bool exit_handler_registered = false;
+    static void registerExitHandler();
+
+  private:
+    void registerAddress() const;
+    void unregisterAddress();
+
+    VALUE* address_ = nullptr;
+  };
+} // namespace Rice
+
+#endif // Rice__Address_Registration_Guard__hpp_

data/rice/Arg.hpp

@@ -35,6 +35,9 @@ namespace Rice
      */
     Arg(std::string name);
 
+    // Make Arg polymorphic so dynamic_cast works
+    virtual ~Arg() = default;
+
     //! Set the default value for this Arg
     /*! Set the default value for this argument.
      *  If this isn't called on this Arg, then this
@@ -56,19 +59,30 @@ namespace Rice
 
     //! Tell the receiving object to keep this argument alive
     //! until the receiving object is freed.
-    Arg& keepAlive();
+    virtual Arg& keepAlive();
     
     //! Returns if the argument should be kept alive
     bool isKeepAlive() const;
 
     //! Specifies if the argument should be treated as a value
-    Arg& setValue();
+    virtual Arg& setValue();
 
     //! Returns if the argument should be treated as a value
     bool isValue() const;
 
+    //! Specifies if the argument is opaque and Rice should not convert it from Ruby to C++ or vice versa.
+    //! This is useful for callbacks and user provided data paramameters.
+    virtual Arg& setOpaque();
+
+    //! Returns if the argument should be treated as a value
+    bool isOpaque() const;
+
+    //! Specifies C++ will take ownership of this value and Ruby should not free it
+    virtual Arg& takeOwnership();
+    bool isOwner();
+
   public:
-    const std::string name;
+    std::string name;
     int32_t position = -1;
 
   private:
@@ -76,9 +90,9 @@ namespace Rice
     std::any defaultValue_;
     bool isValue_ = false;
     bool isKeepAlive_ = false;
+    bool isOwner_ = false;
+    bool isOpaque_ = false;
   };
 } // Rice
 
-#include "Arg.ipp"
-
 #endif // Rice__Arg__hpp_

data/rice/Arg.ipp

@@ -47,4 +47,28 @@ namespace Rice
   {
     return isValue_;
   }
+
+  inline Arg& Arg::setOpaque()
+  {
+    isOpaque_ = true;
+    return *this;
+  }
+
+  inline bool Arg::isOpaque() const
+  {
+    return isOpaque_;
+  }
+
+  inline Arg& Arg::takeOwnership()
+  {
+    this->isOwner_ = true;
+    return *this;
+  }
+
+  inline bool Arg::isOwner()
+  {
+    return this->isOwner_;
+  }
+
+
 } // Rice

data/rice/Callback.hpp

@@ -0,0 +1,21 @@
+#ifndef Rice__Callback__hpp_
+#define Rice__Callback__hpp_
+
+namespace Rice
+{
+  //! Define a callback.
+  /*! When C++ invokes a C style callback, Rice automatically converts the C++ arguments
+   *  to Ruby. However, there may be cases where you need to specify how individual arguments
+   *  should be handled. For example, callbacks often have a user data parameter which is 
+   *  defined as a void pointer (void*). In this case, you need to tell Ruby that the parameter
+   *  is opaque and should not be convered. For example:
+   * 
+   *  define_callback<void(*)(void*)>(Arg("user_data").setOpaque());
+   *
+   *  \param args a list of Arg instance used to define default parameters (optional)
+   *  \return nothing
+   */
+  template<typename Callback_T, typename...Arg_Ts>
+  void define_callback(const Arg_Ts&...args);
+}
+#endif // Rice__Callback__hpp_

data/rice/Callback.ipp

@@ -0,0 +1,13 @@
+namespace Rice
+{
+  template<typename Callback_T, typename...Arg_Ts>
+  void define_callback(const Arg_Ts&...args)
+  {
+    MethodInfo* methodInfo = new MethodInfo(detail::function_traits<Callback_T>::arity, args...);
+  #ifdef HAVE_LIBFFI
+    detail::NativeCallbackFFI<Callback_T>::setMethodInfo(methodInfo);
+  #else
+    detail::NativeCallbackSimple<Callback_T>::setMethodInfo(methodInfo);
+  #endif
+  }
+}

data/rice/Constructor.hpp

@@ -1,9 +1,6 @@
 #ifndef Rice__Constructor__hpp_
 #define Rice__Constructor__hpp_
 
-#include "detail/Wrapper.hpp"
-#include "cpp_api/Object_defn.hpp"
-
 namespace Rice
 {
   //! Define a Type's Constructor and it's arguments.
@@ -13,33 +10,13 @@ namespace Rice
           .define_constructor(Constructor<Test>());
       \endcode
   *
-  *  The first template type must be the type being wrapped.
-  *  Afterwards any extra types must match the appropriate constructor
-  *  to be used in C++ when constructing the object.
+  *  The first template argument must be the type being wrapped.
+  *  Additional arguments must be the types of the parameters sent
+  *  to the constructor.
   *
   *  For more information, see Rice::Data_Type::define_constructor.
   */
   template<typename T, typename...Arg_Ts>
-  class Constructor
-  {
-  public:
-    static void construct(VALUE self, Arg_Ts...args)
-    {
-      T* data = new T(args...);
-      detail::replace<T>(self, Data_Type<T>::ruby_data_type(), data, true);
-    }
-  };
-
-  //! Special-case Constructor used when defining Directors.
-  template<typename T, typename...Arg_Ts>
-  class Constructor<T, Object, Arg_Ts...>
-  {
-    public:
-      static void construct(Object self, Arg_Ts...args)
-      {
-        T* data = new T(self, args...);
-        detail::replace<T>(self.value(), Data_Type<T>::ruby_data_type(), data, true);
-      }
-  };
+  class Constructor;
 }
 #endif // Rice__Constructor__hpp_

data/rice/Constructor.ipp

@@ -0,0 +1,79 @@
+namespace Rice
+{
+  template<typename T, typename...Arg_Ts>
+  class Constructor
+  {
+  public:
+    static constexpr std::size_t arity = sizeof...(Arg_Ts);
+
+    static constexpr bool isCopyConstructor()
+    {
+      if constexpr (arity == 1)
+      {
+        using Arg_Types = std::tuple<Arg_Ts...>;
+        using First_Arg_T = std::tuple_element_t<0, Arg_Types>;
+        return (arity == 1 &&
+                std::is_lvalue_reference_v<First_Arg_T> &&
+                std::is_same_v<T, detail::intrinsic_type<First_Arg_T>>);
+      }
+      else
+      {
+        return false;
+      }
+    }
+
+    static constexpr bool isMoveConstructor()
+    {
+      if constexpr (arity == 1)
+      {
+        using Arg_Types = std::tuple<Arg_Ts...>;
+        using First_Arg_T = std::tuple_element_t<0, Arg_Types>;
+        return (arity == 1 &&
+          std::is_rvalue_reference_v<First_Arg_T> &&
+          std::is_same_v<T, detail::intrinsic_type<First_Arg_T>>);
+      }
+      else
+      {
+        return false;
+      }
+    }
+
+    static void initialize(VALUE self, Arg_Ts...args)
+    {
+      // Call C++ constructor
+      T* data = new T(args...);
+      detail::replace<T>(self, Data_Type<T>::ruby_data_type(), data, true);
+    }
+
+    static void initialize_copy(VALUE self, const T& other)
+    {
+      // Call C++ copy constructor
+      T* data = new T(other);
+      detail::replace<T>(self, Data_Type<T>::ruby_data_type(), data, true);
+    }
+
+  };
+
+  //! Special-case Constructor used when defining Directors.
+  template<typename T, typename...Arg_Ts>
+  class Constructor<T, Object, Arg_Ts...>
+  {
+    public:
+      static constexpr bool isCopyConstructor()
+      {
+        return false;
+      }
+
+      static constexpr bool isMoveConstructor()
+      {
+        return false;
+      }
+
+      static void initialize(Object self, Arg_Ts...args)
+      {
+        // Call C++ constructor
+        T* data = new T(self, args...);
+        detail::replace<T>(self.value(), Data_Type<T>::ruby_data_type(), data, true);
+      }
+  };
+}

data/rice/Data_Object.hpp

@@ -1,8 +1,79 @@
 #ifndef Rice__Data_Object__hpp_
 #define Rice__Data_Object__hpp_
 
-#include "Data_Object_defn.hpp"
-#include "Data_Object.ipp"
+/*! \file
+ *  \brief Provides a helper class for wrapping and unwrapping C++
+ *  objects as Ruby objects.
+ */
 
-#endif // Rice__Data_Object__hpp_
+namespace Rice
+{
+  //! A smartpointer-like wrapper for Ruby data objects.
+  /*! A data object is a ruby object of type T_DATA, which is usually
+   *  created by using the Data_Wrap_Struct or Data_Make_Struct macro.
+   *  This class wraps creation of the data structure, providing a
+   *  type-safe object-oriented interface to the underlying C interface.
+   *  This class works in conjunction with the Data_Type class to ensure
+   *  type safety.
+   *
+   *  Example:
+   *  \code
+   *    class Foo { };
+   *    ...
+   *    Data_Type<Foo> rb_cFoo = define_class("Foo");
+   *    ...
+   *    // Wrap:
+   *    Data_Object<Foo> foo1(new Foo);
+   *
+   *    // Get value to return:
+   *    VALUE v = foo1.value()
+   *
+   *    // Unwrap:
+   *    Data_Object<Foo> foo2(v, rb_cFoo);
+   *  \endcode
+   */
+  template<typename T>
+  class Data_Object : public Object
+  {
+    static_assert(!std::is_pointer_v<T>);
+    static_assert(!std::is_reference_v<T>);
+    static_assert(!std::is_const_v<T>);
+    static_assert(!std::is_volatile_v<T>);
+    static_assert(!std::is_void_v<T>);
+
+  public:
+    static T* from_ruby(VALUE value, bool takeOwnership = false);
+
+  public:
+    //! Wrap a C++ object.
+    /*! This constructor is analogous to calling Data_Wrap_Struct.  Be
+     *  careful not to call this function more than once for the same
+     *  pointer (in general, it should only be called for newly
+     *  constructed objects that need to be managed by Ruby's garbage
+     *  collector).
+     *  \param obj the object to wrap.
+     *  \param isOwner Should the Data_Object take ownership of the object?
+     *  \param klass the Ruby class to use for the newly created Ruby
+     *  object.
+     */
+    Data_Object(T* obj, bool isOwner = false, Class klass = Data_Type<T>::klass());
+    Data_Object(T& obj, bool isOwner = false, Class klass = Data_Type<T>::klass());
+    Data_Object(const T& obj, bool isOwner = false, Class klass = Data_Type<T>::klass());
+
+    //! Unwrap a Ruby object.
+    /*! This constructor is analogous to calling Data_Get_Struct.  Uses
+     *  Data_Type<T>::klass as the class of the object.
+     *  \param value the Ruby object to unwrap.
+     */
+    Data_Object(Object value);
 
+    T& operator*() const; //!< Return a reference to obj_
+    T* operator->() const; //!< Return a pointer to obj_
+    T* get() const;        //!< Return a pointer to obj_
+
+  private:
+    static void check_ruby_type(VALUE value);
+  };
+} // namespace Rice
+
+#endif // Rice__Data_Object__hpp_