rice 4.3.2 → 4.5.0

data/rice/Data_Type.ipp

@@ -1,24 +1,9 @@
-#ifndef Rice__Data_Type__ipp_
-#define Rice__Data_Type__ipp_
-
-#include "traits/attribute_traits.hpp"
-#include "traits/method_traits.hpp"
-#include "detail/NativeRegistry.hpp"
-#include "detail/NativeAttribute.hpp"
-#include "detail/default_allocation_func.hpp"
-#include "detail/TypeRegistry.hpp"
-#include "detail/Wrapper.hpp"
-#include "detail/NativeIterator.hpp"
-#include "cpp_api/Class.hpp"
-#include "cpp_api/String.hpp"
-#include "ruby_mark.hpp"
-
 #include <stdexcept>
 
 namespace Rice
 {
   template<typename T>
-  void ruby_mark_internal(detail::Wrapper* wrapper)
+  inline void ruby_mark_internal(detail::Wrapper* wrapper)
   {
     // Tell the wrapper to mark the objects its keeping alive
     wrapper->ruby_mark();
@@ -29,17 +14,23 @@ namespace Rice
   }
 
   template<typename T>
-  void ruby_free_internal(detail::Wrapper* wrapper)
+  inline void ruby_free_internal(detail::Wrapper* wrapper)
   {
     delete wrapper;
   }
 
   template<typename T>
-  size_t ruby_size_internal(const T* data)
+  inline size_t ruby_size_internal(const T* data)
   {
     return sizeof(T);
   }
 
+  template<>
+  inline size_t ruby_size_internal(const void* data)
+  {
+    return sizeof(void*);
+  }
+
   template<typename T>
   template <typename Base_T>
   inline Data_Type<T> Data_Type<T>::bind(const Module& klass)
@@ -68,12 +59,11 @@ namespace Rice
     // Now register with the type registry
     detail::Registries::instance.types.add<T>(klass_, rb_data_type_);
 
-    for (typename Instances::iterator it = unbound_instances().begin(),
-      end = unbound_instances().end();
-      it != end;
-      unbound_instances().erase(it++))
-    {
-      (*it)->set_value(klass);
+    auto iter = Data_Type<T>::unbound_instances_.begin();
+    while (iter != Data_Type<T>::unbound_instances_.end())
+    { 
+      (*iter)->set_value(klass);
+      iter = Data_Type<T>::unbound_instances_.erase(iter);
     }
 
     return Data_Type<T>();
@@ -99,7 +89,7 @@ namespace Rice
   {
     if (!is_bound())
     {
-      unbound_instances().insert(this);
+      this->unbound_instances_.insert(this);
     }
   }
 
@@ -109,12 +99,6 @@ namespace Rice
     this->bind(klass);
   }
 
-  template<typename T>
-  inline Data_Type<T>::~Data_Type()
-  {
-    unbound_instances().erase(this);
-  }
-
   template<typename T>
   inline rb_data_type_t* Data_Type<T>::ruby_data_type()
   {
@@ -137,17 +121,50 @@ namespace Rice
   }
 
   template<typename T>
-  template<typename Constructor_T, typename...Arg_Ts>
-  inline Data_Type<T>& Data_Type<T>::define_constructor(Constructor_T constructor, Arg_Ts const& ...args)
+  template<typename Constructor_T, typename...Rice_Arg_Ts>
+  inline Data_Type<T>& Data_Type<T>::define_constructor(Constructor_T constructor, Rice_Arg_Ts const& ...args)
   {
     check_is_bound();
 
     // Define a Ruby allocator which creates the Ruby object
     detail::protect(rb_define_alloc_func, static_cast<VALUE>(*this), detail::default_allocation_func<T>);
 
-    // Define an initialize function that will create the C++ object
-    this->define_method("initialize", &Constructor_T::construct, args...);
+    // We can't do anything with move constructors so blow up
+    static_assert(!Constructor_T::isMoveConstructor(), "Rice does not support move constructors");
+
+    // If this is a copy constructor then use it to support Ruby's Object#dup and Object#clone methods.
+    // Otherwise if a user calls #dup or #clone an error will occur because the newly cloned Ruby
+    // object will have a NULL ptr because the C++ object is never copied. This also prevents having
+    // very unlike Ruby code of:
+    // 
+    //    my_object_copy = MyObject.new(my_ojbect_original).
+
+    if constexpr (Constructor_T::isCopyConstructor())
+    {
+      // Define initialize_copy that will copy the C++ object
+      this->define_method("initialize_copy", &Constructor_T::initialize_copy, args...);
+    }
+    else if constexpr (Constructor_T::isMoveConstructor())
+    {
+      throw std::runtime_error("Rice does not support move constructors");
+    }
+    else
+    {
+      // Define an initialize function that will create the C++ object
+      this->define_method("initialize", &Constructor_T::initialize, args...);
+    }
+
+    return *this;
+  }
 
+  template<typename T>
+  template<typename Function_T>
+  inline Data_Type<T>& Data_Type<T>::define(Function_T func)
+  {
+    // The passed in this pointer is an RValue, so we need to keep it alive by
+    // assigning it to a const lvalue
+    const auto& dummy = *this;
+    func(*this);
     return *this;
   }
 
@@ -184,56 +201,84 @@ namespace Rice
   {
     if (!is_bound())
     {
-      std::string message = "Type " + detail::typeName(typeid(T)) + " is not bound";
-      throw std::runtime_error(message.c_str());
+      std::string message = "Type is not defined with Rice: " + detail::typeName(typeid(T));
+      throw std::invalid_argument(message.c_str());
     }
   }
 
-  template<typename T, typename Base_T>
-  inline Data_Type<T> define_class_under(Object module, char const* name)
+  template<typename T>
+  inline bool Data_Type<T>::is_defined(Object parent, const std::string& name)
   {
+    // Is the class already defined?
     if (detail::Registries::instance.types.isDefined<T>())
     {
-      return Data_Type<T>();
+      Data_Type<T> result = Data_Type<T>();
+
+      // If this redefinition is a different name then create a new constant
+      if (result.name() != name)
+      {
+        detail::protect(rb_define_const, parent, name.c_str(), result.klass());
+      }
+
+      return true;
     }
-    
-    Class superKlass;
+    return false;
+  }
+  
+  template<typename Base_T>
+  inline Class get_superklass()
+  {
+    Class result;
 
     if constexpr (std::is_void_v<Base_T>)
     {
-      superKlass = rb_cObject;
+      result = rb_cObject;
     }
     else
     {
-      superKlass = Data_Type<Base_T>::klass();
+      // This gives a chance for to auto-register classes such as std::exception
+      detail::verifyType<Base_T>();
+      result = Data_Type<Base_T>::klass();
     }
-    
-    Class c = define_class_under(module, name, superKlass);
-    c.undef_creation_funcs();
-    return Data_Type<T>::template bind<Base_T>(c);
+
+    return result;
   }
 
   template<typename T, typename Base_T>
-  inline Data_Type<T> define_class(char const* name)
+  inline Data_Type<T> define_class_under(Object parent, Identifier id, Class superKlass)
   {
-    if (detail::Registries::instance.types.isDefined<T>())
+    if (Rice::Data_Type<T>::is_defined(parent, id.str()))
     {
       return Data_Type<T>();
     }
 
-    Class superKlass;
-    if constexpr (std::is_void_v<Base_T>)
-    {
-      superKlass = rb_cObject;
-    }
-    else
+    Class klass = define_class_under(parent, id, superKlass);
+    klass.undef_creation_funcs();
+    return Data_Type<T>::template bind<Base_T>(klass);
+  }
+
+  template<typename T, typename Base_T>
+  inline Data_Type<T> define_class_under(Object parent, char const* name)
+  {
+    Identifier id(name);
+    Class superKlass = get_superklass<Base_T>();
+    return define_class_under<T, Base_T>(parent, id, superKlass);
+  }
+  
+  template<typename T, typename Base_T>
+  inline Data_Type<T> define_class(char const* name)
+  {
+    std::string klassName(name);
+
+    if (Rice::Data_Type<T>::is_defined(rb_cObject, klassName))
     {
-      superKlass = Data_Type<Base_T>::klass();
+      return Data_Type<T>();
     }
 
-    Class c = define_class(name, superKlass);
-    c.undef_creation_funcs();
-    return Data_Type<T>::template bind<Base_T>(c);
+    Class superKlass = get_superklass<Base_T>();
+    Class klass = define_class(name, superKlass);
+    klass.undef_creation_funcs();
+    return Data_Type<T>::template bind<Base_T>(klass);
   }
 
   template<typename T>
@@ -256,8 +301,18 @@ namespace Rice
     // Make sure the Attribute type has been previously seen by Rice
     detail::verifyType<typename detail::attribute_traits<Attribute_T>::attr_type>();
 
-    // Define native attribute
-    detail::NativeAttribute<Attribute_T>::define(klass_, name, std::forward<Attribute_T>(attribute), access);
+    // Define native attribute getter
+    if (access == AttrAccess::ReadWrite || access == AttrAccess::Read)
+      detail::NativeAttributeGet<Attribute_T>::define(klass_, name, std::forward<Attribute_T>(attribute));
+
+    using Attr_T = typename detail::NativeAttributeSet<Attribute_T>::Attr_T;
+    if constexpr (!std::is_const_v<Attr_T> &&
+                  (std::is_fundamental_v<Attr_T> || std::is_assignable_v<Attr_T, Attr_T>))
+        {
+      // Define native attribute setter
+      if (access == AttrAccess::ReadWrite || access == AttrAccess::Write)
+        detail::NativeAttributeSet<Attribute_T>::define(klass_, name, std::forward<Attribute_T>(attribute));
+    }
 
     return *this;
   }
@@ -271,7 +326,14 @@ namespace Rice
 
     // Define native attribute
     VALUE singleton = detail::protect(rb_singleton_class, this->value());
-    detail::NativeAttribute<Attribute_T>::define(singleton, name, std::forward<Attribute_T>(attribute), access);
+
+    // Define native attribute getter
+    if (access == AttrAccess::ReadWrite || access == AttrAccess::Read)
+      detail::NativeAttributeGet<Attribute_T>::define(singleton, name, std::forward<Attribute_T>(attribute));
+
+    // Define native attribute setter
+    if (access == AttrAccess::ReadWrite || access == AttrAccess::Write)
+      detail::NativeAttributeSet<Attribute_T>::define(singleton, name, std::forward<Attribute_T>(attribute));
 
     return *this;
   }
@@ -289,4 +351,3 @@ namespace Rice
     detail::NativeFunction<T, Function_T, IsMethod>::define(klass, name, std::forward<Function_T>(function), methodInfo);
   }
 }
-#endif

data/rice/Director.hpp

@@ -1,8 +1,6 @@
 #ifndef Rice__Director__hpp_
 #define Rice__Director__hpp_
 
-#include "cpp_api/Object.hpp"
-
 namespace Rice
 {
   /**

data/rice/Enum.hpp

@@ -1,9 +1,6 @@
 #ifndef Rice__Enum__hpp_
 #define Rice__Enum__hpp_
 
-#include "Data_Type.hpp"
-#include <map>
-
 namespace Rice
 {
   /*!
@@ -59,9 +56,10 @@ namespace Rice
   };
 
   template<typename T>
-  Enum<T> define_enum(char const* name, Module module = rb_cObject);
-} // namespace Rice
+  Enum<T> define_enum(char const* name);
 
-#include "Enum.ipp"
+  template<typename T>
+  Enum<T> define_enum_under(char const* name, Module module );
+} // namespace Rice
 
 #endif // Rice__Enum__hpp_

data/rice/Enum.ipp

@@ -1,6 +1,3 @@
-#include "detail/TypeRegistry.hpp"
-#include "Data_Object.hpp"
-#include "cpp_api/String.hpp"
 
 #include <stdexcept>
 
@@ -32,57 +29,68 @@ namespace Rice
     // First we need a constructor
     klass.define_constructor(Constructor<Enum_T>());
 
-    // Instance methods
-    klass.define_method("to_s", [](Enum_T& self)
-        {
-          // We have to return string because we don't know if std::string support has
-          // been included by the user
-          return String(valuesToNames_[self]);
-        })
-      .define_method("to_i", [](Enum_T& self) ->  Underlying_T
-        {
-          return (Underlying_T)self;
-        })
-      .define_method("inspect", [](Enum_T& self)
-        {
-          std::stringstream result;
-          VALUE rubyKlass = Enum<Enum_T>::klass().value();
-          result << "#<" << detail::protect(rb_class2name, rubyKlass)
-            << "::" << Enum<Enum_T>::valuesToNames_[self] << ">";
-
-          // We have to return string because we don't know if std::string support has
-          // been included by the user
-          return String(result.str());
-        })
-      .define_method("hash", [](Enum_T& self) ->  Underlying_T
-        {
-          return (Underlying_T)self;
-        })
-      .define_method("eql?", [](Enum_T& self, Enum_T& other)
-        {
-          return self == other;
-        });
+    // Instance methods. The self parameter is confusing because it is really a Data_Object<Enum_T>.
+    // However, if we make that the type then the From_Ruby code will consider it a 
+    // Data_Type<Data_Object<Enum_T>>>. But in define class above it was actually bound as 
+    // Data_Type<Enum_T>. Thus the static_casts in the methods below.
+    klass.define_method("to_s", [](Enum_T& notSelf)
+      {
+        // We have to return string because we don't know if std::string support has
+        // been included by the user
+        Data_Object<Enum_T> self = static_cast<Data_Object<Enum_T>>(notSelf);
+        return String(valuesToNames_[*self]);
+      })
+      .define_method("to_int", [](Enum_T& notSelf) ->  Underlying_T
+      {
+        Data_Object<Enum_T> self = static_cast<Data_Object<Enum_T>>(notSelf);
+        return static_cast<Underlying_T>(*self);
+      })
+      .define_method("inspect", [](Enum_T& notSelf)
+      {
+        Data_Object<Enum_T> self = static_cast<Data_Object<Enum_T>>(notSelf);
+
+        std::stringstream result;
+        VALUE rubyKlass = Enum<Enum_T>::klass().value();
+        result << "#<" << detail::protect(rb_class2name, rubyKlass)
+          << "::" << Enum<Enum_T>::valuesToNames_[*self] << ">";
+
+        // We have to return string because we don't know if std::string support has
+        // been included by the user
+        return String(result.str());
+      })
+      .define_method("hash", [](Enum_T& notSelf) ->  Underlying_T
+      {
+        Data_Object<Enum_T> self = static_cast<Data_Object<Enum_T>>(notSelf);
+        return (Underlying_T)*self;
+      })
+      .define_method("eql?", [](Enum_T& notSelf, Enum_T& notOther)
+      {
+        Data_Object<Enum_T> self = static_cast<Data_Object<Enum_T>>(notSelf);
+        Data_Object<Enum_T> other = static_cast<Data_Object<Enum_T>>(notOther);
+        return self == other;
+    });
 
     // Add aliases
     rb_define_alias(klass, "===", "eql?");
+    rb_define_alias(klass, "to_i", "to_int");
 
     // Add comparable support
     klass.include_module(rb_mComparable)
       .define_method("<=>", [](Enum_T& self, Enum_T& other)
-    {
-      if (self == other)
-      {
-        return 0;
-      }
-      else if (self < other)
       {
-        return -1;
-      }
-      else
-      {
-        return 1;
-      }
-    });
+        if (self == other)
+        {
+          return 0;
+        }
+        else if (self < other)
+        {
+          return -1;
+        }
+        else
+        {
+          return 1;
+        }
+      });
 
     // Add enumerable support
     klass.include_module(rb_mEnumerable)
@@ -91,7 +99,7 @@ namespace Rice
           if (!rb_block_given_p())
           {
             return rb_enumeratorize_with_size(ruby_klass, Identifier("each").to_sym(),
-                                      0, nullptr, 0);
+              0, nullptr, 0);
           }
 
           for (auto& pair : valuesToNames_)
@@ -102,22 +110,58 @@ namespace Rice
           }
 
           return ruby_klass;
-      }, Return().setValue())
-      .define_singleton_method("from_int", [](VALUE ruby_klass, int32_t value) -> Object
+        }, Return().setValue());
+
+    // Add bitwise operators
+    klass.define_method("&", [](Enum_T& self, Enum_T& other) -> Underlying_T
       {
-          auto iter = Enum<Enum_T>::valuesToNames_.find((Enum_T)value);
-          if (iter == Enum<Enum_T>::valuesToNames_.end())
-          {
-            throw std::runtime_error("Unknown enum value: " + std::to_string(value));
-          }
+        return (Underlying_T)self & (Underlying_T)other;
+      })
+      .define_method("|", [](Enum_T& self, Enum_T& other) -> Underlying_T
+      {
+        return (Underlying_T)self | (Underlying_T)other;
+      })
+      .define_method("^", [](Enum_T& self, Enum_T& other) -> Underlying_T
+      {
+        return (Underlying_T)self ^ (Underlying_T)other;
+      })
+      .define_method("~", [](Enum_T& self) -> Underlying_T
+      {
+        return ~(Underlying_T)self;
+      });
+
+    // Add shift operators
+    klass.define_method("<<", [](Enum_T& self, int shift) -> Underlying_T
+      {
+        return (Underlying_T)self << shift;
+      })
+      .define_method(">>", [](Enum_T& self, int shift) -> Underlying_T
+      {
+        return (Underlying_T)self >> shift;
+      });
+
+    // Add conversions from int
+    klass.define_singleton_method("from_int", [](VALUE ruby_klass, int32_t value) -> Object
+      {
+        auto iter = Enum<Enum_T>::valuesToNames_.find((Enum_T)value);
+        if (iter == Enum<Enum_T>::valuesToNames_.end())
+        {
+          throw std::runtime_error("Unknown enum value: " + std::to_string(value));
+        }
 
-          std::string name = iter->second;
-          return Object(ruby_klass).const_get(name);
+        std::string name = iter->second;
+        return Object(ruby_klass).const_get(name);
       });
   }
 
   template<typename Enum_T>
-  Enum<Enum_T> define_enum(char const* name, Module module)
+  Enum<Enum_T> define_enum(char const* name)
+  {
+    return define_enum_under<Enum_T>(name, rb_cObject);
+  }
+
+  template<typename Enum_T>
+  Enum<Enum_T> define_enum_under(char const* name, Module module)
   {
     if (detail::Registries::instance.types.isDefined<Enum_T>())
     {

data/rice/Exception.hpp

@@ -1,7 +1,67 @@
 #ifndef Rice__Exception__hpp_
 #define Rice__Exception__hpp_
 
-#include "Exception_defn.hpp"
-#include "Exception.ipp"
+#include <stdexcept>
+
+namespace Rice
+{
+  //! A placeholder for Ruby exceptions.
+  /*! You can use this to safely throw a Ruby exception using C++ syntax:
+   *  \code
+   *    VALUE foo(VALUE self) {
+   *      RUBY_TRY {
+   *        throw Rice::Exception(rb_eMyException, "uh oh!");
+   *      RUBY_CATCH
+   *    }
+   *  \endcode
+   */
+  class Exception
+    : public std::exception
+  {
+  public:
+    //! Construct a Exception with a Ruby exception instance
+    explicit Exception(VALUE exception);
+
+    //! Construct a Exception with printf-style formatting.
+    /*! \param exc either an exception object or a class that inherits
+     *  from Exception.
+     *  \param fmt a printf-style format string
+     *  \param ... the arguments to the format string.
+     */
+    template <typename... Arg_Ts>
+    Exception(const Exception& other, char const* fmt, Arg_Ts&&...args);
+
+    //! Construct a Exception with printf-style formatting.
+    /*! \param exc either an exception object or a class that inherits
+     *  from Exception.
+     *  \param fmt a printf-style format string
+     *  \param ... the arguments to the format string.
+     */
+    template <typename... Arg_Ts>
+    Exception(const VALUE exceptionType, char const* fmt, Arg_Ts&&...args);
+
+    //! Destructor
+    virtual ~Exception() noexcept = default;
+
+    //! Get message as a char const *.
+    /*! If message is a non-string object, then this function will attempt
+     *  to throw an exception (which it can't do because of the no-throw
+     *  specification).
+     *  \return the underlying C pointer of the underlying message object.
+     */
+    virtual char const* what() const noexcept override;
+
+    //! Returns the Ruby exception class
+    VALUE class_of() const;
+
+    //! Returns an instance of a Ruby exception
+    VALUE value() const;
+
+  private:
+    // TODO: Do we need to tell the Ruby gc about an exception instance?
+    mutable VALUE exception_ = Qnil;
+    mutable std::string message_;
+  };
+} // namespace Rice
 
 #endif // Rice__Exception__hpp_

data/rice/Exception.ipp

@@ -1,7 +1,3 @@
-#ifndef Rice__Exception__ipp_
-#define Rice__Exception__ipp_
-
-#include "detail/from_ruby.hpp"
 
 namespace Rice
 {
@@ -18,10 +14,10 @@ namespace Rice
   template <typename... Arg_Ts>
   inline Exception::Exception(const VALUE exceptionClass, char const* fmt, Arg_Ts&&...args)
   {
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wformat-security"
-#endif
+    #if defined(__GNUC__) || defined(__clang__)
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wformat-security"
+    #endif
 
     size_t size = std::snprintf(nullptr, 0, fmt, std::forward<Arg_Ts>(args)...);
     this->message_ = std::string(size, '\0');
@@ -31,9 +27,9 @@ namespace Rice
     // will add a null character internally at n + 1
     std::snprintf(&this->message_[0], size + 1, fmt, std::forward<Arg_Ts>(args)...);
 
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
+    #if defined(__GNUC__) || defined(__clang__)
+    #pragma GCC diagnostic pop
+    #endif
 
     // Now create the Ruby exception
     this->exception_ = detail::protect(rb_exc_new2, exceptionClass, this->message_.c_str());
@@ -61,4 +57,3 @@ namespace Rice
     return this->exception_;
   }
 }
-#endif // Rice__Exception__ipp_

data/rice/JumpException.hpp

@@ -0,0 +1,44 @@
+#ifndef Rice__JumpException__hpp_
+#define Rice__JumpException__hpp_
+
+namespace Rice
+{
+  //! A placeholder for Ruby longjmp data.
+  /*! When a Ruby exception is caught, the tag used for the longjmp is stored in
+   *  a Jump_Tag, then later passed to rb_jump_tag() when there is no more
+   *  C++ code to pass over.
+   */
+  class JumpException : public std::exception
+  {
+  public:
+    // Copied from vm_core.h
+    enum ruby_tag_type {
+      RUBY_TAG_NONE = 0x0,
+      RUBY_TAG_RETURN = 0x1,
+      RUBY_TAG_BREAK = 0x2,
+      RUBY_TAG_NEXT = 0x3,
+      RUBY_TAG_RETRY = 0x4,
+      RUBY_TAG_REDO = 0x5,
+      RUBY_TAG_RAISE = 0x6,
+      RUBY_TAG_THROW = 0x7,
+      RUBY_TAG_FATAL = 0x8,
+      RUBY_TAG_MASK = 0xf
+    };
+
+  public:
+    JumpException(ruby_tag_type tag);
+    virtual const char* what() const noexcept override;
+
+  public:
+    //! The tag being held.
+    ruby_tag_type tag;
+
+  private:
+    void createMessage();
+
+  private:
+    std::string message_;
+  };
+} // namespace Rice
+
+#endif // Rice__JumpException__hpp_