rice 4.3.3 → 4.5.0

data/rice/detail/NativeRegistry.ipp

@@ -1,74 +1,49 @@
 
-// Ruby 2.7 now includes a similarly named macro that uses templates to
-// pick the right overload for the underlying function. That doesn't work
-// for our cases because we are using this method dynamically and get a
-// compilation error otherwise. This removes the macro and lets us fall
-// back to the C-API underneath again.
-#undef rb_define_method_id
-
-#include "RubyFunction.hpp"
-
 namespace Rice::detail
 {
-  inline void NativeRegistry::add(VALUE klass, ID method_id, std::any callable)
+  inline void NativeRegistry::add(VALUE klass, ID methodId, std::unique_ptr<Native>& native)
   {
     if (rb_type(klass) == T_ICLASS)
     {
       klass = detail::protect(rb_class_of, klass);
     }
 
-    auto range = this->natives_.equal_range(method_id);
-    for (auto it = range.first; it != range.second; ++it)
-    {
-      const auto [k, d] = it->second;
+    // Create the key
+    std::pair<VALUE, ID> key = std::make_pair(klass, methodId);
 
-      if (k == klass)
-      {
-        std::get<1>(it->second) = callable;
-        return;
-      }
-    }
+    // Lookup items for method
+    std::vector<std::unique_ptr<Native>>& natives = this->natives_[key];
 
-    this->natives_.emplace(std::make_pair(method_id, std::make_pair(klass, callable)));
+    natives.push_back(std::move(native));
   }
 
-  template <typename Return_T>
-  inline Return_T NativeRegistry::lookup()
+  inline void NativeRegistry::reset(VALUE klass)
   {
-    ID method_id;
-    VALUE klass;
-    if (!rb_frame_method_id_and_class(&method_id, &klass))
+    for (auto iter = this->natives_.begin(); iter != this->natives_.end();)
     {
-      rb_raise(rb_eRuntimeError, "Cannot get method id and class for function");
+      // Iter points to a std::pair<std::pair<VALUE, ID>, std::vector<NativeRegistryItem>
+      if (iter->first.first == klass)
+      {
+        iter = this->natives_.erase(iter);
+      }
+      else
+      {
+        ++iter;
+      }
     }
-
-    return this->lookup<Return_T>(klass, method_id);
   }
-
-  template <typename Return_T>
-  inline Return_T NativeRegistry::lookup(VALUE klass, ID method_id)
+  
+  inline const std::vector<std::unique_ptr<Native>>& NativeRegistry::lookup(VALUE klass, ID methodId)
   {
     if (rb_type(klass) == T_ICLASS)
     {
       klass = detail::protect(rb_class_of, klass);
     }
 
-    auto range = this->natives_.equal_range(method_id);
-    for (auto it = range.first; it != range.second; ++it)
-    {
-      const auto [k, d] = it->second;
-
-      if (k == klass)
-      {
-        auto* ptr = std::any_cast<Return_T>(&d);
-        if (!ptr)
-        {
-          rb_raise(rb_eRuntimeError, "Unexpected return type for %s#%s", rb_class2name(klass), rb_id2name(method_id));
-        }
-        return *ptr;
-      }
-    }
+    // Create the key
+    std::pair<VALUE, ID> key = std::make_pair(klass, methodId);
 
-    rb_raise(rb_eRuntimeError, "Could not find data for klass and method id");
+    // Lookup items for method
+    return this->natives_[key];
   }
 }

data/rice/detail/Proc.hpp

@@ -0,0 +1,4 @@
+#ifndef Rice__Proc__hpp_
+#define Rice__Proc__hpp_
+
+#endif // Rice__Proc__hpp_

data/rice/detail/Proc.ipp

@@ -0,0 +1,85 @@
+namespace Rice::detail
+{
+  // Note Return_T(Arg_Ts...) is intentional versus Return_T(*)(Arg_Ts...). That is
+  // because the Type machinery strips all pointers/references/const/val etc to avoid
+  // having an explosion of Type definitions
+  template<typename Return_T, typename ...Arg_Ts>
+  struct Type<Return_T(Arg_Ts...)>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+
+  // Wraps a C++ function as a Ruby proc
+  template<typename Return_T, typename ...Arg_Ts>
+  class To_Ruby<Return_T(*)(Arg_Ts...)>
+  {
+  public:
+    using Proc_T = Return_T(*)(Arg_Ts...);
+
+    VALUE convert(Proc_T proc)
+    {
+      using NativeFunction_T = NativeFunction<void, Proc_T, false>;
+      auto native = new NativeFunction_T(proc);
+      VALUE result = rb_proc_new(NativeFunction_T::procEntry, (VALUE)native);
+
+      // Tie the lifetime of the NativeCallback C++ instance to the lifetime of the Ruby proc object
+      VALUE finalizer = rb_proc_new(NativeFunction_T::finalizerCallback, (VALUE)native);
+      rb_define_finalizer(result, finalizer);
+
+      return result;
+    }
+  };
+
+  // Makes a Ruby proc callable as C callback
+  template<typename Return_T, typename ...Arg_Ts>
+  class From_Ruby<Return_T(*)(Arg_Ts...)>
+  {
+  public:
+    using Callback_T = Return_T(*)(Arg_Ts...);
+
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      if (protect(rb_obj_is_proc, value) == Qtrue || protect(rb_proc_lambda_p, value))
+      {
+        return Convertible::Exact;
+      }
+      else
+      {
+        return Convertible::None;
+      }
+    }
+
+#ifdef HAVE_LIBFFI
+    Callback_T convert(VALUE value)
+    {
+      using NativeCallback_T = NativeCallbackFFI<Return_T(*)(Arg_Ts...)>;
+      NativeCallback_T* nativeCallback = new NativeCallback_T(value);
+
+      // Tie the lifetime of the NativeCallback C++ instance to the lifetime of the Ruby proc object
+      VALUE finalizer = rb_proc_new(NativeCallback_T::finalizerCallback, (VALUE)nativeCallback);
+      rb_define_finalizer(value, finalizer);
+
+      return nativeCallback->callback();
+    }
+#else
+    Callback_T convert(VALUE value)
+    {
+      using NativeCallback_T = NativeCallbackSimple<Return_T(*)(Arg_Ts...)>;
+      NativeCallback_T::proc = value;
+      return &NativeCallback_T::callback;
+    }
+#endif
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+}

data/rice/detail/Registries.hpp

@@ -1,11 +1,6 @@
 #ifndef Rice__Registries__hpp_
 #define Rice__Registries__hpp_
 
-#include "HandlerRegistry.hpp"
-#include "InstanceRegistry.hpp"
-#include "NativeRegistry.hpp"
-#include "TypeRegistry.hpp"
-
 namespace Rice::detail
 {
   class Registries
@@ -21,6 +16,4 @@ namespace Rice::detail
   };
 }
 
-#include "Registries.ipp"
-
 #endif // Rice__Registries__hpp_

data/rice/detail/Registries.ipp

@@ -2,22 +2,4 @@ namespace Rice::detail
 {
   //Initialize static variables here.
   inline Registries Registries::instance;
-
-  // TODO - Big hack here but this code is dependent on internals
-  template<typename T>
-  bool Type<T>::verify()
-  {
-    // Use intrinsic_type so that we don't have to define specializations
-    // for pointers, references, const, etc.
-    using Intrinsic_T = intrinsic_type<T>;
-
-    if constexpr (std::is_fundamental_v<Intrinsic_T>)
-    {
-      return true;
-    }
-    else
-    {
-      return Registries::instance.types.verifyDefined<Intrinsic_T>();
-    }
-  }
 }

data/rice/detail/RubyFunction.hpp

@@ -1,8 +1,6 @@
 #ifndef Rice__detail__ruby_function__hpp_
 #define Rice__detail__ruby_function__hpp_
 
-#include "ruby.hpp"
-
 namespace Rice::detail
 {
   /* This is functor class that wraps calls to a Ruby C API method. It is needed because
@@ -29,6 +27,5 @@ namespace Rice::detail
   template<typename Function_T, typename ...Arg_Ts>
   auto protect(Function_T func, Arg_Ts...args);
 }
-#include "RubyFunction.ipp"
 
 #endif // Rice__detail__ruby_function__hpp_

data/rice/detail/RubyFunction.ipp

@@ -1,5 +1,3 @@
-#include "Jump_Tag.hpp"
-#include "../Exception_defn.hpp"
 
 #include <any>
 
@@ -14,9 +12,6 @@ namespace Rice::detail
   template<typename Function_T, typename...Arg_Ts>
   inline typename RubyFunction<Function_T, Arg_Ts...>::Return_T RubyFunction<Function_T, Arg_Ts...>::operator()()
   {
-    const int TAG_RAISE = 0x6; // From Ruby header files
-    int state = 0;
-
     // Setup a thread local variable to capture the result of the Ruby function call.
     // We use thread_local because the lambda has to be captureless so it can
     // be converted to a function pointer callable by C.
@@ -45,10 +40,11 @@ namespace Rice::detail
     };
 
     // Now call rb_protect which will invoke the callback lambda above
+    int state = (int)JumpException::RUBY_TAG_NONE;
     rb_protect(callback, (VALUE)this, &state);
 
     // Did anything go wrong?
-    if (state == 0)
+    if (state == JumpException::RUBY_TAG_NONE)
     {
       if constexpr (!std::is_same_v<Return_T, void>)
       {
@@ -58,14 +54,14 @@ namespace Rice::detail
     else
     {
       VALUE err = rb_errinfo();
-      if (state == TAG_RAISE && RB_TEST(err))
+      if (state == JumpException::RUBY_TAG_RAISE && RB_TEST(err))
       {
         rb_set_errinfo(Qnil);
         throw Rice::Exception(err);
       }
       else
       {
-        throw Jump_Tag(state);
+        throw Rice::JumpException((Rice::JumpException::ruby_tag_type)state);
       }
     }
   }

data/rice/detail/RubyType.hpp

@@ -0,0 +1,19 @@
+#ifndef Rice__detail__ruby__type__hpp_
+#define Rice__detail__ruby__type__hpp_
+
+#include <set>
+
+namespace Rice::detail
+{
+  template <typename T>
+  class RubyType
+  {
+  public:
+    static std::set<ruby_value_type> types();
+    static std::set<ruby_value_type> convertibleFrom();
+    static T(*converter)(VALUE);
+    static std::string packTemplate;
+  };
+}
+
+#endif // Rice__detail__ruby__type__hpp_

data/rice/detail/RubyType.ipp

@@ -0,0 +1,187 @@
+namespace Rice::detail
+{
+  template<>
+  class RubyType<bool>
+  {
+  public:
+    using FromRuby_T = bool(*)(VALUE);
+
+    static inline FromRuby_T fromRuby = RB_TEST;
+    static inline std::set<ruby_value_type> Exact = { RUBY_T_TRUE, RUBY_T_FALSE };
+    static inline std::set<ruby_value_type> Castable = { RUBY_T_NIL };
+    static inline std::set<ruby_value_type> Narrowable = {  };
+    static inline std::string packTemplate = "not supported";
+  };
+
+  template<>
+  class RubyType<char>
+  {
+  public:
+    using FromRuby_T = char(*)(VALUE);
+
+    static inline FromRuby_T fromRuby = rb_num2char_inline;
+    static inline std::set<ruby_value_type> Exact = { };
+    static inline std::set<ruby_value_type> Castable = { RUBY_T_STRING };
+    static inline std::set<ruby_value_type> Narrowable = { RUBY_T_FIXNUM };
+    static inline std::string packTemplate = CHAR_MIN < 0 ? "c*" : "C*";
+  };
+
+  template<>
+  class RubyType<signed char>
+  {
+  public:
+    // Hack - need to later typecast
+    using FromRuby_T = char(*)(VALUE);
+
+    static inline FromRuby_T fromRuby = rb_num2char_inline;
+    static inline std::set<ruby_value_type> Exact = { };
+    static inline std::set<ruby_value_type> Castable = { RUBY_T_STRING };
+    static inline std::set<ruby_value_type> Narrowable = { RUBY_T_FIXNUM };
+    static inline std::string packTemplate = "c*";
+  };
+
+  template<>
+  class RubyType<unsigned char>
+  {
+  public:
+    // Hack - need to later typecast, although char's in ruby are unsigned
+    using FromRuby_T = char(*)(VALUE);
+
+    static inline FromRuby_T fromRuby = rb_num2char_inline;
+    static inline std::set<ruby_value_type> Exact = { };
+    static inline std::set<ruby_value_type> Castable = { RUBY_T_STRING };
+    static inline std::set<ruby_value_type> Narrowable = { RUBY_T_FIXNUM };
+    static inline std::string packTemplate = "C*";
+  };
+
+  template<>
+  class RubyType<short>
+  {
+  public:
+    using FromRuby_T = short(*)(VALUE);
+
+    static inline FromRuby_T fromRuby = rb_num2short_inline;
+    static inline std::set<ruby_value_type> Exact = { };
+    static inline std::set<ruby_value_type> Castable = { };
+    static inline std::set<ruby_value_type> Narrowable = { RUBY_T_FIXNUM };
+    static inline std::string packTemplate = "s*";
+  };
+
+  template<>
+  class RubyType<unsigned short>
+  {
+  public:
+    using FromRuby_T = unsigned short(*)(VALUE);
+
+    static inline FromRuby_T fromRuby = rb_num2ushort;
+    static inline std::set<ruby_value_type> Exact = { };
+    static inline std::set<ruby_value_type> Castable = { };
+    static inline std::set<ruby_value_type> Narrowable = { RUBY_T_FIXNUM };
+    static inline std::string packTemplate = "S*";
+  };
+
+  template<>
+  class RubyType<int>
+  {
+  public:
+    using FromRuby_T = int(*)(VALUE);
+
+    static inline FromRuby_T fromRuby = rb_num2int_inline;
+    static inline std::set<ruby_value_type> Exact = { RUBY_T_FIXNUM };
+    static inline std::set<ruby_value_type> Castable = { };
+    static inline std::set<ruby_value_type> Narrowable = { };
+    static inline std::string packTemplate = "i*";
+  };
+
+  template<>
+  class RubyType<unsigned int>
+  {
+  public:
+    using FromRuby_T = unsigned int(*)(VALUE);
+
+    static inline FromRuby_T fromRuby = RB_NUM2UINT;
+    static inline std::set<ruby_value_type> Exact = { RUBY_T_FIXNUM };
+    static inline std::set<ruby_value_type> Castable = { };
+    static inline std::set<ruby_value_type> Narrowable = { };
+    static inline std::string packTemplate = "I*";
+  };
+
+  template<>
+  class RubyType<long>
+  {
+  public:
+    using FromRuby_T = long(*)(VALUE);
+
+    static inline FromRuby_T fromRuby = rb_num2long_inline;
+    static inline std::set<ruby_value_type> Exact = { RUBY_T_FIXNUM };
+    static inline std::set<ruby_value_type> Castable = { };
+    static inline std::set<ruby_value_type> Narrowable = { };
+    static inline std::string packTemplate = "l_*";
+  };
+
+  template<>
+  class RubyType<unsigned long>
+  {
+  public:
+    using FromRuby_T = unsigned long(*)(VALUE);
+
+    static inline FromRuby_T fromRuby = rb_num2ulong_inline;
+    static inline std::set<ruby_value_type> Exact = { RUBY_T_FIXNUM  };
+    static inline std::set<ruby_value_type> Castable = { };
+    static inline std::set<ruby_value_type> Narrowable = { };
+    static inline std::string packTemplate = "L_*";
+  };
+
+  template<>
+  class RubyType<long long>
+  {
+  public:
+    using FromRuby_T = long long(*)(VALUE);
+
+    static inline FromRuby_T fromRuby = rb_num2ll_inline;
+    static inline std::set<ruby_value_type> Exact = { RUBY_T_FIXNUM, RUBY_T_BIGNUM };
+    static inline std::set<ruby_value_type> Castable = { };
+    static inline std::set<ruby_value_type> Narrowable = { };
+    static inline std::string packTemplate = "q_*";
+  };
+
+  template<>
+  class RubyType<unsigned long long>
+  {
+  public:
+    using FromRuby_T = unsigned long long(*)(VALUE);
+
+    static inline FromRuby_T fromRuby = RB_NUM2ULL;
+    static inline std::set<ruby_value_type> Exact = { RUBY_T_FIXNUM, RUBY_T_BIGNUM };
+    static inline std::set<ruby_value_type> Castable = { };
+    static inline std::set<ruby_value_type> Narrowable = { };
+    static inline std::string packTemplate = "Q_*";
+  };
+
+
+  template<>
+  class RubyType<float>
+  {
+  public:
+    using FromRuby_T = double(*)(VALUE);
+
+    static inline FromRuby_T fromRuby = rb_num2dbl;
+    static inline std::set<ruby_value_type> Exact = { };
+    static inline std::set<ruby_value_type> Castable = { RUBY_T_FIXNUM };
+    static inline std::set<ruby_value_type> Narrowable = { RUBY_T_FLOAT };
+    static inline std::string packTemplate = "f*";
+  };
+
+  template<>
+  class RubyType<double>
+  {
+  public:
+    using FromRuby_T = double(*)(VALUE);
+
+    static inline FromRuby_T fromRuby = rb_num2dbl;
+    static inline std::set<ruby_value_type> Exact = { RUBY_T_FLOAT };
+    static inline std::set<ruby_value_type> Castable = { RUBY_T_FIXNUM, RUBY_T_BIGNUM };
+    static inline std::set<ruby_value_type> Narrowable = { };
+    static inline std::string packTemplate = "d*";
+  };
+}

data/rice/detail/TupleIterator.hpp

@@ -0,0 +1,14 @@
+#ifndef Rice__stl__tuple_iterator__hpp_
+#define Rice__stl__tuple_iterator__hpp_
+
+// See https://www.cppstories.com/2022/tuple-iteration-apply/
+template <typename Tuple_T, typename Function_T>
+void for_each_tuple(Tuple_T&& tuple, Function_T&& callable)
+{
+    std::apply([&callable](auto&& ...args)
+      {
+        (callable(std::forward<decltype(args)>(args)), ...);
+      }, std::forward<Tuple_T>(tuple));
+}
+
+#endif // Rice__stl__tuple_iterator__hpp_

data/rice/detail/Type.hpp

@@ -1,9 +1,7 @@
 #ifndef Rice__Type__hpp_
 #define Rice__Type__hpp_
 
-#include <string>
-#include <typeinfo>
-#include "../traits/rice_traits.hpp"
+#include <regex>
 
 namespace Rice::detail
 {
@@ -15,7 +13,10 @@ namespace Rice::detail
 
   // Return the name of a type
   std::string typeName(const std::type_info& typeInfo);
-  std::string makeClassName(const std::type_info& typeInfo);
+  std::string typeName(const std::type_index& typeIndex);
+  std::string makeClassName(const std::string& typeInfoName);
+  std::string findGroup(std::string& string, size_t start = 0);
+  void replaceAll(std::string& string, std::regex regex, std::string replacement);
 
   template<typename T>
   void verifyType();
@@ -24,6 +25,4 @@ namespace Rice::detail
   void verifyTypes();
 }
 
-#include "Type.ipp"
-
 #endif // Rice__Type__hpp_