keyme-rice 1.5.1.keyme

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,159 @@
+#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"
+
+#ifndef RUBY_VM
+/* pre-YARV */
+#include <node.h>
+#include "env.hpp"
+#endif
+
+/* 1.8.6 compatibility */
+#ifndef RCLASS_M_TBL
+#define RCLASS_M_TBL(x) (RCLASS(x)->m_tbl)
+#endif
+
+namespace
+{
+
+VALUE DATA_MAGIC = rb_fix_new(0xDA7A);
+
+} // namespace
+
+#ifdef RUBY_VM
+
+VALUE
+Rice::detail::
+method_data()
+{
+  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");
+  }
+
+  VALUE memo = rb_ivar_get(origin, 0);
+
+  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");
+  }
+
+  return RARRAY_PTR(memo)[1];
+}
+
+#else
+
+/* pre-YARV */
+
+VALUE
+Rice::detail::
+method_data()
+{
+  VALUE origin = ruby_frame->last_class;
+  VALUE memo = rb_ivar_get(origin, 0);
+  return RARRAY_PTR(memo)[1];
+}
+
+#endif
+
+// 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)
+{
+  VALUE origin = rb_class_boot(klass);
+
+  // 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_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);
+
+  // 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);
+
+  // Clear the table so we don't try to double-free the method entry
+  RCLASS_M_TBL(origin) = st_init_numtable();
+
+  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