rice 1.0.2 → 1.1.0

data/rice/detail/env.hpp

@@ -8,8 +8,12 @@
 
 // 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/method_data.cpp

@@ -1,105 +1,392 @@
 #include "method_data.hpp"
 
-#include "st.hpp"
-#include "ruby.hpp"
+// TODO: This is silly, autoconf...
+#undef PACKAGE_NAME
+#undef PACKAGE_STRING
+#undef PACKAGE_TARNAME
+#undef PACKAGE_VERSION
 
-#include <stdexcept>
+#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"
-#include "node.hpp"
-
-// Every C function in ruby (pre-YARV) is stored like this:
-//
-// NODE_METHOD
-//   |- (u1) noex - method visibility
-//   +- (u2) body
-//      +- NODE_CFUNC
-//          |- (u1) cfnc - function to call
-//          +- (u2) argc - number of arguments
-//
-// We use the unused third member (u3) of the CFUNC node to store method
-// data.
-//
-// We could use the unused third member of the METHOD node, but then the
-// method data would not be copied when the method is aliased.  The
-// result then would be a segfault whenver the method is called.
-//
-// Using the third member of the METHOD node would also prevent adding
-// the method atomically (rather, the method would be added and then the
-// node later modified to contain the data).
-//
-// When the function is called, it can retrieve the defined data by
-// calling method_data().  We then do a lookup in the class to find the
-// node for the method's bdoy.  This is necessary, because there's no
-// way to get the node of a called function directly.  However, by using
-// the class's method table, we can do one lookup instead of two (one to
-// find the class data and another to find the method data).
+
+#ifdef RUBY_VM
+
+/* YARV */
 
 namespace
 {
 
-NODE * get_method_node(VALUE klass, ID id)
+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
 {
-  union { VALUE value; RClass * ptr; } class_u = { klass };
-  union { ID id; st_data_t data; } id_u = { id };
-  st_data_t node_data;
-  if (!st_lookup(class_u.ptr->m_tbl, id_u.data, &node_data))
-  {
-    throw std::runtime_error("Could not find method node");
-  }
-  union { st_data_t data; RNode * node; } node_u = { node_data };
-  return node_u.node;
+
+#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);
 }
 
-NODE * get_method_body(VALUE klass, ID id)
+#define FIX_FRAME() \
+  fix_frame()
+
+static NODE * data_memo_node()
 {
-  NODE * node = get_method_node(klass, id);
+  VALUE * cfp = ruby_current_thread->cfp;
+  return (NODE *)CFP_DATA_MEMO_NODE_AND_PC;
+}
 
-  if (!node->nd_body)
-  {
-    throw std::runtime_error("Method has no body");
-  }
+#else
 
-  return node->nd_body;
+/* 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);
 }
 
-} // namespace
+#endif
 
-void * Rice::detail::
-method_data()
+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)
 {
-  NODE * node = get_method_body(
-      ruby_frame->last_class,
-      ruby_frame->last_func);
+  VALUE result;
+  FIX_FRAME();
+  result = (*actual_cfunc())(argc, argv, self);
+  return result;
+}
 
-  return (void *)node->nd_entry;
+static VALUE data_wrapper_0(VALUE self)
+{
+  VALUE result;
+  FIX_FRAME();
+  result = (*actual_cfunc())(self);
+  return result;
 }
 
-void Rice::detail::
+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,
-    char const * name,
-    RUBY_METHOD_FUNC func,
-    int num_args,
-    void * data)
-{
-  NODE * node = NEW_CFUNC(func, num_args);
-  node->nd_entry = (global_entry *)data;
-#if RUBY_VERSION_CODE >= 180
-  rb_add_method(klass, rb_intern(name), node, NOEX_PUBLIC);
+    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
-  rb_add_method(klass, rb_intern(name), node, NOEX_PUBLIC|NOEX_CFUNC);
-  rb_enable_super(klass, name);
+  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;
 }
 
-void Rice::detail::
-set_method_data(
-    VALUE klass,
-    char const * name,
-    void * data)
+VALUE
+Rice::detail::
+method_data()
 {
-  NODE * node = get_method_body(klass, rb_intern(name));
-  node->nd_entry = (global_entry *)data;
+  return data_memo_node()->nd_rval;
 }