rice 2.1.2 → 4.0.1

data/lib/mkmf-rice.rb

@@ -0,0 +1,127 @@
+require 'mkmf'
+
+IS_MSWIN = !RbConfig::CONFIG['host_os'].match(/mswin/).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
+
+# The cpp_command is not overwritten in the experimental mkmf C++ support.
+# See https://bugs.ruby-lang.org/issues/17578
+MakeMakefile['C++'].module_eval do
+  def cpp_command(outfile, opt="")
+    conf = cc_config(opt)
+    if $universal and (arch_flag = conf['ARCH_FLAG']) and !arch_flag.empty?
+      conf['ARCH_FLAG'] = arch_flag.gsub(/(?:\G|\s)-arch\s+\S+/, '')
+    end
+    RbConfig::expand("$(CXX) -E #$INCFLAGS #$CPPFLAGS #$CFLAGS #{opt} #{CONFTEST_CXX} #{outfile}",
+                     conf)
+  end
+end
+
+# Now pull in the C++ support
+include MakeMakefile['C++']
+
+# Rice needs c++17.
+if IS_MSWIN
+  $CXXFLAGS += " /std:c++17 /EHsc /permissive-"
+  $CPPFLAGS += " -D_ALLOW_KEYWORD_MACROS"
+else
+  $CXXFLAGS += " -std=c++17"
+end
+
+# Rice needs to include its header. Let's setup the include path
+# to make this easy
+path = File.expand_path(File.join(__dir__, '../include'))
+
+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
+  have_library('stdc++')
+end

data/lib/version.rb

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

data/rice/Address_Registration_Guard.ipp

@@ -1,37 +1,80 @@
-#include "Object.hpp"
-#include <algorithm>
-
-inline Rice::Address_Registration_Guard::
-Address_Registration_Guard(VALUE * address)
-  : address_(address)
+namespace Rice
 {
-  registerExitHandler();
-  rb_gc_register_address(address);
-}
+  inline Address_Registration_Guard::Address_Registration_Guard(VALUE* address) : address_(address)
+  {
+    registerExitHandler();
+    registerAddress();
+  }
 
-inline Rice::Address_Registration_Guard::
-Address_Registration_Guard(Object * object)
-  : address_(const_cast<VALUE *>(&object->value()))
-{
-  registerExitHandler();
-  rb_gc_register_address(address_);
-}
+  inline Address_Registration_Guard::Address_Registration_Guard(Object* object)
+    : address_(const_cast<VALUE*>(&object->value()))
+  {
+    registerExitHandler();
+    registerAddress();
+  }
 
-inline Rice::Address_Registration_Guard::
-~Address_Registration_Guard()
-{
-  if (enabled)
-    rb_gc_unregister_address(address_);
-}
+  inline Address_Registration_Guard::~Address_Registration_Guard()
+  {
+    unregisterAddress();
+  }
 
-inline VALUE * Rice::Address_Registration_Guard::
-address() const
-{
-  return address_;
-}
+  inline Address_Registration_Guard::Address_Registration_Guard(Address_Registration_Guard&& other)
+  {
+    // We don't use the constructor because we don't want to double register this address
+    address_ = other.address_;
+    other.address_ = nullptr;
+  }
 
-inline void Rice::Address_Registration_Guard::
-swap(Rice::Address_Registration_Guard & other)
-{
-  std::swap(address_, other.address_);
-}
+  inline Address_Registration_Guard& Address_Registration_Guard::operator=(Address_Registration_Guard&& other)
+  {
+    this->unregisterAddress();
+
+    this->address_ = other.address_;
+    other.address_ = nullptr;
+    return *this;
+  }
+
+  inline void Address_Registration_Guard::registerAddress() const
+  {
+    if (enabled)
+    {
+      detail::protect(rb_gc_register_address, address_);
+    }
+  }
+
+  inline void Address_Registration_Guard::unregisterAddress()
+  {
+    if (enabled && address_)
+    {
+      detail::protect(rb_gc_unregister_address, address_);
+    }
+
+    address_ = nullptr;
+  }
+
+  inline VALUE* Address_Registration_Guard::address() const
+  {
+    return address_;
+  }
+
+  static void disable_all_guards(VALUE)
+  {
+    Address_Registration_Guard::disable();
+  }
+
+  inline void Address_Registration_Guard::registerExitHandler()
+  {
+    if (exit_handler_registered)
+    {
+      return;
+    }
+
+    detail::protect(rb_set_end_proc, &disable_all_guards, Qnil);
+    exit_handler_registered = true;
+  }
+
+  inline void Address_Registration_Guard::disable()
+  {
+    enabled = false;
+  }
+} // Rice

data/rice/Address_Registration_Guard_defn.hpp

@@ -1,75 +1,79 @@
 #ifndef Rice__Address_Registration_Guard_defn__hpp_
 #define Rice__Address_Registration_Guard_defn__hpp_
 
-#include "Object_defn.hpp"
+#include "cpp_api/Object_defn.hpp"
 #include "detail/ruby.hpp"
-#include "detail/Not_Copyable.hpp"
 
 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
-  : private detail::Not_Copyable
-{
-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).
+  //! 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
    */
-  Address_Registration_Guard(VALUE * address);
+  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);
 
-  //! 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);
+    //! 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();
+    //! 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();
 
-  //! Get the address that is registered with the GC.
-  VALUE * address() const;
+    // Disable copying
+    Address_Registration_Guard(Address_Registration_Guard const& other) = delete;
+    Address_Registration_Guard& operator=(Address_Registration_Guard const& other) = delete;
 
-  //! Swap with another Address_Registration_Guard.
-  void swap(Address_Registration_Guard & other);
+    // Enable moving
+    Address_Registration_Guard(Address_Registration_Guard&& other);
+    Address_Registration_Guard& operator=(Address_Registration_Guard&& other);
 
-  /** Called during Ruby's exit process since we should not call
-   * rb_gc unregister_address there
-   */
-  static void disable();
+    //! Get the address that is registered with the GC.
+    VALUE* address() const;
 
-private:
-  static bool enabled;
-  static bool exit_handler_registered;
+    /** Called during Ruby's exit process since we should not call
+     * rb_gc unregister_address there
+     */
+    static void disable();
 
-  static void registerExitHandler();
+  private:
+    inline static bool enabled = true;
+    inline static bool exit_handler_registered = false;
+    static void registerExitHandler();
 
-  VALUE * address_;
-};
+  private:
+    void registerAddress() const;
+    void unregisterAddress();
 
+    VALUE* address_ = nullptr;
+  };
 } // namespace Rice
 
-#endif // Rice__Address_Registration_Guard_defn__hpp_
+#endif // Rice__Address_Registration_Guard_defn__hpp_

data/rice/Arg.hpp

@@ -1,8 +1,84 @@
 #ifndef Rice__Arg__hpp_
 #define Rice__Arg__hpp_
 
-#include "Arg_impl.hpp"
-#include "detail/Arguments.hpp"
-#include "Arg_operators.hpp"
+#include <any>
 
-#endif // Rice__Arg__hpp_
+namespace Rice
+{
+  //! Helper for defining default arguments of a method
+  /*! This class exposes the ability to define the default values of a
+   *  wrapped method. Inspired by how Boost.Python handles keyword and
+   *  default arguments, the syntax is simple:
+   *
+   *  \code
+   *    define_method(
+   *      "method",
+   *      &method,
+   *      Arg("arg1"), Arg("arg2") = 3, Arg("arg3") = true
+   *    );
+   *  \endcode
+   *
+   *  which means "for method &method, it takes 3 arguments
+   *  [arg1, arg2, arg3]. Of these arguments, arg2's default is 3
+   *  and arg3's default is true.
+   *
+   *  It may be required to explicitly cast the type of the default
+   *  value to prevent compilation errors.
+   */
+  class Arg
+  {
+  public:
+    //! Initialize a new Arg with the name of the argument
+    /*! We require the name of the argument because 1) it makes code
+     *  easier to read and 2) hopefully Ruby gets keyword arguments
+     *  in the future and this means Rice will be ready for it.
+     */
+    Arg(std::string name);
+
+    //! Set the default value for this Arg
+    /*! Set the default value for this argument.
+     *  If this isn't called on this Arg, then this
+     *  Arg is required in the method call.
+     *
+     *  \param val the value to store as default
+     */
+    template<typename Arg_Type>
+    Arg& operator=(Arg_Type val);
+
+    //! Check if this Arg has a default value associated with it
+    bool hasDefaultValue() const;
+
+    //! Return a reference to the default value associated with this Arg
+    /*! \return the type saved to this Arg
+     */
+    template<typename Arg_Type>
+    Arg_Type& defaultValue();
+
+    //! Tell the receiving object to keep this argument alive
+    //! until the receiving object is freed.
+    Arg& keepAlive();
+
+    //! Specifies if the argument should be treated as a value
+    Arg& isValue();
+
+    //! Returns if the argument should be treated as a value
+    bool getIsValue();
+
+    // No longer supported - implemented to raise error
+    Arg operator,(const Arg& other);
+
+  public:
+    bool isKeepAlive = false;
+    const std::string name;
+    int32_t position = -1;
+
+  private:
+    //! Our saved default value
+    std::any defaultValue_;
+    bool isValue_ = false;
+  };
+} // Rice
+
+#include "Arg.ipp"
+
+#endif // Rice__Arg__hpp_