rice 4.7.1 → 4.8.0

data/rice/detail/ruby.hpp

@@ -8,10 +8,33 @@
 
 #include <cmath>
 
+// Clang has to be first because on Windows it defines _MSC_VER too
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunknown-pragmas"
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#elif defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable: 4100)  // unreferenced formal parameter
+#pragma warning(disable: 4702)  // unreachable code
+#elif defined(__GNUC__ )
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunknown-pragmas"
+#endif
+
 #include <ruby.h>
 #include <ruby/encoding.h>
 #include <ruby/thread.h>
 
+// Clang has to be first because on Windows it defines _MSC_VER too
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#elif defined(_MSC_VER)
+#pragma warning(pop)
+#elif defined(__GNUC__ )
+#pragma GCC diagnostic pop
+#endif
+
 // ruby.h has a few defines that conflict with Visual Studio's STL
 #if defined(_MSC_VER)
 #undef write

data/rice/libc/file.hpp

@@ -1,11 +1,11 @@
-#ifndef Rice__libc__file__hpp_
-#define Rice__libc__file__hpp_
+#ifndef Rice__Libc__file__hpp_
+#define Rice__Libc__file__hpp_
 
-namespace Rice::libc
+namespace Rice::Libc
 {
   extern Class rb_cLibcFile;
 }
 
 #include "file.ipp"
 
-#endif // Rice__libc__file__hpp_
+#endif // Rice__Libc__file__hpp_

data/rice/rice.hpp

@@ -7,6 +7,7 @@
 // C++ headers have to come after Ruby on MacOS for reasons I do not understand
 #include <cstdio>
 #include <cstring> // For std::memset
+#include <map>
 #include <string>
 #include <typeinfo>
 #include <typeindex>
@@ -37,8 +38,6 @@
 // Code for Ruby to call C++
 #include "Arg.hpp"
 #include "Return.hpp"
-#include "Function.hpp"
-#include "detail/MethodInfo.hpp"
 #include "detail/from_ruby.hpp"
 #include "detail/RubyType.hpp"
 #include "detail/Parameter.hpp"
@@ -76,16 +75,18 @@
 // To / From Ruby
 #include "Arg.ipp"
 #include "detail/Parameter.ipp"
+#include "NoGVL.hpp"
 #include "Return.ipp"
-#include "Function.ipp"
 #include "Constructor.hpp"
 #include "Buffer.hpp"
 #include "Pointer.hpp"
+#include "Reference.hpp"
 #include "Buffer.ipp"
 #include "Pointer.ipp"
 #include "detail/Types.ipp"
 #include "detail/to_ruby.ipp"
 #include "detail/from_ruby.ipp"
+#include "Reference.ipp"
 #include "detail/Proc.hpp"
 
 // Registries
@@ -103,7 +104,6 @@
 #include "Exception.ipp"
 #include "detail/cpp_protect.hpp"
 #include "detail/Wrapper.ipp"
-#include "detail/MethodInfo.ipp"
 #include "detail/Native.ipp"
 #include "detail/NativeAttributeGet.ipp"
 #include "detail/NativeAttributeSet.ipp"
@@ -115,10 +115,8 @@
 #include "detail/NativeMethod.ipp"
 #include "detail/NativeProc.hpp"
 #include "detail/NativeProc.ipp"
-#include "detail/NativeCallbackFFI.hpp"
-#include "detail/NativeCallbackFFI.ipp"
-#include "detail/NativeCallbackSimple.hpp"
-#include "detail/NativeCallbackSimple.ipp"
+#include "detail/NativeCallback.hpp"
+#include "detail/NativeCallback.ipp"
 #include "detail/Proc.ipp"
 
 // C++ API definitions

data/rice/rice_api/Native.ipp

@@ -12,7 +12,8 @@ inline void Init_Native()
     .define_value("Method", detail::NativeKind::Method)
     .define_value("AttributeReader", detail::NativeKind::AttributeReader)
     .define_value("AttributeWriter", detail::NativeKind::AttributeWriter)
-    .define_value("Proc", detail::NativeKind::Proc);
+    .define_value("Proc", detail::NativeKind::Proc)
+    .define_value("Callback", detail::NativeKind::Callback);
 
   define_class_under<detail::Native>(rb_mRice, "Native").
     define_method("name", &detail::Native::name).
@@ -44,6 +45,9 @@ inline void Init_Native()
           case detail::NativeKind::Proc:
             stream << "Proc";
             break;
+          case detail::NativeKind::Callback:
+            stream << "Callback";
+            break;
         }
 
         stream << "<" << self.name() << "> ";

data/rice/rice_api/Parameter.ipp

@@ -5,7 +5,7 @@ inline void Init_Parameter()
   Module rb_mRice = define_module("Rice");
 
   define_class_under<detail::ParameterAbstract>(rb_mRice, "Parameter").
-    define_attr("arg", &detail::ParameterAbstract::arg).
+    define_method("arg", &detail::ParameterAbstract::arg).
     define_method("klass", &detail::ParameterAbstract::klass, Return().setValue()).
     define_method("cpp_klass", &detail::ParameterAbstract::cppTypeName);
 }

data/rice/ruby_mark.hpp

@@ -8,8 +8,9 @@
 namespace Rice
 {
   template<typename T>
-  void ruby_mark(T* data)
+  void ruby_mark(T*)
   {
+    // Do nothing by default
   }
 }
 #endif // Rice__ruby_mark__hpp_

data/rice/stl/complex.ipp

@@ -22,7 +22,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -35,7 +35,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<typename T>
@@ -44,7 +44,7 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
@@ -57,7 +57,7 @@ namespace Rice::detail
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<typename T>
@@ -66,11 +66,11 @@ namespace Rice::detail
   public:
     From_Ruby() = default;
 
-    explicit From_Ruby(Arg* arg)
+    explicit From_Ruby(Arg* arg) :arg_(arg)
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
@@ -89,6 +89,9 @@ namespace Rice::detail
 
       return std::complex<T>(From_Ruby<T>().convert(real), From_Ruby<T>().convert(imaginary));
     }
+
+  private:
+    Arg* arg_ = nullptr;
   };
 
   template<typename T>
@@ -97,11 +100,11 @@ namespace Rice::detail
   public:
     From_Ruby() = default;
 
-    explicit From_Ruby(Arg* arg)
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
       switch (rb_type(value))
       {
@@ -123,6 +126,7 @@ namespace Rice::detail
     }
 
   private:
+    Arg* arg_ = nullptr;
     std::complex<T> converted_;
   };
 }

data/rice/stl/map.ipp

@@ -107,20 +107,25 @@ namespace Rice
       {
         if constexpr (detail::is_comparable_v<Mapped_T>)
         {
-          klass_.define_method("value?", [](T& map, Mapped_T& value) -> bool
-            {
-              auto it = std::find_if(map.begin(), map.end(),
-              [&value](auto& pair)
-                {
-                  return pair.second == value;
-                });
+          klass_.define_method("==", [](T& map, T& other)->bool
+          {
+            return map == other;
+          })
+          .define_method("value?", [](T& map, Mapped_T& value) -> bool
+          {
+            auto it = std::find_if(map.begin(), map.end(),
+            [&value](auto& pair)
+              {
+                return pair.second == value;
+              });
 
-              return it != map.end();
+            return it != map.end();
           });
+          rb_define_alias(klass_, "eql?", "==");
         }
         else
         {
-          klass_.define_method("value?", [](T& map, Mapped_T& value) -> bool
+          klass_.define_method("value?", [](T&, Mapped_T&) -> bool
           {
               return false;
           });
@@ -205,10 +210,10 @@ namespace Rice
         }
         else
         {
-          klass_.define_method("to_s", [](const T& map)
-            {
-              return "[Not printable]";
-            });
+          klass_.define_method("to_s", [](const T&)
+          {
+            return "[Not printable]";
+          });
         }
       }
 
@@ -299,7 +304,7 @@ namespace Rice
       {
       }
 
-      Convertible is_convertible(VALUE value)
+      double is_convertible(VALUE value)
       {
         switch (rb_type(value))
         {
@@ -307,7 +312,7 @@ namespace Rice
             return Data_Type<std::map<T, U>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
             break;
           case RUBY_T_HASH:
-            return Convertible::Cast;
+            return Convertible::Exact;
             break;
           default:
             return Convertible::None;
@@ -333,7 +338,7 @@ namespace Rice
           }
           default:
           {
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
               detail::protect(rb_obj_classname, value), "std::map");
           }
         }
@@ -353,7 +358,7 @@ namespace Rice
       {
       }
 
-      Convertible is_convertible(VALUE value)
+      double is_convertible(VALUE value)
       {
         switch (rb_type(value))
         {
@@ -361,7 +366,7 @@ namespace Rice
             return Data_Type<std::map<T, U>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
             break;
           case RUBY_T_HASH:
-            return Convertible::Cast;
+            return Convertible::Exact;
             break;
           default:
             return Convertible::None;
@@ -388,7 +393,7 @@ namespace Rice
           }
           default:
           {
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
               detail::protect(rb_obj_classname, value), "std::map");
           }
         }
@@ -409,7 +414,7 @@ namespace Rice
       {
       }
 
-      Convertible is_convertible(VALUE value)
+      double is_convertible(VALUE value)
       {
         switch (rb_type(value))
         {
@@ -420,7 +425,7 @@ namespace Rice
             return Convertible::Exact;
             break;
           case RUBY_T_HASH:
-            return Convertible::Cast;
+            return Convertible::Exact;
             break;
           default:
             return Convertible::None;
@@ -447,7 +452,7 @@ namespace Rice
           }
           default:
           {
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
               detail::protect(rb_obj_classname, value), "std::map");
           }
         }

data/rice/stl/monostate.ipp

@@ -22,18 +22,18 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
-    VALUE convert(const std::monostate& _)
+    VALUE convert(const std::monostate&)
     {
       return Qnil;
     }
 
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<>
@@ -42,17 +42,17 @@ namespace Rice::detail
   public:
     To_Ruby() = default;
 
-    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    explicit To_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
-    VALUE convert(const std::monostate& data)
+    VALUE convert(const std::monostate&)
     {
       return Qnil;
     }
 
   private:
-    Return* returnInfo_ = nullptr;
+    Arg* arg_ = nullptr;
   };
 
   template<>
@@ -61,13 +61,13 @@ namespace Rice::detail
   public:
     From_Ruby() = default;
 
-    explicit From_Ruby(Arg* arg)
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
-      return value == Qnil ? Convertible::Exact : Convertible::None;
+      return value == Qnil ? 1.0 : 0.0;
     }
 
     std::monostate convert(VALUE value)
@@ -81,6 +81,9 @@ namespace Rice::detail
         throw std::runtime_error("Can only convert nil values to std::monostate");
       }
     }
+
+  private:
+    Arg* arg_ = nullptr;
   };
 
   template<>
@@ -89,13 +92,13 @@ namespace Rice::detail
   public:
     From_Ruby() = default;
 
-    explicit From_Ruby(Arg* arg)
+    explicit From_Ruby(Arg* arg) : arg_(arg)
     {
     }
 
-    Convertible is_convertible(VALUE value)
+    double is_convertible(VALUE value)
     {
-      return value == Qnil ? Convertible::Exact : Convertible::None;
+      return value == Qnil ? 1.0 : 0.0;
     }
 
     std::monostate& convert(VALUE value)
@@ -111,6 +114,7 @@ namespace Rice::detail
     }
     
   private:
+    Arg* arg_ = nullptr;
     std::monostate converted_ = std::monostate();
   };
 }

data/rice/stl/multimap.hpp

@@ -1,8 +1,6 @@
 #ifndef Rice__stl__multimap__hpp_
 #define Rice__stl__multimap__hpp_
 
-#include <map>
-
 namespace Rice
 {
   template<typename K, typename T>

data/rice/stl/multimap.ipp

@@ -106,20 +106,25 @@ namespace Rice
       {
         if constexpr (detail::is_comparable_v<Mapped_T>)
         {
-          klass_.define_method("value?", [](T& multimap, Mapped_T& value) -> bool
-            {
-              auto it = std::find_if(multimap.begin(), multimap.end(),
-              [&value](auto& pair)
-                {
-                  return pair.second == value;
-                });
+          klass_.define_method("==", [](T& multimap, T& other)->bool
+          {
+            return multimap == other;
+          })
+          .define_method("value?", [](T& multimap, Mapped_T& value) -> bool
+          {
+            auto it = std::find_if(multimap.begin(), multimap.end(),
+            [&value](auto& pair)
+              {
+                return pair.second == value;
+              });
 
-              return it != multimap.end();
+            return it != multimap.end();
           });
+          rb_define_alias(klass_, "eql?", "==");
         }
         else
         {
-          klass_.define_method("value?", [](T& multimap, Mapped_T& value) -> bool
+          klass_.define_method("value?", [](T&, Mapped_T&) -> bool
           {
               return false;
           });
@@ -188,10 +193,10 @@ namespace Rice
         }
         else
         {
-          klass_.define_method("to_s", [](const T& multimap)
-            {
-              return "[Not printable]";
-            });
+          klass_.define_method("to_s", [](const T&)
+          {
+            return "[Not printable]";
+          });
         }
       }
 
@@ -279,7 +284,7 @@ namespace Rice
       {
       }
 
-      Convertible is_convertible(VALUE value)
+      double is_convertible(VALUE value)
       {
         switch (rb_type(value))
         {
@@ -287,7 +292,7 @@ namespace Rice
             return Data_Type<std::multimap<T, U>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
             break;
           case RUBY_T_HASH:
-            return Convertible::Cast;
+            return Convertible::Exact;
             break;
           default:
             return Convertible::None;
@@ -313,7 +318,7 @@ namespace Rice
           }
           default:
           {
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
               detail::protect(rb_obj_classname, value), "std::multimap");
           }
         }
@@ -333,7 +338,7 @@ namespace Rice
       {
       }
 
-      Convertible is_convertible(VALUE value)
+      double is_convertible(VALUE value)
       {
         switch (rb_type(value))
         {
@@ -341,7 +346,7 @@ namespace Rice
             return Data_Type<std::multimap<T, U>>::is_descendant(value) ? Convertible::Exact : Convertible::None;
             break;
           case RUBY_T_HASH:
-            return Convertible::Cast;
+            return Convertible::Exact;
             break;
           default:
             return Convertible::None;
@@ -368,7 +373,7 @@ namespace Rice
           }
           default:
           {
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
               detail::protect(rb_obj_classname, value), "std::multimap");
           }
         }
@@ -389,7 +394,7 @@ namespace Rice
       {
       }
 
-      Convertible is_convertible(VALUE value)
+      double is_convertible(VALUE value)
       {
         switch (rb_type(value))
         {
@@ -400,7 +405,7 @@ namespace Rice
             return Convertible::Exact;
             break;
           case RUBY_T_HASH:
-            return Convertible::Cast;
+            return Convertible::Exact;
             break;
           default:
             return Convertible::None;
@@ -427,7 +432,7 @@ namespace Rice
           }
           default:
           {
-            throw Exception(rb_eTypeError, "wrong argument type %s (expected % s)",
+            throw Exception(rb_eTypeError, "wrong argument type %s (expected %s)",
               detail::protect(rb_obj_classname, value), "std::multimap");
           }
         }