rice 1.1.0 → 1.2.0

data/rice/detail/Caster.hpp

@@ -44,7 +44,9 @@ protected:
       }
       else
       {
-        throw std::runtime_error("bad cast");
+        std::string s = "bad cast. No caster found for ";
+        s += type_.name().str();
+        throw std::runtime_error(s);
       }
     }
   }

data/rice/detail/creation_funcs.hpp

@@ -9,14 +9,6 @@ class Class;
 namespace detail
 {
 
-//! Ruby 1.6.x doesn't have rb_define_alloc_func, but Ruby 1.8 will.
-//! It's the "new" way to allocate objects.  This function will just
-//! define a singleton new method on older versions of Ruby, and will
-//! call rb_define_alloc_func() on newer versions of Ruby.
-void define_alloc_func(
-    Class const & klass,
-    RUBY_VALUE_FUNC allocate_func);
-
 //! Like define_alloc_func, but allows the user to define an
 //! "initialize" method too.
 template<typename Initialize_Func_T>

data/rice/detail/creation_funcs.ipp

@@ -7,45 +7,19 @@ namespace Rice
 namespace detail
 {
 
-namespace
-{
-  inline VALUE ruby_16_new(int argc, VALUE * argv, VALUE klass)
-  {
-    VALUE obj = rb_funcall(klass, rb_intern("allocate"), 0);
-    rb_obj_call_init(obj, argc, argv);
-    return obj;
-  }
-}
-
-inline void define_alloc_func(
-    Class const & klass,
-    RUBY_VALUE_FUNC allocate_func)
-{
-#if RICE__RUBY_VERSION_CODE < 170
-  klass.define_singleton_method("allocate", allocate_func);
-  klass.define_singleton_method("new", ruby_16_new);
-#else
-  rb_define_alloc_func(klass, allocate_func);
-#endif
-}
-
 template<typename Initialize_Func_T>
 inline void define_creation_funcs(
     Class const & klass,
     RUBY_VALUE_FUNC allocate_func,
     Initialize_Func_T initialize_func)
 {
-  define_alloc_func(klass, allocate_func);
+  rb_define_alloc_func(klass, allocate_func);
   klass.define_method("initialize", initialize_func);
 }
 
 inline void undef_alloc_func(Class const & klass)
 {
-#if RICE__RUBY_VERSION_CODE >= 170
   rb_undef_alloc_func(klass);
-#else
-  rb_undef_method(CLASS_OF(klass), "new");
-#endif
 }
 
 inline void undef_creation_funcs(Class const & klass)

data/rice/detail/define_method_and_auto_wrap.hpp

@@ -4,6 +4,7 @@
 #include "ruby.hpp"
 #include "../Data_Object.hpp"
 #include "../Identifier.hpp"
+#include "Arguments.hpp"
 
 namespace Rice
 {
@@ -18,7 +19,8 @@ void define_method_and_auto_wrap(
     VALUE klass,
     Identifier name,
     Fun_T function,
-    Data_Object<Exception_Handler> handler);
+    Data_Object<Exception_Handler> handler,
+    Arguments* arguments = 0);
 
 } // detail
 

data/rice/detail/define_method_and_auto_wrap.ipp

@@ -12,17 +12,18 @@ define_method_and_auto_wrap(
     VALUE klass,
     Identifier name,
     Fun_T function,
-    Data_Object<Exception_Handler> handler)
+    Data_Object<Exception_Handler> handler,
+    Arguments* arguments)
 {
   Data_Object<Wrapped_Function> f(
-      wrap_function(function, handler),
+      wrap_function(function, handler, arguments),
       rb_cObject);
   Rice::protect(
       define_method_with_data,
       klass,
       name.id(),
       f->func(),
-      f->arity(),
+      -1,
       f);
 }
 

data/rice/detail/object_call.ipp

@@ -6,7 +6,7 @@
 inline Rice::Object Rice::Object::
 call(Identifier id) const
 {
-  VALUE args[] = { Qnil };
+  VALUE args[] = {  };
   return protect(rb_funcall2, value(), id, 0, args);
 }
 

data/rice/detail/ruby.hpp

@@ -42,39 +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 RICE__RUBY_VERSION_CODE <= 166
-    extern "C" typedef VALUE (*RUBY_METHOD_FUNC)();
-# else
-    extern "C" typedef VALUE (*RUBY_METHOD_FUNC)(ANYARGS);
-# endif
-#endif
-
-// Some functions have the wrong prototype on Ruby 1.6.  Casting from a
-// 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 RICE__RUBY_VERSION_CODE < 170
-  namespace Rice
-  {
-    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) \
-     ((::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) \
-    ((::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) \
-    ((::Rice::detail::Rb_Set_End_Proc_Signature)(rb_set_end_proc))(f, v)
+  extern "C" typedef VALUE (*RUBY_METHOD_FUNC)(ANYARGS);
 #endif
 
 #ifndef RSTRING_LEN

data/rice/detail/wrap_function.hpp

@@ -11,6 +11,7 @@
 #include "Wrapped_Function.hpp"
 #include "../Object_defn.hpp"
 #include "../Data_Object.hpp"
+#include "Arguments.hpp"
 
 namespace Rice
 {
@@ -22,260 +23,314 @@ namespace detail
 
 #else
 
+template<typename Ret_T>
+Wrapped_Function * wrap_function(
+    Ret_T (*func)(),
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
+
 template<typename Ret_T, typename Arg0_T>
 Wrapped_Function * wrap_function(
     Ret_T (*func)(Arg0_T),
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 template<typename Ret_T, typename Self_T>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(),
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 template<typename Ret_T, typename Self_T>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)() const,
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 // ---------------------------------------------------------------------
 template<typename Ret_T, typename Arg0_T, typename Arg1_T>
 Wrapped_Function * wrap_function(
     Ret_T (*func)(Arg0_T, Arg1_T),
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 template<typename Ret_T, typename Self_T, typename Arg1_T>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(Arg1_T),
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 template<typename Ret_T, typename Self_T, typename Arg1_T>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(Arg1_T) const,
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 // ---------------------------------------------------------------------
 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),
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 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),
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 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,
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 // ---------------------------------------------------------------------
 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),
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 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),
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 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,
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 // ---------------------------------------------------------------------
 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),
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 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),
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 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,
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 // ---------------------------------------------------------------------
 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),
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 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),
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 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,
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 // ---------------------------------------------------------------------
 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),
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 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),
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 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,
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 // ---------------------------------------------------------------------
 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),
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 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),
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 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,
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 // ---------------------------------------------------------------------
 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),
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 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),
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 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,
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 // ---------------------------------------------------------------------
 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),
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 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),
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 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,
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 // ---------------------------------------------------------------------
 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),
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 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),
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 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,
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 // ---------------------------------------------------------------------
 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),
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 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),
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 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,
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 // ---------------------------------------------------------------------
 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),
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 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),
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 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,
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 // ---------------------------------------------------------------------
 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),
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 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),
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 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,
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 // ---------------------------------------------------------------------
 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),
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 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),
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 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,
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 // ---------------------------------------------------------------------
 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),
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 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),
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 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,
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 // ---------------------------------------------------------------------
 #endif // DOXYGEN