rice 1.2.0 → 1.3.0

data/rice/detail/cfp.hpp

@@ -0,0 +1,24 @@
+#ifndef Rice__detail__cfp__hpp_
+#define Rice__detail__cfp__hpp_
+
+#include "ruby.hpp"
+
+namespace Rice
+{
+
+namespace detail
+{
+
+VALUE * cfp();
+
+VALUE & cfp_data_memo_node_and_pc(VALUE * cfp);
+VALUE & cfp_self(VALUE * cfp);
+VALUE & cfp_method_class(VALUE * cfp);
+
+} // detail
+
+} // Rice
+
+#include "cfp.ipp"
+
+#endif // Rice__detail__cfp__hpp_

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/method_data.cpp

@@ -1,392 +1,163 @@
 #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"
 
-
-#if defined(HAVE_NODE_H)
+#ifndef RUBY_VM
 /* 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"
+#endif
 
-#ifdef RUBY_VM
-
-/* YARV */
+/* 1.8.6 compatibility */
+#ifndef RCLASS_M_TBL
+#define RCLASS_M_TBL(x) (RCLASS(x)->m_tbl)
+#endif
 
 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;
+VALUE DATA_MAGIC = rb_fix_new(0xDA7A);
 
 } // 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()
+VALUE
+Rice::detail::
+method_data()
 {
-  do {
-    VALUE * cfp = ruby_current_thread->cfp;
-    CFP_DATA_MEMO_NODE_AND_PC = RBASIC(CFP_METHOD_CLASS)->klass;
+  ID id;
+  VALUE origin;
+  if (!rb_frame_method_id_and_class(&id, &origin))
+  {
+    rb_raise(
+        rb_eRuntimeError,
+        "Cannot get method id and class for function");
+  }
 
-    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);
-}
+  VALUE memo = rb_ivar_get(origin, 0);
 
-#define FIX_FRAME() \
-  fix_frame()
+  if(rb_type(memo) != T_ARRAY && RARRAY_PTR(memo)[0] != DATA_MAGIC)
+  {
+    /* This can happen for module functions that are created after
+     * the stub function */
+    rb_raise(
+        rb_eRuntimeError,
+        "Cannot find method data for module function");
+  }
 
-static NODE * data_memo_node()
-{
-  VALUE * cfp = ruby_current_thread->cfp;
-  return (NODE *)CFP_DATA_MEMO_NODE_AND_PC;
+  return RARRAY_PTR(memo)[1];
 }
 
 #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()
+VALUE
+Rice::detail::
+method_data()
 {
-  return (NODE *)(RBASIC(ruby_frame->prev->last_class)->klass);
+  VALUE origin = ruby_frame->last_class;
+  VALUE memo = rb_ivar_get(origin, 0);
+  return RARRAY_PTR(memo)[1];
 }
 
 #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
- *   +- ...
- *
- */
+// 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 defining a method on a dummy class,
+// then attaching that method to our real class.  The method is a real
+// method in our class, but its origin class is our dummy class.
+// 
+// When Ruby makes a method call, it stores the origin class in the
+// current stack frame.  When Ruby calls into Rice, we grab the origin
+// class from the stack frame, then pull the data out of the origin
+// class.  The data item is then used to determine how to convert
+// arguments and return type, how to handle exceptions, etc.
+//
+// It used to be the case that Rice would "fix" the call frame so that
+// the modified origin class was not visible to the called function (it
+// would appear to the callee that the origin class was the same as the
+// class it was defined on).  However, this required modifying the call
+// frame directly, and the layout of that frame varies from version to
+// version.  To keep things simple (and as a side effect improve
+// performance), Rice no longer hides the modified origin class this way.
+//
+// Functions that make use of "last_class" (1.8) or
+// "rb_frame_method_id_and_class" (1.9) will therefore not get the
+// results they expect.
 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);
-  }
+  // Create the memo object with a magic number so we can detect if
+  // we're getting the origin class we expect (this can happen if the
+  // module_function method is called on a Rice function on ruby 1.9).
+  VALUE memo = rb_assoc_new(DATA_MAGIC, data);
 
+  // Set the class name of our modified origin class to something
+  // obvious in case someone tries to inspect it.
+  VALUE real_class_name = rb_class_name(klass);
+  VALUE origin_class_name = rb_str_plus(
+      real_class_name,
+      rb_str_new2("<data wrapper>"));
+
+  // Create the modified origin class
   FL_SET(origin, FL_SINGLETON);
   rb_singleton_class_attached(origin, klass);
-  rb_name_class(origin, SYM2ID(rb_class_name(klass)));
+  rb_name_class(origin, SYM2ID(rb_str_intern(origin_class_name)));
+
+  // Attach our "memo" to the origin class
+  rb_ivar_set(origin, 0, memo);
+
+  // Create the aliased method on the origin class
+  rb_define_method(
+      origin,
+      rb_id2name(id),
+      cfunc,
+      arity);
+
+  // Alias the method in the origin class so we can copy it to another
+  // class with the origin class intact as part of the method entry
+  rb_alias(
+      origin,
+      rb_intern("dummy"),
+      id);
 
-  RBASIC(origin)->klass = (VALUE)NEW_NODE(NODE_MEMO, cfunc, data, 0);
+  // Copy the method entry to the real class
+  st_data_t dummy_entry;
+  st_lookup(RCLASS_M_TBL(origin), rb_intern("dummy"), &dummy_entry);
+  st_insert(RCLASS_M_TBL(klass), id, dummy_entry);
 
-#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
+  // Clear the table so we don't try to double-free the method entry
+  RCLASS_M_TBL(origin) = st_init_numtable();
 
   return Qnil;
 }
-
-VALUE
-Rice::detail::
-method_data()
-{
-  return data_memo_node()->nd_rval;
-}
-