rice2 2.2.0

data/rice/detail/method_data.cpp

@@ -0,0 +1,92 @@
+#include "method_data.hpp"
+#include "ruby.hpp"
+
+// TODO: This is silly, autoconf...
+#undef PACKAGE_NAME
+#undef PACKAGE_STRING
+#undef PACKAGE_TARNAME
+#undef PACKAGE_VERSION
+#include "../config.hpp"
+
+#define RICE_ID rb_intern("__rice__")
+
+VALUE
+Rice::detail::
+method_data()
+{
+  ID id;
+  VALUE klass;
+  if (!rb_frame_method_id_and_class(&id, &klass))
+  {
+    rb_raise(
+        rb_eRuntimeError,
+        "Cannot get method id and class for function");
+  }
+
+  if (rb_type(klass) == T_ICLASS) {
+    klass = rb_class_of(klass);
+  }
+
+  VALUE store = rb_ivar_get(klass, RICE_ID);
+  return (store == Qnil) ? Qnil : rb_ivar_get(store, id);
+}
+
+// Ruby 2.7 now includes a similarly named macro that uses templates to
+// pick the right overload for the underlying function. That doesn't work
+// for our cases because we are using this method dynamically and get a
+// compilation error otherwise. This removes the macro and lets us fall
+// back to the C-API underneath again.
+#undef rb_define_method_id
+
+// Define a method and attach data to it.
+// The method looks to ruby like a normal aliased CFUNC, with a modified
+// origin class.
+//
+// How this works:
+//
+// To store method data and have it registered with the GC, we need a
+// "slot" to put it in.  This "slot" must be recognized and marked by
+// the garbage collector.  There happens to be such a place we can put
+// data, and it has to do with aliased methods.  When Ruby creates an
+// alias for a method, it stores a reference to the original class in
+// the method entry.  The form of the method entry differs from ruby
+// version to ruby version, but the concept is the same across all of
+// them.
+// 
+// In Rice, we make use of this by attach the data to a dummy object 
+// (store) in the class variables table.
+// 
+// When Ruby makes a method call, it stores the class Object and method
+// ID in the current stack frame.  When Ruby calls into Rice, we grab
+// the class and method ID from the stack frame, then pull the data out
+// of the class. The data item is then used to determine how to convert
+// arguments and return type, how to handle exceptions, etc.
+//
+VALUE
+Rice::detail::
+define_method_with_data(
+    VALUE klass, ID id, VALUE (*cfunc)(ANYARGS), int arity, VALUE data)
+{
+  VALUE store = rb_attr_get(klass, RICE_ID);
+
+  if (store == Qnil) {
+    store = rb_obj_alloc(rb_cObject);
+    // store is stored in the instance variables table with
+    // name "__rice__".
+    // since "__rice__" does not have the @ prefix,
+    // so it can never be read at the Ruby level.
+    rb_ivar_set(klass, RICE_ID, store);
+  }
+
+  rb_ivar_set(store, id, data);
+
+  // Create the aliased method on the origin class
+  rb_define_method_id(
+      klass,
+      id,
+      cfunc,
+      arity);
+
+  return Qnil;
+}
+

data/rice/detail/method_data.hpp

@@ -0,0 +1,21 @@
+#ifndef Rice__detail__method_data__hpp
+#define Rice__detail__method_data__hpp
+
+#include "ruby.hpp"
+
+namespace Rice
+{
+
+namespace detail
+{
+
+VALUE define_method_with_data(
+    VALUE klass, ID id, VALUE (*cfunc)(ANYARGS), int arity, VALUE data);
+
+VALUE method_data();
+
+} // namespace detail
+
+} // namespace Rice
+
+#endif // Rice__detail__method_data__hpp

data/rice/detail/node.hpp

@@ -0,0 +1,13 @@
+#ifndef Rice__detail__node__hpp_
+#define Rice__detail__node__hpp_
+
+/**
+ * Helper header for the node.h ruby include file, which does
+ * not have extern "C"
+ */
+
+extern "C" {
+  #include "node.h"
+}
+
+#endif

data/rice/detail/protect.cpp

@@ -0,0 +1,29 @@
+#include "protect.hpp"
+#include "../Exception.hpp"
+#include "../Jump_Tag.hpp"
+
+#ifndef TAG_RAISE
+#define TAG_RAISE 0x6
+#endif
+
+VALUE Rice::detail::
+protect(
+    RUBY_VALUE_FUNC f,
+    VALUE arg)
+{
+  int state = 0;
+  VALUE retval = rb_protect(f, arg, &state);
+  if(state != 0)
+  {
+    VALUE err = rb_errinfo();
+    if(state == TAG_RAISE && RTEST(err))
+    {
+      // TODO: convert NoMemoryError into bad_alloc?
+      rb_set_errinfo(Rice::Nil);
+      throw Rice::Exception(err);
+    }
+    throw Jump_Tag(state);
+  }
+  return retval;
+}
+

data/rice/detail/protect.hpp

@@ -0,0 +1,34 @@
+#ifndef Rice__detail__protect__hpp_
+#define Rice__detail__protect__hpp_
+
+#include "ruby.hpp"
+
+/*! \file
+ *  \brief Functions for making exception-safe calls into Ruby code.
+ *  These are the building blocks for building other exception-safe
+ *  helper functions.
+ */
+
+namespace Rice
+{
+
+namespace detail
+{
+
+//! Call the given function, converting Ruby exceptions to C++
+//! exceptions.
+/*! Call the function f with the parameter arg  If f raises a Ruby
+ * exception, then the exception is re-thrown as an Exception.  If f
+ * exits with any other non-zero tag (e.g. a Symbol is thrown), then the
+ * tag is re-thrown as a Jump_Tag.
+ */
+VALUE protect(
+    RUBY_VALUE_FUNC f,
+    VALUE arg);
+
+} // namespace detail
+
+} // namespace Rice
+
+#endif // Rice__detail__protect__hpp_
+

data/rice/detail/ruby.hpp

@@ -0,0 +1,74 @@
+#ifndef Rice__detail__ruby__hpp_
+#define Rice__detail__ruby__hpp_
+
+/*! \file
+ * \brief Hacks for addressing incompatibilities between various Ruby
+ * versions.
+ */
+
+#include <cmath>
+
+// missing.h that comes with the one-click installer doesn't properly
+// check for double-definition of isinf
+#ifdef isinf
+#define HAVE_ISINF
+#endif
+
+#include "ruby_version_code.hpp"
+#include "../config.hpp"
+
+#include <ruby.h>
+
+#ifdef WIN32
+#include "win32.hpp"
+#endif
+
+// This causes problems with certain C++ libraries
+#undef TYPE
+
+//! A function that takes a VALUE as a parameter and returns a VALUE.
+// TODO: Casting from a C++ function to an extern "C" function won't
+// work on all platforms.  I'm not sure what to do about this.
+extern "C" typedef VALUE (*RUBY_VALUE_FUNC)(VALUE);
+
+// Fix Ruby RUBY_METHOD_FUNC from macro to typedef
+#if defined(RUBY_METHOD_FUNC)
+# undef RUBY_METHOD_FUNC
+  extern "C" typedef VALUE (*RUBY_METHOD_FUNC)(ANYARGS);
+#endif
+
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(str) RSTRING(str)->len
+#endif
+
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(str) RSTRING(str)->ptr
+#endif
+
+#ifndef RARRAY_LEN
+#define RARRAY_LEN(arr) RARRAY(arr)->len
+#endif
+
+#ifndef RARRAY_PTR
+#define RARRAY_PTR(arr) RARRAY(arr)->ptr
+#endif
+
+#ifndef RHASH_TBL
+#define RHASH_TBL(hsh) RHASH(hsh)->tbl
+#endif
+
+#ifndef RCLASS_M_TBL
+#define RCLASS_M_TBL(c) RCLASS(c)->m_tbl
+#endif
+
+// ruby.h has a few defines that conflict with Visual Studio's STL
+#if defined(_MSC_VER)
+  #undef write
+  #undef read
+  #undef bind
+#endif
+
+#define std_unique_ptr std::unique_ptr
+
+#endif // Rice__detail__ruby__hpp_
+

data/rice/detail/ruby_version_code.hpp

@@ -0,0 +1,6 @@
+#ifndef Rice__detail__ruby_version_code__hpp
+#define Rice__detail__ruby_version_code__hpp
+
+#define RICE__RUBY_VERSION_CODE 265
+
+#endif // Rice__detail__ruby_version_code__hpp

data/rice/detail/ruby_version_code.hpp.in

@@ -0,0 +1,6 @@
+#ifndef Rice__detail__ruby_version_code__hpp
+#define Rice__detail__ruby_version_code__hpp
+
+#define RICE__RUBY_VERSION_CODE @RUBY_VERSION_CODE@
+
+#endif // Rice__detail__ruby_version_code__hpp

data/rice/detail/st.hpp

@@ -0,0 +1,22 @@
+#ifndef Exc_Ruby___cpp__st__hpp_
+#define Exc_Ruby___cpp__st__hpp_
+
+/*! \file
+ * \brief Hacks to allow functions in st.h to be called from C++
+ * programs.
+ */
+
+#include "ruby.hpp"
+
+// Ruby doesn't put extern "C" around st.h
+
+extern "C"
+{
+#ifdef RUBY_VM
+#include "ruby/st.h"
+#else
+#include "st.h"
+#endif
+}
+
+#endif // Exc_Ruby___cpp__st__hpp_

data/rice/detail/to_ruby.hpp

@@ -0,0 +1,22 @@
+#ifndef Rice__detail__to_ruby__hpp_
+#define Rice__detail__to_ruby__hpp_
+
+namespace Rice
+{
+  namespace detail
+  {
+    template<typename T>
+    struct to_ruby_
+    {
+      static Rice::Object convert(T const & x);
+    };
+
+    template<typename T>
+    struct to_ruby_<T *>
+    {
+      static Rice::Object convert(T * x);
+    };
+  } // detail
+} // Rice
+
+#endif // Rice__detail__to_ruby__hpp_

data/rice/detail/to_ruby.ipp

@@ -0,0 +1,36 @@
+#include "../Data_Object.hpp"
+
+template<typename T>
+Rice::Object
+Rice::detail::to_ruby_<T>::
+convert(T const & x)
+{
+  if(Data_Type<T>::is_bound())
+  {
+    return Rice::Data_Object<T >(new T(x), Rice::Data_Type<T >::klass());
+  }
+  else
+  {
+    std::string s("Unable to convert ");
+    s += demangle(typeid(T *).name());
+    throw std::invalid_argument(s.c_str());
+  }
+}   
+
+template<typename T>
+Rice::Object
+Rice::detail::to_ruby_<T *>::
+convert(T * x)
+{
+  if(Data_Type<T>::is_bound())
+  {
+    Data_Object<T> obj(x);
+    return obj;
+  }
+  else
+  {
+    std::string s("Unable to convert ");
+    s += demangle(typeid(T *).name());
+    throw std::invalid_argument(s.c_str());
+  }
+}

data/rice/detail/traits.hpp

@@ -0,0 +1,43 @@
+#ifndef Rice__detail__traits__hpp_
+#define Rice__detail__traits__hpp_
+
+namespace Rice
+{
+namespace detail
+{
+
+/**
+ * Remove const from a type
+ */
+template<typename T>
+struct remove_const { typedef T Type; };
+
+template<typename T>
+struct remove_const<const T> { typedef T Type; };
+
+/**
+ * Remove a reference from a type
+ */
+template<typename T>
+struct remove_ref { typedef T Type; };
+
+template<typename T>
+struct remove_ref<T &> { typedef T Type; };
+
+/**
+ * Do both of the above in one easy step
+ */
+template<typename T>
+struct sanitize
+{
+  typedef T Type;
+  //typedef typename remove_const< 
+    //typename remove_ref<T>::Type 
+    //>::Type Type;
+};
+
+}
+}
+
+
+#endif // Rice__detail__traits__hpp_

data/rice/detail/win32.hpp

@@ -0,0 +1,16 @@
+#ifndef Rice__detail__win32__hpp_
+#define Rice__detail__win32__hpp_
+
+/*! \file
+ * \brief Undefine all the evil macros that are defined in win32.h
+ */
+
+// None of these macros are used in Ruby header files
+#undef bind
+#undef read
+#undef write
+#undef send
+#undef recv
+#undef times
+
+#endif // Rice__detail__win32__hpp_

data/rice/detail/wrap_function.hpp

@@ -0,0 +1,66 @@
+#ifndef Rice__detail__wrap_function__hpp_
+#define Rice__detail__wrap_function__hpp_
+
+// This causes problems with certain C++ libraries
+#undef TYPE
+
+#include "Exception_Handler.hpp"
+#include "Wrapped_Function.hpp"
+#include "../Object_defn.hpp"
+#include "../Data_Object.hpp"
+#include "Arguments.hpp"
+#include "Auto_Function_Wrapper.hpp"
+#include "Auto_Member_Function_Wrapper.hpp"
+
+namespace Rice
+{
+
+namespace detail
+{
+
+template<typename Ret_T>
+Wrapped_Function * wrap_function(
+    Ret_T (*func)(),
+    Data_Object<Exception_Handler> handler,
+    Arguments* arguments)
+{
+  typedef Ret_T (*Func)();
+  return new Auto_Function_Wrapper<Func, Ret_T>(func, handler, arguments);
+}
+
+template<typename Ret_T, typename ...Arg_T>
+Wrapped_Function * wrap_function(
+    Ret_T (*func)(Arg_T...),
+    Data_Object<Exception_Handler> handler,
+    Arguments* arguments)
+{
+  typedef Ret_T (*Func)(Arg_T...);
+  return new Auto_Function_Wrapper<Func, Ret_T, Arg_T...>(func, handler, arguments);
+}
+
+template<typename Ret_T, typename Self_T, typename ...Arg_T>
+Wrapped_Function * wrap_function(
+    Ret_T (Self_T::*func)(Arg_T...),
+    Data_Object<Exception_Handler> handler,
+    Arguments* arguments)
+{
+  typedef Ret_T (Self_T::*Func)(Arg_T...);
+  return new Auto_Member_Function_Wrapper<Func, Ret_T, Self_T, Arg_T...>(func, handler, arguments);
+}
+
+template<typename Ret_T, typename Self_T, typename ...Arg_T>
+Wrapped_Function * wrap_function(
+    Ret_T (Self_T::*func)(Arg_T...) const,
+    Data_Object<Exception_Handler> handler,
+    Arguments* arguments)
+{
+  typedef Ret_T (Self_T::*Func)(Arg_T...) const;
+  return new Auto_Member_Function_Wrapper<Func, Ret_T, Self_T, Arg_T...>(func, handler, arguments);
+}
+
+} // namespace detail
+
+} // namespace Rice
+
+#endif // Rice__detail__wrap_function__hpp_
+