rice 4.3.3 → 4.6.0

data/lib/make_rice_headers.rb

@@ -0,0 +1,79 @@
+require 'stringio'
+
+LINE_ENDING = "\n"
+RICE_INCLUDE_REGEX = %r{#include "(.*)"}
+OTHER_INCLUDE_REGEX = %r{#include <(.*)>}
+
+RICE_HEADER_GUARD_1 = %r{#ifndef Rice__}
+RICE_HEADER_GUARD_2 = %r{#define Rice__}
+RICE_HEADER_GUARD_3 = %r{#endif\s*//\s*Rice__}
+SHARED_METHODS_REGEX = %r{#include "((?:cpp_api\/)?shared_methods.hpp)"}
+
+def load_file(relative_path)
+  content = File.read(relative_path, mode: 'rb')
+
+  # Special case shared_methods.hpp which if requested we want to
+  # merge into the current file
+  match = content.match(SHARED_METHODS_REGEX)
+  if match
+    shared_path = File.join(File.dirname(relative_path), match[1])
+    content.gsub!(SHARED_METHODS_REGEX, File.read(shared_path, mode: 'rb'))
+  end
+
+  content
+end
+
+def strip_includes(content)
+  content.lines.find_all do |line|
+    !line.match(RICE_INCLUDE_REGEX)
+  end.join
+end
+
+def add_include(path, stream)
+  basename = File.basename(path)
+  basename_no_ext = File.basename(path, ".*")
+
+  stream << "\n" << "// =========   #{File.basename(path)}   =========" << "\n"
+
+  load_file(path).each_line do |line|
+    if match = line.match(RICE_INCLUDE_REGEX)
+      # Check for related includes, ie., Object.hpp, Object_defn.hpp and Object.ipp
+      sub_include = File.basename(match[1])
+      if ["#{basename_no_ext}_defn.hpp", "#{basename_no_ext}.ipp"].include?(sub_include)
+        sub_include_path = File.join(File.dirname(path), match[1])
+        stream << "\n" << "// ---------   #{File.basename(sub_include_path)}   ---------" << "\n"
+        stream << strip_includes(load_file(sub_include_path))
+      end
+    elsif line.match(RICE_HEADER_GUARD_1) || line.match(RICE_HEADER_GUARD_2) || line.match(RICE_HEADER_GUARD_3)
+      # Skip the header guard
+    else
+      # Include the line in the output
+      stream << line
+    end
+  end
+end
+
+def combine_headers(filename)
+  stream = StringIO.new
+
+  load_file("rice/#{filename}").each_line do |line|
+    if matches = line.match(RICE_INCLUDE_REGEX)
+      path = File.join("rice", matches[1])
+      add_include(path, stream)
+    else
+      stream << line
+    end
+  end
+
+  File.open("include/rice/#{filename}", 'wb') do |file|
+    file << stream.string
+  end
+end
+
+puts "Building rice.hpp"
+combine_headers('rice.hpp')
+
+puts "Building stl.hpp"
+combine_headers('stl.hpp')
+
+puts "Success"

data/lib/mkmf-rice.rb

@@ -1,93 +1,12 @@
 require 'mkmf'
+require 'rice/version'
 
-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?
+major, minor, patch = Rice::VERSION.split(".")
+$CXXFLAGS += " -DRICE_VERSION_MAJOR=#{major} -DRICE_VERSION_MINOR=#{minor} -DRICE_VERSION_PATCH=#{patch}"
 
-# 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 +26,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 +42,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/lib/rice/version.rb

@@ -0,0 +1,3 @@
+module Rice
+  VERSION = "4.6.0"
+end

data/lib/rice.rb

@@ -0,0 +1 @@
+require_relative "rice/version"

data/lib/rubygems/builder.rb

@@ -0,0 +1,11 @@
+class Gem::Ext::Builder
+	alias :builder_for_original :builder_for
+	def builder_for(extension)
+		case extension
+			when /CMakeLists.txt/ then
+				Gem::Ext::CmakeBuilder.new
+			else
+				builder_for_original(extension)
+		end
+	end
+end

data/lib/rubygems/cmake_builder.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+# This builder creates extensions defined using CMake. Its is invoked if a Gem's spec file
+# sets the `extension` property to a string that contains `CMakeLists.txt`.
+#
+# In general, CMake projects are built in two steps:
+#
+#  * configure
+#  * build
+#
+# The builder follow this convention. First it runs a configuration step and then it runs a build step.
+#
+# CMake projects can be quite configurable - it is likely you will want to specify options when
+# installing a gem. To pass options to CMake specify them after `--` in the gem install command. For example:
+#
+#   gem install <gem_name> -- --preset <preset_name>
+#
+# Note that options are ONLY sent to the configure step - it is not currently possible to specify
+# options for the build step. If this becomes and issue then the CMake builder can be updated to
+# support build options.
+#
+# Useful options to know are:
+#
+#  -G to specify a generator (-G Ninja is recommended)
+#  -D<CMAKE_VARIABLE> to set a CMake variable (for example -DCMAKE_BUILD_TYPE=Release)
+#  --preset <preset_name> to use a preset
+#
+# If the Gem author provides presets, via CMakePresets.json file, you will likely want to us use one of them.
+# If not, then you may wish to specify a generator (Ninja is recommended since it can build projects in parallel
+# versus a Make generator which build ins serial and thus is *much* slower).
+
+require "fileutils"
+
+class Gem::Ext::CmakeBuilder
+  attr_accessor :runner, :profile
+
+  def initialize
+    @runner = self.class.method(:run)
+    @profile = :release
+  end
+
+  def build(extension, gem_dir, results, args = [], lib_dir = nil, cmake_dir = Dir.pwd, target_rbconfig = Gem.target_rbconfig)
+    if target_rbconfig.path
+      warn "--target-rbconfig is not yet supported for CMake extensions. Ignoring"
+    end
+
+    # Make sure lib dir is set
+    lib_dir ||= File.join(gem_dir, "lib")
+
+    # Figure the build dir
+    build_dir = File.join(cmake_dir, "build")
+
+    # Check if the gem defined presets
+    check_presets(cmake_dir, args)
+
+    # Configure
+    configure(cmake_dir, build_dir, lib_dir, args, results)
+
+    # Compile
+    compile(cmake_dir, build_dir, args, results)
+
+    results
+  end
+
+  def configure(cmake_dir, build_dir, lib_dir, args, results)
+    cmd = ["cmake",
+           cmake_dir,
+           "-B #{build_dir}",
+           "-DCMAKE_RUNTIME_OUTPUT_DIRECTORY=#{lib_dir}", # Windows
+           "-DCMAKE_LIBRARY_OUTPUT_DIRECTORY=#{lib_dir}", # Not Windows
+           *Gem::Command.build_args,
+           *args]
+
+    runner.call(cmd, results, "cmake", cmake_dir)
+  end
+
+  def compile(cmake_dir, build_dir, args, results)
+    cmd = ["cmake",
+           "--build",
+           build_dir.to_s,
+           "--config",
+           @profile.to_s]
+    runner.call(cmd, results, "cmake", cmake_dir)
+  end
+
+  private
+
+  def check_presets(cmake_dir, args)
+    # Return if the user specified a preset
+    return unless args.grep(/--preset/i).empty?
+
+    cmd = ["cmake",
+           "--list-presets"]
+
+    begin
+      require "open3"
+      build_env = { "SOURCE_DATE_EPOCH" => Gem.source_date_epoch_string }
+      stdout, _, _ = Open3.capture3(build_env, *cmd, chdir: cmake_dir)
+      message = <<~EOS
+        The gem author provided a list of presets that can be used to build the gem. To use a preset specify it on the command line:
+
+          gem install <gem_name> -- --preset <preset_name>
+
+        #{stdout}
+      EOS
+
+      STDOUT << message << "\n"
+      STDOUT.flush
+    rescue Gem::InstallError
+      # Do nothing, CMakePresets.json was not included in the Gem
+    end
+  end
+end

data/lib/rubygems_plugin.rb

@@ -0,0 +1,9 @@
+# Create RubyGems hook so we can replace the default CMakeBuilder with our own version
+Gem.pre_install do |installer|
+  extensions = installer.package&.spec&.extensions
+  if extensions && extensions.grep(/CMakeLists/)
+    require_relative 'rubygems/builder'
+    require_relative 'rubygems/cmake_builder'
+  end
+  true
+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
@@ -52,23 +55,38 @@ namespace Rice
     /*! \return the type saved to this Arg
      */
     template<typename Arg_Type>
-    Arg_Type& defaultValue();
+    Arg_Type defaultValue();
 
     //! 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();
+
+    //! Is the parameter a C style array
+    virtual Arg& setArray();
+    bool isArray();
+
   public:
-    const std::string name;
+    std::string name;
     int32_t position = -1;
 
   private:
@@ -76,9 +94,11 @@ namespace Rice
     std::any defaultValue_;
     bool isValue_ = false;
     bool isKeepAlive_ = false;
+    bool isOwner_ = false;
+    bool isOpaque_ = false;
+    bool isArray_ = false;
+
   };
 } // Rice
 
-#include "Arg.ipp"
-
 #endif // Rice__Arg__hpp_

data/rice/Arg.ipp

@@ -21,9 +21,9 @@ namespace Rice
   /*! \return the type saved to this Arg
     */
   template<typename Arg_Type>
-  inline Arg_Type& Arg::defaultValue()
+  inline Arg_Type Arg::defaultValue()
   {
-    return std::any_cast<Arg_Type&>(this->defaultValue_);
+    return std::any_cast<Arg_Type>(this->defaultValue_);
   }
 
   inline Arg& Arg::keepAlive()
@@ -47,4 +47,37 @@ 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_;
+  }
+
+  inline Arg& Arg::setArray()
+  {
+    this->isArray_ = true;
+    return *this;
+  }
+
+  inline bool Arg::isArray()
+  {
+    return this->isArray_;
+  }
 } // Rice

data/rice/Buffer.hpp

@@ -0,0 +1,123 @@
+#ifndef Rice__Buffer__hpp_
+#define Rice__Buffer__hpp_
+
+namespace Rice
+{
+  template<typename T>
+  class Buffer
+  {
+  public:
+    using type = T;
+
+    Buffer(T* pointer);
+    Buffer(T* pointer, size_t size);
+    Buffer(VALUE value);
+
+    ~Buffer();
+
+    Buffer(const Buffer& other) = delete;
+    Buffer(Buffer&& other);
+
+    Buffer& operator=(const Buffer& other) = delete;
+    Buffer& operator=(Buffer&& other);
+
+    T* ptr();
+    T& reference();
+    void release();
+
+    size_t size() const;
+    void setSize(size_t value);
+
+    // Ruby API
+  //  VALUE toString() const;
+
+    VALUE bytes() const;
+    VALUE bytes(size_t count) const;
+
+    Array toArray() const;
+    Array toArray(size_t count) const;
+
+    T get(size_t index) const;
+    void set(size_t index, T value);
+
+    bool isOwner() const;
+    void setOwner(bool value);
+
+  private:
+    void fromRubyType(VALUE value);
+    void fromDataType(VALUE value);
+
+    bool m_owner = false;
+    size_t m_size = 0;
+    // std::unique_ptr would be greate but std::unique_ptr<void> isn't allowed
+    T* m_buffer = nullptr;
+  };
+
+  template<typename T>
+  class Buffer<T*>
+  {
+  public:
+    using type = T*;
+
+    Buffer(T** pointer);
+    Buffer(T** pointer, size_t size);
+    Buffer(VALUE value);
+
+    ~Buffer();
+
+    Buffer(const Buffer& other) = delete;
+    Buffer(Buffer&& other);
+
+    Buffer& operator=(const Buffer& other) = delete;
+    Buffer& operator=(Buffer&& other);
+
+    const Buffer<T>& operator[](size_t index);
+
+    T** ptr();
+    void release();
+
+    size_t size() const;
+    void setSize(size_t value);
+
+    // Ruby API
+   // VALUE toString() const;
+
+    VALUE bytes() const;
+    VALUE bytes(size_t count) const;
+
+    Array toArray() const;
+    Array toArray(size_t count) const;
+
+    void setOwner(bool value);
+    bool isOwner() const;
+
+  private:
+    bool m_owner = false;
+    size_t m_size = 0;
+    T** m_outer = nullptr;
+    std::vector<Buffer<T>> m_inner;
+  };
+
+  template<>
+  class Buffer<void>
+  {
+  public:
+    Buffer(void* pointer);
+    Buffer(const Buffer& other) = delete;
+    Buffer(Buffer&& other);
+
+    Buffer& operator=(const Buffer& other) = delete;
+    Buffer& operator=(Buffer&& other);
+
+    void* ptr();
+
+  private:
+    void* m_buffer = nullptr;
+  };
+
+  template<typename T>
+  Data_Type<Buffer<T>> define_buffer(std::string klassName = "");
+
+  void define_fundamental_buffer_types();
+}
+#endif // Rice__Buffer__hpp_