jameskilton-rice 1.2.0

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,19 @@
+#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"
+ */
+
+// TODO: Won't work on ruby 1.9
+
+#include "ruby_version_code.hpp"
+
+#if RICE__RUBY_VERSION_CODE < 190
+extern "C" {
+  #include "env.h"
+}
+#endif
+
+#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_
+

data/rice/detail/method_data.cpp

@@ -0,0 +1,392 @@
+#include "method_data.hpp"
+
+// TODO: This is silly, autoconf...
+#undef PACKAGE_NAME
+#undef PACKAGE_STRING
+#undef PACKAGE_TARNAME
+#undef PACKAGE_VERSION
+
+#include "../config.hpp"
+
+
+#if defined(HAVE_NODE_H)
+/* pre-YARV */
+#include <node.h>
+#elif defined(REALLY_HAVE_RUBY_NODE_H)
+/* YARV */
+#include <ruby/node.h>
+#else
+/* YARV without node.h */
+#include "mininode.hpp"
+using namespace Rice::detail::Mininode;
+#endif
+
+#include "env.hpp"
+
+#ifdef RUBY_VM
+
+/* YARV */
+
+namespace
+{
+
+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
+
+extern "C" rb_thread_t * ruby_current_thread;
+
+#endif
+
+namespace
+{
+
+#ifdef RUBY_VM
+
+/* YARV */
+
+#define CFP_DATA_MEMO_NODE_AND_PC cfp[0]
+#define CFP_METHOD_CLASS cfp[11]
+
+/* On YARV, we store the method data on the stack.  We don't have to pop
+ * it off the stack, because the stack pointer will be reset to the
+ * previous frame's stack pointer when the function returns.
+ */
+static void fix_frame()
+{
+  do {
+    VALUE * cfp = ruby_current_thread->cfp;
+    CFP_DATA_MEMO_NODE_AND_PC = RBASIC(CFP_METHOD_CLASS)->klass;
+
+    if(rb_type(CFP_DATA_MEMO_NODE_AND_PC) != T_NODE)
+    {
+      /* This can happen for module functions that are created after
+       * the stub function */
+      rb_raise(
+          rb_eRuntimeError,
+          "Cannot find method data for module function");
+    }
+    else
+    {
+      CFP_METHOD_CLASS = RCLASS_SUPER(CFP_METHOD_CLASS);
+    }
+  } while(0);
+}
+
+#define FIX_FRAME() \
+  fix_frame()
+
+static NODE * data_memo_node()
+{
+  VALUE * cfp = ruby_current_thread->cfp;
+  return (NODE *)CFP_DATA_MEMO_NODE_AND_PC;
+}
+
+#else
+
+/* pre-YARV */
+
+/* Okay to not pop this temporary frame, since it will be popped by the
+ * caller
+ */
+#define FIX_FRAME() \
+  struct FRAME _frame = *ruby_frame; \
+  _frame.last_class = RCLASS(ruby_frame->last_class)->super; \
+  _frame.prev = ruby_frame; \
+  ruby_frame = &_frame; \
+
+static NODE * data_memo_node()
+{
+  return (NODE *)(RBASIC(ruby_frame->prev->last_class)->klass);
+}
+
+#endif
+
+typedef VALUE (*Method_Func)(ANYARGS);
+
+static Method_Func actual_cfunc()
+{
+  return data_memo_node()->nd_cfnc;
+}
+
+static VALUE data_wrapper_m1(int argc, VALUE * argv, VALUE self)
+{
+  VALUE result;
+  FIX_FRAME();
+  result = (*actual_cfunc())(argc, argv, self);
+  return result;
+}
+
+static VALUE data_wrapper_0(VALUE self)
+{
+  VALUE result;
+  FIX_FRAME();
+  result = (*actual_cfunc())(self);
+  return result;
+}
+
+static VALUE data_wrapper_1(VALUE self, VALUE arg1)
+{
+  VALUE result;
+  FIX_FRAME();
+  result = (*actual_cfunc())(self, arg1);
+  return result;
+}
+static VALUE data_wrapper_2(VALUE self, VALUE arg1, VALUE arg2)
+{
+  VALUE result;
+  FIX_FRAME();
+  result = (*actual_cfunc())(self, arg1, arg2);
+  return result;
+}
+static VALUE data_wrapper_3(VALUE self, VALUE arg1, VALUE arg2, VALUE arg3)
+{
+  VALUE result;
+  FIX_FRAME();
+  result = (*actual_cfunc())(self, arg1, arg2, arg3);
+  return result;
+}
+static VALUE data_wrapper_4(VALUE self, VALUE arg1, VALUE arg2, VALUE arg3, VALUE arg4)
+{
+  VALUE result;
+  FIX_FRAME();
+  result = (*actual_cfunc())(self, arg1, arg2, arg3, arg4);
+  return result;
+}
+static VALUE data_wrapper_5(VALUE self, VALUE arg1, VALUE arg2, VALUE arg3, VALUE arg4, VALUE arg5)
+{
+  VALUE result;
+  FIX_FRAME();
+  result = (*actual_cfunc())(self, arg1, arg2, arg3, arg4, arg5);
+  return result;
+}
+static VALUE data_wrapper_6(VALUE self, VALUE arg1, VALUE arg2, VALUE arg3, VALUE arg4, VALUE arg5, VALUE arg6)
+{
+  VALUE result;
+  FIX_FRAME();
+  result = (*actual_cfunc())(self, arg1, arg2, arg3, arg4, arg5, arg6);
+  return result;
+}
+static VALUE data_wrapper_7(VALUE self, VALUE arg1, VALUE arg2, VALUE arg3, VALUE arg4, VALUE arg5, VALUE arg6, VALUE arg7)
+{
+  VALUE result;
+  FIX_FRAME();
+  result = (*actual_cfunc())(self, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+  return result;
+}
+static VALUE data_wrapper_8(VALUE self, VALUE arg1, VALUE arg2, VALUE arg3, VALUE arg4, VALUE arg5, VALUE arg6, VALUE arg7, VALUE arg8)
+{
+  VALUE result;
+  FIX_FRAME();
+  result = (*actual_cfunc())(self, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+  return result;
+}
+static VALUE data_wrapper_9(VALUE self, VALUE arg1, VALUE arg2, VALUE arg3, VALUE arg4, VALUE arg5, VALUE arg6, VALUE arg7, VALUE arg8, VALUE arg9)
+{
+  VALUE result;
+  FIX_FRAME();
+  result = (*actual_cfunc())(self, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+  return result;
+}
+static VALUE data_wrapper_10(VALUE self, VALUE arg1, VALUE arg2, VALUE arg3, VALUE arg4, VALUE arg5, VALUE arg6, VALUE arg7, VALUE arg8, VALUE arg9, VALUE arg10)
+{
+  VALUE result;
+  FIX_FRAME();
+  result = (*actual_cfunc())(self, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
+  return result;
+}
+static VALUE data_wrapper_11(VALUE self, VALUE arg1, VALUE arg2, VALUE arg3, VALUE arg4, VALUE arg5, VALUE arg6, VALUE arg7, VALUE arg8, VALUE arg9, VALUE arg10, VALUE arg11)
+{
+  VALUE result;
+  FIX_FRAME();
+  result = (*actual_cfunc())(self, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
+  return result;
+}
+static VALUE data_wrapper_12(VALUE self, VALUE arg1, VALUE arg2, VALUE arg3, VALUE arg4, VALUE arg5, VALUE arg6, VALUE arg7, VALUE arg8, VALUE arg9, VALUE arg10, VALUE arg11, VALUE arg12)
+{
+  VALUE result;
+  FIX_FRAME();
+  result = (*actual_cfunc())(self, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
+  return result;
+}
+static VALUE data_wrapper_13(VALUE self, VALUE arg1, VALUE arg2, VALUE arg3, VALUE arg4, VALUE arg5, VALUE arg6, VALUE arg7, VALUE arg8, VALUE arg9, VALUE arg10, VALUE arg11, VALUE arg12, VALUE arg13)
+{
+  VALUE result;
+  FIX_FRAME();
+  result = (*actual_cfunc())(self, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
+  return result;
+}
+static VALUE data_wrapper_14(VALUE self, VALUE arg1, VALUE arg2, VALUE arg3, VALUE arg4, VALUE arg5, VALUE arg6, VALUE arg7, VALUE arg8, VALUE arg9, VALUE arg10, VALUE arg11, VALUE arg12, VALUE arg13, VALUE arg14)
+{
+  VALUE result;
+  FIX_FRAME();
+  result = (*actual_cfunc())(self, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
+  return result;
+}
+static VALUE data_wrapper_15(VALUE self, VALUE arg1, VALUE arg2, VALUE arg3, VALUE arg4, VALUE arg5, VALUE arg6, VALUE arg7, VALUE arg8, VALUE arg9, VALUE arg10, VALUE arg11, VALUE arg12, VALUE arg13, VALUE arg14, VALUE arg15)
+{
+  VALUE result;
+  FIX_FRAME();
+  result = (*actual_cfunc())(self, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15);
+  return result;
+}
+
+} // namespace
+
+/* Define a method and attach data to it.
+ *
+ * The method looks to ruby like a normal aliased CFUNC, with a modified
+ * origin class:
+ *
+ * NODE_FBODY
+ *   |- (u1) orig - origin class
+ *   |  |- basic
+ *   |  |  |- flags - origin class flags + FL_SINGLETON
+ *   |  |  +- klass - NODE_MEMO
+ *   |  |     |- (u1) cfnc - actual C function to call
+ *   |  |     |- (u2) rval - stored data
+ *   |  |     +- (u3) 0
+ *   |  |- iv_tbl - 0
+ *   |  |- m_tbl - 0
+ *   |  +- super - actual origin class
+ *   |- (u2) mid - name of the method
+ *   +- (u3) head - NODE_CFUNC
+ *      |- (u1) cfnc - wrapper function to call
+ *      +- (u2) argc - function arity
+ *
+ * Or, on YARV:
+ *
+ * NODE_FBODY
+ *   |- (u1) oid - name of the method
+ *   +- (u2) body - NODE_METHOD
+ *      |- (u1) clss - origin class
+ *      |  |- basic
+ *      |  |  |- flags - origin class flags + FL_SINGLETON
+ *      |  |  +- klass - NODE_MEMO
+ *      |  |     |- (u1) cfnc - actual C function to call
+ *      |  |     |- (u2) rval - stored data
+ *      |  |     +- (u3) 0
+ *      |  |- ptr - rb_classext_t
+ *      |  |  |- super - actual origin class
+ *      |  |  +- iv_tbl - 0
+ *      |  |- m_tbl - 0
+ *      |  +- iv_index_tbl - 0?
+ *      |- (u2) body - NODE_CFUNC
+ *      |  |- (u1) cfnc - wrapper function to call
+ *      |  |- (u2) argc - function arity
+ *      +- (u3) noex - NOEX_PUBLIC
+ *
+ * When the wrapper function is called, last_class is set to the origin
+ * class found in the FBODY node.  So that the method data will be
+ * accessible, and so last_class will point to klass and not to our MEMO
+ * node, it is necessary to "fix" the current frame.
+ *
+ * Pre-YARV, this means we duplicate the current frame and set last_class:
+ *
+ * ruby_frame
+ *   |- last_class - klass
+ *   |- prev
+ *   |  |- last_class - NODE_MEMO
+ *   |  |  |- (u1) cfnc - actual C function to call
+ *   |  |  |- (u2) rval - stored data
+ *   |  |  +- (u3) 0
+ *   |  |- prev - the real previous frame
+ *   |  +- ...
+ *   +- ...
+ *
+ * The method data is then accessible via
+ * ruby_frame->prev->last_class->rval.
+ *
+ * On YARV, the current frame is not duplicated; rather, the method data
+ * is placed on the stack and is referenced by one of the unused members
+ * of the control frame (the program counter):
+ *
+ * ruby_current_thread->cfp
+ *   |- pc - NODE_MEMO
+ *   |  |- (u1) cfnc - actual C function to call
+ *   |  |- (u2) rval - stored data
+ *   |  +- (u3) 0
+ *   |- method_class - klass
+ *   +- ...
+ *
+ */
+VALUE
+Rice::detail::
+define_method_with_data(
+    VALUE klass, ID id, VALUE (*cfunc)(ANYARGS), int arity, VALUE data)
+{
+  /* TODO: origin should have #to_s and #inspect methods defined */
+#ifdef HAVE_RB_CLASS_BOOT
+  VALUE origin = rb_class_boot(klass);
+#else
+  VALUE origin = rb_class_new(klass);
+#endif
+  NODE * node;
+
+  VALUE (*data_wrapper)(ANYARGS);
+  switch(arity)
+  {
+    case 0: data_wrapper = RUBY_METHOD_FUNC(data_wrapper_0); break;
+    case 1: data_wrapper = RUBY_METHOD_FUNC(data_wrapper_1); break;
+    case 2: data_wrapper = RUBY_METHOD_FUNC(data_wrapper_2); break;
+    case 3: data_wrapper = RUBY_METHOD_FUNC(data_wrapper_3); break;
+    case 4: data_wrapper = RUBY_METHOD_FUNC(data_wrapper_4); break;
+    case 5: data_wrapper = RUBY_METHOD_FUNC(data_wrapper_5); break;
+    case 6: data_wrapper = RUBY_METHOD_FUNC(data_wrapper_6); break;
+    case 7: data_wrapper = RUBY_METHOD_FUNC(data_wrapper_7); break;
+    case 8: data_wrapper = RUBY_METHOD_FUNC(data_wrapper_8); break;
+    case 9: data_wrapper = RUBY_METHOD_FUNC(data_wrapper_9); break;
+    case 10: data_wrapper = RUBY_METHOD_FUNC(data_wrapper_10); break;
+    case 11: data_wrapper = RUBY_METHOD_FUNC(data_wrapper_11); break;
+    case 12: data_wrapper = RUBY_METHOD_FUNC(data_wrapper_12); break;
+    case 13: data_wrapper = RUBY_METHOD_FUNC(data_wrapper_13); break;
+    case 14: data_wrapper = RUBY_METHOD_FUNC(data_wrapper_14); break;
+    case 15: data_wrapper = RUBY_METHOD_FUNC(data_wrapper_15); break;
+    case -1: data_wrapper = RUBY_METHOD_FUNC(data_wrapper_m1); break;
+    default: rb_raise(rb_eArgError, "unsupported arity %d", arity);
+  }
+
+  FL_SET(origin, FL_SINGLETON);
+  rb_singleton_class_attached(origin, klass);
+  rb_name_class(origin, SYM2ID(rb_class_name(klass)));
+
+  RBASIC(origin)->klass = (VALUE)NEW_NODE(NODE_MEMO, cfunc, data, 0);
+
+#ifdef RUBY_VM
+  /* YARV */
+  node = NEW_FBODY(
+      NEW_METHOD(
+          NEW_CFUNC(data_wrapper, arity),
+          origin,
+          NOEX_PUBLIC),
+      id);
+  st_insert(RCLASS_M_TBL(klass), id, (st_data_t)node);
+#else
+  /* pre-YARV */
+  node = NEW_FBODY(
+      NEW_CFUNC(data_wrapper, arity),
+      id,
+      origin);
+  rb_add_method(klass, id, node, NOEX_PUBLIC);
+#endif
+
+  return Qnil;
+}
+
+VALUE
+Rice::detail::
+method_data()
+{
+  return data_memo_node()->nd_rval;
+}
+