rice 1.3.0 → 1.3.1

data/Doxyfile

@@ -23,7 +23,7 @@ PROJECT_NAME           = Rice
 # This could be handy for archiving the generated documentation or 
 # if some version control system is used.
 
-PROJECT_NUMBER         = 1.3.0
+PROJECT_NUMBER         = 1.3.1
 
 # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) 
 # base path where the generated documentation will be put. 

data/README

@@ -21,7 +21,7 @@ The source is hosted on github: http://github.com/jameskilton/rice
 
 Bug tracking: http://github.com/jameskilton/rice/issues
 
-Mailing List: http://groups.google.com/group/ruby-rice
+Mailing List: rice@librelist.com (your first email will be used as a subscription request and dropped)
 
 \section installation Installation
 

data/Rakefile

@@ -22,7 +22,7 @@ task :doc do
 end
 
 desc "Upload documentation to the website. Requires rubyforge gem" 
-task :upload_web => [:build, :doc] do
+task :upload_web => [:doc] do
   config = YAML.load(File.read(File.expand_path("~/.rubyforge/user-config.yml")))
   host = "#{config["username"]}@rubyforge.org"
 
@@ -32,6 +32,4 @@ end
 # Gemspec kept externally
 eval(File.read("rice.gemspec"))
 Rake::GemPackageTask.new($spec) do |pkg|
-  pkg.need_zip = true
-  pkg.need_tar = true
 end

data/extconf.rb

@@ -18,7 +18,9 @@ require 'rubygems'
 require 'ruby/lib/version.rb'
 
 gem_name = "rice-#{Rice::VERSION}"
-prefix_dir = File.join(Gem.default_dir, "gems", gem_name, "ruby", "lib")
+
+gem_base_dir = File.writable?(Gem.default_dir) ? Gem.default_dir : Gem.user_dir
+prefix_dir = File.join(gem_base_dir, "gems", gem_name, "ruby", "lib")
 with_ruby = File.join(Config::CONFIG["bindir"], Config::CONFIG["RUBY_INSTALL_NAME"])
 
 other_opts = ""
@@ -27,6 +29,8 @@ env = ""
 if RUBY_PLATFORM =~ /darwin10/
   other_opts = "--disable-dependency-tracking"
   env = "ARCHFLAGS='-arch x86_64'"
+elsif RUBY_PLATFORM =~ /darwin9/
+  env = "ARCHFLAGS='-arch #{`uname -p`.chomp}'"
 end
 
 system "#{env} sh configure --with-ruby=#{with_ruby} --prefix=#{prefix_dir} #{other_opts}"

data/rice/Arg_impl.hpp

@@ -42,6 +42,9 @@ namespace Rice {
 
       virtual ~Arg()
       {
+        if(defaultValue) {
+          delete defaultValue;
+        }
       }
 
       //! Set the default value for this Arg

data/rice/Arg_operators.cpp

@@ -4,7 +4,7 @@
 
 namespace Rice {
 
-  Arguments* operator,(const Arg& arg1, const Arg& arg2)
+  Arguments* operator,(Arg arg1, Arg arg2)
   {
     Arguments* a = new Arguments();
     a->add(arg1);
@@ -12,7 +12,7 @@ namespace Rice {
     return a;
   }
 
-  Arguments* operator,(Arguments* arguments, const Arg& arg)
+  Arguments* operator,(Arguments* arguments, Arg arg)
   {
     arguments->add(arg);
     return arguments;

data/rice/Arg_operators.hpp

@@ -8,11 +8,11 @@ namespace Rice
   /*! Take a list of Arg objects and build up a single Argument
    *  object used later in method dispatch
    */
-  Arguments* operator,(const Arg& arg1, const Arg& arg2);
+  Arguments* operator,(Arg arg1, Arg arg2);
 
   /*! @see operator,(Arg, Arg)
    */
-  Arguments* operator,(Arguments* arguments, const Arg& arg);
+  Arguments* operator,(Arguments* arguments, Arg arg);
 
 }
 

data/rice/detail/Arguments.hpp

@@ -38,7 +38,7 @@ namespace Rice {
        * In the case of no Args (default case), this
        * method uses the passed in full argument count
        */
-      const char* formatString(int fullArgCount)
+      std::string formatString(int fullArgCount)
       {
         std::stringstream s;
         if(required_ == 0 && optional_ == 0)
@@ -50,7 +50,7 @@ namespace Rice {
           s << required_ << optional_;
         }
 
-        return s.str().c_str();
+        return s.str();
       }
 
       /**

data/rice/detail/Auto_Function_Wrapper.ipp

@@ -56,7 +56,7 @@ call(int argc, VALUE *argv, VALUE self)
     VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13, varg14, varg15;
 
     if(hasSelf) {
-      rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
+      rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
 
       Arg0_T arg0 = from_ruby<Arg0_T>(self); 
@@ -93,7 +93,7 @@ call(int argc, VALUE *argv, VALUE self)
 
       return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15));
     } else {
-      rb_scan_args(argc, argv, args->formatString(Num_Args)
+      rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
 
       typedef typename sanitize< Arg0_T >::Type Arg0_Type;
@@ -189,7 +189,7 @@ call(int argc, VALUE* argv, VALUE self)
     VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13, varg14, varg15;
 
     if(hasSelf) {
-      rb_scan_args(argc, argv, args->formatString(Num_Args - 1) 
+      rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
 
       Arg0_T arg0 = from_ruby<Arg0_T>(self); 
@@ -227,7 +227,7 @@ call(int argc, VALUE* argv, VALUE self)
       wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15);
       return Qnil;
     } else {
-      rb_scan_args(argc, argv, args->formatString(Num_Args)
+      rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
 
       typedef typename sanitize< Arg0_T >::Type Arg0_Type;
@@ -324,7 +324,7 @@ call(int argc, VALUE *argv, VALUE self)
     VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13, varg14;
 
     if(hasSelf) {
-      rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
+      rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
 
       Arg0_T arg0 = from_ruby<Arg0_T>(self); 
@@ -359,7 +359,7 @@ call(int argc, VALUE *argv, VALUE self)
 
       return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14));
     } else {
-      rb_scan_args(argc, argv, args->formatString(Num_Args)
+      rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
 
       typedef typename sanitize< Arg0_T >::Type Arg0_Type;
@@ -453,7 +453,7 @@ call(int argc, VALUE* argv, VALUE self)
     VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13, varg14;
 
     if(hasSelf) {
-      rb_scan_args(argc, argv, args->formatString(Num_Args - 1) 
+      rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
 
       Arg0_T arg0 = from_ruby<Arg0_T>(self); 
@@ -489,7 +489,7 @@ call(int argc, VALUE* argv, VALUE self)
       wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
       return Qnil;
     } else {
-      rb_scan_args(argc, argv, args->formatString(Num_Args)
+      rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
 
       typedef typename sanitize< Arg0_T >::Type Arg0_Type;
@@ -584,7 +584,7 @@ call(int argc, VALUE *argv, VALUE self)
     VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13;
 
     if(hasSelf) {
-      rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
+      rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
 
       Arg0_T arg0 = from_ruby<Arg0_T>(self); 
@@ -617,7 +617,7 @@ call(int argc, VALUE *argv, VALUE self)
 
       return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13));
     } else {
-      rb_scan_args(argc, argv, args->formatString(Num_Args)
+      rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
 
       typedef typename sanitize< Arg0_T >::Type Arg0_Type;
@@ -709,7 +709,7 @@ call(int argc, VALUE* argv, VALUE self)
     VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13;
 
     if(hasSelf) {
-      rb_scan_args(argc, argv, args->formatString(Num_Args - 1) 
+      rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
 
       Arg0_T arg0 = from_ruby<Arg0_T>(self); 
@@ -743,7 +743,7 @@ call(int argc, VALUE* argv, VALUE self)
       wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
       return Qnil;
     } else {
-      rb_scan_args(argc, argv, args->formatString(Num_Args)
+      rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
 
       typedef typename sanitize< Arg0_T >::Type Arg0_Type;
@@ -836,7 +836,7 @@ call(int argc, VALUE *argv, VALUE self)
     VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12;
 
     if(hasSelf) {
-      rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
+      rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
 
       Arg0_T arg0 = from_ruby<Arg0_T>(self); 
@@ -867,7 +867,7 @@ call(int argc, VALUE *argv, VALUE self)
 
       return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12));
     } else {
-      rb_scan_args(argc, argv, args->formatString(Num_Args)
+      rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
 
       typedef typename sanitize< Arg0_T >::Type Arg0_Type;
@@ -957,7 +957,7 @@ call(int argc, VALUE* argv, VALUE self)
     VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12;
 
     if(hasSelf) {
-      rb_scan_args(argc, argv, args->formatString(Num_Args - 1) 
+      rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
 
       Arg0_T arg0 = from_ruby<Arg0_T>(self); 
@@ -989,7 +989,7 @@ call(int argc, VALUE* argv, VALUE self)
       wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
       return Qnil;
     } else {
-      rb_scan_args(argc, argv, args->formatString(Num_Args)
+      rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
 
       typedef typename sanitize< Arg0_T >::Type Arg0_Type;
@@ -1080,7 +1080,7 @@ call(int argc, VALUE *argv, VALUE self)
     VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11;
 
     if(hasSelf) {
-      rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
+      rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
 
       Arg0_T arg0 = from_ruby<Arg0_T>(self); 
@@ -1109,7 +1109,7 @@ call(int argc, VALUE *argv, VALUE self)
 
       return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11));
     } else {
-      rb_scan_args(argc, argv, args->formatString(Num_Args)
+      rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
 
       typedef typename sanitize< Arg0_T >::Type Arg0_Type;
@@ -1197,7 +1197,7 @@ call(int argc, VALUE* argv, VALUE self)
     VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11;
 
     if(hasSelf) {
-      rb_scan_args(argc, argv, args->formatString(Num_Args - 1) 
+      rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
 
       Arg0_T arg0 = from_ruby<Arg0_T>(self); 
@@ -1227,7 +1227,7 @@ call(int argc, VALUE* argv, VALUE self)
       wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
       return Qnil;
     } else {
-      rb_scan_args(argc, argv, args->formatString(Num_Args)
+      rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
 
       typedef typename sanitize< Arg0_T >::Type Arg0_Type;
@@ -1316,7 +1316,7 @@ call(int argc, VALUE *argv, VALUE self)
     VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10;
 
     if(hasSelf) {
-      rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
+      rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
 
       Arg0_T arg0 = from_ruby<Arg0_T>(self); 
@@ -1343,7 +1343,7 @@ call(int argc, VALUE *argv, VALUE self)
 
       return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10));
     } else {
-      rb_scan_args(argc, argv, args->formatString(Num_Args)
+      rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
 
       typedef typename sanitize< Arg0_T >::Type Arg0_Type;
@@ -1429,7 +1429,7 @@ call(int argc, VALUE* argv, VALUE self)
     VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10;
 
     if(hasSelf) {
-      rb_scan_args(argc, argv, args->formatString(Num_Args - 1) 
+      rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
 
       Arg0_T arg0 = from_ruby<Arg0_T>(self); 
@@ -1457,7 +1457,7 @@ call(int argc, VALUE* argv, VALUE self)
       wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
       return Qnil;
     } else {
-      rb_scan_args(argc, argv, args->formatString(Num_Args)
+      rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
 
       typedef typename sanitize< Arg0_T >::Type Arg0_Type;
@@ -1544,7 +1544,7 @@ call(int argc, VALUE *argv, VALUE self)
     VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9;
 
     if(hasSelf) {
-      rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
+      rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
 
       Arg0_T arg0 = from_ruby<Arg0_T>(self); 
@@ -1569,7 +1569,7 @@ call(int argc, VALUE *argv, VALUE self)
 
       return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9));
     } else {
-      rb_scan_args(argc, argv, args->formatString(Num_Args)
+      rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
 
       typedef typename sanitize< Arg0_T >::Type Arg0_Type;
@@ -1653,7 +1653,7 @@ call(int argc, VALUE* argv, VALUE self)
     VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9;
 
     if(hasSelf) {
-      rb_scan_args(argc, argv, args->formatString(Num_Args - 1) 
+      rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
 
       Arg0_T arg0 = from_ruby<Arg0_T>(self); 
@@ -1679,7 +1679,7 @@ call(int argc, VALUE* argv, VALUE self)
       wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
       return Qnil;
     } else {
-      rb_scan_args(argc, argv, args->formatString(Num_Args)
+      rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
 
       typedef typename sanitize< Arg0_T >::Type Arg0_Type;
@@ -1764,7 +1764,7 @@ call(int argc, VALUE *argv, VALUE self)
     VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8;
 
     if(hasSelf) {
-      rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
+      rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
 
       Arg0_T arg0 = from_ruby<Arg0_T>(self); 
@@ -1787,7 +1787,7 @@ call(int argc, VALUE *argv, VALUE self)
 
       return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8));
     } else {
-      rb_scan_args(argc, argv, args->formatString(Num_Args)
+      rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
 
       typedef typename sanitize< Arg0_T >::Type Arg0_Type;
@@ -1869,7 +1869,7 @@ call(int argc, VALUE* argv, VALUE self)
     VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8;
 
     if(hasSelf) {
-      rb_scan_args(argc, argv, args->formatString(Num_Args - 1) 
+      rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
 
       Arg0_T arg0 = from_ruby<Arg0_T>(self); 
@@ -1893,7 +1893,7 @@ call(int argc, VALUE* argv, VALUE self)
       wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
       return Qnil;
     } else {
-      rb_scan_args(argc, argv, args->formatString(Num_Args)
+      rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
 
       typedef typename sanitize< Arg0_T >::Type Arg0_Type;
@@ -1976,7 +1976,7 @@ call(int argc, VALUE *argv, VALUE self)
     VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7;
 
     if(hasSelf) {
-      rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
+      rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
 
       Arg0_T arg0 = from_ruby<Arg0_T>(self); 
@@ -1997,7 +1997,7 @@ call(int argc, VALUE *argv, VALUE self)
 
       return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7));
     } else {
-      rb_scan_args(argc, argv, args->formatString(Num_Args)
+      rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
 
       typedef typename sanitize< Arg0_T >::Type Arg0_Type;
@@ -2077,7 +2077,7 @@ call(int argc, VALUE* argv, VALUE self)
     VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7;
 
     if(hasSelf) {
-      rb_scan_args(argc, argv, args->formatString(Num_Args - 1) 
+      rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
 
       Arg0_T arg0 = from_ruby<Arg0_T>(self); 
@@ -2099,7 +2099,7 @@ call(int argc, VALUE* argv, VALUE self)
       wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
       return Qnil;
     } else {
-      rb_scan_args(argc, argv, args->formatString(Num_Args)
+      rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
 
       typedef typename sanitize< Arg0_T >::Type Arg0_Type;
@@ -2180,7 +2180,7 @@ call(int argc, VALUE *argv, VALUE self)
     VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6;
 
     if(hasSelf) {
-      rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
+      rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
 
       Arg0_T arg0 = from_ruby<Arg0_T>(self); 
@@ -2199,7 +2199,7 @@ call(int argc, VALUE *argv, VALUE self)
 
       return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6));
     } else {
-      rb_scan_args(argc, argv, args->formatString(Num_Args)
+      rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
 
       typedef typename sanitize< Arg0_T >::Type Arg0_Type;
@@ -2277,7 +2277,7 @@ call(int argc, VALUE* argv, VALUE self)
     VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6;
 
     if(hasSelf) {
-      rb_scan_args(argc, argv, args->formatString(Num_Args - 1) 
+      rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
 
       Arg0_T arg0 = from_ruby<Arg0_T>(self); 
@@ -2297,7 +2297,7 @@ call(int argc, VALUE* argv, VALUE self)
       wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
       return Qnil;
     } else {
-      rb_scan_args(argc, argv, args->formatString(Num_Args)
+      rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
 
       typedef typename sanitize< Arg0_T >::Type Arg0_Type;
@@ -2376,7 +2376,7 @@ call(int argc, VALUE *argv, VALUE self)
     VALUE varg0, varg1, varg2, varg3, varg4, varg5;
 
     if(hasSelf) {
-      rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
+      rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
 
       Arg0_T arg0 = from_ruby<Arg0_T>(self); 
@@ -2393,7 +2393,7 @@ call(int argc, VALUE *argv, VALUE self)
 
       return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5));
     } else {
-      rb_scan_args(argc, argv, args->formatString(Num_Args)
+      rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
 
       typedef typename sanitize< Arg0_T >::Type Arg0_Type;
@@ -2469,7 +2469,7 @@ call(int argc, VALUE* argv, VALUE self)
     VALUE varg0, varg1, varg2, varg3, varg4, varg5;
 
     if(hasSelf) {
-      rb_scan_args(argc, argv, args->formatString(Num_Args - 1) 
+      rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
 
       Arg0_T arg0 = from_ruby<Arg0_T>(self); 
@@ -2487,7 +2487,7 @@ call(int argc, VALUE* argv, VALUE self)
       wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5);
       return Qnil;
     } else {
-      rb_scan_args(argc, argv, args->formatString(Num_Args)
+      rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
 
       typedef typename sanitize< Arg0_T >::Type Arg0_Type;
@@ -2564,7 +2564,7 @@ call(int argc, VALUE *argv, VALUE self)
     VALUE varg0, varg1, varg2, varg3, varg4;
 
     if(hasSelf) {
-      rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
+      rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4);
 
       Arg0_T arg0 = from_ruby<Arg0_T>(self); 
@@ -2579,7 +2579,7 @@ call(int argc, VALUE *argv, VALUE self)
 
       return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4));
     } else {
-      rb_scan_args(argc, argv, args->formatString(Num_Args)
+      rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4);
 
       typedef typename sanitize< Arg0_T >::Type Arg0_Type;
@@ -2653,7 +2653,7 @@ call(int argc, VALUE* argv, VALUE self)
     VALUE varg0, varg1, varg2, varg3, varg4;
 
     if(hasSelf) {
-      rb_scan_args(argc, argv, args->formatString(Num_Args - 1) 
+      rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4);
 
       Arg0_T arg0 = from_ruby<Arg0_T>(self); 
@@ -2669,7 +2669,7 @@ call(int argc, VALUE* argv, VALUE self)
       wrapper->func_(arg0, arg1, arg2, arg3, arg4);
       return Qnil;
     } else {
-      rb_scan_args(argc, argv, args->formatString(Num_Args)
+      rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
         , &varg0, &varg1, &varg2, &varg3, &varg4);
 
       typedef typename sanitize< Arg0_T >::Type Arg0_Type;
@@ -2744,7 +2744,7 @@ call(int argc, VALUE *argv, VALUE self)
     VALUE varg0, varg1, varg2, varg3;
 
     if(hasSelf) {
-      rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
+      rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
         , &varg0, &varg1, &varg2, &varg3);
 
       Arg0_T arg0 = from_ruby<Arg0_T>(self); 
@@ -2757,7 +2757,7 @@ call(int argc, VALUE *argv, VALUE self)
 
       return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3));
     } else {
-      rb_scan_args(argc, argv, args->formatString(Num_Args)
+      rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
         , &varg0, &varg1, &varg2, &varg3);
 
       typedef typename sanitize< Arg0_T >::Type Arg0_Type;
@@ -2829,7 +2829,7 @@ call(int argc, VALUE* argv, VALUE self)
     VALUE varg0, varg1, varg2, varg3;
 
     if(hasSelf) {
-      rb_scan_args(argc, argv, args->formatString(Num_Args - 1) 
+      rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
         , &varg0, &varg1, &varg2, &varg3);
 
       Arg0_T arg0 = from_ruby<Arg0_T>(self); 
@@ -2843,7 +2843,7 @@ call(int argc, VALUE* argv, VALUE self)
       wrapper->func_(arg0, arg1, arg2, arg3);
       return Qnil;
     } else {
-      rb_scan_args(argc, argv, args->formatString(Num_Args)
+      rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
         , &varg0, &varg1, &varg2, &varg3);
 
       typedef typename sanitize< Arg0_T >::Type Arg0_Type;
@@ -2916,7 +2916,7 @@ call(int argc, VALUE *argv, VALUE self)
     VALUE varg0, varg1, varg2;
 
     if(hasSelf) {
-      rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
+      rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
         , &varg0, &varg1, &varg2);
 
       Arg0_T arg0 = from_ruby<Arg0_T>(self); 
@@ -2927,7 +2927,7 @@ call(int argc, VALUE *argv, VALUE self)
 
       return to_ruby(wrapper->func_(arg0, arg1, arg2));
     } else {
-      rb_scan_args(argc, argv, args->formatString(Num_Args)
+      rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
         , &varg0, &varg1, &varg2);
 
       typedef typename sanitize< Arg0_T >::Type Arg0_Type;
@@ -2997,7 +2997,7 @@ call(int argc, VALUE* argv, VALUE self)
     VALUE varg0, varg1, varg2;
 
     if(hasSelf) {
-      rb_scan_args(argc, argv, args->formatString(Num_Args - 1) 
+      rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
         , &varg0, &varg1, &varg2);
 
       Arg0_T arg0 = from_ruby<Arg0_T>(self); 
@@ -3009,7 +3009,7 @@ call(int argc, VALUE* argv, VALUE self)
       wrapper->func_(arg0, arg1, arg2);
       return Qnil;
     } else {
-      rb_scan_args(argc, argv, args->formatString(Num_Args)
+      rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
         , &varg0, &varg1, &varg2);
 
       typedef typename sanitize< Arg0_T >::Type Arg0_Type;
@@ -3080,7 +3080,7 @@ call(int argc, VALUE *argv, VALUE self)
     VALUE varg0, varg1;
 
     if(hasSelf) {
-      rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
+      rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
         , &varg0, &varg1);
 
       Arg0_T arg0 = from_ruby<Arg0_T>(self); 
@@ -3089,7 +3089,7 @@ call(int argc, VALUE *argv, VALUE self)
 
       return to_ruby(wrapper->func_(arg0, arg1));
     } else {
-      rb_scan_args(argc, argv, args->formatString(Num_Args)
+      rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
         , &varg0, &varg1);
 
       typedef typename sanitize< Arg0_T >::Type Arg0_Type;
@@ -3157,7 +3157,7 @@ call(int argc, VALUE* argv, VALUE self)
     VALUE varg0, varg1;
 
     if(hasSelf) {
-      rb_scan_args(argc, argv, args->formatString(Num_Args - 1) 
+      rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
         , &varg0, &varg1);
 
       Arg0_T arg0 = from_ruby<Arg0_T>(self); 
@@ -3167,7 +3167,7 @@ call(int argc, VALUE* argv, VALUE self)
       wrapper->func_(arg0, arg1);
       return Qnil;
     } else {
-      rb_scan_args(argc, argv, args->formatString(Num_Args)
+      rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
         , &varg0, &varg1);
 
       typedef typename sanitize< Arg0_T >::Type Arg0_Type;
@@ -3236,7 +3236,7 @@ call(int argc, VALUE *argv, VALUE self)
     VALUE varg0;
 
     if(hasSelf) {
-      rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
+      rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
         , &varg0);
 
       Arg0_T arg0 = from_ruby<Arg0_T>(self); 
@@ -3244,7 +3244,7 @@ call(int argc, VALUE *argv, VALUE self)
 
       return to_ruby(wrapper->func_(arg0));
     } else {
-      rb_scan_args(argc, argv, args->formatString(Num_Args)
+      rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
         , &varg0);
 
       typedef typename sanitize< Arg0_T >::Type Arg0_Type;
@@ -3310,7 +3310,7 @@ call(int argc, VALUE* argv, VALUE self)
     VALUE varg0;
 
     if(hasSelf) {
-      rb_scan_args(argc, argv, args->formatString(Num_Args - 1) 
+      rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
         , &varg0);
 
       Arg0_T arg0 = from_ruby<Arg0_T>(self); 
@@ -3319,7 +3319,7 @@ call(int argc, VALUE* argv, VALUE self)
       wrapper->func_(arg0);
       return Qnil;
     } else {
-      rb_scan_args(argc, argv, args->formatString(Num_Args)
+      rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
         , &varg0);
 
       typedef typename sanitize< Arg0_T >::Type Arg0_Type;
@@ -3370,7 +3370,7 @@ call()
     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_());
+    return to_ruby(wrapper->func_());
   }
   catch(...)
   {