rice 1.1.0 → 1.2.0

data/rice/generate_code.rb

@@ -284,7 +284,7 @@ wrap_header(hpp_filename, nil, docstring, false, nil, nil, GENERATED_FILE_WARNIN
       arg_list = t_array.map { |x| ", T#{x} arg#{x}" }
       if j == 0 then
         template = ''
-        convert_list = 'Qnil';
+        convert_list = '';
       else
         template = 'template<' + t_array.map { |x| "typename T#{x}" }.join(', ') + '>'
         convert_list = t_array.map { |x| "to_ruby(arg#{x})" }.join(', ')
@@ -313,25 +313,56 @@ template<typename Func_T, typename Ret_T, %(typename_list)>
 Auto_Function_Wrapper<Func_T, Ret_T, %(typenames)>::
 Auto_Function_Wrapper(
     Func func,
-    Data_Object<Exception_Handler> handler)
+    Data_Object<Exception_Handler> handler,
+    Arguments* arguments)
   : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
   , func_(func)
   , handler_(handler)
   , handler_guard_(&handler_)
 {
+  if(arguments == 0) {
+    arguments_ = new Arguments();
+  } else {
+    arguments_ = arguments;
+  }
 }
 
 template<typename Func_T, typename Ret_T, %(typename_list)>
 VALUE Auto_Function_Wrapper<Func_T, Ret_T, %(typenames)>::
-call(%(value_args))
+call(int argc, VALUE *argv, VALUE self)
 {
   Auto_Function_Wrapper<Func_T, Ret_T, %(typenames)> * wrapper = 0;
   try
   {
     Data_Object<Wrapped_Function> data(detail::method_data());
     wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, %(typenames)> *)data.get();
-    %(arg_convert_list)
-    return to_ruby(wrapper->func_(%(arg_list)));
+    Arguments* args = wrapper->arguments_;
+
+    bool hasSelf = (self && self != Qnil);
+    if(args->count() >= 0) {
+      hasSelf = hasSelf && args->count() == Num_Args - 1;
+    } else {
+      hasSelf = hasSelf && argc == Num_Args -1;
+    }
+
+    VALUE %(scan_def_list);
+
+    if(hasSelf) {
+      rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
+        %(scan_args_list));
+
+      Arg0_T arg0 = from_ruby<Arg0_T>(self); 
+      %(self_arg_convert_list)
+
+      return to_ruby(wrapper->func_(%(arg_list)));
+    } else {
+      rb_scan_args(argc, argv, args->formatString(Num_Args)
+        %(scan_args_list));
+
+      %(arg_convert_list)
+
+      return to_ruby(wrapper->func_(%(arg_list)));
+    }
   }
   catch(...)
   {
@@ -354,17 +385,23 @@ template<typename Func_T, %(typename_list)>
 Auto_Function_Wrapper<Func_T, void, %(typenames)>::
 Auto_Function_Wrapper(
     Func func,
-    Data_Object<Exception_Handler> handler)
+    Data_Object<Exception_Handler> handler,
+    Arguments* arguments)
   : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
   , func_(func)
   , handler_(handler)
   , handler_guard_(&handler_)
 {
+  if(arguments == 0) {
+    arguments_ = new Arguments();
+  } else {
+    arguments_ = arguments;
+  }
 }
 
 template<typename Func_T, %(typename_list)>
 VALUE Auto_Function_Wrapper<Func_T, void, %(typenames)>::
-call(%(value_args))
+call(int argc, VALUE* argv, VALUE self)
 {
   Auto_Function_Wrapper<Func_T, void, %(typenames)> * wrapper = 0;
   try
@@ -372,9 +409,35 @@ call(%(value_args))
     Data_Object<Wrapped_Function> data(detail::method_data());
     wrapper =
       (Auto_Function_Wrapper<Func_T, void, %(typenames)> *)data.get();
-    %(arg_convert_list)
-    wrapper->func_(%(arg_list));
-    return Qnil;
+    Arguments* args = wrapper->arguments_;
+
+    bool hasSelf = (self && self != Qnil);
+    if(args->count() >= 0) {
+      hasSelf = hasSelf && args->count() == Num_Args - 1;
+    } else {
+      hasSelf = hasSelf && argc == Num_Args -1;
+    }
+
+    VALUE %(scan_def_list);
+
+    if(hasSelf) {
+      rb_scan_args(argc, argv, args->formatString(Num_Args - 1) 
+        %(scan_args_list));
+
+      Arg0_T arg0 = from_ruby<Arg0_T>(self); 
+      %(self_arg_convert_list)
+
+      wrapper->func_(%(arg_list));
+      return Qnil;
+    } else {
+      rb_scan_args(argc, argv, args->formatString(Num_Args)
+        %(scan_args_list));
+
+      %(arg_convert_list)
+
+      wrapper->func_(%(arg_list));
+      return Qnil;
+    }
   }
   catch(...)
   {
@@ -412,14 +475,16 @@ public:
 
   Auto_Function_Wrapper(
       Func func,
-      Data_Object<Exception_Handler> handler);
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
 
-  static VALUE call(%(value_args));
+  static VALUE call(int argc, VALUE* args, VALUE self);
 
 private:
   Func func_;
   Data_Object<Exception_Handler> handler_;
   Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
 };
 
 template<typename Func_T, %(typename_list)>
@@ -434,14 +499,16 @@ public:
 
   Auto_Function_Wrapper(
       Func func,
-      Data_Object<Exception_Handler> handler);
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
 
-  static VALUE call(%(value_args));
+  static VALUE call(int argc, VALUE* args, VALUE self);
 
 private:
   Func func_;
   Data_Object<Exception_Handler> handler_;
   Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
 };
 
 // ---------------------------------------------------------------------
@@ -455,19 +522,159 @@ ipp_head = <<END
 #include "../ruby_try_catch.hpp"
 #include "../to_from_ruby.hpp"
 END
+ipp_tail = <<END
+template<typename Func_T, typename Ret_T>
+Auto_Function_Wrapper<Func_T, Ret_T>::
+Auto_Function_Wrapper(
+    Func func,
+    Data_Object<Exception_Handler> handler,
+    Arguments* arguments)
+  : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
+  , func_(func)
+  , handler_(handler ? handler : new Default_Exception_Handler)
+  , arguments_(arguments)
+{
+}
+
+template<typename Func_T, typename Ret_T>
+VALUE Auto_Function_Wrapper<Func_T, Ret_T>::
+call()
+{
+  Auto_Function_Wrapper<Func_T, Ret_T> * wrapper = 0;
+  try
+  {
+    Data_Object<Wrapped_Function> data(detail::method_data());
+    wrapper = (Auto_Function_Wrapper<Func_T, Ret_T>*)data.get();
+
+    return to_ruby<Ret_T>(wrapper->func_());
+  }
+  catch(...)
+  {
+    RUBY_TRY
+    {
+      if(wrapper)
+      {
+        return wrapper->handler_->handle_exception();
+      }
+      else
+      {
+        throw;
+      }
+    }
+    RUBY_CATCH
+  }
+}
+
+template<typename Func_T>
+Auto_Function_Wrapper<Func_T, void>::
+Auto_Function_Wrapper(
+    Func func,
+    Data_Object<Exception_Handler> handler,
+    Arguments* arguments)
+  : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
+  , func_(func)
+  , handler_(handler ? handler : new Default_Exception_Handler)
+  , arguments_(arguments)
+{
+}
+
+template<typename Func_T>
+VALUE Auto_Function_Wrapper<Func_T, void>::
+call()
+{
+  Auto_Function_Wrapper<Func_T, void> * wrapper = 0;
+  try
+  {
+    Data_Object<Wrapped_Function> data(detail::method_data());
+    wrapper =
+      (Auto_Function_Wrapper<Func_T, void> *)data.get();
+
+    wrapper->func_();
+    return Qnil;
+  }
+  catch(...)
+  {
+    RUBY_TRY
+    {
+      if(wrapper)
+      {
+        return wrapper->handler_->handle_exception();
+      }
+      else
+      {
+        throw;
+      }
+    }
+    RUBY_CATCH
+  }
+}
+END
+hpp_tail = <<END
+
+template<typename Func_T, typename Ret_T>
+class Auto_Function_Wrapper<Func_T, Ret_T>
+  : public Wrapped_Function
+{
+public:
+  // typedef void (*Func)();
+  typedef Func_T Func;
+
+  static const int Num_Args = 0;
+
+  Auto_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = new Arguments());
+
+  static VALUE call();
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Arguments* arguments_;
+};
+
+template<typename Func_T>
+class Auto_Function_Wrapper<Func_T, void>
+  : public Wrapped_Function
+{
+public:
+  // typedef void (*Func)();
+  typedef Func_T Func;
+
+  static const int Num_Args = 0;
+
+  Auto_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = new Arguments());
+
+  static VALUE call();
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Arguments* arguments_;
+};
+END
 ipp_filename = 'detail/Auto_Function_Wrapper.ipp'
 hpp_filename = 'detail/Auto_Function_Wrapper.hpp'
 wrap_header(hpp_filename, 'Rice::detail', docstring, true, hpp_head) do |hpp|
   wrap_header(ipp_filename, 'Rice::detail', nil, false, ipp_head) do |ipp|
-    j = MAX_ARGS # TODO: what's the best way to iterate backward?
-    while j >= 0 do
+    MAX_ARGS.downto(0) do |j|
       t_array = (0..j).to_a
-      value_args    = t_array.map { |x| "VALUE ruby_arg#{x}" }.join(', ')
+      scan_def_list  = t_array.map { |x| "varg#{x}" }.join(', ')
+      arg_def_list  = t_array.map { |x| "Arg#{x}_T arg#{x};"}
       arg_list      = t_array.map { |x| "arg#{x}" }.join(', ')
+      scan_args_list = t_array.map { |x| ", &varg#{x}"}
       typenames     = t_array.map { |x| "Arg#{x}_T" }.join(', ')
-      arg_convert_list = t_array.map do |x|
-        "Arg#{x}_T arg#{x}(from_ruby<Arg#{x}_T>(ruby_arg#{x})); "
-      end
+      arg_convert_list  = t_array.map do |x|
+        "Arg#{x}_T arg#{x} = args->getArgumentOrDefault<Arg#{x}_T>(#{x}, varg#{x});"
+      end.join("\n\t\t\t")
+      self_arg_convert_list = (0...j).to_a.map do |x|
+        n = x + 1
+        "Arg#{n}_T arg#{n} = args->getArgumentOrDefault<Arg#{n}_T>(#{x}, varg#{x});"
+      end.join("\n\t\t\t")
       if j == MAX_ARGS then
         typename_list = t_array.map { |x| "typename Arg#{x}_T" }.join(', ')
         typename_list_d = t_array.map { |x| "typename Arg#{x}_T = void" }.join(', ')
@@ -478,22 +685,24 @@ wrap_header(hpp_filename, 'Rice::detail', docstring, true, hpp_head) do |hpp|
         specializations = "<Func_T, Ret_T, #{typenames}>"
       end
       ipp.puts fill_template(ipp_template, {
-        :value_args       => value_args,
+        :scan_def_list    => scan_def_list,
         :arg_list         => arg_list,
         :typenames        => typenames,
         :typename_list    => typename_list,
         :arg_convert_list => arg_convert_list,
+        :scan_args_list   => scan_args_list,
+        :self_arg_convert_list => self_arg_convert_list,
       })
       hpp.puts fill_template(hpp_template, {
-        :value_args       => value_args,
         :typenames        => typenames,
         :typename_list_d  => typename_list_d,
         :typename_list    => typename_list,
-        :j                => j,
+        :j                => j + 1,
         :specializations  => specializations,
       })
-      j -= 1
     end
+    ipp.puts ipp_tail
+    hpp.puts hpp_tail
   end
 end
 
@@ -508,17 +717,24 @@ template<typename Func_T, typename Ret_T, typename Self_T%(typename_list)>
 Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T%(typenames)>::
 Auto_Member_Function_Wrapper(
     Func func,
-    Data_Object<Exception_Handler> handler)
+    Data_Object<Exception_Handler> handler,
+    Arguments* arguments)
   : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
   , func_(func)
   , handler_(handler)
   , handler_guard_(&handler_)
+  , arguments_(arguments)
 {
+  if(arguments == 0) {
+    arguments_ = new Arguments();
+  } else {
+    arguments_ = arguments;
+  }
 }
 
 template<typename Func_T, typename Ret_T, typename Self_T%(typename_list)>
 VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T%(typenames)>::
-call(VALUE self%(value_args))
+call(int argc, VALUE* argv, VALUE self)
 {
   Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T%(typenames)> * wrapper = 0;
   try
@@ -526,8 +742,16 @@ call(VALUE self%(value_args))
     Data_Object<Wrapped_Function> data(detail::method_data());
     wrapper =
       (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T%(typenames)> *)data.get();
+    Arguments* args = wrapper->arguments_;
+
+    VALUE %(scan_def_list);
+
+    rb_scan_args(argc, argv, args->formatString(Num_Args), 
+      %(scan_args_list));
+
     Self_T * obj = from_ruby<Self_T *>(self);
     %(arg_convert_list)
+
     Func func = wrapper->func_;
     return to_ruby((*obj.*func)(%(arg_list)));
   }
@@ -552,17 +776,24 @@ template<typename Func_T, typename Self_T%(typename_list)>
 Auto_Member_Function_Wrapper<Func_T, void, Self_T%(typenames)>::
 Auto_Member_Function_Wrapper(
     Func func,
-    Data_Object<Exception_Handler> handler)
+    Data_Object<Exception_Handler> handler,
+    Arguments* arguments)
   : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
   , func_(func)
   , handler_(handler)
   , handler_guard_(&handler_)
+  , arguments_(arguments)
 {
+  if(arguments == 0) {
+    arguments_ = new Arguments();
+  } else {
+    arguments_ = arguments;
+  }
 }
 
 template<typename Func_T, typename Self_T%(typename_list)>
 VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_T%(typenames)>::
-call(VALUE self%(value_args))
+call(int argc, VALUE* argv, VALUE self)
 {
   Auto_Member_Function_Wrapper<Func_T, void, Self_T%(typenames)> * wrapper = 0;
   try
@@ -570,8 +801,16 @@ call(VALUE self%(value_args))
     Data_Object<Wrapped_Function> data(detail::method_data());
     wrapper =
       (Auto_Member_Function_Wrapper<Func_T, void, Self_T%(typenames)> *)data.get();
+    Arguments* args = wrapper->arguments_;
+
+    VALUE %(scan_def_list);
+
+    rb_scan_args(argc, argv, args->formatString(Num_Args), 
+      %(scan_args_list));
+
     Self_T * obj = from_ruby<Self_T *>(self);
     %(arg_convert_list)
+
     Func func = wrapper->func_;
     (*obj.*func)(%(arg_list));
     return Qnil;
@@ -593,6 +832,115 @@ call(VALUE self%(value_args))
   }
 }
 
+// ---------------------------------------------------------------------
+END
+ipp_tail = <<END
+template<typename Func_T, typename Ret_T, typename Self_T>
+Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T>::
+Auto_Member_Function_Wrapper(
+    Func func,
+    Data_Object<Exception_Handler> handler,
+    Arguments* arguments)
+  : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
+  , func_(func)
+  , handler_(handler)
+  , handler_guard_(&handler_)
+  , arguments_(arguments)
+{
+  if(arguments == 0) {
+    arguments_ = new Arguments();
+  } else {
+    arguments_ = arguments;
+  }
+}
+
+template<typename Func_T, typename Ret_T, typename Self_T>
+VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T>::
+call(int argc, VALUE* argv, VALUE self)
+{
+  Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T> * wrapper = 0;
+  try
+  {
+    Data_Object<Wrapped_Function> data(detail::method_data());
+    wrapper =
+      (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T> *)data.get();
+
+    rb_scan_args(argc, argv, "0");
+    Self_T * obj = from_ruby<Self_T *>(self);
+
+    Func func = wrapper->func_;
+    return to_ruby((*obj.*func)());
+  }
+  catch(...)
+  {
+    RUBY_TRY
+    {
+      if(wrapper)
+      {
+        return wrapper->handler_->handle_exception();
+      }
+      else
+      {
+        throw;
+      }
+    }
+    RUBY_CATCH
+  }
+}
+
+template<typename Func_T, typename Self_T>
+Auto_Member_Function_Wrapper<Func_T, void, Self_T>::
+Auto_Member_Function_Wrapper(
+    Func func,
+    Data_Object<Exception_Handler> handler,
+    Arguments* arguments)
+  : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
+  , func_(func)
+  , handler_(handler)
+  , handler_guard_(&handler_)
+  , arguments_(arguments)
+{
+  if(arguments == 0) {
+    arguments_ = new Arguments();
+  } else {
+    arguments_ = arguments;
+  }
+}
+
+template<typename Func_T, typename Self_T>
+VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_T>::
+call(int argc, VALUE* argv, VALUE self)
+{
+  Auto_Member_Function_Wrapper<Func_T, void, Self_T> * wrapper = 0;
+  try
+  {
+    Data_Object<Wrapped_Function> data(detail::method_data());
+    wrapper =
+      (Auto_Member_Function_Wrapper<Func_T, void, Self_T> *)data.get();
+    rb_scan_args(argc, argv, "0");
+    Self_T * obj = from_ruby<Self_T *>(self);
+
+    Func func = wrapper->func_;
+    (*obj.*func)();
+    return Qnil;
+  }
+  catch(...)
+  {
+    RUBY_TRY
+    {
+      if(wrapper)
+      {
+        return wrapper->handler_->handle_exception();
+      }
+      else
+      {
+        throw;
+      }
+    }
+    RUBY_CATCH
+  }
+}
+
 // ---------------------------------------------------------------------
 END
 hpp_template = <<END
@@ -607,14 +955,16 @@ public:
 
   Auto_Member_Function_Wrapper(
       Func func,
-      Data_Object<Exception_Handler> handler);
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
 
-  static VALUE call(VALUE self%(value_args));
+  static VALUE call(int argc, VALUE* argv, VALUE self);
 
 private:
   Func func_;
   Data_Object<Exception_Handler> handler_;
   Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
 };
 
 template<typename Func_T, typename Self_T%(typename_list)>
@@ -628,14 +978,65 @@ public:
 
   Auto_Member_Function_Wrapper(
       Func func,
-      Data_Object<Exception_Handler> handler);
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
+
+  static VALUE call(int argc, VALUE* argv, VALUE self);
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
+};
+
+// ---------------------------------------------------------------------
+END
+hpp_tail = <<END
+template<typename Func_T, typename Ret_T, typename Self_T>
+class Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T>
+  : public Wrapped_Function
+{
+public:
+  typedef Func_T Func;
+
+  static const int Num_Args = 0;
+
+  Auto_Member_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
 
-  static VALUE call(VALUE self%(value_args));
+  static VALUE call(int argc, VALUE* argv, VALUE self);
 
 private:
   Func func_;
   Data_Object<Exception_Handler> handler_;
   Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
+};
+
+template<typename Func_T, typename Self_T>
+class Auto_Member_Function_Wrapper<Func_T, void, Self_T>
+  : public Wrapped_Function
+{
+public:
+  typedef Func_T Func;
+
+  static const int Num_Args = 0;
+
+  Auto_Member_Function_Wrapper(
+      Func func,
+      Data_Object<Exception_Handler> handler,
+      Arguments* arguments = 0);
+
+  static VALUE call(int argc, VALUE* argv, VALUE self);
+
+private:
+  Func func_;
+  Data_Object<Exception_Handler> handler_;
+  Address_Registration_Guard handler_guard_;
+  Arguments* arguments_;
 };
 
 // ---------------------------------------------------------------------
@@ -650,16 +1051,16 @@ ipp_filename = 'detail/Auto_Member_Function_Wrapper.ipp'
 hpp_filename = 'detail/Auto_Member_Function_Wrapper.hpp'
 wrap_header(hpp_filename, 'Rice::detail', docstring, true) do |hpp|
   wrap_header(ipp_filename, 'Rice::detail', nil, false, ipp_head) do |ipp|
-    j = MAX_ARGS # TODO: what's the best way to iterate backward?
-    while j >= 0 do
-      t_array = (1..j).to_a
-      value_args   = t_array.map { |x| ", VALUE ruby_arg#{x}" }
+    MAX_ARGS.downto(0) do |j|
+      t_array = (0..j).to_a
+      scan_def_list  = t_array.map { |x| "varg#{x}" }.join(', ')
       arg_list      = t_array.map { |x| "arg#{x}" }.join(', ')
+      scan_args_list = t_array.map { |x| "&varg#{x}"}.join(', ')
       typenames     = t_array.map { |x| ", Arg#{x}_T" }
       typenames_n   = t_array.map { |x| "Arg#{x}_T" }.join(', ')
-      arg_convert_list = t_array.map do |x|
-        "Arg#{x}_T arg#{x}(from_ruby<Arg#{x}_T>(ruby_arg#{x})); "
-      end
+      arg_convert_list  = t_array.map do |x|
+        "Arg#{x}_T arg#{x} = args->getArgumentOrDefault<Arg#{x}_T>(#{x}, varg#{x});"
+      end.join("\n\t\t")
       if j == MAX_ARGS then
         typename_list = t_array.map { |x| ", typename Arg#{x}_T" }.join
         typename_list_d = t_array.map { |x| ", typename Arg#{x}_T = void" }.join
@@ -670,23 +1071,23 @@ wrap_header(hpp_filename, 'Rice::detail', docstring, true) do |hpp|
         specializations = "<Func_T, Ret_T, Self_T#{typenames}>"
       end
       ipp.puts fill_template(ipp_template, {
-        :value_args       => value_args,
+        :scan_def_list    => scan_def_list,
         :arg_list         => arg_list,
         :typenames        => typenames,
         :typename_list    => typename_list,
+        :scan_args_list   => scan_args_list,
         :arg_convert_list => arg_convert_list,
       })
       hpp.puts fill_template(hpp_template, {
-        :value_args       => value_args,
         :typenames        => typenames,
-        # :typenames_n      => typenames_n,
         :typename_list    => typename_list,
         :typename_list_d  => typename_list_d,
-        :j                => j,
+        :j                => j + 1,
         :specializations  => specializations,
       })
-      j -= 1
     end
+    hpp.puts hpp_tail
+    ipp.puts ipp_tail
   end
 end
 
@@ -696,28 +1097,31 @@ ipp_template = <<END
 template<typename Ret_T, %(typename_list)>
 Wrapped_Function * wrap_function(
     Ret_T (*func)(%(typenames)),
-    Data_Object<Exception_Handler> handler)
+    Data_Object<Exception_Handler> handler,
+    Arguments* arguments)
 {
   typedef Ret_T (*Func)(%(typenames));
-  return new Auto_Function_Wrapper<Func, Ret_T, %(typenames)>(func, handler);
+  return new Auto_Function_Wrapper<Func, Ret_T, %(typenames)>(func, handler, arguments);
 }
 
 template<typename Ret_T, typename Self_T%(typename_list_no_self)>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(%(typenames_no_self_no_comma)),
-    Data_Object<Exception_Handler> handler)
+    Data_Object<Exception_Handler> handler,
+    Arguments* arguments)
 {
   typedef Ret_T (Self_T::*Func)(%(typenames_no_self_no_comma));
-  return new Auto_Member_Function_Wrapper<Func, Ret_T, Self_T%(typenames_no_self)>(func, handler);
+  return new Auto_Member_Function_Wrapper<Func, Ret_T, Self_T%(typenames_no_self)>(func, handler, arguments);
 }
 
 template<typename Ret_T, typename Self_T%(typename_list_no_self)>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(%(typenames_no_self_no_comma)) const,
-    Data_Object<Exception_Handler> handler)
+    Data_Object<Exception_Handler> handler,
+    Arguments* arguments)
 {
   typedef Ret_T (Self_T::*Func)(%(typenames_no_self_no_comma)) const;
-  return new Auto_Member_Function_Wrapper<Func, Ret_T, Self_T%(typenames_no_self)>(func, handler);
+  return new Auto_Member_Function_Wrapper<Func, Ret_T, Self_T%(typenames_no_self)>(func, handler, arguments);
 }
 
 // ---------------------------------------------------------------------
@@ -726,17 +1130,20 @@ hpp_template = <<END
 template<typename Ret_T, %(typename_list)>
 Wrapped_Function * wrap_function(
     Ret_T (*func)(%(typenames)),
-    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_list_no_self)>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(%(typenames_no_self_no_comma)),
-    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_list_no_self)>
 Wrapped_Function * wrap_function(
     Ret_T (Self_T::*func)(%(typenames_no_self_no_comma)) const,
-    Data_Object<Exception_Handler> handler = Rice::Nil);
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 // ---------------------------------------------------------------------
 END
@@ -745,16 +1152,39 @@ hpp_head = <<END
 #include "Wrapped_Function.hpp"
 #include "../Object_defn.hpp"
 #include "../Data_Object.hpp"
+#include "Arguments.hpp"
+
+END
+hpp_start = <<END
+template<typename Ret_T>
+Wrapped_Function * wrap_function(
+    Ret_T (*func)(),
+    Data_Object<Exception_Handler> handler = Rice::Nil,
+    Arguments* arguments = 0);
 
 END
 ipp_head = <<END
 #include "Auto_Function_Wrapper.hpp"
 #include "Auto_Member_Function_Wrapper.hpp"
+END
+ipp_start = <<END
+template<typename Ret_T>
+Wrapped_Function * wrap_function(
+    Ret_T (*func)(),
+    Data_Object<Exception_Handler> handler,
+    Arguments* arguments)
+{
+  typedef Ret_T (*Func)();
+  return new Auto_Function_Wrapper<Func, Ret_T>(func, handler, arguments);
+}
+
 END
 ipp_filename = 'detail/wrap_function.ipp'
 hpp_filename = 'detail/wrap_function.hpp'
 wrap_header(hpp_filename, 'Rice::detail', docstring, true, hpp_head) do |hpp|
   wrap_header(ipp_filename, 'Rice::detail', nil, false, ipp_head) do |ipp|
+    ipp.puts ipp_start
+    hpp.puts hpp_start
     for j in 0..MAX_ARGS do
       t_array = (0..j).to_a
       typenames     = t_array.map { |x| "Arg#{x}_T" }.join(', ')
@@ -806,6 +1236,19 @@ public:
   }
 };
 
+END
+
+hpp_self_template = <<END
+template<typename T%(typename_list)>
+class Constructor<T, Object%(type_list)%(void_list)>
+{
+public:
+  static void construct(Object self%(arg_list))
+  {
+    DATA_PTR(self.value()) = new T(self%(arg_names));
+  }
+};
+
 END
 hpp_head = <<END
 #include "to_from_ruby_defn.hpp"
@@ -820,18 +1263,40 @@ wrap_header(hpp_filename, 'Rice', nil, false, hpp_head) do |hpp|
     typename_list    = t_array.map { |x| ", typename Arg#{x}_T" }
     type_list        = t_array.map { |x| ", Arg#{x}_T" }
     void_list        = o_array.map { |x| ", void" }
+
     arg_list         = t_array.map { |x| ", Arg#{x}_T arg#{x}" }
     arg_names        = t_array.map { |x| "arg#{x}" }.join(', ')
+
     hpp.puts fill_template(hpp_template, {
       :typename_list    => typename_list,
       :type_list        => type_list,
       :void_list        => void_list,
       :arg_list         => arg_list,
-      :arg_names        => arg_names,
+      :arg_names        => arg_names
+    })
+  end
+
+  # For the self / Director system
+  for j in 0..(MAX_ARGS - 1) do
+    t_array = (1..j).to_a
+    o_array = (j..(MAX_ARGS - 1)).to_a
+    typename_list    = t_array.map { |x| ", typename Arg#{x}_T" }
+    type_list        = t_array.map { |x| ", Arg#{x}_T" }
+    void_list        = o_array.map { |x| ", void" }
+
+    arg_list         = t_array.map { |x| ", Arg#{x}_T arg#{x}" }
+    arg_names        = t_array.map { |x| ", arg#{x}" }
+
+    hpp.puts fill_template(hpp_self_template, {
+      :typename_list    => typename_list,
+      :type_list        => type_list,
+      :void_list        => void_list,
+      :arg_list         => arg_list,
+      :arg_names        => arg_names
     })
   end
 end
- 
+
 if ARGV[0] == '--clean' then
   $filenames.each do |filename|
     File.rm_f(filename)