rice 1.0.2 → 1.1.0

data/rice/detail/protect.cpp

@@ -15,10 +15,12 @@ protect(
   VALUE retval = rb_protect(f, arg, &state);
   if(state != 0)
   {
-    if(state == TAG_RAISE && ruby_errinfo != Qnil)
+    VALUE err = rb_errinfo();
+    if(state == TAG_RAISE && RTEST(err))
     {
       // TODO: convert NoMemoryError into bad_alloc?
-      throw Rice::Exception(ruby_errinfo);
+      rb_set_errinfo(Rice::Nil);
+      throw Rice::Exception(err);
     }
     throw Jump_Tag(state);
   }

data/rice/detail/ruby.hpp

@@ -14,18 +14,16 @@
 #define HAVE_ISINF
 #endif
 
-// TODO: Is there a way to ensure that this is Ruby's version.h?
-#define RUBY_EXTERN extern "C"
-#include <version.h>
+#include "ruby_version_code.hpp"
 
 // workaround for ruby 1.8.4, which defines eaccess and shouldn't
-#if RUBY_VERSION_CODE <= 184
+#if RICE__RUBY_VERSION_CODE <= 184
 #define eaccess ruby_eaccess
 #endif
 
 #include <ruby.h>
 
-#if RUBY_VERSION_CODE <= 184
+#if RICE__RUBY_VERSION_CODE <= 184
 #undef eaccess
 #endif
 
@@ -44,7 +42,7 @@ extern "C" typedef VALUE (*RUBY_VALUE_FUNC)(VALUE);
 // Fix Ruby RUBY_METHOD_FUNC from macro to typedef
 #if defined(RUBY_METHOD_FUNC)
 # undef RUBY_METHOD_FUNC
-# if RUBY_VERSION_CODE <= 166
+# if RICE__RUBY_VERSION_CODE <= 166
     extern "C" typedef VALUE (*RUBY_METHOD_FUNC)();
 # else
     extern "C" typedef VALUE (*RUBY_METHOD_FUNC)(ANYARGS);
@@ -55,25 +53,28 @@ extern "C" typedef VALUE (*RUBY_VALUE_FUNC)(VALUE);
 // C++ function to an extern "C" function won't result in correct
 // behavior on all platforms.  Fortunately this has been fixed in newer
 // versions of Ruby.
-#if RUBY_VERSION_CODE < 170
-  namespace Exc_Ruby
+#if RICE__RUBY_VERSION_CODE < 170
+  namespace Rice
   {
-    extern "C" typedef VALUE
-      (*Rb_Protect_Signature)(RUBY_VALUE_FUNC, VALUE, int *);
-    extern "C" typedef void
-      (*Rb_Gc_Mark_Signature)(VALUE);
-    extern "C" typedef void
-      (*Rb_Set_End_Proc_Signature)(void (*)(VALUE), VALUE);
-  }
+    namespace detail
+    {
+      extern "C" typedef VALUE
+        (*Rb_Protect_Signature)(RUBY_VALUE_FUNC, VALUE, int *);
+      extern "C" typedef void
+        (*Rb_Gc_Mark_Signature)(VALUE);
+      extern "C" typedef void
+        (*Rb_Set_End_Proc_Signature)(void (*)(VALUE), VALUE);
+    } // detail
+  } // Rice
   //! Ruby 1.6 has the wrong signature for rb_protect.
 # define rb_protect(f, arg, state) \
-     ((::Exc_Ruby::Rb_Protect_Signature)(rb_protect))(f, arg, state)
+     ((::Rice::detail::Rb_Protect_Signature)(rb_protect))(f, arg, state)
 //! Ruby 1.6 has the wrong signature for rb_gc_mark.
 # define rb_gc_mark(value) \
-    ((::Exc_Ruby::Rb_Gc_Mark_Signature)(rb_gc_mark))(value)
+    ((::Rice::detail::Rb_Gc_Mark_Signature)(rb_gc_mark))(value)
 //! Ruby 1.6 has the wrong signature for rb_set_end_proc.
 # define rb_set_end_proc(f,v) \
-    ((::Exc_Ruby::Rb_Set_End_Proc_Signature)(rb_set_end_proc))(f, v)
+    ((::Rice::detail::Rb_Set_End_Proc_Signature)(rb_set_end_proc))(f, v)
 #endif
 
 #ifndef RSTRING_LEN
@@ -84,6 +85,18 @@ extern "C" typedef VALUE (*RUBY_VALUE_FUNC)(VALUE);
 #define RSTRING_PTR(str) RSTRING(str)->ptr
 #endif
 
+#ifndef RARRAY_LEN
+#define RARRAY_LEN(arr) RARRAY(arr)->len
+#endif
+
+#ifndef RARRAY_PTR
+#define RARRAY_PTR(arr) RARRAY(arr)->ptr
+#endif
+
+#ifndef RHASH_TBL
+#define RHASH_TBL(hsh) RHASH(hsh)->tbl
+#endif
+
 // ruby.h has a few defines that conflict with Visual Studio's STL
 #if defined(_MSC_VER)
   #undef write
@@ -91,5 +104,18 @@ extern "C" typedef VALUE (*RUBY_VALUE_FUNC)(VALUE);
   #undef bind
 #endif
 
+#if RICE__RUBY_VERSION_CODE < 190
+namespace Rice
+{
+  namespace detail
+  {
+    inline VALUE rb_errinfo() { return ruby_errinfo; }
+    inline void rb_set_errinfo(VALUE exc) { ruby_errinfo = exc; }
+  } // detail
+} // Rice
+#define rb_errinfo() ::Rice::detail::rb_errinfo()
+#define rb_set_errinfo(exc) ::Rice::detail::rb_set_errinfo(exc)
+#endif
+
 #endif // Rice__detail__ruby__hpp_
 

data/rice/detail/ruby_version_code.hpp

@@ -0,0 +1,6 @@
+#ifndef Rice__detail__ruby_version_code__hpp
+#define Rice__detail__ruby_version_code__hpp
+
+#define RICE__RUBY_VERSION_CODE 187
+
+#endif // Rice__detail__ruby_version_code__hpp

data/rice/detail/ruby_version_code.hpp.in

@@ -0,0 +1,6 @@
+#ifndef Rice__detail__ruby_version_code__hpp
+#define Rice__detail__ruby_version_code__hpp
+
+#define RICE__RUBY_VERSION_CODE @RUBY_VERSION_CODE@
+
+#endif // Rice__detail__ruby_version_code__hpp

data/rice/detail/rubysig.hpp

@@ -1,13 +1,19 @@
 #ifndef Rice__detail__rubysig__hpp_
 #define Rice__detail__rubysig__hpp_
 
+#include "ruby_version_code.hpp"
+
 /**
  * Helper header for the rubysig.h ruby include file, which does
  * not have extern "C"
  */
 
+#if RICE__RUBY_VERSION_CODE < 190
+
 extern "C" {
   #include "rubysig.h"
 }
 
 #endif
+
+#endif

data/rice/detail/st.hpp

@@ -12,13 +12,17 @@
 
 extern "C"
 {
+#ifdef RUBY_VM
+#include "ruby/st.h"
+#else
 #include "st.h"
+#endif
 }
 
 // Older versions of Ruby don't have proper signatures for the st_
 // functions
 
-#if RUBY_VERSION_CODE < 180
+#if RICE__RUBY_VERSION_CODE < 180
 
 typedef char * st_data_t;
 
@@ -50,7 +54,7 @@ extern "C" typedef st_table* (*St_Init_Table_Signature)(
 
 } // namespace Exc_Ruby
 
-#endif // RUBY_VERSION_CODE < 180
+#endif // RICE__RUBY_VERSION_CODE < 180
 
 #endif // Exc_Ruby___cpp__st__hpp_
 

data/rice/detail/wrap_function.hpp

@@ -9,6 +9,8 @@
 
 #include "Exception_Handler.hpp"
 #include "Wrapped_Function.hpp"
+#include "../Object_defn.hpp"
+#include "../Data_Object.hpp"
 
 namespace Rice
 {
@@ -23,257 +25,257 @@ namespace detail
 template<typename Ret_T, typename Arg0_T>
 Wrapped_Function * wrap_function(
     Ret_T (*func)(Arg0_T),
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 template<typename Ret_T, typename Self_T>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(),
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 template<typename Ret_T, typename Self_T>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)() const,
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 // ---------------------------------------------------------------------
 template<typename Ret_T, typename Arg0_T, typename Arg1_T>
 Wrapped_Function * wrap_function(
     Ret_T (*func)(Arg0_T, Arg1_T),
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 template<typename Ret_T, typename Self_T, typename Arg1_T>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(Arg1_T),
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 template<typename Ret_T, typename Self_T, typename Arg1_T>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(Arg1_T) const,
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 // ---------------------------------------------------------------------
 template<typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T>
 Wrapped_Function * wrap_function(
     Ret_T (*func)(Arg0_T, Arg1_T, Arg2_T),
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 template<typename Ret_T, typename Self_T, typename Arg1_T, typename Arg2_T>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(Arg1_T, Arg2_T),
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 template<typename Ret_T, typename Self_T, typename Arg1_T, typename Arg2_T>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(Arg1_T, Arg2_T) const,
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 // ---------------------------------------------------------------------
 template<typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T>
 Wrapped_Function * wrap_function(
     Ret_T (*func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T),
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 template<typename Ret_T, typename Self_T, typename Arg1_T, typename Arg2_T, typename Arg3_T>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(Arg1_T, Arg2_T, Arg3_T),
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 template<typename Ret_T, typename Self_T, typename Arg1_T, typename Arg2_T, typename Arg3_T>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(Arg1_T, Arg2_T, Arg3_T) const,
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 // ---------------------------------------------------------------------
 template<typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T>
 Wrapped_Function * wrap_function(
     Ret_T (*func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T),
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 template<typename Ret_T, typename Self_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(Arg1_T, Arg2_T, Arg3_T, Arg4_T),
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 template<typename Ret_T, typename Self_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(Arg1_T, Arg2_T, Arg3_T, Arg4_T) const,
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 // ---------------------------------------------------------------------
 template<typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T>
 Wrapped_Function * wrap_function(
     Ret_T (*func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T),
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 template<typename Ret_T, typename Self_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T),
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 template<typename Ret_T, typename Self_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T) const,
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 // ---------------------------------------------------------------------
 template<typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T>
 Wrapped_Function * wrap_function(
     Ret_T (*func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T),
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 template<typename Ret_T, typename Self_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T),
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 template<typename Ret_T, typename Self_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T) const,
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 // ---------------------------------------------------------------------
 template<typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T>
 Wrapped_Function * wrap_function(
     Ret_T (*func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T),
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 template<typename Ret_T, typename Self_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T),
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 template<typename Ret_T, typename Self_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T) const,
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 // ---------------------------------------------------------------------
 template<typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T>
 Wrapped_Function * wrap_function(
     Ret_T (*func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T),
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 template<typename Ret_T, typename Self_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T),
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 template<typename Ret_T, typename Self_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T) const,
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 // ---------------------------------------------------------------------
 template<typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T>
 Wrapped_Function * wrap_function(
     Ret_T (*func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T),
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 template<typename Ret_T, typename Self_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T),
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 template<typename Ret_T, typename Self_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T) const,
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 // ---------------------------------------------------------------------
 template<typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T>
 Wrapped_Function * wrap_function(
     Ret_T (*func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T),
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 template<typename Ret_T, typename Self_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T),
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 template<typename Ret_T, typename Self_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T) const,
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 // ---------------------------------------------------------------------
 template<typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T>
 Wrapped_Function * wrap_function(
     Ret_T (*func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T),
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 template<typename Ret_T, typename Self_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T),
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 template<typename Ret_T, typename Self_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T) const,
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 // ---------------------------------------------------------------------
 template<typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T>
 Wrapped_Function * wrap_function(
     Ret_T (*func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T),
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 template<typename Ret_T, typename Self_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T),
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 template<typename Ret_T, typename Self_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T) const,
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 // ---------------------------------------------------------------------
 template<typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T>
 Wrapped_Function * wrap_function(
     Ret_T (*func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T),
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 template<typename Ret_T, typename Self_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T),
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 template<typename Ret_T, typename Self_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T) const,
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 // ---------------------------------------------------------------------
 template<typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T, typename Arg14_T>
 Wrapped_Function * wrap_function(
     Ret_T (*func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T),
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 template<typename Ret_T, typename Self_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T, typename Arg14_T>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T),
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 template<typename Ret_T, typename Self_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T, typename Arg14_T>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T) const,
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 // ---------------------------------------------------------------------
 template<typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T, typename Arg14_T, typename Arg15_T>
 Wrapped_Function * wrap_function(
     Ret_T (*func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T, Arg15_T),
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 template<typename Ret_T, typename Self_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T, typename Arg14_T, typename Arg15_T>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T, Arg15_T),
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 template<typename Ret_T, typename Self_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T, typename Arg14_T, typename Arg15_T>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T, Arg15_T) const,
-    Exception_Handler const * handler = 0);
+    Data_Object<Exception_Handler> handler = Rice::Nil);
 
 // ---------------------------------------------------------------------
 #endif // DOXYGEN