rice 4.3.3 → 4.6.0

data/rice/detail/NativeCallbackFFI.hpp

@@ -0,0 +1,55 @@
+#ifndef Rice__detail__Native_Callback_Ffi_hpp_
+#define Rice__detail__Native_Callback_Ffi_hpp_
+
+#ifdef HAVE_LIBFFI
+
+#include <ffi.h>
+
+namespace Rice::detail
+{
+  template<typename Callback_T>
+  class NativeCallbackFFI;
+
+  template<typename Return_T, typename ...Arg_Ts>
+  class NativeCallbackFFI<Return_T(*)(Arg_Ts...)>
+  {
+  public:
+    using Callback_T = Return_T(Arg_Ts...);
+    using Tuple_T = std::tuple<Arg_Ts...>;
+    static void ffiCallback(ffi_cif* cif, void* ret, void* args[], void* instance);
+    static VALUE finalizerCallback(VALUE yielded_arg, VALUE callback_arg, int argc, const VALUE* argv, VALUE blockarg);
+    static void setMethodInfo(MethodInfo* methodInfo);
+
+  public:
+    NativeCallbackFFI(VALUE proc);
+    ~NativeCallbackFFI();
+    NativeCallbackFFI(const NativeCallbackFFI&) = delete;
+    NativeCallbackFFI(NativeCallbackFFI&&) = delete;
+    void operator=(const NativeCallbackFFI&) = delete;
+    void operator=(NativeCallbackFFI&&) = delete;
+
+    Return_T operator()(Arg_Ts...args);
+    Callback_T* callback();
+
+  private:
+    template <typename Arg_T>
+    static ffi_type* ffiType();
+
+    template<std::size_t... I>
+    static Tuple_T convertArgsToTuple(void* args[], std::index_sequence<I...>& indices);
+
+    static inline std::array<ffi_type*, sizeof...(Arg_Ts)> args_ = { ffiType<Arg_Ts>()... };
+    static inline ffi_cif cif_;
+    static inline ffi_closure* closure_ = nullptr;
+    static inline Callback_T* callback_ = nullptr;
+    static inline std::unique_ptr<MethodInfo> methodInfo_ = std::make_unique<MethodInfo>();
+
+    template<std::size_t... I>
+    Return_T callRuby(std::index_sequence<I...>& indices, Arg_Ts...args);
+  private:
+    VALUE proc_;
+  };
+}
+#endif // HAVE_LIBFFI
+
+#endif // Rice__detail__Native_Callback_Ffi_hpp_

data/rice/detail/NativeCallbackFFI.ipp

@@ -0,0 +1,151 @@
+#ifdef HAVE_LIBFFI
+#include <ffi.h>
+
+namespace Rice::detail
+{
+  template<typename Return_T, typename ...Arg_Ts>
+  template<typename Arg_T>
+  ffi_type* NativeCallbackFFI<Return_T(*)(Arg_Ts...)>::ffiType()
+  {
+    std::map<std::type_index, ffi_type*> nativeToFfiMapping = { 
+      {std::type_index(typeid(bool)),               &ffi_type_uint8},
+      {std::type_index(typeid(bool)),               &ffi_type_uint8},
+      {std::type_index(typeid(char)),               &ffi_type_schar},
+      {std::type_index(typeid(unsigned char)),      &ffi_type_uchar},
+      {std::type_index(typeid(signed char)),        &ffi_type_schar},
+      {std::type_index(typeid(uint8_t)),            &ffi_type_uint8},
+      {std::type_index(typeid(unsigned short)),     &ffi_type_uint8},
+      {std::type_index(typeid(int8_t)),             &ffi_type_sint8},
+      {std::type_index(typeid(short)),              &ffi_type_sint8},
+      {std::type_index(typeid(uint16_t)),           &ffi_type_uint16},
+      {std::type_index(typeid(int16_t)),            &ffi_type_sint16},
+      {std::type_index(typeid(uint32_t)),           &ffi_type_uint32},
+      {std::type_index(typeid(unsigned int)),       &ffi_type_uint32},
+      {std::type_index(typeid(signed int)),         &ffi_type_uint32},
+      {std::type_index(typeid(int32_t)),            &ffi_type_sint32},
+      {std::type_index(typeid(uint64_t)),           &ffi_type_uint64},
+      {std::type_index(typeid(unsigned long long)), &ffi_type_uint64},
+      {std::type_index(typeid(int64_t)),            &ffi_type_sint64},
+      {std::type_index(typeid(signed long long)),   &ffi_type_sint64},
+      {std::type_index(typeid(float)),              &ffi_type_float},
+      {std::type_index(typeid(double)),             &ffi_type_double},
+      {std::type_index(typeid(void)),               &ffi_type_pointer},
+      {std::type_index(typeid(long double)),        &ffi_type_longdouble}
+    };
+
+    if (sizeof(long) == 32)
+    {
+      nativeToFfiMapping[std::type_index(typeid(unsigned long))] = &ffi_type_uint32;
+      nativeToFfiMapping[std::type_index(typeid(long))] = &ffi_type_sint32;
+    }
+    else if (sizeof(long) == 64)
+    {
+      nativeToFfiMapping[std::type_index(typeid(unsigned long))] = &ffi_type_uint64;
+      nativeToFfiMapping[std::type_index(typeid(long))] = &ffi_type_sint64;
+    }
+    
+    if (std::is_pointer_v<Arg_T>)
+    {
+      return &ffi_type_pointer;
+    }
+    else
+    {
+      const std::type_index& key = std::type_index(typeid(Arg_T));
+      return nativeToFfiMapping[key];
+    }
+  }
+
+  template<typename Return_T, typename ...Arg_Ts>
+  template<std::size_t... I>
+  typename NativeCallbackFFI<Return_T(*)(Arg_Ts...)>::Tuple_T NativeCallbackFFI<Return_T(*)(Arg_Ts...)>::convertArgsToTuple(void* args[], std::index_sequence<I...>& indices)
+  {
+    /* Loop over each value returned from Ruby and convert it to the appropriate C++ type based
+       on the arguments (Arg_Ts) required by the C++ function. Arg_T may have const/volatile while
+       the associated From_Ruby<T> template parameter will not. Thus From_Ruby produces non-const values
+       which we let the compiler convert to const values as needed. This works except for
+       T** -> const T**, see comment in getNativeValue method. */
+    return std::forward_as_tuple(*(std::tuple_element_t<I, Tuple_T>*)(args[I])...);
+  }
+
+  template<typename Return_T, typename ...Arg_Ts>
+  void NativeCallbackFFI<Return_T(*)(Arg_Ts...)>::ffiCallback(ffi_cif* cif, void* ret, void* args[], void* instance)
+  {
+    using Self_T = NativeCallbackFFI<Return_T(*)(Arg_Ts...)>;
+    Self_T* self = (Self_T*)instance;
+
+    auto indices = std::make_index_sequence<sizeof...(Arg_Ts)>{};
+
+    if constexpr (sizeof...(Arg_Ts) == 0)
+    {
+      *(Return_T*)ret = self->operator()();
+    }
+    else
+    {
+      std::tuple<Arg_Ts...> tuple = convertArgsToTuple(args, indices);
+      *(Return_T*)ret = std::apply(*self, tuple);
+    }
+  }
+
+  template<typename Return_T, typename ...Arg_Ts>
+  void NativeCallbackFFI<Return_T(*)(Arg_Ts...)>::setMethodInfo(MethodInfo* methodInfo)
+  {
+    methodInfo_.reset(methodInfo);
+  }
+
+  template<typename Return_T, typename ...Arg_Ts>
+  NativeCallbackFFI<Return_T(*)(Arg_Ts...)>::~NativeCallbackFFI()
+  {
+    this->proc_ = Qnil;
+  }
+
+  template<typename Return_T, typename ...Arg_Ts>
+  VALUE NativeCallbackFFI<Return_T(*)(Arg_Ts...)>::finalizerCallback(VALUE yielded_arg, VALUE callback_arg, int argc, const VALUE* argv, VALUE blockarg)
+  {
+    using NativeCallback_T = NativeCallbackFFI<Return_T(*)(Arg_Ts...)>;
+    NativeCallback_T* nativeCallback = (NativeCallback_T*)callback_arg;
+    delete nativeCallback;
+    return Qnil;
+  }
+
+  template<typename Return_T, typename ...Arg_Ts>
+  NativeCallbackFFI<Return_T(*)(Arg_Ts...)>::NativeCallbackFFI(VALUE proc) : proc_(proc)
+  {
+    // First setup desccription of callback
+    if (cif_.bytes == 0)
+    {
+      ffi_prep_cif(&cif_, FFI_DEFAULT_ABI, sizeof...(Arg_Ts), &ffi_type_pointer, args_.data());
+    }
+
+    // Create FFI closure
+    this->closure_ = (ffi_closure *)ffi_closure_alloc(sizeof(ffi_closure) + sizeof(void*), (void**)(&this->callback_));
+    ffi_prep_closure_loc(this->closure_, &cif_, ffiCallback, (void*)this, (void*)this->callback_);
+  }
+
+  template<typename Return_T, typename ...Arg_Ts>
+  typename NativeCallbackFFI<Return_T(*)(Arg_Ts...)>::Callback_T* NativeCallbackFFI<Return_T(*)(Arg_Ts...)>::callback()
+  {
+    return (Callback_T*)this->callback_;
+  }
+
+  template<typename Return_T, typename ...Arg_Ts>
+  template<std::size_t... I>
+  Return_T NativeCallbackFFI<Return_T(*)(Arg_Ts...)>::callRuby(std::index_sequence<I...>& indices, Arg_Ts...args)
+  {
+    static Identifier id("call");
+    std::array<VALUE, sizeof...(Arg_Ts)> values = { detail::To_Ruby<detail::remove_cv_recursive_t<Arg_Ts>>(methodInfo_->arg(I)).convert(args)... };
+    VALUE result = detail::protect(rb_funcallv, this->proc_, id.id(), (int)sizeof...(Arg_Ts), values.data());
+    if constexpr (!std::is_void_v<Return_T>)
+    {
+      static From_Ruby<Return_T> fromRuby(dynamic_cast<Arg*>(&methodInfo_->returnInfo));
+      return fromRuby.convert(result);
+    }
+  }
+
+  template<typename Return_T, typename ...Arg_Ts>
+  Return_T NativeCallbackFFI<Return_T(*)(Arg_Ts...)>::operator()(Arg_Ts...args)
+  {
+    auto indices = std::make_index_sequence<sizeof...(Arg_Ts)>{};
+    return NativeCallbackFFI<Return_T(*)(Arg_Ts...)>::callRuby(indices, args...);
+  }
+}
+#endif // HAVE_LIBFFI

data/rice/detail/NativeCallbackSimple.hpp

@@ -0,0 +1,30 @@
+#ifndef Rice__detail__Native_Callback_Simple_hpp_
+#define Rice__detail__Native_Callback_Simple_hpp_
+
+namespace Rice::detail
+{
+  template<typename Callback_T>
+  class NativeCallbackSimple;
+
+  template<typename Return_T, typename ...Arg_Ts>
+  class NativeCallbackSimple<Return_T(*)(Arg_Ts...)>
+  {
+  public:
+    static Return_T callback(Arg_Ts...args);
+    static inline VALUE proc = Qnil;
+    static void setMethodInfo(MethodInfo* methodInfo);
+
+  public:
+    NativeCallbackSimple()  = delete;
+    NativeCallbackSimple(const NativeCallbackSimple&) = delete;
+    NativeCallbackSimple(NativeCallbackSimple&&) = delete;
+    void operator=(const NativeCallbackSimple&) = delete;
+    void operator=(NativeCallbackSimple&&) = delete;
+
+  private:
+    template<std::size_t... I>
+    static Return_T callRuby(std::index_sequence<I...>& indices, Arg_Ts...args);
+    static inline std::unique_ptr<MethodInfo> methodInfo_ = std::make_unique<MethodInfo>();
+  };
+}
+#endif // Rice__detail__Native_Callback_Simple_hpp_

data/rice/detail/NativeCallbackSimple.ipp

@@ -0,0 +1,29 @@
+namespace Rice::detail
+{
+  template<typename Return_T, typename ...Arg_Ts>
+  void NativeCallbackSimple<Return_T(*)(Arg_Ts...)>::setMethodInfo(MethodInfo* methodInfo)
+  {
+    methodInfo_.reset(methodInfo);
+  }
+
+  template<typename Return_T, typename ...Arg_Ts>
+  template<std::size_t... I>
+  Return_T NativeCallbackSimple<Return_T(*)(Arg_Ts...)>::callRuby(std::index_sequence<I...>& indices, Arg_Ts...args)
+  {
+    static Identifier id("call");
+    std::array<VALUE, sizeof...(Arg_Ts)> values = { detail::To_Ruby<detail::remove_cv_recursive_t<Arg_Ts>>(methodInfo_->arg(I)).convert(args)... };
+    VALUE result = detail::protect(rb_funcallv, proc, id.id(), (int)sizeof...(Arg_Ts), values.data());
+    if constexpr (!std::is_void_v<Return_T>)
+    {
+      static From_Ruby<Return_T> fromRuby(dynamic_cast<Arg*>(&methodInfo_->returnInfo));
+      return fromRuby.convert(result);
+    }
+  }
+
+  template<typename Return_T, typename ...Arg_Ts>
+  Return_T NativeCallbackSimple<Return_T(*)(Arg_Ts...)>::callback(Arg_Ts...args)
+  {
+    auto indices = std::make_index_sequence<sizeof...(Arg_Ts)>{};
+    return NativeCallbackSimple<Return_T(*)(Arg_Ts...)>::callRuby(indices, args...);
+  }
+}

data/rice/detail/NativeFunction.hpp

@@ -1,13 +1,6 @@
 #ifndef Rice__detail__Native_Function__hpp_
 #define Rice__detail__Native_Function__hpp_
 
-#include "ruby.hpp"
-#include "ExceptionHandler_defn.hpp"
-#include "MethodInfo.hpp"
-#include "../traits/function_traits.hpp"
-#include "../traits/method_traits.hpp"
-#include "from_ruby.hpp"
-
 namespace Rice::detail
 {
   //! The NativeFunction class calls C++ functions/methods/lambdas on behalf of Ruby
@@ -43,24 +36,26 @@ namespace Rice::detail
    */
 
   template<typename Class_T, typename Function_T, bool IsMethod>
-  class NativeFunction
+  class NativeFunction: Native
   {
   public:
     using NativeFunction_T = NativeFunction<Class_T, Function_T, IsMethod>;
 
     // We remove const to avoid an explosion of To_Ruby specializations and Ruby doesn't
     // have the concept of constants anyways
-    using Return_T = remove_cv_recursive_t<typename function_traits<Function_T>::return_type>;
+    using Return_T = typename function_traits<Function_T>::return_type;
     using Receiver_T = typename method_traits<Function_T, IsMethod>::Class_T;
     using Arg_Ts = typename method_traits<Function_T, IsMethod>::Arg_Ts;
+    static constexpr std::size_t arity = method_traits<Function_T, IsMethod>::arity;
     using From_Ruby_Args_Ts = typename tuple_map<From_Ruby, Arg_Ts>::type;
+    using To_Ruby_T = remove_cv_recursive_t<Return_T>;
 
     // Register function with Ruby
     static void define(VALUE klass, std::string method_name, Function_T function, MethodInfo* methodInfo);
 
-    // Static member function that Ruby calls
-    static VALUE call(int argc, VALUE* argv, VALUE self);
-
+    // Proc entry
+    static VALUE procEntry(VALUE yielded_arg, VALUE callback_arg, int argc, const VALUE* argv, VALUE blockarg);
+    static VALUE finalizerCallback(VALUE yielded_arg, VALUE callback_arg, int argc, const VALUE* argv, VALUE blockarg);
   public:
     // Disallow creating/copying/moving
     NativeFunction() = delete;
@@ -69,13 +64,25 @@ namespace Rice::detail
     void operator=(const NativeFunction_T&) = delete;
     void operator=(NativeFunction_T&&) = delete;
 
-    // Invokes the wrapped function
-    VALUE operator()(int argc, VALUE* argv, VALUE self);
+    Resolved matches(size_t argc, const VALUE* argv, VALUE self) override;
+    VALUE operator()(size_t argc, const VALUE* argv, VALUE self) override;
+    std::string toString() override;
 
-  protected:
+    NativeFunction(Function_T function);
     NativeFunction(VALUE klass, std::string method_name, Function_T function, MethodInfo* methodInfo);
 
+  protected:
+
   private:
+    template<int I>
+    Convertible matchParameter(std::vector<std::optional<VALUE>>& value);
+
+    template<std::size_t...I>
+    Convertible matchParameters(std::vector<std::optional<VALUE>>& values, std::index_sequence<I...>& indices);
+
+    template<std::size_t...I>
+    std::vector<std::string> argTypeNames(std::ostringstream& stream, std::index_sequence<I...>& indices);
+
     template<typename T, std::size_t I>
     From_Ruby<T> createFromRuby();
       
@@ -83,14 +90,18 @@ namespace Rice::detail
     template<std::size_t...I>
     From_Ruby_Args_Ts createFromRuby(std::index_sequence<I...>& indices);
 
-    To_Ruby<Return_T> createToRuby();
+    // Convert C++ value to Ruby
+    To_Ruby<To_Ruby_T> createToRuby();
       
     // Convert Ruby argv pointer to Ruby values
-    std::vector<VALUE> getRubyValues(int argc, VALUE* argv);
+    std::vector<std::optional<VALUE>> getRubyValues(size_t argc, const VALUE* argv, bool validate);
+
+    template<typename Arg_T, int I>
+    Arg_T getNativeValue(std::vector<std::optional<VALUE>>& values);
 
     // Convert Ruby values to C++ values
     template<typename std::size_t...I>
-    Arg_Ts getNativeValues(std::vector<VALUE>& values, std::index_sequence<I...>& indices);
+    Arg_Ts getNativeValues(std::vector<std::optional<VALUE>>& values, std::index_sequence<I...>& indices);
 
     // Figure out what self is
     Receiver_T getReceiver(VALUE self);
@@ -99,21 +110,20 @@ namespace Rice::detail
     [[noreturn]] void noWrapper(const VALUE klass, const std::string& wrapper);
 
     // Do we need to keep alive any arguments?
-    void checkKeepAlive(VALUE self, VALUE returnValue, std::vector<VALUE>& rubyValues);
+    void checkKeepAlive(VALUE self, VALUE returnValue, std::vector<std::optional<VALUE>>& rubyValues);
 
     // Call the underlying C++ function
-    VALUE invokeNativeFunction(const Arg_Ts& nativeArgs);
-    VALUE invokeNativeMethod(VALUE self, const Arg_Ts& nativeArgs);
+    VALUE invokeNativeFunction(Arg_Ts&& nativeArgs);
+    VALUE invokeNativeMethod(VALUE self, Arg_Ts&& nativeArgs);
 
   private:
     VALUE klass_;
     std::string method_name_;
     Function_T function_;
     From_Ruby_Args_Ts fromRubys_;
-    To_Ruby<Return_T> toRuby_;
+    To_Ruby<To_Ruby_T> toRuby_;
     std::unique_ptr<MethodInfo> methodInfo_;
   };
 }
-#include "NativeFunction.ipp"
 
 #endif // Rice__detail__Native_Function__hpp_