rice 4.7.1 → 4.8.0

data/rice/detail/MethodInfo.ipp

@@ -1,99 +0,0 @@
-#include <sstream>
-
-namespace Rice
-{
-  template <typename...Arg_Ts>
-  inline MethodInfo::MethodInfo(size_t argCount, const Arg_Ts&...args)
-  {
-    // Process the passed in arguments
-    (this->processArg(args), ...);
-
-    // Fill in any missing arguments
-    for (size_t i = this->args_.size(); i < argCount; i++)
-    {
-      Arg arg("arg_" + std::to_string(i));
-      this->addArg(arg);
-    }
-
-    // TODO - so hacky but update the Arg positions
-    for (uint32_t i = 0; i < this->args_.size(); i++)
-    {
-      this->args_[i].position = i;
-    }
-  }
-
-  template <typename Arg_T>
-  inline void MethodInfo::processArg(const Arg_T& arg)
-  {
-    if constexpr (std::is_same_v<Arg_T, Return>)
-    {
-      this->returnInfo_ = arg;
-    }
-    else if constexpr (std::is_same_v<Arg_T, Function>)
-    {
-      this->function_ = arg;
-    }
-    else if constexpr (std::is_same_v<Arg_T, Arg>)
-    {
-      this->addArg(arg);
-    }
-    else
-    {
-      static_assert(true, "Unknown argument type");
-    }
-  }
-
-  inline void MethodInfo::addArg(const Arg& arg)
-  {
-    this->args_.push_back(arg);
-  }
-
-  inline int MethodInfo::argCount()
-  {
-    return this->args_.size();
-  }
-
-  inline Arg* MethodInfo::arg(size_t pos)
-  {
-    if (pos < this->args_.size())
-    {
-      return &this->args_[pos];
-    }
-    else
-    {
-      return nullptr;
-    }
-  }
-
-  inline Arg* MethodInfo::arg(std::string name)
-  {
-    for (Arg& arg : this->args_)
-    {
-      if (arg.name == name)
-      {
-        return &arg;
-      }
-    }
-    return nullptr;
-  }
-
-  inline Return* MethodInfo::returnInfo()
-  {
-    return &this->returnInfo_;
-  }
-  
-  inline Function* MethodInfo::function()
-  {
-    return &this->function_;
-  }
-
-  inline std::vector<Arg>::iterator MethodInfo::begin()
-  {
-    return this->args_.begin();
-  }
-
-  inline std::vector<Arg>::iterator MethodInfo::end()
-  {
-    return this->args_.end();
-  }
-}

data/rice/detail/NativeCallbackFFI.hpp

@@ -1,55 +0,0 @@
-#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

@@ -1,152 +0,0 @@
-#ifdef HAVE_LIBFFI
-#include <tuple>
-#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 convertToNative 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

@@ -1,30 +0,0 @@
-#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

@@ -1,29 +0,0 @@
-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...);
-  }
-}