rice 1.1.0 → 1.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (54) hide show
  1. data/Doxyfile +1 -1
  2. data/Makefile.in +3 -2
  3. data/README +247 -16
  4. data/aclocal.m4 +62 -51
  5. data/configure +1585 -1456
  6. data/extconf.rb +9 -1
  7. data/rice/Arg.hpp +8 -0
  8. data/rice/Arg_impl.hpp +124 -0
  9. data/rice/Arg_operators.cpp +21 -0
  10. data/rice/Arg_operators.hpp +19 -0
  11. data/rice/Constructor.hpp +150 -0
  12. data/rice/Data_Type.ipp +51 -6
  13. data/rice/Director.cpp +19 -0
  14. data/rice/Director.hpp +47 -0
  15. data/rice/Enum.hpp +2 -3
  16. data/rice/Enum.ipp +1 -1
  17. data/rice/Hash.hpp +1 -1
  18. data/rice/Makefile.am +7 -0
  19. data/rice/Makefile.in +18 -7
  20. data/rice/Module_impl.hpp +36 -3
  21. data/rice/Module_impl.ipp +56 -7
  22. data/rice/VM.cpp +2 -2
  23. data/rice/config.hpp +1 -1
  24. data/rice/detail/Arguments.hpp +118 -0
  25. data/rice/detail/Auto_Function_Wrapper.hpp +206 -96
  26. data/rice/detail/Auto_Function_Wrapper.ipp +1687 -144
  27. data/rice/detail/Auto_Member_Function_Wrapper.hpp +234 -123
  28. data/rice/detail/Auto_Member_Function_Wrapper.ipp +1133 -306
  29. data/rice/detail/Caster.hpp +3 -1
  30. data/rice/detail/creation_funcs.hpp +0 -8
  31. data/rice/detail/creation_funcs.ipp +1 -27
  32. data/rice/detail/define_method_and_auto_wrap.hpp +3 -1
  33. data/rice/detail/define_method_and_auto_wrap.ipp +4 -3
  34. data/rice/detail/object_call.ipp +1 -1
  35. data/rice/detail/ruby.hpp +1 -33
  36. data/rice/detail/wrap_function.hpp +103 -48
  37. data/rice/detail/wrap_function.ipp +154 -96
  38. data/rice/generate_code.rb +520 -55
  39. data/rice/global_function.hpp +12 -1
  40. data/rice/global_function.ipp +14 -2
  41. data/ruby/Makefile.in +5 -4
  42. data/ruby/lib/Makefile.in +4 -3
  43. data/ruby/lib/version.rb +1 -1
  44. data/sample/Makefile.in +4 -3
  45. data/test/Makefile.am +2 -0
  46. data/test/Makefile.in +32 -13
  47. data/test/test_Class.cpp +36 -14
  48. data/test/test_Constructor.cpp +176 -1
  49. data/test/test_Data_Type.cpp +121 -0
  50. data/test/test_Director.cpp +225 -0
  51. data/test/test_Enum.cpp +33 -0
  52. data/test/test_Module.cpp +175 -0
  53. data/test/test_global_functions.cpp +70 -1
  54. metadata +27 -7
data/rice/detail/Auto_Function_Wrapper.ipp CHANGED
@@ -20,25 +20,85 @@ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, type
20
20
  Auto_Function_Wrapper<Func_T, Ret_T, 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>::
21
21
  Auto_Function_Wrapper(
22
22
  Func func,
23
- Data_Object<Exception_Handler> handler)
23
+ Data_Object<Exception_Handler> handler,
24
+ Arguments* arguments)
24
25
  : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
25
26
  , func_(func)
26
27
  , handler_(handler)
27
28
  , handler_guard_(&handler_)
28
29
  {
30
+ if(arguments == 0) {
31
+ arguments_ = new Arguments();
32
+ } else {
33
+ arguments_ = arguments;
34
+ }
29
35
  }
30
36
 
31
37
  template<typename Func_T, 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>
32
38
  VALUE Auto_Function_Wrapper<Func_T, Ret_T, 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>::
33
- call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6, VALUE ruby_arg7, VALUE ruby_arg8, VALUE ruby_arg9, VALUE ruby_arg10, VALUE ruby_arg11, VALUE ruby_arg12, VALUE ruby_arg13, VALUE ruby_arg14, VALUE ruby_arg15)
39
+ call(int argc, VALUE *argv, VALUE self)
34
40
  {
35
41
  Auto_Function_Wrapper<Func_T, Ret_T, 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> * wrapper = 0;
36
42
  try
37
43
  {
38
44
  Data_Object<Wrapped_Function> data(detail::method_data());
39
45
  wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, 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.get();
40
- Arg0_T arg0(from_ruby<Arg0_T>(ruby_arg0)); Arg1_T arg1(from_ruby<Arg1_T>(ruby_arg1)); Arg2_T arg2(from_ruby<Arg2_T>(ruby_arg2)); Arg3_T arg3(from_ruby<Arg3_T>(ruby_arg3)); Arg4_T arg4(from_ruby<Arg4_T>(ruby_arg4)); Arg5_T arg5(from_ruby<Arg5_T>(ruby_arg5)); Arg6_T arg6(from_ruby<Arg6_T>(ruby_arg6)); Arg7_T arg7(from_ruby<Arg7_T>(ruby_arg7)); Arg8_T arg8(from_ruby<Arg8_T>(ruby_arg8)); Arg9_T arg9(from_ruby<Arg9_T>(ruby_arg9)); Arg10_T arg10(from_ruby<Arg10_T>(ruby_arg10)); Arg11_T arg11(from_ruby<Arg11_T>(ruby_arg11)); Arg12_T arg12(from_ruby<Arg12_T>(ruby_arg12)); Arg13_T arg13(from_ruby<Arg13_T>(ruby_arg13)); Arg14_T arg14(from_ruby<Arg14_T>(ruby_arg14)); Arg15_T arg15(from_ruby<Arg15_T>(ruby_arg15));
41
- return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15));
46
+ Arguments* args = wrapper->arguments_;
47
+
48
+ bool hasSelf = (self && self != Qnil);
49
+ if(args->count() >= 0) {
50
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
51
+ } else {
52
+ hasSelf = hasSelf && argc == Num_Args -1;
53
+ }
54
+
55
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13, varg14, varg15;
56
+
57
+ if(hasSelf) {
58
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
59
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
60
+
61
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
62
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
63
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
64
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
65
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
66
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
67
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
68
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
69
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
70
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
71
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
72
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
73
+ Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(11, varg11);
74
+ Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(12, varg12);
75
+ Arg14_T arg14 = args->getArgumentOrDefault<Arg14_T>(13, varg13);
76
+ Arg15_T arg15 = args->getArgumentOrDefault<Arg15_T>(14, varg14);
77
+
78
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15));
79
+ } else {
80
+ rb_scan_args(argc, argv, args->formatString(Num_Args)
81
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
82
+
83
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
84
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
85
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
86
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
87
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
88
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
89
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
90
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
91
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
92
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
93
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
94
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
95
+ Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(12, varg12);
96
+ Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(13, varg13);
97
+ Arg14_T arg14 = args->getArgumentOrDefault<Arg14_T>(14, varg14);
98
+ Arg15_T arg15 = args->getArgumentOrDefault<Arg15_T>(15, varg15);
99
+
100
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15));
101
+ }
42
102
  }
43
103
  catch(...)
44
104
  {
@@ -61,17 +121,23 @@ template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typ
61
121
  Auto_Function_Wrapper<Func_T, void, 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>::
62
122
  Auto_Function_Wrapper(
63
123
  Func func,
64
- Data_Object<Exception_Handler> handler)
124
+ Data_Object<Exception_Handler> handler,
125
+ Arguments* arguments)
65
126
  : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
66
127
  , func_(func)
67
128
  , handler_(handler)
68
129
  , handler_guard_(&handler_)
69
130
  {
131
+ if(arguments == 0) {
132
+ arguments_ = new Arguments();
133
+ } else {
134
+ arguments_ = arguments;
135
+ }
70
136
  }
71
137
 
72
138
  template<typename Func_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>
73
139
  VALUE Auto_Function_Wrapper<Func_T, void, 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>::
74
- call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6, VALUE ruby_arg7, VALUE ruby_arg8, VALUE ruby_arg9, VALUE ruby_arg10, VALUE ruby_arg11, VALUE ruby_arg12, VALUE ruby_arg13, VALUE ruby_arg14, VALUE ruby_arg15)
140
+ call(int argc, VALUE* argv, VALUE self)
75
141
  {
76
142
  Auto_Function_Wrapper<Func_T, void, 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> * wrapper = 0;
77
143
  try
@@ -79,9 +145,64 @@ call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE r
79
145
  Data_Object<Wrapped_Function> data(detail::method_data());
80
146
  wrapper =
81
147
  (Auto_Function_Wrapper<Func_T, void, 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.get();
82
- Arg0_T arg0(from_ruby<Arg0_T>(ruby_arg0)); Arg1_T arg1(from_ruby<Arg1_T>(ruby_arg1)); Arg2_T arg2(from_ruby<Arg2_T>(ruby_arg2)); Arg3_T arg3(from_ruby<Arg3_T>(ruby_arg3)); Arg4_T arg4(from_ruby<Arg4_T>(ruby_arg4)); Arg5_T arg5(from_ruby<Arg5_T>(ruby_arg5)); Arg6_T arg6(from_ruby<Arg6_T>(ruby_arg6)); Arg7_T arg7(from_ruby<Arg7_T>(ruby_arg7)); Arg8_T arg8(from_ruby<Arg8_T>(ruby_arg8)); Arg9_T arg9(from_ruby<Arg9_T>(ruby_arg9)); Arg10_T arg10(from_ruby<Arg10_T>(ruby_arg10)); Arg11_T arg11(from_ruby<Arg11_T>(ruby_arg11)); Arg12_T arg12(from_ruby<Arg12_T>(ruby_arg12)); Arg13_T arg13(from_ruby<Arg13_T>(ruby_arg13)); Arg14_T arg14(from_ruby<Arg14_T>(ruby_arg14)); Arg15_T arg15(from_ruby<Arg15_T>(ruby_arg15));
83
- wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15);
84
- return Qnil;
148
+ Arguments* args = wrapper->arguments_;
149
+
150
+ bool hasSelf = (self && self != Qnil);
151
+ if(args->count() >= 0) {
152
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
153
+ } else {
154
+ hasSelf = hasSelf && argc == Num_Args -1;
155
+ }
156
+
157
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13, varg14, varg15;
158
+
159
+ if(hasSelf) {
160
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
161
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
162
+
163
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
164
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
165
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
166
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
167
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
168
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
169
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
170
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
171
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
172
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
173
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
174
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
175
+ Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(11, varg11);
176
+ Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(12, varg12);
177
+ Arg14_T arg14 = args->getArgumentOrDefault<Arg14_T>(13, varg13);
178
+ Arg15_T arg15 = args->getArgumentOrDefault<Arg15_T>(14, varg14);
179
+
180
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15);
181
+ return Qnil;
182
+ } else {
183
+ rb_scan_args(argc, argv, args->formatString(Num_Args)
184
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
185
+
186
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
187
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
188
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
189
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
190
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
191
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
192
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
193
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
194
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
195
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
196
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
197
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
198
+ Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(12, varg12);
199
+ Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(13, varg13);
200
+ Arg14_T arg14 = args->getArgumentOrDefault<Arg14_T>(14, varg14);
201
+ Arg15_T arg15 = args->getArgumentOrDefault<Arg15_T>(15, varg15);
202
+
203
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15);
204
+ return Qnil;
205
+ }
85
206
  }
86
207
  catch(...)
87
208
  {
@@ -105,25 +226,83 @@ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, type
105
226
  Auto_Function_Wrapper<Func_T, Ret_T, 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>::
106
227
  Auto_Function_Wrapper(
107
228
  Func func,
108
- Data_Object<Exception_Handler> handler)
229
+ Data_Object<Exception_Handler> handler,
230
+ Arguments* arguments)
109
231
  : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
110
232
  , func_(func)
111
233
  , handler_(handler)
112
234
  , handler_guard_(&handler_)
113
235
  {
236
+ if(arguments == 0) {
237
+ arguments_ = new Arguments();
238
+ } else {
239
+ arguments_ = arguments;
240
+ }
114
241
  }
115
242
 
116
243
  template<typename Func_T, 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>
117
244
  VALUE Auto_Function_Wrapper<Func_T, Ret_T, 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>::
118
- call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6, VALUE ruby_arg7, VALUE ruby_arg8, VALUE ruby_arg9, VALUE ruby_arg10, VALUE ruby_arg11, VALUE ruby_arg12, VALUE ruby_arg13, VALUE ruby_arg14)
245
+ call(int argc, VALUE *argv, VALUE self)
119
246
  {
120
247
  Auto_Function_Wrapper<Func_T, Ret_T, 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> * wrapper = 0;
121
248
  try
122
249
  {
123
250
  Data_Object<Wrapped_Function> data(detail::method_data());
124
251
  wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, 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.get();
125
- Arg0_T arg0(from_ruby<Arg0_T>(ruby_arg0)); Arg1_T arg1(from_ruby<Arg1_T>(ruby_arg1)); Arg2_T arg2(from_ruby<Arg2_T>(ruby_arg2)); Arg3_T arg3(from_ruby<Arg3_T>(ruby_arg3)); Arg4_T arg4(from_ruby<Arg4_T>(ruby_arg4)); Arg5_T arg5(from_ruby<Arg5_T>(ruby_arg5)); Arg6_T arg6(from_ruby<Arg6_T>(ruby_arg6)); Arg7_T arg7(from_ruby<Arg7_T>(ruby_arg7)); Arg8_T arg8(from_ruby<Arg8_T>(ruby_arg8)); Arg9_T arg9(from_ruby<Arg9_T>(ruby_arg9)); Arg10_T arg10(from_ruby<Arg10_T>(ruby_arg10)); Arg11_T arg11(from_ruby<Arg11_T>(ruby_arg11)); Arg12_T arg12(from_ruby<Arg12_T>(ruby_arg12)); Arg13_T arg13(from_ruby<Arg13_T>(ruby_arg13)); Arg14_T arg14(from_ruby<Arg14_T>(ruby_arg14));
126
- return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14));
252
+ Arguments* args = wrapper->arguments_;
253
+
254
+ bool hasSelf = (self && self != Qnil);
255
+ if(args->count() >= 0) {
256
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
257
+ } else {
258
+ hasSelf = hasSelf && argc == Num_Args -1;
259
+ }
260
+
261
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13, varg14;
262
+
263
+ if(hasSelf) {
264
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
265
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
266
+
267
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
268
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
269
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
270
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
271
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
272
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
273
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
274
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
275
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
276
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
277
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
278
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
279
+ Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(11, varg11);
280
+ Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(12, varg12);
281
+ Arg14_T arg14 = args->getArgumentOrDefault<Arg14_T>(13, varg13);
282
+
283
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14));
284
+ } else {
285
+ rb_scan_args(argc, argv, args->formatString(Num_Args)
286
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
287
+
288
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
289
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
290
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
291
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
292
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
293
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
294
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
295
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
296
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
297
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
298
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
299
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
300
+ Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(12, varg12);
301
+ Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(13, varg13);
302
+ Arg14_T arg14 = args->getArgumentOrDefault<Arg14_T>(14, varg14);
303
+
304
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14));
305
+ }
127
306
  }
128
307
  catch(...)
129
308
  {
@@ -146,17 +325,23 @@ template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typ
146
325
  Auto_Function_Wrapper<Func_T, void, 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>::
147
326
  Auto_Function_Wrapper(
148
327
  Func func,
149
- Data_Object<Exception_Handler> handler)
328
+ Data_Object<Exception_Handler> handler,
329
+ Arguments* arguments)
150
330
  : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
151
331
  , func_(func)
152
332
  , handler_(handler)
153
333
  , handler_guard_(&handler_)
154
334
  {
335
+ if(arguments == 0) {
336
+ arguments_ = new Arguments();
337
+ } else {
338
+ arguments_ = arguments;
339
+ }
155
340
  }
156
341
 
157
342
  template<typename Func_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>
158
343
  VALUE Auto_Function_Wrapper<Func_T, void, 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>::
159
- call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6, VALUE ruby_arg7, VALUE ruby_arg8, VALUE ruby_arg9, VALUE ruby_arg10, VALUE ruby_arg11, VALUE ruby_arg12, VALUE ruby_arg13, VALUE ruby_arg14)
344
+ call(int argc, VALUE* argv, VALUE self)
160
345
  {
161
346
  Auto_Function_Wrapper<Func_T, void, 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> * wrapper = 0;
162
347
  try
@@ -164,9 +349,62 @@ call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE r
164
349
  Data_Object<Wrapped_Function> data(detail::method_data());
165
350
  wrapper =
166
351
  (Auto_Function_Wrapper<Func_T, void, 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.get();
167
- Arg0_T arg0(from_ruby<Arg0_T>(ruby_arg0)); Arg1_T arg1(from_ruby<Arg1_T>(ruby_arg1)); Arg2_T arg2(from_ruby<Arg2_T>(ruby_arg2)); Arg3_T arg3(from_ruby<Arg3_T>(ruby_arg3)); Arg4_T arg4(from_ruby<Arg4_T>(ruby_arg4)); Arg5_T arg5(from_ruby<Arg5_T>(ruby_arg5)); Arg6_T arg6(from_ruby<Arg6_T>(ruby_arg6)); Arg7_T arg7(from_ruby<Arg7_T>(ruby_arg7)); Arg8_T arg8(from_ruby<Arg8_T>(ruby_arg8)); Arg9_T arg9(from_ruby<Arg9_T>(ruby_arg9)); Arg10_T arg10(from_ruby<Arg10_T>(ruby_arg10)); Arg11_T arg11(from_ruby<Arg11_T>(ruby_arg11)); Arg12_T arg12(from_ruby<Arg12_T>(ruby_arg12)); Arg13_T arg13(from_ruby<Arg13_T>(ruby_arg13)); Arg14_T arg14(from_ruby<Arg14_T>(ruby_arg14));
168
- wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
169
- return Qnil;
352
+ Arguments* args = wrapper->arguments_;
353
+
354
+ bool hasSelf = (self && self != Qnil);
355
+ if(args->count() >= 0) {
356
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
357
+ } else {
358
+ hasSelf = hasSelf && argc == Num_Args -1;
359
+ }
360
+
361
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13, varg14;
362
+
363
+ if(hasSelf) {
364
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
365
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
366
+
367
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
368
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
369
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
370
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
371
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
372
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
373
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
374
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
375
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
376
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
377
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
378
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
379
+ Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(11, varg11);
380
+ Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(12, varg12);
381
+ Arg14_T arg14 = args->getArgumentOrDefault<Arg14_T>(13, varg13);
382
+
383
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
384
+ return Qnil;
385
+ } else {
386
+ rb_scan_args(argc, argv, args->formatString(Num_Args)
387
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
388
+
389
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
390
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
391
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
392
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
393
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
394
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
395
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
396
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
397
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
398
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
399
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
400
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
401
+ Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(12, varg12);
402
+ Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(13, varg13);
403
+ Arg14_T arg14 = args->getArgumentOrDefault<Arg14_T>(14, varg14);
404
+
405
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
406
+ return Qnil;
407
+ }
170
408
  }
171
409
  catch(...)
172
410
  {
@@ -190,25 +428,81 @@ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, type
190
428
  Auto_Function_Wrapper<Func_T, Ret_T, 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>::
191
429
  Auto_Function_Wrapper(
192
430
  Func func,
193
- Data_Object<Exception_Handler> handler)
431
+ Data_Object<Exception_Handler> handler,
432
+ Arguments* arguments)
194
433
  : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
195
434
  , func_(func)
196
435
  , handler_(handler)
197
436
  , handler_guard_(&handler_)
198
437
  {
438
+ if(arguments == 0) {
439
+ arguments_ = new Arguments();
440
+ } else {
441
+ arguments_ = arguments;
442
+ }
199
443
  }
200
444
 
201
445
  template<typename Func_T, 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>
202
446
  VALUE Auto_Function_Wrapper<Func_T, Ret_T, 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>::
203
- call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6, VALUE ruby_arg7, VALUE ruby_arg8, VALUE ruby_arg9, VALUE ruby_arg10, VALUE ruby_arg11, VALUE ruby_arg12, VALUE ruby_arg13)
447
+ call(int argc, VALUE *argv, VALUE self)
204
448
  {
205
449
  Auto_Function_Wrapper<Func_T, Ret_T, 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> * wrapper = 0;
206
450
  try
207
451
  {
208
452
  Data_Object<Wrapped_Function> data(detail::method_data());
209
453
  wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, 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.get();
210
- Arg0_T arg0(from_ruby<Arg0_T>(ruby_arg0)); Arg1_T arg1(from_ruby<Arg1_T>(ruby_arg1)); Arg2_T arg2(from_ruby<Arg2_T>(ruby_arg2)); Arg3_T arg3(from_ruby<Arg3_T>(ruby_arg3)); Arg4_T arg4(from_ruby<Arg4_T>(ruby_arg4)); Arg5_T arg5(from_ruby<Arg5_T>(ruby_arg5)); Arg6_T arg6(from_ruby<Arg6_T>(ruby_arg6)); Arg7_T arg7(from_ruby<Arg7_T>(ruby_arg7)); Arg8_T arg8(from_ruby<Arg8_T>(ruby_arg8)); Arg9_T arg9(from_ruby<Arg9_T>(ruby_arg9)); Arg10_T arg10(from_ruby<Arg10_T>(ruby_arg10)); Arg11_T arg11(from_ruby<Arg11_T>(ruby_arg11)); Arg12_T arg12(from_ruby<Arg12_T>(ruby_arg12)); Arg13_T arg13(from_ruby<Arg13_T>(ruby_arg13));
211
- return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13));
454
+ Arguments* args = wrapper->arguments_;
455
+
456
+ bool hasSelf = (self && self != Qnil);
457
+ if(args->count() >= 0) {
458
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
459
+ } else {
460
+ hasSelf = hasSelf && argc == Num_Args -1;
461
+ }
462
+
463
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13;
464
+
465
+ if(hasSelf) {
466
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
467
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
468
+
469
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
470
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
471
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
472
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
473
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
474
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
475
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
476
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
477
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
478
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
479
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
480
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
481
+ Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(11, varg11);
482
+ Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(12, varg12);
483
+
484
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13));
485
+ } else {
486
+ rb_scan_args(argc, argv, args->formatString(Num_Args)
487
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
488
+
489
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
490
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
491
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
492
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
493
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
494
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
495
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
496
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
497
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
498
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
499
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
500
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
501
+ Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(12, varg12);
502
+ Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(13, varg13);
503
+
504
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13));
505
+ }
212
506
  }
213
507
  catch(...)
214
508
  {
@@ -231,17 +525,23 @@ template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typ
231
525
  Auto_Function_Wrapper<Func_T, void, 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>::
232
526
  Auto_Function_Wrapper(
233
527
  Func func,
234
- Data_Object<Exception_Handler> handler)
528
+ Data_Object<Exception_Handler> handler,
529
+ Arguments* arguments)
235
530
  : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
236
531
  , func_(func)
237
532
  , handler_(handler)
238
533
  , handler_guard_(&handler_)
239
534
  {
535
+ if(arguments == 0) {
536
+ arguments_ = new Arguments();
537
+ } else {
538
+ arguments_ = arguments;
539
+ }
240
540
  }
241
541
 
242
542
  template<typename Func_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>
243
543
  VALUE Auto_Function_Wrapper<Func_T, void, 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>::
244
- call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6, VALUE ruby_arg7, VALUE ruby_arg8, VALUE ruby_arg9, VALUE ruby_arg10, VALUE ruby_arg11, VALUE ruby_arg12, VALUE ruby_arg13)
544
+ call(int argc, VALUE* argv, VALUE self)
245
545
  {
246
546
  Auto_Function_Wrapper<Func_T, void, 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> * wrapper = 0;
247
547
  try
@@ -249,9 +549,60 @@ call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE r
249
549
  Data_Object<Wrapped_Function> data(detail::method_data());
250
550
  wrapper =
251
551
  (Auto_Function_Wrapper<Func_T, void, 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.get();
252
- Arg0_T arg0(from_ruby<Arg0_T>(ruby_arg0)); Arg1_T arg1(from_ruby<Arg1_T>(ruby_arg1)); Arg2_T arg2(from_ruby<Arg2_T>(ruby_arg2)); Arg3_T arg3(from_ruby<Arg3_T>(ruby_arg3)); Arg4_T arg4(from_ruby<Arg4_T>(ruby_arg4)); Arg5_T arg5(from_ruby<Arg5_T>(ruby_arg5)); Arg6_T arg6(from_ruby<Arg6_T>(ruby_arg6)); Arg7_T arg7(from_ruby<Arg7_T>(ruby_arg7)); Arg8_T arg8(from_ruby<Arg8_T>(ruby_arg8)); Arg9_T arg9(from_ruby<Arg9_T>(ruby_arg9)); Arg10_T arg10(from_ruby<Arg10_T>(ruby_arg10)); Arg11_T arg11(from_ruby<Arg11_T>(ruby_arg11)); Arg12_T arg12(from_ruby<Arg12_T>(ruby_arg12)); Arg13_T arg13(from_ruby<Arg13_T>(ruby_arg13));
253
- wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
254
- return Qnil;
552
+ Arguments* args = wrapper->arguments_;
553
+
554
+ bool hasSelf = (self && self != Qnil);
555
+ if(args->count() >= 0) {
556
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
557
+ } else {
558
+ hasSelf = hasSelf && argc == Num_Args -1;
559
+ }
560
+
561
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13;
562
+
563
+ if(hasSelf) {
564
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
565
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
566
+
567
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
568
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
569
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
570
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
571
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
572
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
573
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
574
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
575
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
576
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
577
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
578
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
579
+ Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(11, varg11);
580
+ Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(12, varg12);
581
+
582
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
583
+ return Qnil;
584
+ } else {
585
+ rb_scan_args(argc, argv, args->formatString(Num_Args)
586
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
587
+
588
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
589
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
590
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
591
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
592
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
593
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
594
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
595
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
596
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
597
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
598
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
599
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
600
+ Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(12, varg12);
601
+ Arg13_T arg13 = args->getArgumentOrDefault<Arg13_T>(13, varg13);
602
+
603
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
604
+ return Qnil;
605
+ }
255
606
  }
256
607
  catch(...)
257
608
  {
@@ -275,25 +626,79 @@ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, type
275
626
  Auto_Function_Wrapper<Func_T, Ret_T, 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>::
276
627
  Auto_Function_Wrapper(
277
628
  Func func,
278
- Data_Object<Exception_Handler> handler)
629
+ Data_Object<Exception_Handler> handler,
630
+ Arguments* arguments)
279
631
  : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
280
632
  , func_(func)
281
633
  , handler_(handler)
282
634
  , handler_guard_(&handler_)
283
635
  {
636
+ if(arguments == 0) {
637
+ arguments_ = new Arguments();
638
+ } else {
639
+ arguments_ = arguments;
640
+ }
284
641
  }
285
642
 
286
643
  template<typename Func_T, 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>
287
644
  VALUE Auto_Function_Wrapper<Func_T, Ret_T, 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>::
288
- call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6, VALUE ruby_arg7, VALUE ruby_arg8, VALUE ruby_arg9, VALUE ruby_arg10, VALUE ruby_arg11, VALUE ruby_arg12)
645
+ call(int argc, VALUE *argv, VALUE self)
289
646
  {
290
647
  Auto_Function_Wrapper<Func_T, Ret_T, 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> * wrapper = 0;
291
648
  try
292
649
  {
293
650
  Data_Object<Wrapped_Function> data(detail::method_data());
294
651
  wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, 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.get();
295
- Arg0_T arg0(from_ruby<Arg0_T>(ruby_arg0)); Arg1_T arg1(from_ruby<Arg1_T>(ruby_arg1)); Arg2_T arg2(from_ruby<Arg2_T>(ruby_arg2)); Arg3_T arg3(from_ruby<Arg3_T>(ruby_arg3)); Arg4_T arg4(from_ruby<Arg4_T>(ruby_arg4)); Arg5_T arg5(from_ruby<Arg5_T>(ruby_arg5)); Arg6_T arg6(from_ruby<Arg6_T>(ruby_arg6)); Arg7_T arg7(from_ruby<Arg7_T>(ruby_arg7)); Arg8_T arg8(from_ruby<Arg8_T>(ruby_arg8)); Arg9_T arg9(from_ruby<Arg9_T>(ruby_arg9)); Arg10_T arg10(from_ruby<Arg10_T>(ruby_arg10)); Arg11_T arg11(from_ruby<Arg11_T>(ruby_arg11)); Arg12_T arg12(from_ruby<Arg12_T>(ruby_arg12));
296
- return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12));
652
+ Arguments* args = wrapper->arguments_;
653
+
654
+ bool hasSelf = (self && self != Qnil);
655
+ if(args->count() >= 0) {
656
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
657
+ } else {
658
+ hasSelf = hasSelf && argc == Num_Args -1;
659
+ }
660
+
661
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12;
662
+
663
+ if(hasSelf) {
664
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
665
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
666
+
667
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
668
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
669
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
670
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
671
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
672
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
673
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
674
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
675
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
676
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
677
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
678
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
679
+ Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(11, varg11);
680
+
681
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12));
682
+ } else {
683
+ rb_scan_args(argc, argv, args->formatString(Num_Args)
684
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
685
+
686
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
687
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
688
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
689
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
690
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
691
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
692
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
693
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
694
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
695
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
696
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
697
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
698
+ Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(12, varg12);
699
+
700
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12));
701
+ }
297
702
  }
298
703
  catch(...)
299
704
  {
@@ -316,17 +721,23 @@ template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typ
316
721
  Auto_Function_Wrapper<Func_T, void, 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>::
317
722
  Auto_Function_Wrapper(
318
723
  Func func,
319
- Data_Object<Exception_Handler> handler)
724
+ Data_Object<Exception_Handler> handler,
725
+ Arguments* arguments)
320
726
  : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
321
727
  , func_(func)
322
728
  , handler_(handler)
323
729
  , handler_guard_(&handler_)
324
730
  {
731
+ if(arguments == 0) {
732
+ arguments_ = new Arguments();
733
+ } else {
734
+ arguments_ = arguments;
735
+ }
325
736
  }
326
737
 
327
738
  template<typename Func_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>
328
739
  VALUE Auto_Function_Wrapper<Func_T, void, 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>::
329
- call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6, VALUE ruby_arg7, VALUE ruby_arg8, VALUE ruby_arg9, VALUE ruby_arg10, VALUE ruby_arg11, VALUE ruby_arg12)
740
+ call(int argc, VALUE* argv, VALUE self)
330
741
  {
331
742
  Auto_Function_Wrapper<Func_T, void, 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> * wrapper = 0;
332
743
  try
@@ -334,9 +745,58 @@ call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE r
334
745
  Data_Object<Wrapped_Function> data(detail::method_data());
335
746
  wrapper =
336
747
  (Auto_Function_Wrapper<Func_T, void, 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.get();
337
- Arg0_T arg0(from_ruby<Arg0_T>(ruby_arg0)); Arg1_T arg1(from_ruby<Arg1_T>(ruby_arg1)); Arg2_T arg2(from_ruby<Arg2_T>(ruby_arg2)); Arg3_T arg3(from_ruby<Arg3_T>(ruby_arg3)); Arg4_T arg4(from_ruby<Arg4_T>(ruby_arg4)); Arg5_T arg5(from_ruby<Arg5_T>(ruby_arg5)); Arg6_T arg6(from_ruby<Arg6_T>(ruby_arg6)); Arg7_T arg7(from_ruby<Arg7_T>(ruby_arg7)); Arg8_T arg8(from_ruby<Arg8_T>(ruby_arg8)); Arg9_T arg9(from_ruby<Arg9_T>(ruby_arg9)); Arg10_T arg10(from_ruby<Arg10_T>(ruby_arg10)); Arg11_T arg11(from_ruby<Arg11_T>(ruby_arg11)); Arg12_T arg12(from_ruby<Arg12_T>(ruby_arg12));
338
- wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
339
- return Qnil;
748
+ Arguments* args = wrapper->arguments_;
749
+
750
+ bool hasSelf = (self && self != Qnil);
751
+ if(args->count() >= 0) {
752
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
753
+ } else {
754
+ hasSelf = hasSelf && argc == Num_Args -1;
755
+ }
756
+
757
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12;
758
+
759
+ if(hasSelf) {
760
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
761
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
762
+
763
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
764
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
765
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
766
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
767
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
768
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
769
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
770
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
771
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
772
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
773
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
774
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
775
+ Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(11, varg11);
776
+
777
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
778
+ return Qnil;
779
+ } else {
780
+ rb_scan_args(argc, argv, args->formatString(Num_Args)
781
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
782
+
783
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
784
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
785
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
786
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
787
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
788
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
789
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
790
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
791
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
792
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
793
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
794
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
795
+ Arg12_T arg12 = args->getArgumentOrDefault<Arg12_T>(12, varg12);
796
+
797
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
798
+ return Qnil;
799
+ }
340
800
  }
341
801
  catch(...)
342
802
  {
@@ -360,25 +820,77 @@ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, type
360
820
  Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T>::
361
821
  Auto_Function_Wrapper(
362
822
  Func func,
363
- Data_Object<Exception_Handler> handler)
823
+ Data_Object<Exception_Handler> handler,
824
+ Arguments* arguments)
364
825
  : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
365
826
  , func_(func)
366
827
  , handler_(handler)
367
828
  , handler_guard_(&handler_)
368
829
  {
830
+ if(arguments == 0) {
831
+ arguments_ = new Arguments();
832
+ } else {
833
+ arguments_ = arguments;
834
+ }
369
835
  }
370
836
 
371
837
  template<typename Func_T, 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>
372
838
  VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T>::
373
- call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6, VALUE ruby_arg7, VALUE ruby_arg8, VALUE ruby_arg9, VALUE ruby_arg10, VALUE ruby_arg11)
839
+ call(int argc, VALUE *argv, VALUE self)
374
840
  {
375
841
  Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T> * wrapper = 0;
376
842
  try
377
843
  {
378
844
  Data_Object<Wrapped_Function> data(detail::method_data());
379
845
  wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, 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.get();
380
- Arg0_T arg0(from_ruby<Arg0_T>(ruby_arg0)); Arg1_T arg1(from_ruby<Arg1_T>(ruby_arg1)); Arg2_T arg2(from_ruby<Arg2_T>(ruby_arg2)); Arg3_T arg3(from_ruby<Arg3_T>(ruby_arg3)); Arg4_T arg4(from_ruby<Arg4_T>(ruby_arg4)); Arg5_T arg5(from_ruby<Arg5_T>(ruby_arg5)); Arg6_T arg6(from_ruby<Arg6_T>(ruby_arg6)); Arg7_T arg7(from_ruby<Arg7_T>(ruby_arg7)); Arg8_T arg8(from_ruby<Arg8_T>(ruby_arg8)); Arg9_T arg9(from_ruby<Arg9_T>(ruby_arg9)); Arg10_T arg10(from_ruby<Arg10_T>(ruby_arg10)); Arg11_T arg11(from_ruby<Arg11_T>(ruby_arg11));
381
- return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11));
846
+ Arguments* args = wrapper->arguments_;
847
+
848
+ bool hasSelf = (self && self != Qnil);
849
+ if(args->count() >= 0) {
850
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
851
+ } else {
852
+ hasSelf = hasSelf && argc == Num_Args -1;
853
+ }
854
+
855
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11;
856
+
857
+ if(hasSelf) {
858
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
859
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
860
+
861
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
862
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
863
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
864
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
865
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
866
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
867
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
868
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
869
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
870
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
871
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
872
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
873
+
874
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11));
875
+ } else {
876
+ rb_scan_args(argc, argv, args->formatString(Num_Args)
877
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
878
+
879
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
880
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
881
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
882
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
883
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
884
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
885
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
886
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
887
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
888
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
889
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
890
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
891
+
892
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11));
893
+ }
382
894
  }
383
895
  catch(...)
384
896
  {
@@ -401,17 +913,23 @@ template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typ
401
913
  Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T>::
402
914
  Auto_Function_Wrapper(
403
915
  Func func,
404
- Data_Object<Exception_Handler> handler)
916
+ Data_Object<Exception_Handler> handler,
917
+ Arguments* arguments)
405
918
  : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
406
919
  , func_(func)
407
920
  , handler_(handler)
408
921
  , handler_guard_(&handler_)
409
922
  {
923
+ if(arguments == 0) {
924
+ arguments_ = new Arguments();
925
+ } else {
926
+ arguments_ = arguments;
927
+ }
410
928
  }
411
929
 
412
930
  template<typename Func_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>
413
931
  VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T>::
414
- call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6, VALUE ruby_arg7, VALUE ruby_arg8, VALUE ruby_arg9, VALUE ruby_arg10, VALUE ruby_arg11)
932
+ call(int argc, VALUE* argv, VALUE self)
415
933
  {
416
934
  Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T> * wrapper = 0;
417
935
  try
@@ -419,9 +937,56 @@ call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE r
419
937
  Data_Object<Wrapped_Function> data(detail::method_data());
420
938
  wrapper =
421
939
  (Auto_Function_Wrapper<Func_T, void, 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.get();
422
- Arg0_T arg0(from_ruby<Arg0_T>(ruby_arg0)); Arg1_T arg1(from_ruby<Arg1_T>(ruby_arg1)); Arg2_T arg2(from_ruby<Arg2_T>(ruby_arg2)); Arg3_T arg3(from_ruby<Arg3_T>(ruby_arg3)); Arg4_T arg4(from_ruby<Arg4_T>(ruby_arg4)); Arg5_T arg5(from_ruby<Arg5_T>(ruby_arg5)); Arg6_T arg6(from_ruby<Arg6_T>(ruby_arg6)); Arg7_T arg7(from_ruby<Arg7_T>(ruby_arg7)); Arg8_T arg8(from_ruby<Arg8_T>(ruby_arg8)); Arg9_T arg9(from_ruby<Arg9_T>(ruby_arg9)); Arg10_T arg10(from_ruby<Arg10_T>(ruby_arg10)); Arg11_T arg11(from_ruby<Arg11_T>(ruby_arg11));
423
- wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
424
- return Qnil;
940
+ Arguments* args = wrapper->arguments_;
941
+
942
+ bool hasSelf = (self && self != Qnil);
943
+ if(args->count() >= 0) {
944
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
945
+ } else {
946
+ hasSelf = hasSelf && argc == Num_Args -1;
947
+ }
948
+
949
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11;
950
+
951
+ if(hasSelf) {
952
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
953
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
954
+
955
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
956
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
957
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
958
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
959
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
960
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
961
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
962
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
963
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
964
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
965
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
966
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(10, varg10);
967
+
968
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
969
+ return Qnil;
970
+ } else {
971
+ rb_scan_args(argc, argv, args->formatString(Num_Args)
972
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
973
+
974
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
975
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
976
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
977
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
978
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
979
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
980
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
981
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
982
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
983
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
984
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
985
+ Arg11_T arg11 = args->getArgumentOrDefault<Arg11_T>(11, varg11);
986
+
987
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
988
+ return Qnil;
989
+ }
425
990
  }
426
991
  catch(...)
427
992
  {
@@ -445,25 +1010,75 @@ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, type
445
1010
  Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T>::
446
1011
  Auto_Function_Wrapper(
447
1012
  Func func,
448
- Data_Object<Exception_Handler> handler)
1013
+ Data_Object<Exception_Handler> handler,
1014
+ Arguments* arguments)
449
1015
  : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
450
1016
  , func_(func)
451
1017
  , handler_(handler)
452
1018
  , handler_guard_(&handler_)
453
1019
  {
1020
+ if(arguments == 0) {
1021
+ arguments_ = new Arguments();
1022
+ } else {
1023
+ arguments_ = arguments;
1024
+ }
454
1025
  }
455
1026
 
456
1027
  template<typename Func_T, 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>
457
1028
  VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T>::
458
- call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6, VALUE ruby_arg7, VALUE ruby_arg8, VALUE ruby_arg9, VALUE ruby_arg10)
1029
+ call(int argc, VALUE *argv, VALUE self)
459
1030
  {
460
1031
  Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T> * wrapper = 0;
461
1032
  try
462
1033
  {
463
1034
  Data_Object<Wrapped_Function> data(detail::method_data());
464
1035
  wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T> *)data.get();
465
- Arg0_T arg0(from_ruby<Arg0_T>(ruby_arg0)); Arg1_T arg1(from_ruby<Arg1_T>(ruby_arg1)); Arg2_T arg2(from_ruby<Arg2_T>(ruby_arg2)); Arg3_T arg3(from_ruby<Arg3_T>(ruby_arg3)); Arg4_T arg4(from_ruby<Arg4_T>(ruby_arg4)); Arg5_T arg5(from_ruby<Arg5_T>(ruby_arg5)); Arg6_T arg6(from_ruby<Arg6_T>(ruby_arg6)); Arg7_T arg7(from_ruby<Arg7_T>(ruby_arg7)); Arg8_T arg8(from_ruby<Arg8_T>(ruby_arg8)); Arg9_T arg9(from_ruby<Arg9_T>(ruby_arg9)); Arg10_T arg10(from_ruby<Arg10_T>(ruby_arg10));
466
- return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10));
1036
+ Arguments* args = wrapper->arguments_;
1037
+
1038
+ bool hasSelf = (self && self != Qnil);
1039
+ if(args->count() >= 0) {
1040
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
1041
+ } else {
1042
+ hasSelf = hasSelf && argc == Num_Args -1;
1043
+ }
1044
+
1045
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10;
1046
+
1047
+ if(hasSelf) {
1048
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
1049
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
1050
+
1051
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
1052
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
1053
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
1054
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
1055
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
1056
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
1057
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
1058
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
1059
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
1060
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
1061
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
1062
+
1063
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10));
1064
+ } else {
1065
+ rb_scan_args(argc, argv, args->formatString(Num_Args)
1066
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
1067
+
1068
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
1069
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
1070
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
1071
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
1072
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
1073
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
1074
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
1075
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
1076
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
1077
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
1078
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
1079
+
1080
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10));
1081
+ }
467
1082
  }
468
1083
  catch(...)
469
1084
  {
@@ -486,17 +1101,23 @@ template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typ
486
1101
  Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T>::
487
1102
  Auto_Function_Wrapper(
488
1103
  Func func,
489
- Data_Object<Exception_Handler> handler)
1104
+ Data_Object<Exception_Handler> handler,
1105
+ Arguments* arguments)
490
1106
  : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
491
1107
  , func_(func)
492
1108
  , handler_(handler)
493
1109
  , handler_guard_(&handler_)
494
1110
  {
1111
+ if(arguments == 0) {
1112
+ arguments_ = new Arguments();
1113
+ } else {
1114
+ arguments_ = arguments;
1115
+ }
495
1116
  }
496
1117
 
497
1118
  template<typename Func_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>
498
1119
  VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T>::
499
- call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6, VALUE ruby_arg7, VALUE ruby_arg8, VALUE ruby_arg9, VALUE ruby_arg10)
1120
+ call(int argc, VALUE* argv, VALUE self)
500
1121
  {
501
1122
  Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T> * wrapper = 0;
502
1123
  try
@@ -504,9 +1125,54 @@ call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE r
504
1125
  Data_Object<Wrapped_Function> data(detail::method_data());
505
1126
  wrapper =
506
1127
  (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T> *)data.get();
507
- Arg0_T arg0(from_ruby<Arg0_T>(ruby_arg0)); Arg1_T arg1(from_ruby<Arg1_T>(ruby_arg1)); Arg2_T arg2(from_ruby<Arg2_T>(ruby_arg2)); Arg3_T arg3(from_ruby<Arg3_T>(ruby_arg3)); Arg4_T arg4(from_ruby<Arg4_T>(ruby_arg4)); Arg5_T arg5(from_ruby<Arg5_T>(ruby_arg5)); Arg6_T arg6(from_ruby<Arg6_T>(ruby_arg6)); Arg7_T arg7(from_ruby<Arg7_T>(ruby_arg7)); Arg8_T arg8(from_ruby<Arg8_T>(ruby_arg8)); Arg9_T arg9(from_ruby<Arg9_T>(ruby_arg9)); Arg10_T arg10(from_ruby<Arg10_T>(ruby_arg10));
508
- wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
509
- return Qnil;
1128
+ Arguments* args = wrapper->arguments_;
1129
+
1130
+ bool hasSelf = (self && self != Qnil);
1131
+ if(args->count() >= 0) {
1132
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
1133
+ } else {
1134
+ hasSelf = hasSelf && argc == Num_Args -1;
1135
+ }
1136
+
1137
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10;
1138
+
1139
+ if(hasSelf) {
1140
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
1141
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
1142
+
1143
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
1144
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
1145
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
1146
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
1147
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
1148
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
1149
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
1150
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
1151
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
1152
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
1153
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(9, varg9);
1154
+
1155
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
1156
+ return Qnil;
1157
+ } else {
1158
+ rb_scan_args(argc, argv, args->formatString(Num_Args)
1159
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
1160
+
1161
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
1162
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
1163
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
1164
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
1165
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
1166
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
1167
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
1168
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
1169
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
1170
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
1171
+ Arg10_T arg10 = args->getArgumentOrDefault<Arg10_T>(10, varg10);
1172
+
1173
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
1174
+ return Qnil;
1175
+ }
510
1176
  }
511
1177
  catch(...)
512
1178
  {
@@ -530,25 +1196,73 @@ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, type
530
1196
  Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T>::
531
1197
  Auto_Function_Wrapper(
532
1198
  Func func,
533
- Data_Object<Exception_Handler> handler)
1199
+ Data_Object<Exception_Handler> handler,
1200
+ Arguments* arguments)
534
1201
  : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
535
1202
  , func_(func)
536
1203
  , handler_(handler)
537
1204
  , handler_guard_(&handler_)
538
1205
  {
1206
+ if(arguments == 0) {
1207
+ arguments_ = new Arguments();
1208
+ } else {
1209
+ arguments_ = arguments;
1210
+ }
539
1211
  }
540
1212
 
541
1213
  template<typename Func_T, 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>
542
1214
  VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T>::
543
- call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6, VALUE ruby_arg7, VALUE ruby_arg8, VALUE ruby_arg9)
1215
+ call(int argc, VALUE *argv, VALUE self)
544
1216
  {
545
1217
  Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T> * wrapper = 0;
546
1218
  try
547
1219
  {
548
1220
  Data_Object<Wrapped_Function> data(detail::method_data());
549
1221
  wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T> *)data.get();
550
- Arg0_T arg0(from_ruby<Arg0_T>(ruby_arg0)); Arg1_T arg1(from_ruby<Arg1_T>(ruby_arg1)); Arg2_T arg2(from_ruby<Arg2_T>(ruby_arg2)); Arg3_T arg3(from_ruby<Arg3_T>(ruby_arg3)); Arg4_T arg4(from_ruby<Arg4_T>(ruby_arg4)); Arg5_T arg5(from_ruby<Arg5_T>(ruby_arg5)); Arg6_T arg6(from_ruby<Arg6_T>(ruby_arg6)); Arg7_T arg7(from_ruby<Arg7_T>(ruby_arg7)); Arg8_T arg8(from_ruby<Arg8_T>(ruby_arg8)); Arg9_T arg9(from_ruby<Arg9_T>(ruby_arg9));
551
- return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9));
1222
+ Arguments* args = wrapper->arguments_;
1223
+
1224
+ bool hasSelf = (self && self != Qnil);
1225
+ if(args->count() >= 0) {
1226
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
1227
+ } else {
1228
+ hasSelf = hasSelf && argc == Num_Args -1;
1229
+ }
1230
+
1231
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9;
1232
+
1233
+ if(hasSelf) {
1234
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
1235
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
1236
+
1237
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
1238
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
1239
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
1240
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
1241
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
1242
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
1243
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
1244
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
1245
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
1246
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
1247
+
1248
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9));
1249
+ } else {
1250
+ rb_scan_args(argc, argv, args->formatString(Num_Args)
1251
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
1252
+
1253
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
1254
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
1255
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
1256
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
1257
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
1258
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
1259
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
1260
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
1261
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
1262
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
1263
+
1264
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9));
1265
+ }
552
1266
  }
553
1267
  catch(...)
554
1268
  {
@@ -571,17 +1285,23 @@ template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typ
571
1285
  Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T>::
572
1286
  Auto_Function_Wrapper(
573
1287
  Func func,
574
- Data_Object<Exception_Handler> handler)
1288
+ Data_Object<Exception_Handler> handler,
1289
+ Arguments* arguments)
575
1290
  : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
576
1291
  , func_(func)
577
1292
  , handler_(handler)
578
1293
  , handler_guard_(&handler_)
579
1294
  {
1295
+ if(arguments == 0) {
1296
+ arguments_ = new Arguments();
1297
+ } else {
1298
+ arguments_ = arguments;
1299
+ }
580
1300
  }
581
1301
 
582
1302
  template<typename Func_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>
583
1303
  VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T>::
584
- call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6, VALUE ruby_arg7, VALUE ruby_arg8, VALUE ruby_arg9)
1304
+ call(int argc, VALUE* argv, VALUE self)
585
1305
  {
586
1306
  Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T> * wrapper = 0;
587
1307
  try
@@ -589,9 +1309,52 @@ call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE r
589
1309
  Data_Object<Wrapped_Function> data(detail::method_data());
590
1310
  wrapper =
591
1311
  (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T> *)data.get();
592
- Arg0_T arg0(from_ruby<Arg0_T>(ruby_arg0)); Arg1_T arg1(from_ruby<Arg1_T>(ruby_arg1)); Arg2_T arg2(from_ruby<Arg2_T>(ruby_arg2)); Arg3_T arg3(from_ruby<Arg3_T>(ruby_arg3)); Arg4_T arg4(from_ruby<Arg4_T>(ruby_arg4)); Arg5_T arg5(from_ruby<Arg5_T>(ruby_arg5)); Arg6_T arg6(from_ruby<Arg6_T>(ruby_arg6)); Arg7_T arg7(from_ruby<Arg7_T>(ruby_arg7)); Arg8_T arg8(from_ruby<Arg8_T>(ruby_arg8)); Arg9_T arg9(from_ruby<Arg9_T>(ruby_arg9));
593
- wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
594
- return Qnil;
1312
+ Arguments* args = wrapper->arguments_;
1313
+
1314
+ bool hasSelf = (self && self != Qnil);
1315
+ if(args->count() >= 0) {
1316
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
1317
+ } else {
1318
+ hasSelf = hasSelf && argc == Num_Args -1;
1319
+ }
1320
+
1321
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9;
1322
+
1323
+ if(hasSelf) {
1324
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
1325
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
1326
+
1327
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
1328
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
1329
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
1330
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
1331
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
1332
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
1333
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
1334
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
1335
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
1336
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(8, varg8);
1337
+
1338
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
1339
+ return Qnil;
1340
+ } else {
1341
+ rb_scan_args(argc, argv, args->formatString(Num_Args)
1342
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
1343
+
1344
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
1345
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
1346
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
1347
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
1348
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
1349
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
1350
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
1351
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
1352
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
1353
+ Arg9_T arg9 = args->getArgumentOrDefault<Arg9_T>(9, varg9);
1354
+
1355
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
1356
+ return Qnil;
1357
+ }
595
1358
  }
596
1359
  catch(...)
597
1360
  {
@@ -615,25 +1378,71 @@ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, type
615
1378
  Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T>::
616
1379
  Auto_Function_Wrapper(
617
1380
  Func func,
618
- Data_Object<Exception_Handler> handler)
1381
+ Data_Object<Exception_Handler> handler,
1382
+ Arguments* arguments)
619
1383
  : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
620
1384
  , func_(func)
621
1385
  , handler_(handler)
622
1386
  , handler_guard_(&handler_)
623
1387
  {
1388
+ if(arguments == 0) {
1389
+ arguments_ = new Arguments();
1390
+ } else {
1391
+ arguments_ = arguments;
1392
+ }
624
1393
  }
625
1394
 
626
1395
  template<typename Func_T, 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>
627
1396
  VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T>::
628
- call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6, VALUE ruby_arg7, VALUE ruby_arg8)
1397
+ call(int argc, VALUE *argv, VALUE self)
629
1398
  {
630
1399
  Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T> * wrapper = 0;
631
1400
  try
632
1401
  {
633
1402
  Data_Object<Wrapped_Function> data(detail::method_data());
634
1403
  wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T> *)data.get();
635
- Arg0_T arg0(from_ruby<Arg0_T>(ruby_arg0)); Arg1_T arg1(from_ruby<Arg1_T>(ruby_arg1)); Arg2_T arg2(from_ruby<Arg2_T>(ruby_arg2)); Arg3_T arg3(from_ruby<Arg3_T>(ruby_arg3)); Arg4_T arg4(from_ruby<Arg4_T>(ruby_arg4)); Arg5_T arg5(from_ruby<Arg5_T>(ruby_arg5)); Arg6_T arg6(from_ruby<Arg6_T>(ruby_arg6)); Arg7_T arg7(from_ruby<Arg7_T>(ruby_arg7)); Arg8_T arg8(from_ruby<Arg8_T>(ruby_arg8));
636
- return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8));
1404
+ Arguments* args = wrapper->arguments_;
1405
+
1406
+ bool hasSelf = (self && self != Qnil);
1407
+ if(args->count() >= 0) {
1408
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
1409
+ } else {
1410
+ hasSelf = hasSelf && argc == Num_Args -1;
1411
+ }
1412
+
1413
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8;
1414
+
1415
+ if(hasSelf) {
1416
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
1417
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
1418
+
1419
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
1420
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
1421
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
1422
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
1423
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
1424
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
1425
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
1426
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
1427
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
1428
+
1429
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8));
1430
+ } else {
1431
+ rb_scan_args(argc, argv, args->formatString(Num_Args)
1432
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
1433
+
1434
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
1435
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
1436
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
1437
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
1438
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
1439
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
1440
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
1441
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
1442
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
1443
+
1444
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8));
1445
+ }
637
1446
  }
638
1447
  catch(...)
639
1448
  {
@@ -656,17 +1465,23 @@ template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typ
656
1465
  Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T>::
657
1466
  Auto_Function_Wrapper(
658
1467
  Func func,
659
- Data_Object<Exception_Handler> handler)
1468
+ Data_Object<Exception_Handler> handler,
1469
+ Arguments* arguments)
660
1470
  : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
661
1471
  , func_(func)
662
1472
  , handler_(handler)
663
1473
  , handler_guard_(&handler_)
664
1474
  {
1475
+ if(arguments == 0) {
1476
+ arguments_ = new Arguments();
1477
+ } else {
1478
+ arguments_ = arguments;
1479
+ }
665
1480
  }
666
1481
 
667
1482
  template<typename Func_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>
668
1483
  VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T>::
669
- call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6, VALUE ruby_arg7, VALUE ruby_arg8)
1484
+ call(int argc, VALUE* argv, VALUE self)
670
1485
  {
671
1486
  Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T> * wrapper = 0;
672
1487
  try
@@ -674,9 +1489,50 @@ call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE r
674
1489
  Data_Object<Wrapped_Function> data(detail::method_data());
675
1490
  wrapper =
676
1491
  (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T> *)data.get();
677
- Arg0_T arg0(from_ruby<Arg0_T>(ruby_arg0)); Arg1_T arg1(from_ruby<Arg1_T>(ruby_arg1)); Arg2_T arg2(from_ruby<Arg2_T>(ruby_arg2)); Arg3_T arg3(from_ruby<Arg3_T>(ruby_arg3)); Arg4_T arg4(from_ruby<Arg4_T>(ruby_arg4)); Arg5_T arg5(from_ruby<Arg5_T>(ruby_arg5)); Arg6_T arg6(from_ruby<Arg6_T>(ruby_arg6)); Arg7_T arg7(from_ruby<Arg7_T>(ruby_arg7)); Arg8_T arg8(from_ruby<Arg8_T>(ruby_arg8));
678
- wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
679
- return Qnil;
1492
+ Arguments* args = wrapper->arguments_;
1493
+
1494
+ bool hasSelf = (self && self != Qnil);
1495
+ if(args->count() >= 0) {
1496
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
1497
+ } else {
1498
+ hasSelf = hasSelf && argc == Num_Args -1;
1499
+ }
1500
+
1501
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8;
1502
+
1503
+ if(hasSelf) {
1504
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
1505
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
1506
+
1507
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
1508
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
1509
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
1510
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
1511
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
1512
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
1513
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
1514
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
1515
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(7, varg7);
1516
+
1517
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
1518
+ return Qnil;
1519
+ } else {
1520
+ rb_scan_args(argc, argv, args->formatString(Num_Args)
1521
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
1522
+
1523
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
1524
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
1525
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
1526
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
1527
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
1528
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
1529
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
1530
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
1531
+ Arg8_T arg8 = args->getArgumentOrDefault<Arg8_T>(8, varg8);
1532
+
1533
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
1534
+ return Qnil;
1535
+ }
680
1536
  }
681
1537
  catch(...)
682
1538
  {
@@ -700,25 +1556,69 @@ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, type
700
1556
  Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T>::
701
1557
  Auto_Function_Wrapper(
702
1558
  Func func,
703
- Data_Object<Exception_Handler> handler)
1559
+ Data_Object<Exception_Handler> handler,
1560
+ Arguments* arguments)
704
1561
  : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
705
1562
  , func_(func)
706
1563
  , handler_(handler)
707
1564
  , handler_guard_(&handler_)
708
1565
  {
1566
+ if(arguments == 0) {
1567
+ arguments_ = new Arguments();
1568
+ } else {
1569
+ arguments_ = arguments;
1570
+ }
709
1571
  }
710
1572
 
711
1573
  template<typename Func_T, 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>
712
1574
  VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T>::
713
- call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6, VALUE ruby_arg7)
1575
+ call(int argc, VALUE *argv, VALUE self)
714
1576
  {
715
1577
  Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T> * wrapper = 0;
716
1578
  try
717
1579
  {
718
1580
  Data_Object<Wrapped_Function> data(detail::method_data());
719
1581
  wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T> *)data.get();
720
- Arg0_T arg0(from_ruby<Arg0_T>(ruby_arg0)); Arg1_T arg1(from_ruby<Arg1_T>(ruby_arg1)); Arg2_T arg2(from_ruby<Arg2_T>(ruby_arg2)); Arg3_T arg3(from_ruby<Arg3_T>(ruby_arg3)); Arg4_T arg4(from_ruby<Arg4_T>(ruby_arg4)); Arg5_T arg5(from_ruby<Arg5_T>(ruby_arg5)); Arg6_T arg6(from_ruby<Arg6_T>(ruby_arg6)); Arg7_T arg7(from_ruby<Arg7_T>(ruby_arg7));
721
- return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7));
1582
+ Arguments* args = wrapper->arguments_;
1583
+
1584
+ bool hasSelf = (self && self != Qnil);
1585
+ if(args->count() >= 0) {
1586
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
1587
+ } else {
1588
+ hasSelf = hasSelf && argc == Num_Args -1;
1589
+ }
1590
+
1591
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7;
1592
+
1593
+ if(hasSelf) {
1594
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
1595
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
1596
+
1597
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
1598
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
1599
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
1600
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
1601
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
1602
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
1603
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
1604
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
1605
+
1606
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7));
1607
+ } else {
1608
+ rb_scan_args(argc, argv, args->formatString(Num_Args)
1609
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
1610
+
1611
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
1612
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
1613
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
1614
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
1615
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
1616
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
1617
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
1618
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
1619
+
1620
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7));
1621
+ }
722
1622
  }
723
1623
  catch(...)
724
1624
  {
@@ -741,17 +1641,23 @@ template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typ
741
1641
  Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T>::
742
1642
  Auto_Function_Wrapper(
743
1643
  Func func,
744
- Data_Object<Exception_Handler> handler)
1644
+ Data_Object<Exception_Handler> handler,
1645
+ Arguments* arguments)
745
1646
  : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
746
1647
  , func_(func)
747
1648
  , handler_(handler)
748
1649
  , handler_guard_(&handler_)
749
1650
  {
1651
+ if(arguments == 0) {
1652
+ arguments_ = new Arguments();
1653
+ } else {
1654
+ arguments_ = arguments;
1655
+ }
750
1656
  }
751
1657
 
752
1658
  template<typename Func_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>
753
1659
  VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T>::
754
- call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6, VALUE ruby_arg7)
1660
+ call(int argc, VALUE* argv, VALUE self)
755
1661
  {
756
1662
  Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T> * wrapper = 0;
757
1663
  try
@@ -759,9 +1665,48 @@ call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE r
759
1665
  Data_Object<Wrapped_Function> data(detail::method_data());
760
1666
  wrapper =
761
1667
  (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T> *)data.get();
762
- Arg0_T arg0(from_ruby<Arg0_T>(ruby_arg0)); Arg1_T arg1(from_ruby<Arg1_T>(ruby_arg1)); Arg2_T arg2(from_ruby<Arg2_T>(ruby_arg2)); Arg3_T arg3(from_ruby<Arg3_T>(ruby_arg3)); Arg4_T arg4(from_ruby<Arg4_T>(ruby_arg4)); Arg5_T arg5(from_ruby<Arg5_T>(ruby_arg5)); Arg6_T arg6(from_ruby<Arg6_T>(ruby_arg6)); Arg7_T arg7(from_ruby<Arg7_T>(ruby_arg7));
763
- wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
764
- return Qnil;
1668
+ Arguments* args = wrapper->arguments_;
1669
+
1670
+ bool hasSelf = (self && self != Qnil);
1671
+ if(args->count() >= 0) {
1672
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
1673
+ } else {
1674
+ hasSelf = hasSelf && argc == Num_Args -1;
1675
+ }
1676
+
1677
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7;
1678
+
1679
+ if(hasSelf) {
1680
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
1681
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
1682
+
1683
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
1684
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
1685
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
1686
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
1687
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
1688
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
1689
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
1690
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(6, varg6);
1691
+
1692
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
1693
+ return Qnil;
1694
+ } else {
1695
+ rb_scan_args(argc, argv, args->formatString(Num_Args)
1696
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
1697
+
1698
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
1699
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
1700
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
1701
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
1702
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
1703
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
1704
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
1705
+ Arg7_T arg7 = args->getArgumentOrDefault<Arg7_T>(7, varg7);
1706
+
1707
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
1708
+ return Qnil;
1709
+ }
765
1710
  }
766
1711
  catch(...)
767
1712
  {
@@ -785,25 +1730,67 @@ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, type
785
1730
  Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T>::
786
1731
  Auto_Function_Wrapper(
787
1732
  Func func,
788
- Data_Object<Exception_Handler> handler)
1733
+ Data_Object<Exception_Handler> handler,
1734
+ Arguments* arguments)
789
1735
  : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
790
1736
  , func_(func)
791
1737
  , handler_(handler)
792
1738
  , handler_guard_(&handler_)
793
1739
  {
1740
+ if(arguments == 0) {
1741
+ arguments_ = new Arguments();
1742
+ } else {
1743
+ arguments_ = arguments;
1744
+ }
794
1745
  }
795
1746
 
796
1747
  template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T>
797
1748
  VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T>::
798
- call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6)
1749
+ call(int argc, VALUE *argv, VALUE self)
799
1750
  {
800
1751
  Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T> * wrapper = 0;
801
1752
  try
802
1753
  {
803
1754
  Data_Object<Wrapped_Function> data(detail::method_data());
804
1755
  wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T> *)data.get();
805
- Arg0_T arg0(from_ruby<Arg0_T>(ruby_arg0)); Arg1_T arg1(from_ruby<Arg1_T>(ruby_arg1)); Arg2_T arg2(from_ruby<Arg2_T>(ruby_arg2)); Arg3_T arg3(from_ruby<Arg3_T>(ruby_arg3)); Arg4_T arg4(from_ruby<Arg4_T>(ruby_arg4)); Arg5_T arg5(from_ruby<Arg5_T>(ruby_arg5)); Arg6_T arg6(from_ruby<Arg6_T>(ruby_arg6));
806
- return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6));
1756
+ Arguments* args = wrapper->arguments_;
1757
+
1758
+ bool hasSelf = (self && self != Qnil);
1759
+ if(args->count() >= 0) {
1760
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
1761
+ } else {
1762
+ hasSelf = hasSelf && argc == Num_Args -1;
1763
+ }
1764
+
1765
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6;
1766
+
1767
+ if(hasSelf) {
1768
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
1769
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
1770
+
1771
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
1772
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
1773
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
1774
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
1775
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
1776
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
1777
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
1778
+
1779
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6));
1780
+ } else {
1781
+ rb_scan_args(argc, argv, args->formatString(Num_Args)
1782
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
1783
+
1784
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
1785
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
1786
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
1787
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
1788
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
1789
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
1790
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
1791
+
1792
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6));
1793
+ }
807
1794
  }
808
1795
  catch(...)
809
1796
  {
@@ -826,17 +1813,23 @@ template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typ
826
1813
  Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T>::
827
1814
  Auto_Function_Wrapper(
828
1815
  Func func,
829
- Data_Object<Exception_Handler> handler)
1816
+ Data_Object<Exception_Handler> handler,
1817
+ Arguments* arguments)
830
1818
  : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
831
1819
  , func_(func)
832
1820
  , handler_(handler)
833
1821
  , handler_guard_(&handler_)
834
1822
  {
1823
+ if(arguments == 0) {
1824
+ arguments_ = new Arguments();
1825
+ } else {
1826
+ arguments_ = arguments;
1827
+ }
835
1828
  }
836
1829
 
837
1830
  template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T>
838
1831
  VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T>::
839
- call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6)
1832
+ call(int argc, VALUE* argv, VALUE self)
840
1833
  {
841
1834
  Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T> * wrapper = 0;
842
1835
  try
@@ -844,9 +1837,46 @@ call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE r
844
1837
  Data_Object<Wrapped_Function> data(detail::method_data());
845
1838
  wrapper =
846
1839
  (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T> *)data.get();
847
- Arg0_T arg0(from_ruby<Arg0_T>(ruby_arg0)); Arg1_T arg1(from_ruby<Arg1_T>(ruby_arg1)); Arg2_T arg2(from_ruby<Arg2_T>(ruby_arg2)); Arg3_T arg3(from_ruby<Arg3_T>(ruby_arg3)); Arg4_T arg4(from_ruby<Arg4_T>(ruby_arg4)); Arg5_T arg5(from_ruby<Arg5_T>(ruby_arg5)); Arg6_T arg6(from_ruby<Arg6_T>(ruby_arg6));
848
- wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
849
- return Qnil;
1840
+ Arguments* args = wrapper->arguments_;
1841
+
1842
+ bool hasSelf = (self && self != Qnil);
1843
+ if(args->count() >= 0) {
1844
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
1845
+ } else {
1846
+ hasSelf = hasSelf && argc == Num_Args -1;
1847
+ }
1848
+
1849
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6;
1850
+
1851
+ if(hasSelf) {
1852
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
1853
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
1854
+
1855
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
1856
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
1857
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
1858
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
1859
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
1860
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
1861
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(5, varg5);
1862
+
1863
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
1864
+ return Qnil;
1865
+ } else {
1866
+ rb_scan_args(argc, argv, args->formatString(Num_Args)
1867
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
1868
+
1869
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
1870
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
1871
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
1872
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
1873
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
1874
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
1875
+ Arg6_T arg6 = args->getArgumentOrDefault<Arg6_T>(6, varg6);
1876
+
1877
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
1878
+ return Qnil;
1879
+ }
850
1880
  }
851
1881
  catch(...)
852
1882
  {
@@ -870,25 +1900,65 @@ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, type
870
1900
  Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T>::
871
1901
  Auto_Function_Wrapper(
872
1902
  Func func,
873
- Data_Object<Exception_Handler> handler)
1903
+ Data_Object<Exception_Handler> handler,
1904
+ Arguments* arguments)
874
1905
  : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
875
1906
  , func_(func)
876
1907
  , handler_(handler)
877
1908
  , handler_guard_(&handler_)
878
1909
  {
1910
+ if(arguments == 0) {
1911
+ arguments_ = new Arguments();
1912
+ } else {
1913
+ arguments_ = arguments;
1914
+ }
879
1915
  }
880
1916
 
881
1917
  template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T>
882
1918
  VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T>::
883
- call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5)
1919
+ call(int argc, VALUE *argv, VALUE self)
884
1920
  {
885
1921
  Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T> * wrapper = 0;
886
1922
  try
887
1923
  {
888
1924
  Data_Object<Wrapped_Function> data(detail::method_data());
889
1925
  wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T> *)data.get();
890
- Arg0_T arg0(from_ruby<Arg0_T>(ruby_arg0)); Arg1_T arg1(from_ruby<Arg1_T>(ruby_arg1)); Arg2_T arg2(from_ruby<Arg2_T>(ruby_arg2)); Arg3_T arg3(from_ruby<Arg3_T>(ruby_arg3)); Arg4_T arg4(from_ruby<Arg4_T>(ruby_arg4)); Arg5_T arg5(from_ruby<Arg5_T>(ruby_arg5));
891
- return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5));
1926
+ Arguments* args = wrapper->arguments_;
1927
+
1928
+ bool hasSelf = (self && self != Qnil);
1929
+ if(args->count() >= 0) {
1930
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
1931
+ } else {
1932
+ hasSelf = hasSelf && argc == Num_Args -1;
1933
+ }
1934
+
1935
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5;
1936
+
1937
+ if(hasSelf) {
1938
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
1939
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
1940
+
1941
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
1942
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
1943
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
1944
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
1945
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
1946
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
1947
+
1948
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5));
1949
+ } else {
1950
+ rb_scan_args(argc, argv, args->formatString(Num_Args)
1951
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
1952
+
1953
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
1954
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
1955
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
1956
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
1957
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
1958
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
1959
+
1960
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5));
1961
+ }
892
1962
  }
893
1963
  catch(...)
894
1964
  {
@@ -911,17 +1981,23 @@ template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typ
911
1981
  Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T>::
912
1982
  Auto_Function_Wrapper(
913
1983
  Func func,
914
- Data_Object<Exception_Handler> handler)
1984
+ Data_Object<Exception_Handler> handler,
1985
+ Arguments* arguments)
915
1986
  : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
916
1987
  , func_(func)
917
1988
  , handler_(handler)
918
1989
  , handler_guard_(&handler_)
919
1990
  {
1991
+ if(arguments == 0) {
1992
+ arguments_ = new Arguments();
1993
+ } else {
1994
+ arguments_ = arguments;
1995
+ }
920
1996
  }
921
1997
 
922
1998
  template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T>
923
1999
  VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T>::
924
- call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5)
2000
+ call(int argc, VALUE* argv, VALUE self)
925
2001
  {
926
2002
  Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T> * wrapper = 0;
927
2003
  try
@@ -929,9 +2005,44 @@ call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE r
929
2005
  Data_Object<Wrapped_Function> data(detail::method_data());
930
2006
  wrapper =
931
2007
  (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T> *)data.get();
932
- Arg0_T arg0(from_ruby<Arg0_T>(ruby_arg0)); Arg1_T arg1(from_ruby<Arg1_T>(ruby_arg1)); Arg2_T arg2(from_ruby<Arg2_T>(ruby_arg2)); Arg3_T arg3(from_ruby<Arg3_T>(ruby_arg3)); Arg4_T arg4(from_ruby<Arg4_T>(ruby_arg4)); Arg5_T arg5(from_ruby<Arg5_T>(ruby_arg5));
933
- wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5);
934
- return Qnil;
2008
+ Arguments* args = wrapper->arguments_;
2009
+
2010
+ bool hasSelf = (self && self != Qnil);
2011
+ if(args->count() >= 0) {
2012
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
2013
+ } else {
2014
+ hasSelf = hasSelf && argc == Num_Args -1;
2015
+ }
2016
+
2017
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5;
2018
+
2019
+ if(hasSelf) {
2020
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
2021
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
2022
+
2023
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
2024
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
2025
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
2026
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
2027
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
2028
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(4, varg4);
2029
+
2030
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5);
2031
+ return Qnil;
2032
+ } else {
2033
+ rb_scan_args(argc, argv, args->formatString(Num_Args)
2034
+ , &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
2035
+
2036
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
2037
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
2038
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
2039
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
2040
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
2041
+ Arg5_T arg5 = args->getArgumentOrDefault<Arg5_T>(5, varg5);
2042
+
2043
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4, arg5);
2044
+ return Qnil;
2045
+ }
935
2046
  }
936
2047
  catch(...)
937
2048
  {
@@ -955,25 +2066,63 @@ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, type
955
2066
  Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T>::
956
2067
  Auto_Function_Wrapper(
957
2068
  Func func,
958
- Data_Object<Exception_Handler> handler)
2069
+ Data_Object<Exception_Handler> handler,
2070
+ Arguments* arguments)
959
2071
  : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
960
2072
  , func_(func)
961
2073
  , handler_(handler)
962
2074
  , handler_guard_(&handler_)
963
2075
  {
2076
+ if(arguments == 0) {
2077
+ arguments_ = new Arguments();
2078
+ } else {
2079
+ arguments_ = arguments;
2080
+ }
964
2081
  }
965
2082
 
966
2083
  template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T>
967
2084
  VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T>::
968
- call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4)
2085
+ call(int argc, VALUE *argv, VALUE self)
969
2086
  {
970
2087
  Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T> * wrapper = 0;
971
2088
  try
972
2089
  {
973
2090
  Data_Object<Wrapped_Function> data(detail::method_data());
974
2091
  wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T> *)data.get();
975
- Arg0_T arg0(from_ruby<Arg0_T>(ruby_arg0)); Arg1_T arg1(from_ruby<Arg1_T>(ruby_arg1)); Arg2_T arg2(from_ruby<Arg2_T>(ruby_arg2)); Arg3_T arg3(from_ruby<Arg3_T>(ruby_arg3)); Arg4_T arg4(from_ruby<Arg4_T>(ruby_arg4));
976
- return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4));
2092
+ Arguments* args = wrapper->arguments_;
2093
+
2094
+ bool hasSelf = (self && self != Qnil);
2095
+ if(args->count() >= 0) {
2096
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
2097
+ } else {
2098
+ hasSelf = hasSelf && argc == Num_Args -1;
2099
+ }
2100
+
2101
+ VALUE varg0, varg1, varg2, varg3, varg4;
2102
+
2103
+ if(hasSelf) {
2104
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
2105
+ , &varg0, &varg1, &varg2, &varg3, &varg4);
2106
+
2107
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
2108
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
2109
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
2110
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
2111
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
2112
+
2113
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4));
2114
+ } else {
2115
+ rb_scan_args(argc, argv, args->formatString(Num_Args)
2116
+ , &varg0, &varg1, &varg2, &varg3, &varg4);
2117
+
2118
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
2119
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
2120
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
2121
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
2122
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
2123
+
2124
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3, arg4));
2125
+ }
977
2126
  }
978
2127
  catch(...)
979
2128
  {
@@ -996,17 +2145,23 @@ template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typ
996
2145
  Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T>::
997
2146
  Auto_Function_Wrapper(
998
2147
  Func func,
999
- Data_Object<Exception_Handler> handler)
2148
+ Data_Object<Exception_Handler> handler,
2149
+ Arguments* arguments)
1000
2150
  : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1001
2151
  , func_(func)
1002
2152
  , handler_(handler)
1003
2153
  , handler_guard_(&handler_)
1004
2154
  {
2155
+ if(arguments == 0) {
2156
+ arguments_ = new Arguments();
2157
+ } else {
2158
+ arguments_ = arguments;
2159
+ }
1005
2160
  }
1006
2161
 
1007
2162
  template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T>
1008
2163
  VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T>::
1009
- call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4)
2164
+ call(int argc, VALUE* argv, VALUE self)
1010
2165
  {
1011
2166
  Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T> * wrapper = 0;
1012
2167
  try
@@ -1014,9 +2169,42 @@ call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE r
1014
2169
  Data_Object<Wrapped_Function> data(detail::method_data());
1015
2170
  wrapper =
1016
2171
  (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T> *)data.get();
1017
- Arg0_T arg0(from_ruby<Arg0_T>(ruby_arg0)); Arg1_T arg1(from_ruby<Arg1_T>(ruby_arg1)); Arg2_T arg2(from_ruby<Arg2_T>(ruby_arg2)); Arg3_T arg3(from_ruby<Arg3_T>(ruby_arg3)); Arg4_T arg4(from_ruby<Arg4_T>(ruby_arg4));
1018
- wrapper->func_(arg0, arg1, arg2, arg3, arg4);
1019
- return Qnil;
2172
+ Arguments* args = wrapper->arguments_;
2173
+
2174
+ bool hasSelf = (self && self != Qnil);
2175
+ if(args->count() >= 0) {
2176
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
2177
+ } else {
2178
+ hasSelf = hasSelf && argc == Num_Args -1;
2179
+ }
2180
+
2181
+ VALUE varg0, varg1, varg2, varg3, varg4;
2182
+
2183
+ if(hasSelf) {
2184
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
2185
+ , &varg0, &varg1, &varg2, &varg3, &varg4);
2186
+
2187
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
2188
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
2189
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
2190
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
2191
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(3, varg3);
2192
+
2193
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4);
2194
+ return Qnil;
2195
+ } else {
2196
+ rb_scan_args(argc, argv, args->formatString(Num_Args)
2197
+ , &varg0, &varg1, &varg2, &varg3, &varg4);
2198
+
2199
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
2200
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
2201
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
2202
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
2203
+ Arg4_T arg4 = args->getArgumentOrDefault<Arg4_T>(4, varg4);
2204
+
2205
+ wrapper->func_(arg0, arg1, arg2, arg3, arg4);
2206
+ return Qnil;
2207
+ }
1020
2208
  }
1021
2209
  catch(...)
1022
2210
  {
@@ -1040,25 +2228,61 @@ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, type
1040
2228
  Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T>::
1041
2229
  Auto_Function_Wrapper(
1042
2230
  Func func,
1043
- Data_Object<Exception_Handler> handler)
2231
+ Data_Object<Exception_Handler> handler,
2232
+ Arguments* arguments)
1044
2233
  : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1045
2234
  , func_(func)
1046
2235
  , handler_(handler)
1047
2236
  , handler_guard_(&handler_)
1048
2237
  {
2238
+ if(arguments == 0) {
2239
+ arguments_ = new Arguments();
2240
+ } else {
2241
+ arguments_ = arguments;
2242
+ }
1049
2243
  }
1050
2244
 
1051
2245
  template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T>
1052
2246
  VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T>::
1053
- call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3)
2247
+ call(int argc, VALUE *argv, VALUE self)
1054
2248
  {
1055
2249
  Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T> * wrapper = 0;
1056
2250
  try
1057
2251
  {
1058
2252
  Data_Object<Wrapped_Function> data(detail::method_data());
1059
2253
  wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T> *)data.get();
1060
- Arg0_T arg0(from_ruby<Arg0_T>(ruby_arg0)); Arg1_T arg1(from_ruby<Arg1_T>(ruby_arg1)); Arg2_T arg2(from_ruby<Arg2_T>(ruby_arg2)); Arg3_T arg3(from_ruby<Arg3_T>(ruby_arg3));
1061
- return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3));
2254
+ Arguments* args = wrapper->arguments_;
2255
+
2256
+ bool hasSelf = (self && self != Qnil);
2257
+ if(args->count() >= 0) {
2258
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
2259
+ } else {
2260
+ hasSelf = hasSelf && argc == Num_Args -1;
2261
+ }
2262
+
2263
+ VALUE varg0, varg1, varg2, varg3;
2264
+
2265
+ if(hasSelf) {
2266
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
2267
+ , &varg0, &varg1, &varg2, &varg3);
2268
+
2269
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
2270
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
2271
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
2272
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
2273
+
2274
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3));
2275
+ } else {
2276
+ rb_scan_args(argc, argv, args->formatString(Num_Args)
2277
+ , &varg0, &varg1, &varg2, &varg3);
2278
+
2279
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
2280
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
2281
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
2282
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
2283
+
2284
+ return to_ruby(wrapper->func_(arg0, arg1, arg2, arg3));
2285
+ }
1062
2286
  }
1063
2287
  catch(...)
1064
2288
  {
@@ -1081,17 +2305,23 @@ template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typ
1081
2305
  Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T>::
1082
2306
  Auto_Function_Wrapper(
1083
2307
  Func func,
1084
- Data_Object<Exception_Handler> handler)
2308
+ Data_Object<Exception_Handler> handler,
2309
+ Arguments* arguments)
1085
2310
  : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1086
2311
  , func_(func)
1087
2312
  , handler_(handler)
1088
2313
  , handler_guard_(&handler_)
1089
2314
  {
2315
+ if(arguments == 0) {
2316
+ arguments_ = new Arguments();
2317
+ } else {
2318
+ arguments_ = arguments;
2319
+ }
1090
2320
  }
1091
2321
 
1092
2322
  template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T>
1093
2323
  VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T>::
1094
- call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3)
2324
+ call(int argc, VALUE* argv, VALUE self)
1095
2325
  {
1096
2326
  Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T> * wrapper = 0;
1097
2327
  try
@@ -1099,9 +2329,40 @@ call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3)
1099
2329
  Data_Object<Wrapped_Function> data(detail::method_data());
1100
2330
  wrapper =
1101
2331
  (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T, Arg3_T> *)data.get();
1102
- Arg0_T arg0(from_ruby<Arg0_T>(ruby_arg0)); Arg1_T arg1(from_ruby<Arg1_T>(ruby_arg1)); Arg2_T arg2(from_ruby<Arg2_T>(ruby_arg2)); Arg3_T arg3(from_ruby<Arg3_T>(ruby_arg3));
1103
- wrapper->func_(arg0, arg1, arg2, arg3);
1104
- return Qnil;
2332
+ Arguments* args = wrapper->arguments_;
2333
+
2334
+ bool hasSelf = (self && self != Qnil);
2335
+ if(args->count() >= 0) {
2336
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
2337
+ } else {
2338
+ hasSelf = hasSelf && argc == Num_Args -1;
2339
+ }
2340
+
2341
+ VALUE varg0, varg1, varg2, varg3;
2342
+
2343
+ if(hasSelf) {
2344
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
2345
+ , &varg0, &varg1, &varg2, &varg3);
2346
+
2347
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
2348
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
2349
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
2350
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(2, varg2);
2351
+
2352
+ wrapper->func_(arg0, arg1, arg2, arg3);
2353
+ return Qnil;
2354
+ } else {
2355
+ rb_scan_args(argc, argv, args->formatString(Num_Args)
2356
+ , &varg0, &varg1, &varg2, &varg3);
2357
+
2358
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
2359
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
2360
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
2361
+ Arg3_T arg3 = args->getArgumentOrDefault<Arg3_T>(3, varg3);
2362
+
2363
+ wrapper->func_(arg0, arg1, arg2, arg3);
2364
+ return Qnil;
2365
+ }
1105
2366
  }
1106
2367
  catch(...)
1107
2368
  {
@@ -1125,25 +2386,59 @@ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, type
1125
2386
  Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T>::
1126
2387
  Auto_Function_Wrapper(
1127
2388
  Func func,
1128
- Data_Object<Exception_Handler> handler)
2389
+ Data_Object<Exception_Handler> handler,
2390
+ Arguments* arguments)
1129
2391
  : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1130
2392
  , func_(func)
1131
2393
  , handler_(handler)
1132
2394
  , handler_guard_(&handler_)
1133
2395
  {
2396
+ if(arguments == 0) {
2397
+ arguments_ = new Arguments();
2398
+ } else {
2399
+ arguments_ = arguments;
2400
+ }
1134
2401
  }
1135
2402
 
1136
2403
  template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T, typename Arg2_T>
1137
2404
  VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T>::
1138
- call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2)
2405
+ call(int argc, VALUE *argv, VALUE self)
1139
2406
  {
1140
2407
  Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T> * wrapper = 0;
1141
2408
  try
1142
2409
  {
1143
2410
  Data_Object<Wrapped_Function> data(detail::method_data());
1144
2411
  wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T, Arg2_T> *)data.get();
1145
- Arg0_T arg0(from_ruby<Arg0_T>(ruby_arg0)); Arg1_T arg1(from_ruby<Arg1_T>(ruby_arg1)); Arg2_T arg2(from_ruby<Arg2_T>(ruby_arg2));
1146
- return to_ruby(wrapper->func_(arg0, arg1, arg2));
2412
+ Arguments* args = wrapper->arguments_;
2413
+
2414
+ bool hasSelf = (self && self != Qnil);
2415
+ if(args->count() >= 0) {
2416
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
2417
+ } else {
2418
+ hasSelf = hasSelf && argc == Num_Args -1;
2419
+ }
2420
+
2421
+ VALUE varg0, varg1, varg2;
2422
+
2423
+ if(hasSelf) {
2424
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
2425
+ , &varg0, &varg1, &varg2);
2426
+
2427
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
2428
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
2429
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
2430
+
2431
+ return to_ruby(wrapper->func_(arg0, arg1, arg2));
2432
+ } else {
2433
+ rb_scan_args(argc, argv, args->formatString(Num_Args)
2434
+ , &varg0, &varg1, &varg2);
2435
+
2436
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
2437
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
2438
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
2439
+
2440
+ return to_ruby(wrapper->func_(arg0, arg1, arg2));
2441
+ }
1147
2442
  }
1148
2443
  catch(...)
1149
2444
  {
@@ -1166,17 +2461,23 @@ template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T>
1166
2461
  Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T>::
1167
2462
  Auto_Function_Wrapper(
1168
2463
  Func func,
1169
- Data_Object<Exception_Handler> handler)
2464
+ Data_Object<Exception_Handler> handler,
2465
+ Arguments* arguments)
1170
2466
  : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1171
2467
  , func_(func)
1172
2468
  , handler_(handler)
1173
2469
  , handler_guard_(&handler_)
1174
2470
  {
2471
+ if(arguments == 0) {
2472
+ arguments_ = new Arguments();
2473
+ } else {
2474
+ arguments_ = arguments;
2475
+ }
1175
2476
  }
1176
2477
 
1177
2478
  template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T>
1178
2479
  VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T>::
1179
- call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2)
2480
+ call(int argc, VALUE* argv, VALUE self)
1180
2481
  {
1181
2482
  Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T> * wrapper = 0;
1182
2483
  try
@@ -1184,9 +2485,38 @@ call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2)
1184
2485
  Data_Object<Wrapped_Function> data(detail::method_data());
1185
2486
  wrapper =
1186
2487
  (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T, Arg2_T> *)data.get();
1187
- Arg0_T arg0(from_ruby<Arg0_T>(ruby_arg0)); Arg1_T arg1(from_ruby<Arg1_T>(ruby_arg1)); Arg2_T arg2(from_ruby<Arg2_T>(ruby_arg2));
1188
- wrapper->func_(arg0, arg1, arg2);
1189
- return Qnil;
2488
+ Arguments* args = wrapper->arguments_;
2489
+
2490
+ bool hasSelf = (self && self != Qnil);
2491
+ if(args->count() >= 0) {
2492
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
2493
+ } else {
2494
+ hasSelf = hasSelf && argc == Num_Args -1;
2495
+ }
2496
+
2497
+ VALUE varg0, varg1, varg2;
2498
+
2499
+ if(hasSelf) {
2500
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
2501
+ , &varg0, &varg1, &varg2);
2502
+
2503
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
2504
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
2505
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(1, varg1);
2506
+
2507
+ wrapper->func_(arg0, arg1, arg2);
2508
+ return Qnil;
2509
+ } else {
2510
+ rb_scan_args(argc, argv, args->formatString(Num_Args)
2511
+ , &varg0, &varg1, &varg2);
2512
+
2513
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
2514
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
2515
+ Arg2_T arg2 = args->getArgumentOrDefault<Arg2_T>(2, varg2);
2516
+
2517
+ wrapper->func_(arg0, arg1, arg2);
2518
+ return Qnil;
2519
+ }
1190
2520
  }
1191
2521
  catch(...)
1192
2522
  {
@@ -1210,25 +2540,57 @@ template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T>
1210
2540
  Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T>::
1211
2541
  Auto_Function_Wrapper(
1212
2542
  Func func,
1213
- Data_Object<Exception_Handler> handler)
2543
+ Data_Object<Exception_Handler> handler,
2544
+ Arguments* arguments)
1214
2545
  : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1215
2546
  , func_(func)
1216
2547
  , handler_(handler)
1217
2548
  , handler_guard_(&handler_)
1218
2549
  {
2550
+ if(arguments == 0) {
2551
+ arguments_ = new Arguments();
2552
+ } else {
2553
+ arguments_ = arguments;
2554
+ }
1219
2555
  }
1220
2556
 
1221
2557
  template<typename Func_T, typename Ret_T, typename Arg0_T, typename Arg1_T>
1222
2558
  VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T>::
1223
- call(VALUE ruby_arg0, VALUE ruby_arg1)
2559
+ call(int argc, VALUE *argv, VALUE self)
1224
2560
  {
1225
2561
  Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T> * wrapper = 0;
1226
2562
  try
1227
2563
  {
1228
2564
  Data_Object<Wrapped_Function> data(detail::method_data());
1229
2565
  wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T, Arg1_T> *)data.get();
1230
- Arg0_T arg0(from_ruby<Arg0_T>(ruby_arg0)); Arg1_T arg1(from_ruby<Arg1_T>(ruby_arg1));
1231
- return to_ruby(wrapper->func_(arg0, arg1));
2566
+ Arguments* args = wrapper->arguments_;
2567
+
2568
+ bool hasSelf = (self && self != Qnil);
2569
+ if(args->count() >= 0) {
2570
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
2571
+ } else {
2572
+ hasSelf = hasSelf && argc == Num_Args -1;
2573
+ }
2574
+
2575
+ VALUE varg0, varg1;
2576
+
2577
+ if(hasSelf) {
2578
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
2579
+ , &varg0, &varg1);
2580
+
2581
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
2582
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
2583
+
2584
+ return to_ruby(wrapper->func_(arg0, arg1));
2585
+ } else {
2586
+ rb_scan_args(argc, argv, args->formatString(Num_Args)
2587
+ , &varg0, &varg1);
2588
+
2589
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
2590
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
2591
+
2592
+ return to_ruby(wrapper->func_(arg0, arg1));
2593
+ }
1232
2594
  }
1233
2595
  catch(...)
1234
2596
  {
@@ -1251,17 +2613,23 @@ template<typename Func_T, typename Arg0_T, typename Arg1_T>
1251
2613
  Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T>::
1252
2614
  Auto_Function_Wrapper(
1253
2615
  Func func,
1254
- Data_Object<Exception_Handler> handler)
2616
+ Data_Object<Exception_Handler> handler,
2617
+ Arguments* arguments)
1255
2618
  : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1256
2619
  , func_(func)
1257
2620
  , handler_(handler)
1258
2621
  , handler_guard_(&handler_)
1259
2622
  {
2623
+ if(arguments == 0) {
2624
+ arguments_ = new Arguments();
2625
+ } else {
2626
+ arguments_ = arguments;
2627
+ }
1260
2628
  }
1261
2629
 
1262
2630
  template<typename Func_T, typename Arg0_T, typename Arg1_T>
1263
2631
  VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T>::
1264
- call(VALUE ruby_arg0, VALUE ruby_arg1)
2632
+ call(int argc, VALUE* argv, VALUE self)
1265
2633
  {
1266
2634
  Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T> * wrapper = 0;
1267
2635
  try
@@ -1269,9 +2637,36 @@ call(VALUE ruby_arg0, VALUE ruby_arg1)
1269
2637
  Data_Object<Wrapped_Function> data(detail::method_data());
1270
2638
  wrapper =
1271
2639
  (Auto_Function_Wrapper<Func_T, void, Arg0_T, Arg1_T> *)data.get();
1272
- Arg0_T arg0(from_ruby<Arg0_T>(ruby_arg0)); Arg1_T arg1(from_ruby<Arg1_T>(ruby_arg1));
1273
- wrapper->func_(arg0, arg1);
1274
- return Qnil;
2640
+ Arguments* args = wrapper->arguments_;
2641
+
2642
+ bool hasSelf = (self && self != Qnil);
2643
+ if(args->count() >= 0) {
2644
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
2645
+ } else {
2646
+ hasSelf = hasSelf && argc == Num_Args -1;
2647
+ }
2648
+
2649
+ VALUE varg0, varg1;
2650
+
2651
+ if(hasSelf) {
2652
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
2653
+ , &varg0, &varg1);
2654
+
2655
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
2656
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(0, varg0);
2657
+
2658
+ wrapper->func_(arg0, arg1);
2659
+ return Qnil;
2660
+ } else {
2661
+ rb_scan_args(argc, argv, args->formatString(Num_Args)
2662
+ , &varg0, &varg1);
2663
+
2664
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
2665
+ Arg1_T arg1 = args->getArgumentOrDefault<Arg1_T>(1, varg1);
2666
+
2667
+ wrapper->func_(arg0, arg1);
2668
+ return Qnil;
2669
+ }
1275
2670
  }
1276
2671
  catch(...)
1277
2672
  {
@@ -1295,25 +2690,56 @@ template<typename Func_T, typename Ret_T, typename Arg0_T>
1295
2690
  Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T>::
1296
2691
  Auto_Function_Wrapper(
1297
2692
  Func func,
1298
- Data_Object<Exception_Handler> handler)
2693
+ Data_Object<Exception_Handler> handler,
2694
+ Arguments* arguments)
1299
2695
  : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1300
2696
  , func_(func)
1301
2697
  , handler_(handler)
1302
2698
  , handler_guard_(&handler_)
1303
2699
  {
2700
+ if(arguments == 0) {
2701
+ arguments_ = new Arguments();
2702
+ } else {
2703
+ arguments_ = arguments;
2704
+ }
1304
2705
  }
1305
2706
 
1306
2707
  template<typename Func_T, typename Ret_T, typename Arg0_T>
1307
2708
  VALUE Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T>::
1308
- call(VALUE ruby_arg0)
2709
+ call(int argc, VALUE *argv, VALUE self)
1309
2710
  {
1310
2711
  Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T> * wrapper = 0;
1311
2712
  try
1312
2713
  {
1313
2714
  Data_Object<Wrapped_Function> data(detail::method_data());
1314
2715
  wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, Arg0_T> *)data.get();
1315
- Arg0_T arg0(from_ruby<Arg0_T>(ruby_arg0));
1316
- return to_ruby(wrapper->func_(arg0));
2716
+ Arguments* args = wrapper->arguments_;
2717
+
2718
+ bool hasSelf = (self && self != Qnil);
2719
+ if(args->count() >= 0) {
2720
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
2721
+ } else {
2722
+ hasSelf = hasSelf && argc == Num_Args -1;
2723
+ }
2724
+
2725
+ VALUE varg0;
2726
+
2727
+ if(hasSelf) {
2728
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
2729
+ , &varg0);
2730
+
2731
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
2732
+
2733
+
2734
+ return to_ruby(wrapper->func_(arg0));
2735
+ } else {
2736
+ rb_scan_args(argc, argv, args->formatString(Num_Args)
2737
+ , &varg0);
2738
+
2739
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
2740
+
2741
+ return to_ruby(wrapper->func_(arg0));
2742
+ }
1317
2743
  }
1318
2744
  catch(...)
1319
2745
  {
@@ -1336,17 +2762,23 @@ template<typename Func_T, typename Arg0_T>
1336
2762
  Auto_Function_Wrapper<Func_T, void, Arg0_T>::
1337
2763
  Auto_Function_Wrapper(
1338
2764
  Func func,
1339
- Data_Object<Exception_Handler> handler)
2765
+ Data_Object<Exception_Handler> handler,
2766
+ Arguments* arguments)
1340
2767
  : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1341
2768
  , func_(func)
1342
2769
  , handler_(handler)
1343
2770
  , handler_guard_(&handler_)
1344
2771
  {
2772
+ if(arguments == 0) {
2773
+ arguments_ = new Arguments();
2774
+ } else {
2775
+ arguments_ = arguments;
2776
+ }
1345
2777
  }
1346
2778
 
1347
2779
  template<typename Func_T, typename Arg0_T>
1348
2780
  VALUE Auto_Function_Wrapper<Func_T, void, Arg0_T>::
1349
- call(VALUE ruby_arg0)
2781
+ call(int argc, VALUE* argv, VALUE self)
1350
2782
  {
1351
2783
  Auto_Function_Wrapper<Func_T, void, Arg0_T> * wrapper = 0;
1352
2784
  try
@@ -1354,9 +2786,35 @@ call(VALUE ruby_arg0)
1354
2786
  Data_Object<Wrapped_Function> data(detail::method_data());
1355
2787
  wrapper =
1356
2788
  (Auto_Function_Wrapper<Func_T, void, Arg0_T> *)data.get();
1357
- Arg0_T arg0(from_ruby<Arg0_T>(ruby_arg0));
1358
- wrapper->func_(arg0);
1359
- return Qnil;
2789
+ Arguments* args = wrapper->arguments_;
2790
+
2791
+ bool hasSelf = (self && self != Qnil);
2792
+ if(args->count() >= 0) {
2793
+ hasSelf = hasSelf && args->count() == Num_Args - 1;
2794
+ } else {
2795
+ hasSelf = hasSelf && argc == Num_Args -1;
2796
+ }
2797
+
2798
+ VALUE varg0;
2799
+
2800
+ if(hasSelf) {
2801
+ rb_scan_args(argc, argv, args->formatString(Num_Args - 1)
2802
+ , &varg0);
2803
+
2804
+ Arg0_T arg0 = from_ruby<Arg0_T>(self);
2805
+
2806
+
2807
+ wrapper->func_(arg0);
2808
+ return Qnil;
2809
+ } else {
2810
+ rb_scan_args(argc, argv, args->formatString(Num_Args)
2811
+ , &varg0);
2812
+
2813
+ Arg0_T arg0 = args->getArgumentOrDefault<Arg0_T>(0, varg0);
2814
+
2815
+ wrapper->func_(arg0);
2816
+ return Qnil;
2817
+ }
1360
2818
  }
1361
2819
  catch(...)
1362
2820
  {
@@ -1376,6 +2834,91 @@ call(VALUE ruby_arg0)
1376
2834
  }
1377
2835
 
1378
2836
  // ---------------------------------------------------------------------
2837
+ template<typename Func_T, typename Ret_T>
2838
+ Auto_Function_Wrapper<Func_T, Ret_T>::
2839
+ Auto_Function_Wrapper(
2840
+ Func func,
2841
+ Data_Object<Exception_Handler> handler,
2842
+ Arguments* arguments)
2843
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
2844
+ , func_(func)
2845
+ , handler_(handler ? handler : new Default_Exception_Handler)
2846
+ , arguments_(arguments)
2847
+ {
2848
+ }
2849
+
2850
+ template<typename Func_T, typename Ret_T>
2851
+ VALUE Auto_Function_Wrapper<Func_T, Ret_T>::
2852
+ call()
2853
+ {
2854
+ Auto_Function_Wrapper<Func_T, Ret_T> * wrapper = 0;
2855
+ try
2856
+ {
2857
+ Data_Object<Wrapped_Function> data(detail::method_data());
2858
+ wrapper = (Auto_Function_Wrapper<Func_T, Ret_T>*)data.get();
2859
+
2860
+ return to_ruby<Ret_T>(wrapper->func_());
2861
+ }
2862
+ catch(...)
2863
+ {
2864
+ RUBY_TRY
2865
+ {
2866
+ if(wrapper)
2867
+ {
2868
+ return wrapper->handler_->handle_exception();
2869
+ }
2870
+ else
2871
+ {
2872
+ throw;
2873
+ }
2874
+ }
2875
+ RUBY_CATCH
2876
+ }
2877
+ }
2878
+
2879
+ template<typename Func_T>
2880
+ Auto_Function_Wrapper<Func_T, void>::
2881
+ Auto_Function_Wrapper(
2882
+ Func func,
2883
+ Data_Object<Exception_Handler> handler,
2884
+ Arguments* arguments)
2885
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
2886
+ , func_(func)
2887
+ , handler_(handler ? handler : new Default_Exception_Handler)
2888
+ , arguments_(arguments)
2889
+ {
2890
+ }
2891
+
2892
+ template<typename Func_T>
2893
+ VALUE Auto_Function_Wrapper<Func_T, void>::
2894
+ call()
2895
+ {
2896
+ Auto_Function_Wrapper<Func_T, void> * wrapper = 0;
2897
+ try
2898
+ {
2899
+ Data_Object<Wrapped_Function> data(detail::method_data());
2900
+ wrapper =
2901
+ (Auto_Function_Wrapper<Func_T, void> *)data.get();
2902
+
2903
+ wrapper->func_();
2904
+ return Qnil;
2905
+ }
2906
+ catch(...)
2907
+ {
2908
+ RUBY_TRY
2909
+ {
2910
+ if(wrapper)
2911
+ {
2912
+ return wrapper->handler_->handle_exception();
2913
+ }
2914
+ else
2915
+ {
2916
+ throw;
2917
+ }
2918
+ }
2919
+ RUBY_CATCH
2920
+ }
2921
+ }
1379
2922
 
1380
2923
  } // namespace detail
1381
2924