rice2 2.2.0

data/rice/detail/cfp.ipp

@@ -0,0 +1,51 @@
+namespace detail
+{
+
+struct rb_thread_struct
+{
+    VALUE self;
+    void *vm;
+    VALUE *stack;
+    unsigned long stack_size;
+    VALUE *cfp;
+    /* ... */
+};
+
+typedef struct rb_thread_struct rb_thread_t;
+
+} // namespace detail
+
+extern "C" detail::rb_thread_t * ruby_current_thread;
+
+inline
+VALUE *
+Rice::detail::
+cfp()
+{
+  return ruby_current_thread->cfp;
+}
+
+inline
+VALUE &
+Rice::detail::
+cfp_data_memo_node_and_pc(VALUE * cfp)
+{
+  return cfp[0];
+}
+
+inline
+VALUE &
+Rice::detail::
+cfp_self(VALUE * cfp)
+{
+  return cfp[5];
+}
+
+inline
+VALUE &
+Rice::detail::
+cfp_method_class(VALUE * cfp)
+{
+  return cfp[11];
+}
+

data/rice/detail/check_ruby_type.cpp

@@ -0,0 +1,27 @@
+#include "check_ruby_type.hpp"
+#include "../Exception.hpp"
+
+void Rice::detail::
+check_ruby_type(
+    VALUE value,
+    VALUE klass,
+    bool include_super
+    )
+{ 
+  if( !rb_obj_is_kind_of(value, klass) ||
+     (!include_super && rb_obj_class(value) != klass))
+  {
+    // Not sure why this stuff can't be chained
+    VALUE gotV = protect(rb_mod_name, rb_obj_class(value));
+    char* got = StringValuePtr(gotV);
+    VALUE exptV = protect(rb_mod_name, klass);
+    char* expected = StringValuePtr(exptV);
+
+    throw Exception(
+        rb_eTypeError,
+        "wrong argument type %s (expected %s)",
+        got, expected
+      );
+  }                                 
+}
+

data/rice/detail/check_ruby_type.hpp

@@ -0,0 +1,23 @@
+#ifndef Rice__detail__check_ruby_type__hpp_
+#define Rice__detail__check_ruby_type__hpp_
+
+#include "ruby.hpp"
+
+namespace Rice
+{
+
+namespace detail
+{
+
+// Throws an exception if the given object is not of type klass.
+void check_ruby_type(
+    VALUE value,
+    VALUE klass,
+    bool include_super);
+
+} // namespace detail
+
+} // namespace Rice
+
+#endif // Rice__detail__check_ruby_type__hpp_
+

data/rice/detail/creation_funcs.hpp

@@ -0,0 +1,37 @@
+#ifndef Rice__detail__creation_funcs__hpp_
+#define Rice__detail__creation_funcs__hpp_
+
+namespace Rice
+{
+
+class Class;
+
+namespace detail
+{
+
+//! Like define_alloc_func, but allows the user to define an
+//! "initialize" method too.
+template<typename Initialize_Func_T>
+void define_creation_funcs(
+    Class const & klass,
+    RUBY_VALUE_FUNC allocate_func,
+    Initialize_Func_T initialize_func);
+
+//! This is just the opposite of define_alloc_func.  It can be
+//! used to create a class that cannot be instantiated by the user.
+void undef_alloc_func(
+    Class const & klass);
+
+//! This is just the opposite of define_creation_func.  It can be
+//! used to create a class that cannot be instantiated by the user.
+void undef_creation_funcs(
+    Class const & klass);
+
+} // namespace detail
+
+} // namespace Rice
+
+#include "creation_funcs.ipp"
+
+#endif // Rice__detail__creation_funcs__hpp_
+

data/rice/detail/creation_funcs.ipp

@@ -0,0 +1,36 @@
+#ifndef Rice__detail__creation_funcs__ipp_
+#define Rice__detail__creation_funcs__ipp_
+
+namespace Rice
+{
+
+namespace detail
+{
+
+template<typename Initialize_Func_T>
+inline void define_creation_funcs(
+    Class const & klass,
+    RUBY_VALUE_FUNC allocate_func,
+    Initialize_Func_T initialize_func)
+{
+  rb_define_alloc_func(klass, allocate_func);
+  klass.define_method("initialize", initialize_func);
+}
+
+inline void undef_alloc_func(Class const & klass)
+{
+  rb_undef_alloc_func(klass);
+}
+
+inline void undef_creation_funcs(Class const & klass)
+{
+  undef_alloc_func(klass);
+  rb_undef_method(klass, "initialize");
+}
+
+} // namespace detail
+
+} // namespace Rice
+
+#endif // Rice__detail__creation_funcs__ipp_
+

data/rice/detail/default_allocation_func.hpp

@@ -0,0 +1,23 @@
+#ifndef Rice__detail__default_allocation_func__hpp_
+#define Rice__detail__default_allocation_func__hpp_
+
+namespace Rice
+{
+
+namespace detail
+{
+
+//! A default implementation of an allocate_func.  This function does no
+//! actual allocation; the initialize_func can later do the real
+//! allocation with: DATA_PTR(self) = new Type(arg1, arg2, ...)
+template<typename T>
+VALUE default_allocation_func(VALUE klass);
+
+} // detail
+
+} // Rice
+
+#include "default_allocation_func.ipp"
+
+#endif // Rice__detail__default_allocation_func__hpp_
+

data/rice/detail/default_allocation_func.ipp

@@ -0,0 +1,11 @@
+#include "../Data_Object.hpp"
+
+template<typename T>
+VALUE Rice::detail::
+default_allocation_func(VALUE klass)
+{
+  Data_Object<T> m(static_cast<T*>(0), klass);
+  return m.value();
+} 
+
+

data/rice/detail/define_method_and_auto_wrap.hpp

@@ -0,0 +1,31 @@
+#ifndef Rice__detail__define_method_and_auto_wrap__hpp_
+#define Rice__detail__define_method_and_auto_wrap__hpp_
+
+#include "ruby.hpp"
+#include "../Data_Object.hpp"
+#include "../Identifier.hpp"
+#include "Arguments.hpp"
+
+namespace Rice
+{
+
+namespace detail
+{
+
+class Exception_Handler;
+
+template<typename Fun_T>
+void define_method_and_auto_wrap(
+    VALUE klass,
+    Identifier name,
+    Fun_T function,
+    Data_Object<Exception_Handler> handler,
+    Arguments* arguments = 0);
+
+} // detail
+
+} // Rice
+
+#include "define_method_and_auto_wrap.ipp"
+
+#endif // Rice__detail__define_method_and_auto_wrap__hpp_

data/rice/detail/define_method_and_auto_wrap.ipp

@@ -0,0 +1,30 @@
+#ifndef Rice__detail__define_method_and_auto_wrap__ipp_
+#define Rice__detail__define_method_and_auto_wrap__ipp_
+
+#include "wrap_function.hpp"
+#include "method_data.hpp"
+#include "Exception_Handler_defn.hpp"
+#include "../protect.hpp"
+
+template<typename Fun_T>
+void Rice::detail::
+define_method_and_auto_wrap(
+    VALUE klass,
+    Identifier name,
+    Fun_T function,
+    Data_Object<Exception_Handler> handler,
+    Arguments* arguments)
+{
+  Data_Object<Wrapped_Function> f(
+      wrap_function(function, handler, arguments),
+      rb_cObject);
+  Rice::protect(
+      define_method_with_data,
+      klass,
+      name.id(),
+      f->func(),
+      -1,
+      f);
+}
+
+#endif // Rice__detail__define_method_and_auto_wrap__ipp_

data/rice/detail/demangle.cpp

@@ -0,0 +1,56 @@
+#include "demangle.hpp"
+
+#ifdef __GNUC__
+#include <cxxabi.h>
+#include <cstdlib>
+#include <cstring>
+#endif
+
+std::string
+Rice::detail::
+demangle(char const * mangled_name)
+{
+#ifdef __GNUC__
+    struct Helper
+  {
+    Helper(
+        char const * mangled_name)
+      : name_(0)
+    {
+      int status = 0;
+      name_ = abi::__cxa_demangle(mangled_name, 0, 0, &status);
+    }
+
+    ~Helper()
+    {
+      std::free(name_);
+    }
+
+    char * name_;
+
+  private:
+    Helper(Helper const &);
+    void operator=(Helper const &);
+  };
+
+  Helper helper(mangled_name);
+  if(helper.name_)
+  {
+    return helper.name_;
+  }
+  else
+  {
+    return mangled_name;
+  }
+#else
+  return mangled_name;
+#endif
+}
+
+
+std::string
+Rice::detail::
+demangle(std::string const & mangled_name)
+{
+  return demangle(mangled_name.c_str());
+}

data/rice/detail/demangle.hpp

@@ -0,0 +1,19 @@
+#ifndef Rice__detail__demangle__hpp_
+#define Rice__detail__demangle__hpp_
+
+#include <string>
+
+namespace Rice
+{
+
+namespace detail
+{
+
+std::string demangle(char const * mangled_name);
+std::string demangle(std::string const & mangled_name);
+
+} // detail
+
+} // Rice
+
+#endif // Rice__detail__demangle__hpp_

data/rice/detail/env.hpp

@@ -0,0 +1,11 @@
+#ifndef Rice__detail__env__hpp_
+#define Rice__detail__env__hpp_
+
+/**
+ * Helper header for the env.h ruby include file, which does
+ * not have extern "C"
+ */
+
+#include "ruby_version_code.hpp"
+
+#endif

data/rice/detail/from_ruby.hpp

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

data/rice/detail/from_ruby.ipp

@@ -0,0 +1,60 @@
+#ifndef Rice__detail__from_ruby__ipp_
+#define Rice__detail__from_ruby__ipp_
+
+#include "../Data_Type.hpp"
+#include "../String.hpp"
+#include "demangle.hpp"
+#include <typeinfo>
+
+template<typename T>
+T Rice::detail::from_ruby_<T>::
+convert(Rice::Object x)
+{
+  if(rb_type(x.value()) == T_DATA)
+  {
+    return *Data_Type<T>::from_ruby(x);
+  }
+  else
+  {
+    std::string s("Unable to convert ");
+    s += x.class_of().name().c_str();
+    s += " to ";
+    s += demangle(typeid(T).name());
+    throw std::invalid_argument(s.c_str());
+  }
+}
+
+template<typename T>
+T * Rice::detail::from_ruby_<T *>::
+convert(Rice::Object x)
+{
+  if(rb_type(x.value()) == T_DATA)
+  {
+    return Data_Type<T>::from_ruby(x);
+  }
+  else
+  {
+    std::string s("Unable to convert ");
+    s += x.class_of().name().c_str();
+    s += " to ";
+    s += demangle(typeid(T *).name());
+    throw std::invalid_argument(s.c_str());
+  }
+}
+
+template<typename T>
+T const * Rice::detail::from_ruby_<T const *>::
+convert(Rice::Object x)
+{
+  return from_ruby<T *>(x);
+}
+
+template<typename T>
+T & Rice::detail::from_ruby_<T &>::
+convert(Rice::Object x)
+{
+  return *from_ruby<T *>(x);
+}
+
+#endif // Rice__detail__from_ruby__ipp_
+