rice 3.0.0 → 4.0.0

data/rice/Exception.hpp

@@ -1,13 +1,7 @@
 #ifndef Rice__Exception__hpp_
 #define Rice__Exception__hpp_
 
-namespace Rice {
-  class Exception;
-}
-
 #include "Exception_defn.hpp"
-#include "Exception_Base.hpp"
-#include "Address_Registration_Guard.hpp"
-
-#endif // Rice__Exception__hpp_
+#include "Exception.ipp"
 
+#endif // Rice__Exception__hpp_

data/rice/Exception.ipp

@@ -0,0 +1,65 @@
+#ifndef Rice__Exception__ipp_
+#define Rice__Exception__ipp_
+
+#include "detail/from_ruby.hpp"
+
+namespace Rice
+{
+  inline Exception::Exception(VALUE exception) : exception_(exception)
+  {
+  }
+
+  template <typename... Arg_Ts>
+  inline Exception::Exception(const Exception& other, char const* fmt, Arg_Ts&&...args)
+    : Exception(other.class_of(), fmt, std::forward<Arg_Ts>(args)...)
+  {
+  }
+
+  template <typename... Arg_Ts>
+  inline Exception::Exception(const VALUE exceptionClass, char const* fmt, Arg_Ts&&...args)
+  {
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wformat-security"
+#endif
+
+    size_t size = std::snprintf(nullptr, 0, fmt, std::forward<Arg_Ts>(args)...);
+    this->message_ = std::string(size, '\0');
+
+    // size+1 avoids truncating the string. Otherwise snprintf writes n - 1 characters
+    // to allow space for null character but we don't need that since std::string
+    // will add a null character internally at n + 1
+    std::snprintf(&this->message_[0], size + 1, fmt, std::forward<Arg_Ts>(args)...);
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
+    // Now create the Ruby exception
+    this->exception_ = detail::protect(rb_exc_new2, exceptionClass, this->message_.c_str());
+  }
+
+  inline char const* Exception::what() const noexcept
+  {
+    if (this->message_.empty())
+    {
+      // Cache the message - this allows the returned pointer to be valid for the
+      // lifetime of this exception instance.
+      VALUE rubyMessage = rb_funcall(this->exception_, rb_intern("message"), 0);
+      //this->message_ = detail::From_Ruby<std::string>::convert(rubyMessage);
+      this->message_ = std::string(RSTRING_PTR(rubyMessage), RSTRING_LEN(rubyMessage));
+    }
+    return this->message_.c_str();
+  }
+
+  inline VALUE Exception::class_of() const
+  {
+    return detail::protect(rb_class_of, this->exception_);
+  }
+
+  inline VALUE Exception::value() const
+  {
+    return this->exception_;
+  }
+}
+#endif // Rice__Exception__ipp_

data/rice/Exception_defn.hpp

@@ -1,69 +1,68 @@
 #ifndef Rice__Exception_defn__hpp_
 #define Rice__Exception_defn__hpp_
 
-#include "Exception_Base_defn.hpp"
-#include "String.hpp"
-#include "Address_Registration_Guard_defn.hpp"
-
 #include <stdexcept>
 #include "detail/ruby.hpp"
 
 namespace Rice
 {
+  //! A placeholder for Ruby exceptions.
+  /*! You can use this to safely throw a Ruby exception using C++ syntax:
+   *  \code
+   *    VALUE foo(VALUE self) {
+   *      RUBY_TRY {
+   *        throw Rice::Exception(rb_eMyException, "uh oh!");
+   *      RUBY_CATCH
+   *    }
+   *  \endcode
+   */
+  class Exception
+    : public std::exception
+  {
+  public:
+    //! Construct a Exception with a Ruby exception instance
+    explicit Exception(VALUE exception);
 
-//! A placeholder for Ruby exceptions.
-/*! You can use this to safely throw a Ruby exception using C++ syntax:
- *  \code
- *    VALUE foo(VALUE self) {
- *      RUBY_TRY {
- *        throw Rice::Exception(rb_eMyException, "uh oh!");
- *      RUBY_CATCH
- *    }
- *  \endcode
- */
-class Exception
-  : public Exception_Base
-{
-public:
-  //! Construct a Exception with the exception e.
-  explicit Exception(VALUE e);
-
-  //! Copy constructor.
-  Exception(Exception const & other);
+    //! Construct a Exception with printf-style formatting.
+    /*! \param exc either an exception object or a class that inherits
+     *  from Exception.
+     *  \param fmt a printf-style format string
+     *  \param ... the arguments to the format string.
+     */
+    template <typename... Arg_Ts>
+    Exception(const Exception& other, char const* fmt, Arg_Ts&&...args);
 
-  //! Construct a Exception with printf-style formatting.
+    //! Construct a Exception with printf-style formatting.
   /*! \param exc either an exception object or a class that inherits
    *  from Exception.
    *  \param fmt a printf-style format string
    *  \param ... the arguments to the format string.
    */
-  Exception(Object exc, char const * fmt, ...);
+    template <typename... Arg_Ts>
+    Exception(const VALUE exceptionType, char const* fmt, Arg_Ts&&...args);
 
-  //! Destructor
-  virtual ~Exception() throw() { }
+    //! Destructor
+    virtual ~Exception() noexcept = default;
 
-  //! Get the message the exception holds
-  /*! \return the result of calling message() on the underlying
-   *  exception object.
-   */
-  String message() const;
+    //! Get message as a char const *.
+    /*! If message is a non-string object, then this function will attempt
+     *  to throw an exception (which it can't do because of the no-throw
+     *  specification).
+     *  \return the underlying C pointer of the underlying message object.
+     */
+    virtual char const* what() const noexcept override;
 
-  //! Get message as a char const *.
-  /*! If message is a non-string object, then this function will attempt
-   *  to throw an exception (which it can't do because of the no-throw
-   *  specification).
-   *  \return the underlying C pointer of the underlying message object.
-   */
-  virtual char const * what() const throw();
+    //! Returns the Ruby exception class
+    VALUE class_of() const;
 
-private:
-  // Keep message around in case someone calls what() and then the GC
-  // gets invoked.
-  mutable VALUE message_;
-  Address_Registration_Guard message_guard_;
-};
+    //! Returns an instance of a Ruby exception
+    VALUE value() const;
 
+  private:
+    // TODO: Do we need to tell the Ruby gc about an exception instance?
+    mutable VALUE exception_ = Qnil;
+    mutable std::string message_;
+  };
 } // namespace Rice
 
-#endif // Rice__Exception_defn__hpp_
-
+#endif // Rice__Exception_defn__hpp_

data/rice/Identifier.hpp

@@ -1,48 +1,48 @@
 #ifndef Rice__Identifier__hpp_
 #define Rice__Identifier__hpp_
 
-#include "detail/ruby.hpp"
 #include <string>
 
 namespace Rice
 {
+  class Symbol;
 
-class Symbol;
+  //! A wrapper for the ID type
+  /*! An ID is ruby's internal representation of a Symbol object.
+   */
+  class Identifier
+  {
+  public:
+    //! Construct a new Identifier from an ID.
+    Identifier(ID id);
 
-//! A wrapper for the ID type
-/*! An ID is ruby's internal representation of a Symbol object.
- */
-class Identifier
-{
-public:
-  //! Construct a new Identifier from an ID.
-  Identifier(ID id);
-
-  //! Construct a new Identifier from a Symbol.
-  Identifier(Symbol const & symbol);
+    //! Construct a new Identifier from a Symbol.
+    Identifier(Symbol const& symbol);
 
-  //! Construct a new Identifier from a string.
-  Identifier(char const * s = "");
+    //! Construct a new Identifier from a c string.
+    Identifier(char const* s);
 
-  //! Return a string representation of the Identifier.
-  char const * c_str() const;
+    //! Construct a new Identifier from a string.
+    Identifier(std::string const string);
 
-  //! Return a string representation of the Identifier.
-  std::string str() const;
+    //! Return a string representation of the Identifier.
+    char const* c_str() const;
 
-  //! Return the underlying ID
-  ID id() const { return id_; }
+    //! Return a string representation of the Identifier.
+    std::string str() const;
 
-  //! Return the underlying ID
-  operator ID() const { return id_; }
+    //! Return the underlying ID
+    ID id() const { return id_; }
 
-  //! Return the ID as a Symbol
-  VALUE to_sym() const;
+    //! Return the underlying ID
+    operator ID() const { return id_; }
 
-private:
-  ID id_;
-};
+    //! Return the ID as a Symbol
+    VALUE to_sym() const;
 
+  private:
+    ID id_;
+  };
 } // namespace Rice
 
 #include "Identifier.ipp"

data/rice/Identifier.ipp

@@ -1,33 +1,29 @@
-inline Rice::Identifier::
-Identifier(ID id)
-  : id_(id)
+namespace Rice
 {
-}
+  inline Identifier::Identifier(ID id) : id_(id)
+  {
+  }
 
-inline Rice::Identifier::
-Identifier(char const * s)
-  : id_(rb_intern(s))
-{
-}
+  inline Identifier::Identifier(char const* s) : id_(rb_intern(s))
+  {
+  }
 
-inline char const *
-Rice::Identifier::
-c_str() const
-{
-  return rb_id2name(id_);
-}
+  inline Identifier::Identifier(std::string const s) : id_(rb_intern(s.c_str()))
+  {
+  }
 
-inline std::string
-Rice::Identifier::
-str() const
-{
-  return c_str();
-}
+  inline char const* Identifier::c_str() const
+  {
+    return detail::protect(rb_id2name, id_);
+  }
 
-inline VALUE
-Rice::Identifier::
-to_sym() const
-{
-  return ID2SYM(id_);
-}
+  inline std::string Identifier::str() const
+  {
+    return c_str();
+  }
 
+  inline VALUE Identifier::to_sym() const
+  {
+    return ID2SYM(id_);
+  }
+}

data/rice/Return.hpp

@@ -0,0 +1,39 @@
+#ifndef Rice__Return__hpp_
+#define Rice__Return__hpp_
+
+#include <any>
+
+namespace Rice
+{
+  //! Helper for defining Return argument of a method
+
+  class Return
+  {
+  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& isValue();
+
+    //! Is the returned value a Ruby value?
+    bool getIsValue();
+
+    //! Tell the returned object to keep alive the receving object
+    Return& keepAlive();
+
+  public:
+    bool isKeepAlive = false;
+
+  private:
+    bool isOwner_ = false;
+    bool isValue_ = false;
+  };
+} // Rice
+
+#include "Return.ipp"
+
+#endif // Rice__Return__hpp_

data/rice/Return.ipp

@@ -0,0 +1,33 @@
+#include <any>
+#include <string>
+
+namespace Rice
+{
+  inline Return& Return::takeOwnership()
+  {
+    this->isOwner_ = true;
+    return *this;
+  }
+
+  inline bool Return::isOwner()
+  {
+    return this->isOwner_;
+  }
+
+  inline Return& Return::isValue()
+  {
+    this->isValue_ = true;
+    return *this;
+  }
+
+  inline bool Return::getIsValue()
+  {
+    return this->isValue_;
+  }
+
+  inline Return& Return::keepAlive()
+  {
+    this->isKeepAlive = true;
+    return *this;
+  }
+}  // Rice

data/rice/detail/Exception_Handler.ipp

@@ -1,68 +1,28 @@
-#include "../Data_Type_defn.hpp"
-
-inline
-Rice::detail::Exception_Handler::
-Exception_Handler(
-    Data_Object<Exception_Handler> next_exception_handler)
-  : next_exception_handler_(next_exception_handler)
-  , next_exception_handler_guard_(&next_exception_handler_)
-{
-}
-
-inline
-Rice::detail::Exception_Handler::
-~Exception_Handler()
-{
-}
-
-inline
-VALUE
-Rice::detail::Exception_Handler::
-call_next_exception_handler() const
-{
-  return next_exception_handler_->handle_exception();
-}
-
-inline Rice::detail::Default_Exception_Handler::
-Default_Exception_Handler()
-  : Exception_Handler(
-      Data_Object<Exception_Handler>(0, rb_cObject))
-{
-}
-
-inline
-VALUE
-Rice::detail::Default_Exception_Handler::
-handle_exception() const
+namespace Rice::detail
 {
-  throw;
-}
-
-template <typename Exception_T, typename Functor_T>
-inline
-Rice::detail::Functor_Exception_Handler<Exception_T, Functor_T>::
-Functor_Exception_Handler(
-    Functor_T handler,
-    Data_Object<Exception_Handler> next_exception_handler)
-  : Exception_Handler(next_exception_handler)
-  , handler_(handler)
-{
-}
-
-template <typename Exception_T, typename Functor_T>
-inline
-VALUE
-Rice::detail::Functor_Exception_Handler<Exception_T, Functor_T>::
-handle_exception() const
-{
-  try
+  inline VALUE Rice::detail::Default_Exception_Handler::handle_exception() const
   {
-    return call_next_exception_handler();
+    throw;
   }
-  catch(Exception_T const & ex)
+
+  template <typename Exception_T, typename Functor_T>
+  inline Rice::detail::Functor_Exception_Handler<Exception_T, Functor_T>::
+    Functor_Exception_Handler(Functor_T handler, std::shared_ptr<Exception_Handler> next_exception_handler)
+    : handler_(handler), next_exception_handler_(next_exception_handler)
   {
-    handler_(ex);
-    throw;
   }
-}
 
+  template <typename Exception_T, typename Functor_T>
+  inline VALUE Rice::detail::Functor_Exception_Handler<Exception_T, Functor_T>::handle_exception() const
+  {
+    try
+    {
+      return this->next_exception_handler_->handle_exception();
+    }
+    catch (Exception_T const& ex)
+    {
+      handler_(ex);
+      throw;
+    }
+  }
+}