rice 4.3.3 → 4.6.0

data/rice/Enum.ipp

@@ -1,7 +1,3 @@
-#include "detail/TypeRegistry.hpp"
-#include "Data_Object.hpp"
-#include "cpp_api/String.hpp"
-
 #include <stdexcept>
 
 namespace Rice
@@ -32,57 +28,72 @@ namespace Rice
     // First we need a constructor
     klass.define_constructor(Constructor<Enum_T>());
 
-    // Instance methods
-    klass.define_method("to_s", [](Enum_T& self)
-        {
-          // We have to return string because we don't know if std::string support has
-          // been included by the user
-          return String(valuesToNames_[self]);
-        })
-      .define_method("to_i", [](Enum_T& self) ->  Underlying_T
-        {
-          return (Underlying_T)self;
-        })
+    klass.define_method("to_s", [](Enum_T& self) -> String
+      {
+        return String(valuesToNames_[self]);
+      })
+      .define_method("to_int", [](Enum_T& self) ->  Underlying_T
+      {
+        return (Underlying_T)(self);
+      })
+      .define_method("coerce", [](Enum_T& self, Underlying_T& other) -> Array
+      {
+        /* Other will be a numeric value that matches the underlying type of the enum, for example an int.
+           Convert that to the enum type and then create new Ruby object to wrap it. This then enables code
+           like this:
+        
+           Colors::Red | Colors:Blue | Colors:Green
+
+        Colors::Red | Colors:Blue returns an integer. Then this method converts the integer back into an Enum
+        instance so that Colors:Blue | Colors:Green works. */
+        Enum_T otherEnum = (Enum_T)other;
+
+        Array result;
+        result.push(self);
+        result.push(otherEnum);
+        return result;
+      })
       .define_method("inspect", [](Enum_T& self)
-        {
-          std::stringstream result;
-          VALUE rubyKlass = Enum<Enum_T>::klass().value();
-          result << "#<" << detail::protect(rb_class2name, rubyKlass)
-            << "::" << Enum<Enum_T>::valuesToNames_[self] << ">";
-
-          // We have to return string because we don't know if std::string support has
-          // been included by the user
-          return String(result.str());
-        })
+      {
+        std::stringstream result;
+        VALUE rubyKlass = Enum<Enum_T>::klass().value();
+        result << "#<" << detail::protect(rb_class2name, rubyKlass)
+          << "::" << Enum<Enum_T>::valuesToNames_[self] << ">";
+
+        // We have to return string because we don't know if std::string support has
+        // been included by the user
+        return String(result.str());
+      })
       .define_method("hash", [](Enum_T& self) ->  Underlying_T
-        {
-          return (Underlying_T)self;
-        })
+      {
+        return (Underlying_T)self;
+      })
       .define_method("eql?", [](Enum_T& self, Enum_T& other)
-        {
-          return self == other;
-        });
+      {
+        return self == other;
+    });
 
     // Add aliases
     rb_define_alias(klass, "===", "eql?");
+    rb_define_alias(klass, "to_i", "to_int");
 
     // Add comparable support
     klass.include_module(rb_mComparable)
       .define_method("<=>", [](Enum_T& self, Enum_T& other)
-    {
-      if (self == other)
-      {
-        return 0;
-      }
-      else if (self < other)
       {
-        return -1;
-      }
-      else
-      {
-        return 1;
-      }
-    });
+        if (self == other)
+        {
+          return 0;
+        }
+        else if (self < other)
+        {
+          return -1;
+        }
+        else
+        {
+          return 1;
+        }
+      });
 
     // Add enumerable support
     klass.include_module(rb_mEnumerable)
@@ -91,7 +102,7 @@ namespace Rice
           if (!rb_block_given_p())
           {
             return rb_enumeratorize_with_size(ruby_klass, Identifier("each").to_sym(),
-                                      0, nullptr, 0);
+              0, nullptr, 0);
           }
 
           for (auto& pair : valuesToNames_)
@@ -102,22 +113,58 @@ namespace Rice
           }
 
           return ruby_klass;
-      }, Return().setValue())
-      .define_singleton_method("from_int", [](VALUE ruby_klass, int32_t value) -> Object
+        }, Return().setValue());
+
+    // Add bitwise operators
+    klass.define_method("&", [](Enum_T& self, Enum_T& other) -> Underlying_T
       {
-          auto iter = Enum<Enum_T>::valuesToNames_.find((Enum_T)value);
-          if (iter == Enum<Enum_T>::valuesToNames_.end())
-          {
-            throw std::runtime_error("Unknown enum value: " + std::to_string(value));
-          }
+        return (Underlying_T)self & (Underlying_T)other;
+      })
+      .define_method("|", [](Enum_T& self, Enum_T& other) -> Underlying_T
+      {
+        return (Underlying_T)self | (Underlying_T)other;
+      })
+      .define_method("^", [](Enum_T& self, Enum_T& other) -> Underlying_T
+      {
+        return (Underlying_T)self ^ (Underlying_T)other;
+      })
+      .define_method("~", [](Enum_T& self) -> Underlying_T
+      {
+        return ~(Underlying_T)self;
+      });
 
-          std::string name = iter->second;
-          return Object(ruby_klass).const_get(name);
+    // Add shift operators
+    klass.define_method("<<", [](Enum_T& self, int shift) -> Underlying_T
+      {
+        return (Underlying_T)self << shift;
+      })
+      .define_method(">>", [](Enum_T& self, int shift) -> Underlying_T
+      {
+        return (Underlying_T)self >> shift;
       });
+
+    // Add conversions from int
+    klass.define_singleton_method("from_int", [](VALUE ruby_klass, int32_t value) -> Object
+      {
+        auto iter = Enum<Enum_T>::valuesToNames_.find((Enum_T)value);
+        if (iter == Enum<Enum_T>::valuesToNames_.end())
+        {
+          throw std::runtime_error("Unknown enum value: " + std::to_string(value));
+        }
+
+        std::string name = iter->second;
+        return Object(ruby_klass).const_get(name);
+      });
+  }
+
+  template<typename Enum_T>
+  Enum<Enum_T> define_enum(char const* name)
+  {
+    return define_enum_under<Enum_T>(name, rb_cObject);
   }
 
   template<typename Enum_T>
-  Enum<Enum_T> define_enum(char const* name, Module module)
+  Enum<Enum_T> define_enum_under(char const* name, Module module)
   {
     if (detail::Registries::instance.types.isDefined<Enum_T>())
     {

data/rice/Exception.hpp

@@ -1,7 +1,67 @@
 #ifndef Rice__Exception__hpp_
 #define Rice__Exception__hpp_
 
-#include "Exception_defn.hpp"
-#include "Exception.ipp"
+#include <stdexcept>
+
+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);
+
+    //! 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.
+    /*! \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 VALUE exceptionType, char const* fmt, Arg_Ts&&...args);
+
+    //! Destructor
+    virtual ~Exception() noexcept = default;
+
+    //! 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;
+
+    //! Returns the Ruby exception class
+    VALUE class_of() const;
+
+    //! 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__hpp_

data/rice/Exception.ipp

@@ -1,7 +1,3 @@
-#ifndef Rice__Exception__ipp_
-#define Rice__Exception__ipp_
-
-#include "detail/from_ruby.hpp"
 
 namespace Rice
 {
@@ -18,10 +14,10 @@ namespace Rice
   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
+    #if defined(__GNUC__) || defined(__clang__)
+    #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');
@@ -31,9 +27,9 @@ namespace Rice
     // 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
+    #if defined(__GNUC__) || defined(__clang__)
+    #pragma GCC diagnostic pop
+    #endif
 
     // Now create the Ruby exception
     this->exception_ = detail::protect(rb_exc_new2, exceptionClass, this->message_.c_str());
@@ -61,4 +57,3 @@ namespace Rice
     return this->exception_;
   }
 }
-#endif // Rice__Exception__ipp_

data/rice/Init.hpp

@@ -0,0 +1,8 @@
+#ifndef Rice__Init__hpp_
+#define Rice__Init__hpp_
+
+namespace Rice
+{
+  void init();
+}
+#endif // Rice__Init__hpp_

data/rice/Init.ipp

@@ -0,0 +1,8 @@
+namespace Rice
+{
+  inline void init()
+  {
+    detail::define_ruby_types();
+    define_fundamental_buffer_types();
+  };
+}

data/rice/JumpException.hpp

@@ -0,0 +1,44 @@
+#ifndef Rice__JumpException__hpp_
+#define Rice__JumpException__hpp_
+
+namespace Rice
+{
+  //! A placeholder for Ruby longjmp data.
+  /*! When a Ruby exception is caught, the tag used for the longjmp is stored in
+   *  a Jump_Tag, then later passed to rb_jump_tag() when there is no more
+   *  C++ code to pass over.
+   */
+  class JumpException : public std::exception
+  {
+  public:
+    // Copied from vm_core.h
+    enum ruby_tag_type {
+      RUBY_TAG_NONE = 0x0,
+      RUBY_TAG_RETURN = 0x1,
+      RUBY_TAG_BREAK = 0x2,
+      RUBY_TAG_NEXT = 0x3,
+      RUBY_TAG_RETRY = 0x4,
+      RUBY_TAG_REDO = 0x5,
+      RUBY_TAG_RAISE = 0x6,
+      RUBY_TAG_THROW = 0x7,
+      RUBY_TAG_FATAL = 0x8,
+      RUBY_TAG_MASK = 0xf
+    };
+
+  public:
+    JumpException(ruby_tag_type tag);
+    virtual const char* what() const noexcept override;
+
+  public:
+    //! The tag being held.
+    ruby_tag_type tag;
+
+  private:
+    void createMessage();
+
+  private:
+    std::string message_;
+  };
+} // namespace Rice
+
+#endif // Rice__JumpException__hpp_

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,3 @@
+namespace Rice
+{
+}

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;
-
-    //! 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;
+    Return();
+    Return& keepAlive() override;
+    Return& setValue() override;
+    Return& setOpaque() override;
+    Return& takeOwnership() override;
+    Return& setArray() override;
   };
 } // Rice
 
-#include "Return.ipp"
-
 #endif // Rice__Return__hpp_

data/rice/Return.ipp

@@ -1,38 +1,38 @@
 #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
+  inline Return& Return::setOpaque()
   {
-    return this->isValue_;
+    Arg::setOpaque();
+    return *this;
   }
 
-  inline Return& Return::keepAlive()
+  inline Return& Return::takeOwnership()
   {
-    this->isKeepAlive_ = true;
+    Arg::takeOwnership();
     return *this;
   }
 
-  inline bool Return::isKeepAlive() const
+  inline Return& Return::setArray()
   {
-    return this->isKeepAlive_;
+    Arg::setArray();
+    return *this;
   }
 }  // Rice