rice 4.3.3 → 4.5.0

data/rice/JumpException.ipp

@@ -0,0 +1,48 @@
+namespace Rice
+{
+  inline JumpException::JumpException(ruby_tag_type tag) : tag(tag)
+  {
+    this->createMessage();
+  }
+
+  inline const char* JumpException::what() const noexcept
+  {
+    return this->message_.c_str();
+  }
+
+  inline void JumpException::createMessage()
+  {
+    switch (this->tag)
+    {
+      case RUBY_TAG_NONE:
+        this->message_ = "No error";
+        break;
+      case RUBY_TAG_RETURN:
+        this->message_ = "Unexpected return";
+        break;
+      case RUBY_TAG_NEXT:
+        this->message_ = "Unexpected next";
+        break;
+      case RUBY_TAG_BREAK:
+        this->message_ = "Unexpected break";
+        break;
+      case RUBY_TAG_REDO:
+        this->message_ = "Unexpected redo";
+        break;
+      case RUBY_TAG_RETRY:
+        this->message_ = "Retry outside of rescue clause";
+        break;
+      case RUBY_TAG_THROW:
+        this->message_ = "Unexpected throw";
+      case RUBY_TAG_RAISE:
+        this->message_ = "Ruby exception was thrown";
+        break;
+      case RUBY_TAG_FATAL:
+        this->message_ = "Fatal error";
+        break;
+      case RUBY_TAG_MASK:
+        this->message_ = "Mask error";
+        break;
+    }
+  }
+} // namespace Rice

data/rice/MemoryView.hpp

@@ -0,0 +1,11 @@
+#ifndef Rice__MemoryView__hpp_
+#define Rice__MemoryView__hpp_
+
+namespace Rice
+{
+  class MemoryView
+  {
+  };
+}
+
+#endif // Rice__MemoryView__hpp_

data/rice/MemoryView.ipp

@@ -0,0 +1,43 @@
+namespace Rice
+{
+}
+
+namespace Rice::detail
+{
+  template<>
+  class To_Ruby<unsigned char**>
+  {
+  public:
+    VALUE convert(unsigned char** x)
+    {
+      std::runtime_error("To_Ruby unsigned char** is not implemented yet");
+      return Qnil;
+    }
+  };
+
+  template<>
+  class From_Ruby<unsigned char**>
+  {
+  public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    Convertible is_convertible(VALUE value)
+    {
+      std::runtime_error("From_Ruby unsigned char** is not implemented yet");
+      return Convertible::None;
+    }
+
+    unsigned char** convert(VALUE value)
+    {
+      std::runtime_error("From_Ruby unsigned char** is not implemented yet");
+      return nullptr;
+    }
+
+  private:
+    Arg* arg_ = nullptr;
+  };
+}

data/rice/Return.hpp

@@ -1,40 +1,20 @@
 #ifndef Rice__Return__hpp_
 #define Rice__Return__hpp_
 
-#include <any>
-
 namespace Rice
 {
   //! Helper for defining Return argument of a method
 
-  class Return
+  class Return: public Arg
   {
   public:
-    //! Specifies Ruby should take ownership of the returned value
-    Return& takeOwnership();
-
-    //! Does Ruby own the returned value?
-    bool isOwner();
-
-    //! Specifies the returned value is a Ruby value
-    Return& setValue();
-
-    //! Is the returned value a Ruby value?
-    bool isValue() const;
+    Return();
+    Return& keepAlive() override;
+    Return& setValue() override;
+    Return& setOpaque() override;
+    Return& takeOwnership() override;
 
-    //! Tell the returned object to keep alive the receving object
-    Return& keepAlive();
-
-    //! Is the returned value being kept alive?
-    bool isKeepAlive() const;
-
-  private:
-    bool isKeepAlive_ = false;
-    bool isOwner_ = false;
-    bool isValue_ = false;
   };
 } // Rice
 
-#include "Return.ipp"
-
 #endif // Rice__Return__hpp_

data/rice/Return.ipp

@@ -1,38 +1,32 @@
 #include <any>
-#include <string>
 
 namespace Rice
 {
-  inline Return& Return::takeOwnership()
+  inline Return::Return(): Arg("Return")
   {
-    this->isOwner_ = true;
-    return *this;
   }
 
-  inline bool Return::isOwner()
+  inline Return& Return::keepAlive()
   {
-    return this->isOwner_;
+    Arg::keepAlive();
+    return *this;
   }
 
   inline Return& Return::setValue()
   {
-    this->isValue_ = true;
+    Arg::setValue();
     return *this;
   }
 
-  inline bool Return::isValue() const
-  {
-    return this->isValue_;
-  }
-
-  inline Return& Return::keepAlive()
+  inline Return& Return::setOpaque()
   {
-    this->isKeepAlive_ = true;
+    Arg::setOpaque();
     return *this;
   }
 
-  inline bool Return::isKeepAlive() const
+  inline Return& Return::takeOwnership()
   {
-    return this->isKeepAlive_;
+    Arg::takeOwnership();
+    return *this;
   }
 }  // Rice

data/rice/detail/DefaultHandler.hpp

@@ -0,0 +1,12 @@
+#ifndef Rice__detail__DefaultHandler__hpp_
+#define Rice__detail__DefaultHandler__hpp_
+
+namespace Rice::detail
+{
+  class DefaultHandler
+  {
+  public:
+    void operator()() const;
+  };
+}
+#endif // Rice__detail__DefaultHandler__hpp_

data/rice/detail/DefaultHandler.ipp

@@ -0,0 +1,8 @@
+namespace Rice::detail
+{
+  inline void Rice::detail::DefaultHandler::operator()() const
+  {
+    // This handler does nothing, it just rethrows the exception so it can be handled
+    throw;
+  }
+}

data/rice/detail/HandlerRegistry.hpp

@@ -1,51 +1,21 @@
 #ifndef Rice__detail__HandlerRegistry__hpp_
 #define Rice__detail__HandlerRegistry__hpp_
 
-#include "ExceptionHandler.hpp"
+#include <functional>
 
 namespace Rice::detail
 {
   class HandlerRegistry
   {
   public:
-    //! Define an exception handler.
-    /*! Whenever an exception of type Exception_T is thrown from a
-     *  function defined on this class, the supplied functor will be called to
-     *  translate the exception into a ruby exception.
-     *  \param Exception_T a template parameter indicating the type of
-     *  exception to be translated.
-     *  \param functor a functor to be called to translate the exception
-     *  into a ruby exception.  This functor should re-throw the exception
-     *  as an Exception.
-     *  Example:
-     *  \code
-     *    Class rb_cFoo;
-     *
-     *    void translate_my_exception(MyException const& ex)
-     *    {
-     *       throw Rice::Exception(rb_eRuntimeError, ex.what_without_backtrace());
-     *    }
-     *
-     *    extern "C"
-     *    void Init_MyExtension()
-     *    {
-     *      rb_cFoo = define_class("Foo");
-     *      register_handler<MyException>(translate_my_exception);
-     *    }
-     *  \endcode
-     */
-    template<typename Exception_T, typename Functor_T>
-    HandlerRegistry& add(Functor_T functor);
-
-    std::shared_ptr<detail::ExceptionHandler> handler() const;
+    HandlerRegistry();
+    void set(std::function<void()> handler);
+    std::function<void()> handler() const;
 
   private:
-    mutable std::shared_ptr<detail::ExceptionHandler> handler_ = std::make_shared<Rice::detail::DefaultExceptionHandler>();
-
+    std::function<void()> handler_;
   };
 } // namespace Rice::detail
 
-#include "HandlerRegistry.ipp"
-
 #endif // Rice__detail__HandlerRegistry__hpp_
 

data/rice/detail/HandlerRegistry.ipp

@@ -1,20 +1,16 @@
-#include <memory>
-
 namespace Rice::detail
 {
-  template<typename Exception_T, typename Functor_T>
-  inline HandlerRegistry& HandlerRegistry::add(Functor_T functor)
+  inline HandlerRegistry::HandlerRegistry() : handler_(DefaultHandler())
   {
-    // Create a new exception handler and pass ownership of the current handler to it (they
-    // get chained together). Then take ownership of the new handler.
-    this->handler_ = std::make_shared<detail::CustomExceptionHandler<Exception_T, Functor_T>>(
-      functor, std::move(this->handler_));
+  }
 
-    return *this;
+  inline void HandlerRegistry::set(std::function<void()> handler)
+  {
+    this->handler_ = handler;
   }
 
-  inline std::shared_ptr<detail::ExceptionHandler> HandlerRegistry::handler() const
+  inline std::function<void()> HandlerRegistry::handler() const
   {
     return this->handler_;
   }
-} // namespace
+}

data/rice/detail/InstanceRegistry.hpp

@@ -2,7 +2,6 @@
 #define Rice__detail__InstanceRegistry__hpp_
 
 #include <map>
-#include "ruby.hpp"
 
 namespace Rice::detail
 {
@@ -14,6 +13,7 @@ namespace Rice::detail
 
     template <typename T>
     VALUE lookup(T* cppInstance);
+    VALUE lookup(void* cppInstance);
 
     void add(void* cppInstance, VALUE rubyInstance);
     void remove(void* cppInstance);
@@ -23,12 +23,9 @@ namespace Rice::detail
     bool isEnabled = false;
 
   private:
-    VALUE lookup(void* cppInstance);
     std::map<void*, VALUE> objectMap_;
   };
 } // namespace Rice::detail
 
-#include "InstanceRegistry.ipp"
-
 #endif // Rice__detail__InstanceRegistry__hpp_
 

data/rice/detail/MethodInfo.hpp

@@ -2,14 +2,14 @@
 #define Rice__MethodInfo__hpp_
 
 #include <vector>
-#include "../Arg.hpp"
-#include "../Return.hpp"
 
 namespace Rice
 {
   class MethodInfo
   {
   public:
+    MethodInfo() = default;
+
     template <typename...Arg_Ts>
     MethodInfo(size_t argCount, const Arg_Ts&...args);
 
@@ -24,7 +24,19 @@ namespace Rice
       */
     void addArg(const Arg& arg);
 
-    Arg& arg(size_t pos);
+    /**
+      * Get argument by position
+      */
+    Arg* arg(size_t pos);
+
+    /**
+      * Get argument by name
+      */
+    Arg* arg(std::string name);
+
+    int requiredArgCount();
+    int optionalArgCount();
+    void verifyArgCount(int argc);
 
     // Iterator support
     std::vector<Arg>::iterator begin();
@@ -39,6 +51,4 @@ namespace Rice
     std::vector<Arg> args_;
   };
 }
-#include "MethodInfo.ipp"
-
 #endif // Rice__MethodInfo__hpp_

data/rice/detail/MethodInfo.ipp

@@ -1,5 +1,4 @@
 #include <sstream>
-#include "from_ruby_defn.hpp"
 
 namespace Rice
 {
@@ -26,13 +25,13 @@ namespace Rice
   template <typename Arg_T>
   inline void MethodInfo::processArg(const Arg_T& arg)
   {
-    if constexpr (std::is_same_v<Arg_T, Arg>)
+    if constexpr (std::is_same_v<Arg_T, Return>)
     {
-      this->addArg(arg);
+      this->returnInfo = arg;
     }
     else
     {
-      this->returnInfo = arg;
+      this->addArg(arg);
     }
   }
 
@@ -41,6 +40,60 @@ namespace Rice
     this->args_.push_back(arg);
   }
 
+  inline int MethodInfo::requiredArgCount()
+  {
+    int result = 0;
+
+    for (const Arg& arg : this->args_)
+    {
+      if (!arg.hasDefaultValue())
+      {
+        result++;
+      }
+    }
+
+    return result;
+  }
+
+  inline int MethodInfo::optionalArgCount()
+  {
+    int result = 0;
+
+    for (const Arg& arg : this->args_)
+    {
+      if (arg.hasDefaultValue())
+      {
+        result++;
+      }
+    }
+
+    return result;
+  }
+
+  inline void MethodInfo::verifyArgCount(int argc)
+  {
+    int requiredArgCount = this->requiredArgCount();
+    int optionalArgCount = this->optionalArgCount();
+
+    if (argc < requiredArgCount || argc > requiredArgCount + optionalArgCount)
+    {
+      std::string message;
+
+      if (optionalArgCount > 0)
+      {
+        message = "wrong number of arguments (given " +
+          std::to_string(argc) + ", expected " +
+          std::to_string(requiredArgCount) + ".." + std::to_string(requiredArgCount + optionalArgCount) + ")";
+      }
+      else
+      {
+        message = "wrong number of arguments (given " +
+          std::to_string(argc) + ", expected " + std::to_string(requiredArgCount) + ")";
+      }
+      throw std::invalid_argument(message);
+    }
+  }
+
   inline std::string MethodInfo::formatString()
   {
     size_t required = 0;
@@ -61,9 +114,28 @@ namespace Rice
     return std::to_string(required) + std::to_string(optional);
   }
 
-  inline Arg& MethodInfo::arg(size_t pos)
+  inline Arg* MethodInfo::arg(size_t pos)
   {
-    return args_[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 std::vector<Arg>::iterator MethodInfo::begin()

data/rice/detail/Native.hpp

@@ -0,0 +1,32 @@
+#ifndef Rice__detail__Native__hpp_
+#define Rice__detail__Native__hpp_
+
+namespace Rice::detail
+{
+  class Native;
+
+  class Resolved
+  {
+  public:
+    inline bool operator<(Resolved other);
+    inline bool operator>(Resolved other);
+
+    Convertible convertible;
+    double parameterMatch;
+    Native* native;
+  };
+
+  class Native
+  {
+  public:
+    static VALUE resolve(int argc, VALUE* argv, VALUE self);
+  public:
+    virtual ~Native() = default;
+    VALUE call(int argc, VALUE* argv, VALUE self);
+
+    virtual Resolved matches(int argc, const VALUE* argv, VALUE self) = 0;
+    virtual VALUE operator()(int argc, const VALUE* argv, VALUE self) = 0;
+  };
+}
+
+#endif // Rice__detail__Native__hpp_

data/rice/detail/Native.ipp

@@ -0,0 +1,129 @@
+
+namespace Rice::detail
+{
+  inline bool Resolved::operator<(Resolved other)
+  {
+    if (this->convertible != other.convertible)
+    {
+      return this->convertible < other.convertible;
+    }
+    else
+    {
+      return this->parameterMatch < other.parameterMatch;
+    }
+  }
+
+  inline bool Resolved::operator>(Resolved other)
+  {
+    if (this->convertible != other.convertible)
+    {
+      return this->convertible > other.convertible;
+    }
+    else
+    {
+      return this->parameterMatch > other.parameterMatch;
+    }
+  }
+
+  inline VALUE Native::resolve(int argc, VALUE* argv, VALUE self)
+  {
+    /* This method is called from Ruby and is responsible for determining the correct
+       Native object (ie, NativeFunction, NativeIterator, NativeAttributeGet and 
+       NativeAttributeSet) that shoudl be used to invoke the underlying C++ code.
+       Most of the time there will be a single Native object registered for a C++ function,
+       method, constructor, iterator or attribute. However, there can be multiple Natives 
+       when a C++ function/method/construtor is overloaded.
+
+       In that case, the code iterates over each Native and calls its matches method. The matches
+       method returns a Resolved object which includes a Convertible field and parameterMatch field.
+       The Convertible field is an enum that specifies if the types of the values supplied by Ruby
+       match the types of the C++ function parameters. Allowed values include  can be Exact (example Ruby into to C++ int),
+       TypeCast (example Ruby into to C++ float) or None (cannot be converted). 
+
+       The parameterMatch field is simply the number or arguments provided by Ruby divided by the
+       number of arguments required by C++. These numbers can be different because C++ method 
+       parameters can have default values.
+
+       Taking these two values into account, the method sorts the Natives and picks the one with the 
+       highest score (Convertible::Exact and 1.0 for parameterMatch). Thus given these two C++ functions:
+
+       void some_method(int a);
+       void some_mtehod(int a, float b = 2.0).
+
+       A call from ruby of some_method(1) will exactly match both signatures, but the first one 
+       will be chosen because the parameterMatch will be 1.0 for the first overload but 0.5
+       for the second. */
+
+    Native* native = nullptr;
+
+    ID methodId;
+    VALUE klass;
+    if (!rb_frame_method_id_and_class(&methodId, &klass))
+    {
+      rb_raise(rb_eRuntimeError, "Cannot get method id and class for function");
+    }
+
+    // Execute the function but make sure to catch any C++ exceptions!
+    return cpp_protect([&]
+    {
+      Identifier id(methodId);
+      std::string methodName = id.str();
+      std::string className = rb_class2name(klass);
+
+      const std::vector<std::unique_ptr<Native>>& natives = Registries::instance.natives.lookup(klass, methodId);
+
+      if (natives.size() == 1)
+      {
+        native = natives.front().get();
+      }
+      else if (natives.size() == 0)
+      {
+        Identifier identifier(methodId);
+        rb_raise(rb_eArgError, "Could not find method call for %s#%s", rb_class2name(klass), identifier.c_str());
+      }
+      else
+      {
+        // Loop over every native to see how well they match the Ruby parameters
+        std::vector<Resolved> resolves;
+        std::transform(natives.begin(), natives.end(), 
+          std::back_inserter(resolves), 
+          [&](const std::unique_ptr<Native>& native)
+          {
+            return native->matches(argc, argv, self);
+          });
+
+        // Now sort from best to worst
+        std::sort(resolves.begin(), resolves.end(), std::greater{});
+
+        // Get the best one
+        Resolved resolved = resolves.front();
+
+        // Did it match?
+        if (resolved.convertible != Convertible::None)
+        {
+          native = resolved.native;
+        }
+        else
+        {
+          // Special case == to make the RubyMine debugger work. It calls == with a Module as
+          // the other argument, thus breaking if C++ operator== is implemented.
+          Identifier identifier(methodId);
+          if (identifier.str() == "==")
+          {
+            return detail::protect(rb_call_super, argc, argv);
+          }
+          else
+          {
+            std::ostringstream message;
+            message << "Could not resolve method call for %s#%s" << "\n"
+                    << "  %d overload(s) were evaluated based on the types of Ruby parameters provided.";
+              rb_raise(rb_eArgError, message.str().c_str(), rb_class2name(klass), identifier.c_str(), natives.size());
+          }
+        }
+      }
+
+      // Call the C++ function
+      return (*native)(argc, argv, self);
+    });
+  }
+}