rice 1.0.0

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));
+  return m.value();
+} 
+
+

data/rice/detail/define_method_and_auto_wrap.hpp

@@ -0,0 +1,27 @@
+#ifndef Rice__detail__define_method_and_auto_wrap__hpp_
+#define Rice__detail__define_method_and_auto_wrap__hpp_
+
+#include "ruby.hpp"
+
+namespace Rice
+{
+
+namespace detail
+{
+
+class Exception_Handler;
+
+template<typename Fun_T>
+void define_method_and_auto_wrap(
+    VALUE klass,
+    char const * name,
+    Fun_T function,
+    Exception_Handler const * handler = 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,20 @@
+#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.hpp"
+
+template<typename Fun_T>
+void Rice::detail::
+define_method_and_auto_wrap(
+    VALUE klass,
+    char const * name,
+    Fun_T function,
+    Exception_Handler const * handler)
+{
+  Wrapped_Function * f(wrap_function(function, handler));
+  define_method_with_data(klass, name, f->func(), f->arity(), f);
+}
+
+#endif // Rice__detail__define_method_and_auto_wrap__ipp_

data/rice/detail/env.hpp

@@ -0,0 +1,13 @@
+#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"
+ */
+
+extern "C" {
+  #include "env.h"
+}
+
+#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,74 @@
+#ifndef Rice__detail__from_ruby__ipp_
+#define Rice__detail__from_ruby__ipp_
+
+#include "../Data_Type.hpp"
+#include <typeinfo>
+
+#if 0
+namespace Rice
+{
+  namespace detail
+  {
+    template<typename T>
+    struct unpointer
+    {
+      // can't unpointer a non-pointer
+    };
+
+    template<typename T>
+    struct unpointer<T *>
+    {
+      typedef T type;
+    };
+  }
+}
+#endif
+
+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("No conversion defined for ");
+    s += typeid(T).name();
+    throw std::runtime_error(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("No conversion defined for ");
+    s += typeid(T).name();
+    throw std::runtime_error(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,105 @@
+#include "method_data.hpp"
+
+#include "st.hpp"
+#include "ruby.hpp"
+
+#include <stdexcept>
+
+#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).
+
+namespace
+{
+
+NODE * get_method_node(VALUE klass, ID id)
+{
+  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;
+}
+
+NODE * get_method_body(VALUE klass, ID id)
+{
+  NODE * node = get_method_node(klass, id);
+
+  if (!node->nd_body)
+  {
+    throw std::runtime_error("Method has no body");
+  }
+
+  return node->nd_body;
+}
+
+} // namespace
+
+void * Rice::detail::
+method_data()
+{
+  NODE * node = get_method_body(
+      ruby_frame->last_class,
+      ruby_frame->last_func);
+
+  return (void *)node->nd_entry;
+}
+
+void 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);
+#else
+  rb_add_method(klass, rb_intern(name), node, NOEX_PUBLIC|NOEX_CFUNC);
+  rb_enable_super(klass, name);
+#endif
+}
+
+void Rice::detail::
+set_method_data(
+    VALUE klass,
+    char const * name,
+    void * data)
+{
+  NODE * node = get_method_body(klass, rb_intern(name));
+  node->nd_entry = (global_entry *)data;
+}
+

data/rice/detail/method_data.hpp

@@ -0,0 +1,33 @@
+#ifndef Rice__method_data__hpp_
+#define Rice__method_data__hpp_
+
+#include "ruby.hpp"
+
+namespace Rice
+{
+
+namespace detail
+{
+
+// Retrieve the data associated with the last called method.
+void * method_data();
+
+// Define a method and attach data to it.
+void define_method_with_data(
+    VALUE klass,
+    char const * name,
+    RUBY_METHOD_FUNC func,
+    int num_args,
+    void * data);
+
+// Set the data associated with a method.
+void set_method_data(
+    VALUE klass,
+    char const * name,
+    void * data);
+
+} // namespace detail
+
+} // namespace Rice
+
+#endif // Rice__method_data__hpp_

data/rice/detail/node.hpp

@@ -0,0 +1,13 @@
+#ifndef Rice__detail__node__hpp_
+#define Rice__detail__node__hpp_
+
+/**
+ * Helper header for the node.h ruby include file, which does
+ * not have extern "C"
+ */
+
+extern "C" {
+  #include "node.h"
+}
+
+#endif

data/rice/detail/object_call.hpp

@@ -0,0 +1,85 @@
+// This is a generated file.  DO NOT EDIT!!
+#ifdef DOXYGEN
+
+//! Call the Ruby method specified by 'id' on object 'obj'.
+/*! Pass in arguments (arg1, arg2, ...).  The arguments will be converted to
+ *  Ruby objects with to_ruby<>.  The return value will automatically be
+ *  converted to type Retval_T with from_ruby<>.
+ *
+ *  E.g.:
+ *  \code
+ *    float y = x.call<float>("foo", z, 42);
+ *  \endcode
+ */
+template<typename Retval_T>
+Retval_T call(Identifier id, T1 arg1, T2 arg2, ...) const;
+
+//! Version of call which defaults to Object return type.
+Object call(Identifier id, T1 arg1, T2 arg2, ...) const;
+#else
+
+
+Object call(Identifier id) const;
+
+
+template<typename T1>
+Object call(Identifier id, T1 arg1) const;
+
+
+template<typename T1, typename T2>
+Object call(Identifier id, T1 arg1, T2 arg2) const;
+
+
+template<typename T1, typename T2, typename T3>
+Object call(Identifier id, T1 arg1, T2 arg2, T3 arg3) const;
+
+
+template<typename T1, typename T2, typename T3, typename T4>
+Object call(Identifier id, T1 arg1, T2 arg2, T3 arg3, T4 arg4) const;
+
+
+template<typename T1, typename T2, typename T3, typename T4, typename T5>
+Object call(Identifier id, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5) const;
+
+
+template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+Object call(Identifier id, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6) const;
+
+
+template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
+Object call(Identifier id, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7) const;
+
+
+template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
+Object call(Identifier id, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8) const;
+
+
+template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
+Object call(Identifier id, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9) const;
+
+
+template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
+Object call(Identifier id, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10) const;
+
+
+template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11>
+Object call(Identifier id, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11) const;
+
+
+template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
+Object call(Identifier id, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12) const;
+
+
+template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13>
+Object call(Identifier id, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13) const;
+
+
+template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14>
+Object call(Identifier id, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14) const;
+
+
+template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15>
+Object call(Identifier id, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15) const;
+
+
+#endif // DOXYGEN