wurlinc-rice 1.4.0.1

Sign up to get free protection for your applications and to get access to all the features.
Files changed (186) hide show
  1. data/COPYING +23 -0
  2. data/Doxyfile +1253 -0
  3. data/Makefile.am +26 -0
  4. data/README +1119 -0
  5. data/README.mingw +8 -0
  6. data/Rakefile +33 -0
  7. data/bootstrap +9 -0
  8. data/configure.ac +52 -0
  9. data/doxygen.ac +314 -0
  10. data/doxygen.am +186 -0
  11. data/extconf.rb +41 -0
  12. data/post-autoconf.rb +22 -0
  13. data/post-automake.rb +28 -0
  14. data/rice/Address_Registration_Guard.hpp +7 -0
  15. data/rice/Address_Registration_Guard.ipp +34 -0
  16. data/rice/Address_Registration_Guard_defn.hpp +65 -0
  17. data/rice/Allocation_Strategies.hpp +37 -0
  18. data/rice/Arg.hpp +8 -0
  19. data/rice/Arg_impl.hpp +127 -0
  20. data/rice/Arg_operators.cpp +21 -0
  21. data/rice/Arg_operators.hpp +19 -0
  22. data/rice/Array.hpp +220 -0
  23. data/rice/Array.ipp +263 -0
  24. data/rice/Builtin_Object.hpp +8 -0
  25. data/rice/Builtin_Object.ipp +50 -0
  26. data/rice/Builtin_Object_defn.hpp +51 -0
  27. data/rice/Class.cpp +57 -0
  28. data/rice/Class.hpp +8 -0
  29. data/rice/Class.ipp +6 -0
  30. data/rice/Class_defn.hpp +83 -0
  31. data/rice/Constructor.hpp +367 -0
  32. data/rice/Critical_Guard.hpp +40 -0
  33. data/rice/Critical_Guard.ipp +26 -0
  34. data/rice/Data_Object.hpp +8 -0
  35. data/rice/Data_Object.ipp +133 -0
  36. data/rice/Data_Object_defn.hpp +132 -0
  37. data/rice/Data_Type.cpp +54 -0
  38. data/rice/Data_Type.hpp +8 -0
  39. data/rice/Data_Type.ipp +365 -0
  40. data/rice/Data_Type_defn.hpp +261 -0
  41. data/rice/Data_Type_fwd.hpp +12 -0
  42. data/rice/Director.cpp +13 -0
  43. data/rice/Director.hpp +39 -0
  44. data/rice/Enum.hpp +117 -0
  45. data/rice/Enum.ipp +246 -0
  46. data/rice/Exception.cpp +59 -0
  47. data/rice/Exception.hpp +9 -0
  48. data/rice/Exception_Base.hpp +8 -0
  49. data/rice/Exception_Base.ipp +13 -0
  50. data/rice/Exception_Base_defn.hpp +27 -0
  51. data/rice/Exception_defn.hpp +69 -0
  52. data/rice/Hash.hpp +210 -0
  53. data/rice/Hash.ipp +338 -0
  54. data/rice/Identifier.cpp +8 -0
  55. data/rice/Identifier.hpp +50 -0
  56. data/rice/Identifier.ipp +33 -0
  57. data/rice/Jump_Tag.hpp +24 -0
  58. data/rice/Makefile.am +129 -0
  59. data/rice/Module.cpp +84 -0
  60. data/rice/Module.hpp +8 -0
  61. data/rice/Module.ipp +6 -0
  62. data/rice/Module_defn.hpp +88 -0
  63. data/rice/Module_impl.hpp +281 -0
  64. data/rice/Module_impl.ipp +348 -0
  65. data/rice/Object.cpp +160 -0
  66. data/rice/Object.hpp +8 -0
  67. data/rice/Object.ipp +19 -0
  68. data/rice/Object_defn.hpp +191 -0
  69. data/rice/Require_Guard.hpp +21 -0
  70. data/rice/String.cpp +94 -0
  71. data/rice/String.hpp +89 -0
  72. data/rice/Struct.cpp +117 -0
  73. data/rice/Struct.hpp +162 -0
  74. data/rice/Struct.ipp +26 -0
  75. data/rice/Symbol.cpp +25 -0
  76. data/rice/Symbol.hpp +66 -0
  77. data/rice/Symbol.ipp +44 -0
  78. data/rice/VM.cpp +92 -0
  79. data/rice/VM.hpp +32 -0
  80. data/rice/config.hpp.in +40 -0
  81. data/rice/detail/Arguments.hpp +118 -0
  82. data/rice/detail/Auto_Function_Wrapper.hpp +829 -0
  83. data/rice/detail/Auto_Function_Wrapper.ipp +3391 -0
  84. data/rice/detail/Auto_Member_Function_Wrapper.hpp +828 -0
  85. data/rice/detail/Auto_Member_Function_Wrapper.ipp +2503 -0
  86. data/rice/detail/Caster.hpp +103 -0
  87. data/rice/detail/Exception_Handler.hpp +8 -0
  88. data/rice/detail/Exception_Handler.ipp +68 -0
  89. data/rice/detail/Exception_Handler_defn.hpp +96 -0
  90. data/rice/detail/Iterator.hpp +93 -0
  91. data/rice/detail/Not_Copyable.hpp +25 -0
  92. data/rice/detail/Wrapped_Function.hpp +33 -0
  93. data/rice/detail/cfp.hpp +24 -0
  94. data/rice/detail/cfp.ipp +51 -0
  95. data/rice/detail/check_ruby_type.cpp +27 -0
  96. data/rice/detail/check_ruby_type.hpp +23 -0
  97. data/rice/detail/creation_funcs.hpp +37 -0
  98. data/rice/detail/creation_funcs.ipp +36 -0
  99. data/rice/detail/default_allocation_func.hpp +23 -0
  100. data/rice/detail/default_allocation_func.ipp +11 -0
  101. data/rice/detail/define_method_and_auto_wrap.hpp +31 -0
  102. data/rice/detail/define_method_and_auto_wrap.ipp +30 -0
  103. data/rice/detail/demangle.cpp +56 -0
  104. data/rice/detail/demangle.hpp +19 -0
  105. data/rice/detail/env.hpp +19 -0
  106. data/rice/detail/from_ruby.hpp +43 -0
  107. data/rice/detail/from_ruby.ipp +60 -0
  108. data/rice/detail/method_data.cpp +159 -0
  109. data/rice/detail/method_data.hpp +21 -0
  110. data/rice/detail/mininode.cpp +1220 -0
  111. data/rice/detail/mininode.hpp +320 -0
  112. data/rice/detail/node.hpp +13 -0
  113. data/rice/detail/object_call.hpp +68 -0
  114. data/rice/detail/object_call.ipp +131 -0
  115. data/rice/detail/protect.cpp +29 -0
  116. data/rice/detail/protect.hpp +34 -0
  117. data/rice/detail/ruby.hpp +93 -0
  118. data/rice/detail/ruby_version_code.hpp.in +6 -0
  119. data/rice/detail/rubysig.hpp +19 -0
  120. data/rice/detail/st.hpp +60 -0
  121. data/rice/detail/to_ruby.hpp +22 -0
  122. data/rice/detail/to_ruby.ipp +36 -0
  123. data/rice/detail/traits.hpp +43 -0
  124. data/rice/detail/win32.hpp +16 -0
  125. data/rice/detail/wrap_function.hpp +341 -0
  126. data/rice/detail/wrap_function.ipp +514 -0
  127. data/rice/global_function.hpp +33 -0
  128. data/rice/global_function.ipp +22 -0
  129. data/rice/protect.hpp +91 -0
  130. data/rice/protect.ipp +1133 -0
  131. data/rice/ruby_mark.hpp +13 -0
  132. data/rice/ruby_try_catch.hpp +86 -0
  133. data/rice/rubypp.rb +97 -0
  134. data/rice/to_from_ruby.hpp +8 -0
  135. data/rice/to_from_ruby.ipp +297 -0
  136. data/rice/to_from_ruby_defn.hpp +71 -0
  137. data/ruby/Makefile.am +1 -0
  138. data/ruby/lib/Makefile.am +3 -0
  139. data/ruby/lib/mkmf-rice.rb.in +216 -0
  140. data/ruby/lib/version.rb +3 -0
  141. data/ruby.ac +136 -0
  142. data/sample/Makefile.am +47 -0
  143. data/sample/enum/extconf.rb +3 -0
  144. data/sample/enum/sample_enum.cpp +54 -0
  145. data/sample/enum/test.rb +8 -0
  146. data/sample/inheritance/animals.cpp +98 -0
  147. data/sample/inheritance/extconf.rb +3 -0
  148. data/sample/inheritance/test.rb +7 -0
  149. data/sample/map/extconf.rb +3 -0
  150. data/sample/map/map.cpp +81 -0
  151. data/sample/map/test.rb +7 -0
  152. data/test/Makefile.am +78 -0
  153. data/test/ext/Makefile.am +43 -0
  154. data/test/ext/t1/Foo.hpp +10 -0
  155. data/test/ext/t1/extconf.rb +2 -0
  156. data/test/ext/t1/t1.cpp +15 -0
  157. data/test/ext/t2/extconf.rb +2 -0
  158. data/test/ext/t2/t2.cpp +11 -0
  159. data/test/test_Address_Registration_Guard.cpp +43 -0
  160. data/test/test_Allocation_Strategies.cpp +77 -0
  161. data/test/test_Array.cpp +241 -0
  162. data/test/test_Builtin_Object.cpp +72 -0
  163. data/test/test_Class.cpp +498 -0
  164. data/test/test_Constructor.cpp +128 -0
  165. data/test/test_Critical_Guard.cpp +51 -0
  166. data/test/test_Data_Object.cpp +275 -0
  167. data/test/test_Data_Type.cpp +348 -0
  168. data/test/test_Director.cpp +301 -0
  169. data/test/test_Enum.cpp +195 -0
  170. data/test/test_Exception.cpp +46 -0
  171. data/test/test_Hash.cpp +195 -0
  172. data/test/test_Identifier.cpp +70 -0
  173. data/test/test_Jump_Tag.cpp +17 -0
  174. data/test/test_Memory_Management.cpp +50 -0
  175. data/test/test_Module.cpp +481 -0
  176. data/test/test_Object.cpp +148 -0
  177. data/test/test_String.cpp +94 -0
  178. data/test/test_Struct.cpp +192 -0
  179. data/test/test_Symbol.cpp +63 -0
  180. data/test/test_To_From_Ruby.cpp +263 -0
  181. data/test/test_VM.cpp +26 -0
  182. data/test/test_global_functions.cpp +114 -0
  183. data/test/test_rice.rb +43 -0
  184. data/test/unittest.cpp +136 -0
  185. data/test/unittest.hpp +292 -0
  186. metadata +276 -0
data/rice/detail/Auto_Member_Function_Wrapper.ipp ADDED
@@ -0,0 +1,2503 @@
1
+ #ifndef Rice__detail__Auto_Member_Function_Wrapper__ipp_
2
+ #define Rice__detail__Auto_Member_Function_Wrapper__ipp_
3
+
4
+ // This is a generated file. DO NOT EDIT!!
5
+
6
+
7
+ // This causes problems with certain C++ libraries
8
+ #undef TYPE
9
+
10
+ #include "method_data.hpp"
11
+ #include "../ruby_try_catch.hpp"
12
+ #include "../to_from_ruby.hpp"
13
+ #include "traits.hpp"
14
+ #include <typeinfo>
15
+ namespace Rice
16
+ {
17
+
18
+ namespace detail
19
+ {
20
+
21
+ template<typename Func_T, typename Ret_T, typename Self_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>
22
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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>::
23
+ Auto_Member_Function_Wrapper(
24
+ Func func,
25
+ Data_Object<Exception_Handler> handler,
26
+ Arguments* arguments)
27
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
28
+ , func_(func)
29
+ , handler_(handler)
30
+ , handler_guard_(&handler_)
31
+ , arguments_(arguments)
32
+ {
33
+ if(arguments == 0) {
34
+ arguments_ = new Arguments();
35
+ } else {
36
+ arguments_ = arguments;
37
+ }
38
+ }
39
+
40
+ template<typename Func_T, typename Ret_T, typename Self_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>
41
+ VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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>::
42
+ call(int argc, VALUE* argv, VALUE self)
43
+ {
44
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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;
45
+ try
46
+ {
47
+ Data_Object<Wrapped_Function> data(detail::method_data());
48
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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();
49
+ Arguments* args = wrapper->arguments_;
50
+
51
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13, varg14, varg15;
52
+
53
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
54
+
55
+ Self_T * obj = from_ruby<Self_T *>(self);
56
+
57
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
58
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
59
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
60
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
61
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
62
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
63
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
64
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
65
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
66
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
67
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
68
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
69
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
70
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
71
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
72
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
73
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
74
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
75
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
76
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
77
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
78
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
79
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
80
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
81
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
82
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
83
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
84
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
85
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
86
+ Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
87
+ typedef typename sanitize< Arg15_T >::Type Arg15_Type;
88
+ Arg15_Type arg15 = args->getArgumentOrDefault<Arg15_Type>(15, varg15);
89
+ Func func = wrapper->func_;
90
+ return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15));
91
+ }
92
+ catch(...)
93
+ {
94
+ RUBY_TRY
95
+ {
96
+ if(wrapper)
97
+ {
98
+ return wrapper->handler_->handle_exception();
99
+ }
100
+ else
101
+ {
102
+ throw;
103
+ }
104
+ }
105
+ RUBY_CATCH
106
+ }
107
+ }
108
+
109
+ template<typename Func_T, typename Self_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>
110
+ Auto_Member_Function_Wrapper<Func_T, void, Self_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>::
111
+ Auto_Member_Function_Wrapper(
112
+ Func func,
113
+ Data_Object<Exception_Handler> handler,
114
+ Arguments* arguments)
115
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
116
+ , func_(func)
117
+ , handler_(handler)
118
+ , handler_guard_(&handler_)
119
+ , arguments_(arguments)
120
+ {
121
+ if(arguments == 0) {
122
+ arguments_ = new Arguments();
123
+ } else {
124
+ arguments_ = arguments;
125
+ }
126
+ }
127
+
128
+ template<typename Func_T, typename Self_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>
129
+ VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_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>::
130
+ call(int argc, VALUE* argv, VALUE self)
131
+ {
132
+ Auto_Member_Function_Wrapper<Func_T, void, Self_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;
133
+ try
134
+ {
135
+ Data_Object<Wrapped_Function> data(detail::method_data());
136
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, void, Self_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();
137
+ Arguments* args = wrapper->arguments_;
138
+
139
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13, varg14, varg15;
140
+
141
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14, &varg15);
142
+
143
+ Self_T * obj = from_ruby<Self_T *>(self);
144
+
145
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
146
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
147
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
148
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
149
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
150
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
151
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
152
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
153
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
154
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
155
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
156
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
157
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
158
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
159
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
160
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
161
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
162
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
163
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
164
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
165
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
166
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
167
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
168
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
169
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
170
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
171
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
172
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
173
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
174
+ Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
175
+ typedef typename sanitize< Arg15_T >::Type Arg15_Type;
176
+ Arg15_Type arg15 = args->getArgumentOrDefault<Arg15_Type>(15, varg15);
177
+ Func func = wrapper->func_;
178
+ (*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15);
179
+ return Qnil;
180
+ }
181
+ catch(...)
182
+ {
183
+ RUBY_TRY
184
+ {
185
+ if(wrapper)
186
+ {
187
+ return wrapper->handler_->handle_exception();
188
+ }
189
+ else
190
+ {
191
+ throw;
192
+ }
193
+ }
194
+ RUBY_CATCH
195
+ }
196
+ }
197
+
198
+ // ---------------------------------------------------------------------
199
+ template<typename Func_T, typename Ret_T, typename Self_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>
200
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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>::
201
+ Auto_Member_Function_Wrapper(
202
+ Func func,
203
+ Data_Object<Exception_Handler> handler,
204
+ Arguments* arguments)
205
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
206
+ , func_(func)
207
+ , handler_(handler)
208
+ , handler_guard_(&handler_)
209
+ , arguments_(arguments)
210
+ {
211
+ if(arguments == 0) {
212
+ arguments_ = new Arguments();
213
+ } else {
214
+ arguments_ = arguments;
215
+ }
216
+ }
217
+
218
+ template<typename Func_T, typename Ret_T, typename Self_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>
219
+ VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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>::
220
+ call(int argc, VALUE* argv, VALUE self)
221
+ {
222
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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;
223
+ try
224
+ {
225
+ Data_Object<Wrapped_Function> data(detail::method_data());
226
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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();
227
+ Arguments* args = wrapper->arguments_;
228
+
229
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13, varg14;
230
+
231
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
232
+
233
+ Self_T * obj = from_ruby<Self_T *>(self);
234
+
235
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
236
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
237
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
238
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
239
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
240
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
241
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
242
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
243
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
244
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
245
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
246
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
247
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
248
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
249
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
250
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
251
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
252
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
253
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
254
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
255
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
256
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
257
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
258
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
259
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
260
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
261
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
262
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
263
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
264
+ Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
265
+ Func func = wrapper->func_;
266
+ return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14));
267
+ }
268
+ catch(...)
269
+ {
270
+ RUBY_TRY
271
+ {
272
+ if(wrapper)
273
+ {
274
+ return wrapper->handler_->handle_exception();
275
+ }
276
+ else
277
+ {
278
+ throw;
279
+ }
280
+ }
281
+ RUBY_CATCH
282
+ }
283
+ }
284
+
285
+ template<typename Func_T, typename Self_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>
286
+ Auto_Member_Function_Wrapper<Func_T, void, Self_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>::
287
+ Auto_Member_Function_Wrapper(
288
+ Func func,
289
+ Data_Object<Exception_Handler> handler,
290
+ Arguments* arguments)
291
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
292
+ , func_(func)
293
+ , handler_(handler)
294
+ , handler_guard_(&handler_)
295
+ , arguments_(arguments)
296
+ {
297
+ if(arguments == 0) {
298
+ arguments_ = new Arguments();
299
+ } else {
300
+ arguments_ = arguments;
301
+ }
302
+ }
303
+
304
+ template<typename Func_T, typename Self_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>
305
+ VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_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>::
306
+ call(int argc, VALUE* argv, VALUE self)
307
+ {
308
+ Auto_Member_Function_Wrapper<Func_T, void, Self_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;
309
+ try
310
+ {
311
+ Data_Object<Wrapped_Function> data(detail::method_data());
312
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, void, Self_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();
313
+ Arguments* args = wrapper->arguments_;
314
+
315
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13, varg14;
316
+
317
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13, &varg14);
318
+
319
+ Self_T * obj = from_ruby<Self_T *>(self);
320
+
321
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
322
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
323
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
324
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
325
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
326
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
327
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
328
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
329
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
330
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
331
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
332
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
333
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
334
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
335
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
336
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
337
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
338
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
339
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
340
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
341
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
342
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
343
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
344
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
345
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
346
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
347
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
348
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
349
+ typedef typename sanitize< Arg14_T >::Type Arg14_Type;
350
+ Arg14_Type arg14 = args->getArgumentOrDefault<Arg14_Type>(14, varg14);
351
+ Func func = wrapper->func_;
352
+ (*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
353
+ return Qnil;
354
+ }
355
+ catch(...)
356
+ {
357
+ RUBY_TRY
358
+ {
359
+ if(wrapper)
360
+ {
361
+ return wrapper->handler_->handle_exception();
362
+ }
363
+ else
364
+ {
365
+ throw;
366
+ }
367
+ }
368
+ RUBY_CATCH
369
+ }
370
+ }
371
+
372
+ // ---------------------------------------------------------------------
373
+ template<typename Func_T, typename Ret_T, typename Self_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>
374
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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>::
375
+ Auto_Member_Function_Wrapper(
376
+ Func func,
377
+ Data_Object<Exception_Handler> handler,
378
+ Arguments* arguments)
379
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
380
+ , func_(func)
381
+ , handler_(handler)
382
+ , handler_guard_(&handler_)
383
+ , arguments_(arguments)
384
+ {
385
+ if(arguments == 0) {
386
+ arguments_ = new Arguments();
387
+ } else {
388
+ arguments_ = arguments;
389
+ }
390
+ }
391
+
392
+ template<typename Func_T, typename Ret_T, typename Self_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>
393
+ VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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>::
394
+ call(int argc, VALUE* argv, VALUE self)
395
+ {
396
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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;
397
+ try
398
+ {
399
+ Data_Object<Wrapped_Function> data(detail::method_data());
400
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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();
401
+ Arguments* args = wrapper->arguments_;
402
+
403
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13;
404
+
405
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
406
+
407
+ Self_T * obj = from_ruby<Self_T *>(self);
408
+
409
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
410
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
411
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
412
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
413
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
414
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
415
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
416
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
417
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
418
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
419
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
420
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
421
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
422
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
423
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
424
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
425
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
426
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
427
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
428
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
429
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
430
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
431
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
432
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
433
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
434
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
435
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
436
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
437
+ Func func = wrapper->func_;
438
+ return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13));
439
+ }
440
+ catch(...)
441
+ {
442
+ RUBY_TRY
443
+ {
444
+ if(wrapper)
445
+ {
446
+ return wrapper->handler_->handle_exception();
447
+ }
448
+ else
449
+ {
450
+ throw;
451
+ }
452
+ }
453
+ RUBY_CATCH
454
+ }
455
+ }
456
+
457
+ template<typename Func_T, typename Self_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>
458
+ Auto_Member_Function_Wrapper<Func_T, void, Self_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>::
459
+ Auto_Member_Function_Wrapper(
460
+ Func func,
461
+ Data_Object<Exception_Handler> handler,
462
+ Arguments* arguments)
463
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
464
+ , func_(func)
465
+ , handler_(handler)
466
+ , handler_guard_(&handler_)
467
+ , arguments_(arguments)
468
+ {
469
+ if(arguments == 0) {
470
+ arguments_ = new Arguments();
471
+ } else {
472
+ arguments_ = arguments;
473
+ }
474
+ }
475
+
476
+ template<typename Func_T, typename Self_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>
477
+ VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_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>::
478
+ call(int argc, VALUE* argv, VALUE self)
479
+ {
480
+ Auto_Member_Function_Wrapper<Func_T, void, Self_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;
481
+ try
482
+ {
483
+ Data_Object<Wrapped_Function> data(detail::method_data());
484
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, void, Self_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();
485
+ Arguments* args = wrapper->arguments_;
486
+
487
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12, varg13;
488
+
489
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12, &varg13);
490
+
491
+ Self_T * obj = from_ruby<Self_T *>(self);
492
+
493
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
494
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
495
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
496
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
497
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
498
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
499
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
500
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
501
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
502
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
503
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
504
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
505
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
506
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
507
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
508
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
509
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
510
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
511
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
512
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
513
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
514
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
515
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
516
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
517
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
518
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
519
+ typedef typename sanitize< Arg13_T >::Type Arg13_Type;
520
+ Arg13_Type arg13 = args->getArgumentOrDefault<Arg13_Type>(13, varg13);
521
+ Func func = wrapper->func_;
522
+ (*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
523
+ return Qnil;
524
+ }
525
+ catch(...)
526
+ {
527
+ RUBY_TRY
528
+ {
529
+ if(wrapper)
530
+ {
531
+ return wrapper->handler_->handle_exception();
532
+ }
533
+ else
534
+ {
535
+ throw;
536
+ }
537
+ }
538
+ RUBY_CATCH
539
+ }
540
+ }
541
+
542
+ // ---------------------------------------------------------------------
543
+ template<typename Func_T, typename Ret_T, typename Self_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>
544
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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>::
545
+ Auto_Member_Function_Wrapper(
546
+ Func func,
547
+ Data_Object<Exception_Handler> handler,
548
+ Arguments* arguments)
549
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
550
+ , func_(func)
551
+ , handler_(handler)
552
+ , handler_guard_(&handler_)
553
+ , arguments_(arguments)
554
+ {
555
+ if(arguments == 0) {
556
+ arguments_ = new Arguments();
557
+ } else {
558
+ arguments_ = arguments;
559
+ }
560
+ }
561
+
562
+ template<typename Func_T, typename Ret_T, typename Self_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>
563
+ VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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>::
564
+ call(int argc, VALUE* argv, VALUE self)
565
+ {
566
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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;
567
+ try
568
+ {
569
+ Data_Object<Wrapped_Function> data(detail::method_data());
570
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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();
571
+ Arguments* args = wrapper->arguments_;
572
+
573
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12;
574
+
575
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
576
+
577
+ Self_T * obj = from_ruby<Self_T *>(self);
578
+
579
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
580
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
581
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
582
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
583
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
584
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
585
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
586
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
587
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
588
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
589
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
590
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
591
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
592
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
593
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
594
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
595
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
596
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
597
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
598
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
599
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
600
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
601
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
602
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
603
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
604
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
605
+ Func func = wrapper->func_;
606
+ return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12));
607
+ }
608
+ catch(...)
609
+ {
610
+ RUBY_TRY
611
+ {
612
+ if(wrapper)
613
+ {
614
+ return wrapper->handler_->handle_exception();
615
+ }
616
+ else
617
+ {
618
+ throw;
619
+ }
620
+ }
621
+ RUBY_CATCH
622
+ }
623
+ }
624
+
625
+ template<typename Func_T, typename Self_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>
626
+ Auto_Member_Function_Wrapper<Func_T, void, Self_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>::
627
+ Auto_Member_Function_Wrapper(
628
+ Func func,
629
+ Data_Object<Exception_Handler> handler,
630
+ Arguments* arguments)
631
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
632
+ , func_(func)
633
+ , handler_(handler)
634
+ , handler_guard_(&handler_)
635
+ , arguments_(arguments)
636
+ {
637
+ if(arguments == 0) {
638
+ arguments_ = new Arguments();
639
+ } else {
640
+ arguments_ = arguments;
641
+ }
642
+ }
643
+
644
+ template<typename Func_T, typename Self_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>
645
+ VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_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>::
646
+ call(int argc, VALUE* argv, VALUE self)
647
+ {
648
+ Auto_Member_Function_Wrapper<Func_T, void, Self_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;
649
+ try
650
+ {
651
+ Data_Object<Wrapped_Function> data(detail::method_data());
652
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, void, Self_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();
653
+ Arguments* args = wrapper->arguments_;
654
+
655
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11, varg12;
656
+
657
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11, &varg12);
658
+
659
+ Self_T * obj = from_ruby<Self_T *>(self);
660
+
661
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
662
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
663
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
664
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
665
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
666
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
667
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
668
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
669
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
670
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
671
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
672
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
673
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
674
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
675
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
676
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
677
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
678
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
679
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
680
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
681
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
682
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
683
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
684
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
685
+ typedef typename sanitize< Arg12_T >::Type Arg12_Type;
686
+ Arg12_Type arg12 = args->getArgumentOrDefault<Arg12_Type>(12, varg12);
687
+ Func func = wrapper->func_;
688
+ (*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
689
+ return Qnil;
690
+ }
691
+ catch(...)
692
+ {
693
+ RUBY_TRY
694
+ {
695
+ if(wrapper)
696
+ {
697
+ return wrapper->handler_->handle_exception();
698
+ }
699
+ else
700
+ {
701
+ throw;
702
+ }
703
+ }
704
+ RUBY_CATCH
705
+ }
706
+ }
707
+
708
+ // ---------------------------------------------------------------------
709
+ template<typename Func_T, typename Ret_T, typename Self_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>
710
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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>::
711
+ Auto_Member_Function_Wrapper(
712
+ Func func,
713
+ Data_Object<Exception_Handler> handler,
714
+ Arguments* arguments)
715
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
716
+ , func_(func)
717
+ , handler_(handler)
718
+ , handler_guard_(&handler_)
719
+ , arguments_(arguments)
720
+ {
721
+ if(arguments == 0) {
722
+ arguments_ = new Arguments();
723
+ } else {
724
+ arguments_ = arguments;
725
+ }
726
+ }
727
+
728
+ template<typename Func_T, typename Ret_T, typename Self_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>
729
+ VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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>::
730
+ call(int argc, VALUE* argv, VALUE self)
731
+ {
732
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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;
733
+ try
734
+ {
735
+ Data_Object<Wrapped_Function> data(detail::method_data());
736
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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();
737
+ Arguments* args = wrapper->arguments_;
738
+
739
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11;
740
+
741
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
742
+
743
+ Self_T * obj = from_ruby<Self_T *>(self);
744
+
745
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
746
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
747
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
748
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
749
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
750
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
751
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
752
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
753
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
754
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
755
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
756
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
757
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
758
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
759
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
760
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
761
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
762
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
763
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
764
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
765
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
766
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
767
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
768
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
769
+ Func func = wrapper->func_;
770
+ return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11));
771
+ }
772
+ catch(...)
773
+ {
774
+ RUBY_TRY
775
+ {
776
+ if(wrapper)
777
+ {
778
+ return wrapper->handler_->handle_exception();
779
+ }
780
+ else
781
+ {
782
+ throw;
783
+ }
784
+ }
785
+ RUBY_CATCH
786
+ }
787
+ }
788
+
789
+ template<typename Func_T, typename Self_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>
790
+ Auto_Member_Function_Wrapper<Func_T, void, Self_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>::
791
+ Auto_Member_Function_Wrapper(
792
+ Func func,
793
+ Data_Object<Exception_Handler> handler,
794
+ Arguments* arguments)
795
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
796
+ , func_(func)
797
+ , handler_(handler)
798
+ , handler_guard_(&handler_)
799
+ , arguments_(arguments)
800
+ {
801
+ if(arguments == 0) {
802
+ arguments_ = new Arguments();
803
+ } else {
804
+ arguments_ = arguments;
805
+ }
806
+ }
807
+
808
+ template<typename Func_T, typename Self_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>
809
+ VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_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>::
810
+ call(int argc, VALUE* argv, VALUE self)
811
+ {
812
+ Auto_Member_Function_Wrapper<Func_T, void, Self_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;
813
+ try
814
+ {
815
+ Data_Object<Wrapped_Function> data(detail::method_data());
816
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, void, Self_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();
817
+ Arguments* args = wrapper->arguments_;
818
+
819
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10, varg11;
820
+
821
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10, &varg11);
822
+
823
+ Self_T * obj = from_ruby<Self_T *>(self);
824
+
825
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
826
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
827
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
828
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
829
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
830
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
831
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
832
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
833
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
834
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
835
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
836
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
837
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
838
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
839
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
840
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
841
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
842
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
843
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
844
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
845
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
846
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
847
+ typedef typename sanitize< Arg11_T >::Type Arg11_Type;
848
+ Arg11_Type arg11 = args->getArgumentOrDefault<Arg11_Type>(11, varg11);
849
+ Func func = wrapper->func_;
850
+ (*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
851
+ return Qnil;
852
+ }
853
+ catch(...)
854
+ {
855
+ RUBY_TRY
856
+ {
857
+ if(wrapper)
858
+ {
859
+ return wrapper->handler_->handle_exception();
860
+ }
861
+ else
862
+ {
863
+ throw;
864
+ }
865
+ }
866
+ RUBY_CATCH
867
+ }
868
+ }
869
+
870
+ // ---------------------------------------------------------------------
871
+ template<typename Func_T, typename Ret_T, typename Self_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>
872
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T>::
873
+ Auto_Member_Function_Wrapper(
874
+ Func func,
875
+ Data_Object<Exception_Handler> handler,
876
+ Arguments* arguments)
877
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
878
+ , func_(func)
879
+ , handler_(handler)
880
+ , handler_guard_(&handler_)
881
+ , arguments_(arguments)
882
+ {
883
+ if(arguments == 0) {
884
+ arguments_ = new Arguments();
885
+ } else {
886
+ arguments_ = arguments;
887
+ }
888
+ }
889
+
890
+ template<typename Func_T, typename Ret_T, typename Self_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>
891
+ VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T>::
892
+ call(int argc, VALUE* argv, VALUE self)
893
+ {
894
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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;
895
+ try
896
+ {
897
+ Data_Object<Wrapped_Function> data(detail::method_data());
898
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_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();
899
+ Arguments* args = wrapper->arguments_;
900
+
901
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10;
902
+
903
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
904
+
905
+ Self_T * obj = from_ruby<Self_T *>(self);
906
+
907
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
908
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
909
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
910
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
911
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
912
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
913
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
914
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
915
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
916
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
917
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
918
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
919
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
920
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
921
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
922
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
923
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
924
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
925
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
926
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
927
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
928
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
929
+ Func func = wrapper->func_;
930
+ return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10));
931
+ }
932
+ catch(...)
933
+ {
934
+ RUBY_TRY
935
+ {
936
+ if(wrapper)
937
+ {
938
+ return wrapper->handler_->handle_exception();
939
+ }
940
+ else
941
+ {
942
+ throw;
943
+ }
944
+ }
945
+ RUBY_CATCH
946
+ }
947
+ }
948
+
949
+ template<typename Func_T, typename Self_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>
950
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T>::
951
+ Auto_Member_Function_Wrapper(
952
+ Func func,
953
+ Data_Object<Exception_Handler> handler,
954
+ Arguments* arguments)
955
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
956
+ , func_(func)
957
+ , handler_(handler)
958
+ , handler_guard_(&handler_)
959
+ , arguments_(arguments)
960
+ {
961
+ if(arguments == 0) {
962
+ arguments_ = new Arguments();
963
+ } else {
964
+ arguments_ = arguments;
965
+ }
966
+ }
967
+
968
+ template<typename Func_T, typename Self_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>
969
+ VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T>::
970
+ call(int argc, VALUE* argv, VALUE self)
971
+ {
972
+ Auto_Member_Function_Wrapper<Func_T, void, Self_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;
973
+ try
974
+ {
975
+ Data_Object<Wrapped_Function> data(detail::method_data());
976
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, void, Self_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();
977
+ Arguments* args = wrapper->arguments_;
978
+
979
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9, varg10;
980
+
981
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9, &varg10);
982
+
983
+ Self_T * obj = from_ruby<Self_T *>(self);
984
+
985
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
986
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
987
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
988
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
989
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
990
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
991
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
992
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
993
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
994
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
995
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
996
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
997
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
998
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
999
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1000
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1001
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1002
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1003
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1004
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1005
+ typedef typename sanitize< Arg10_T >::Type Arg10_Type;
1006
+ Arg10_Type arg10 = args->getArgumentOrDefault<Arg10_Type>(10, varg10);
1007
+ Func func = wrapper->func_;
1008
+ (*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
1009
+ return Qnil;
1010
+ }
1011
+ catch(...)
1012
+ {
1013
+ RUBY_TRY
1014
+ {
1015
+ if(wrapper)
1016
+ {
1017
+ return wrapper->handler_->handle_exception();
1018
+ }
1019
+ else
1020
+ {
1021
+ throw;
1022
+ }
1023
+ }
1024
+ RUBY_CATCH
1025
+ }
1026
+ }
1027
+
1028
+ // ---------------------------------------------------------------------
1029
+ template<typename Func_T, typename Ret_T, typename Self_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>
1030
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T>::
1031
+ Auto_Member_Function_Wrapper(
1032
+ Func func,
1033
+ Data_Object<Exception_Handler> handler,
1034
+ Arguments* arguments)
1035
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1036
+ , func_(func)
1037
+ , handler_(handler)
1038
+ , handler_guard_(&handler_)
1039
+ , arguments_(arguments)
1040
+ {
1041
+ if(arguments == 0) {
1042
+ arguments_ = new Arguments();
1043
+ } else {
1044
+ arguments_ = arguments;
1045
+ }
1046
+ }
1047
+
1048
+ template<typename Func_T, typename Ret_T, typename Self_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>
1049
+ VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T>::
1050
+ call(int argc, VALUE* argv, VALUE self)
1051
+ {
1052
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T> * wrapper = 0;
1053
+ try
1054
+ {
1055
+ Data_Object<Wrapped_Function> data(detail::method_data());
1056
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T> *)data.get();
1057
+ Arguments* args = wrapper->arguments_;
1058
+
1059
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9;
1060
+
1061
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
1062
+
1063
+ Self_T * obj = from_ruby<Self_T *>(self);
1064
+
1065
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1066
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1067
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1068
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1069
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1070
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1071
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1072
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1073
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1074
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1075
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1076
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1077
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1078
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1079
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1080
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1081
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1082
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1083
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1084
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1085
+ Func func = wrapper->func_;
1086
+ return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9));
1087
+ }
1088
+ catch(...)
1089
+ {
1090
+ RUBY_TRY
1091
+ {
1092
+ if(wrapper)
1093
+ {
1094
+ return wrapper->handler_->handle_exception();
1095
+ }
1096
+ else
1097
+ {
1098
+ throw;
1099
+ }
1100
+ }
1101
+ RUBY_CATCH
1102
+ }
1103
+ }
1104
+
1105
+ template<typename Func_T, typename Self_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>
1106
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T>::
1107
+ Auto_Member_Function_Wrapper(
1108
+ Func func,
1109
+ Data_Object<Exception_Handler> handler,
1110
+ Arguments* arguments)
1111
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1112
+ , func_(func)
1113
+ , handler_(handler)
1114
+ , handler_guard_(&handler_)
1115
+ , arguments_(arguments)
1116
+ {
1117
+ if(arguments == 0) {
1118
+ arguments_ = new Arguments();
1119
+ } else {
1120
+ arguments_ = arguments;
1121
+ }
1122
+ }
1123
+
1124
+ template<typename Func_T, typename Self_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>
1125
+ VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T>::
1126
+ call(int argc, VALUE* argv, VALUE self)
1127
+ {
1128
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T> * wrapper = 0;
1129
+ try
1130
+ {
1131
+ Data_Object<Wrapped_Function> data(detail::method_data());
1132
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T> *)data.get();
1133
+ Arguments* args = wrapper->arguments_;
1134
+
1135
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8, varg9;
1136
+
1137
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8, &varg9);
1138
+
1139
+ Self_T * obj = from_ruby<Self_T *>(self);
1140
+
1141
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1142
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1143
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1144
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1145
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1146
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1147
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1148
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1149
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1150
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1151
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1152
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1153
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1154
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1155
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1156
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1157
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1158
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1159
+ typedef typename sanitize< Arg9_T >::Type Arg9_Type;
1160
+ Arg9_Type arg9 = args->getArgumentOrDefault<Arg9_Type>(9, varg9);
1161
+ Func func = wrapper->func_;
1162
+ (*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
1163
+ return Qnil;
1164
+ }
1165
+ catch(...)
1166
+ {
1167
+ RUBY_TRY
1168
+ {
1169
+ if(wrapper)
1170
+ {
1171
+ return wrapper->handler_->handle_exception();
1172
+ }
1173
+ else
1174
+ {
1175
+ throw;
1176
+ }
1177
+ }
1178
+ RUBY_CATCH
1179
+ }
1180
+ }
1181
+
1182
+ // ---------------------------------------------------------------------
1183
+ template<typename Func_T, typename Ret_T, typename Self_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>
1184
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T>::
1185
+ Auto_Member_Function_Wrapper(
1186
+ Func func,
1187
+ Data_Object<Exception_Handler> handler,
1188
+ Arguments* arguments)
1189
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1190
+ , func_(func)
1191
+ , handler_(handler)
1192
+ , handler_guard_(&handler_)
1193
+ , arguments_(arguments)
1194
+ {
1195
+ if(arguments == 0) {
1196
+ arguments_ = new Arguments();
1197
+ } else {
1198
+ arguments_ = arguments;
1199
+ }
1200
+ }
1201
+
1202
+ template<typename Func_T, typename Ret_T, typename Self_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>
1203
+ VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T>::
1204
+ call(int argc, VALUE* argv, VALUE self)
1205
+ {
1206
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T> * wrapper = 0;
1207
+ try
1208
+ {
1209
+ Data_Object<Wrapped_Function> data(detail::method_data());
1210
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T> *)data.get();
1211
+ Arguments* args = wrapper->arguments_;
1212
+
1213
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8;
1214
+
1215
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
1216
+
1217
+ Self_T * obj = from_ruby<Self_T *>(self);
1218
+
1219
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1220
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1221
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1222
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1223
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1224
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1225
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1226
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1227
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1228
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1229
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1230
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1231
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1232
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1233
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1234
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1235
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1236
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1237
+ Func func = wrapper->func_;
1238
+ return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8));
1239
+ }
1240
+ catch(...)
1241
+ {
1242
+ RUBY_TRY
1243
+ {
1244
+ if(wrapper)
1245
+ {
1246
+ return wrapper->handler_->handle_exception();
1247
+ }
1248
+ else
1249
+ {
1250
+ throw;
1251
+ }
1252
+ }
1253
+ RUBY_CATCH
1254
+ }
1255
+ }
1256
+
1257
+ template<typename Func_T, typename Self_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>
1258
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T>::
1259
+ Auto_Member_Function_Wrapper(
1260
+ Func func,
1261
+ Data_Object<Exception_Handler> handler,
1262
+ Arguments* arguments)
1263
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1264
+ , func_(func)
1265
+ , handler_(handler)
1266
+ , handler_guard_(&handler_)
1267
+ , arguments_(arguments)
1268
+ {
1269
+ if(arguments == 0) {
1270
+ arguments_ = new Arguments();
1271
+ } else {
1272
+ arguments_ = arguments;
1273
+ }
1274
+ }
1275
+
1276
+ template<typename Func_T, typename Self_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>
1277
+ VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T>::
1278
+ call(int argc, VALUE* argv, VALUE self)
1279
+ {
1280
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T> * wrapper = 0;
1281
+ try
1282
+ {
1283
+ Data_Object<Wrapped_Function> data(detail::method_data());
1284
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T> *)data.get();
1285
+ Arguments* args = wrapper->arguments_;
1286
+
1287
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7, varg8;
1288
+
1289
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7, &varg8);
1290
+
1291
+ Self_T * obj = from_ruby<Self_T *>(self);
1292
+
1293
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1294
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1295
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1296
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1297
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1298
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1299
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1300
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1301
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1302
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1303
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1304
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1305
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1306
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1307
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1308
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1309
+ typedef typename sanitize< Arg8_T >::Type Arg8_Type;
1310
+ Arg8_Type arg8 = args->getArgumentOrDefault<Arg8_Type>(8, varg8);
1311
+ Func func = wrapper->func_;
1312
+ (*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
1313
+ return Qnil;
1314
+ }
1315
+ catch(...)
1316
+ {
1317
+ RUBY_TRY
1318
+ {
1319
+ if(wrapper)
1320
+ {
1321
+ return wrapper->handler_->handle_exception();
1322
+ }
1323
+ else
1324
+ {
1325
+ throw;
1326
+ }
1327
+ }
1328
+ RUBY_CATCH
1329
+ }
1330
+ }
1331
+
1332
+ // ---------------------------------------------------------------------
1333
+ template<typename Func_T, typename Ret_T, typename Self_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>
1334
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T>::
1335
+ Auto_Member_Function_Wrapper(
1336
+ Func func,
1337
+ Data_Object<Exception_Handler> handler,
1338
+ Arguments* arguments)
1339
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1340
+ , func_(func)
1341
+ , handler_(handler)
1342
+ , handler_guard_(&handler_)
1343
+ , arguments_(arguments)
1344
+ {
1345
+ if(arguments == 0) {
1346
+ arguments_ = new Arguments();
1347
+ } else {
1348
+ arguments_ = arguments;
1349
+ }
1350
+ }
1351
+
1352
+ template<typename Func_T, typename Ret_T, typename Self_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>
1353
+ VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T>::
1354
+ call(int argc, VALUE* argv, VALUE self)
1355
+ {
1356
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T> * wrapper = 0;
1357
+ try
1358
+ {
1359
+ Data_Object<Wrapped_Function> data(detail::method_data());
1360
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T> *)data.get();
1361
+ Arguments* args = wrapper->arguments_;
1362
+
1363
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7;
1364
+
1365
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
1366
+
1367
+ Self_T * obj = from_ruby<Self_T *>(self);
1368
+
1369
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1370
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1371
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1372
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1373
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1374
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1375
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1376
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1377
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1378
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1379
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1380
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1381
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1382
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1383
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1384
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1385
+ Func func = wrapper->func_;
1386
+ return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7));
1387
+ }
1388
+ catch(...)
1389
+ {
1390
+ RUBY_TRY
1391
+ {
1392
+ if(wrapper)
1393
+ {
1394
+ return wrapper->handler_->handle_exception();
1395
+ }
1396
+ else
1397
+ {
1398
+ throw;
1399
+ }
1400
+ }
1401
+ RUBY_CATCH
1402
+ }
1403
+ }
1404
+
1405
+ template<typename Func_T, typename Self_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>
1406
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T>::
1407
+ Auto_Member_Function_Wrapper(
1408
+ Func func,
1409
+ Data_Object<Exception_Handler> handler,
1410
+ Arguments* arguments)
1411
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1412
+ , func_(func)
1413
+ , handler_(handler)
1414
+ , handler_guard_(&handler_)
1415
+ , arguments_(arguments)
1416
+ {
1417
+ if(arguments == 0) {
1418
+ arguments_ = new Arguments();
1419
+ } else {
1420
+ arguments_ = arguments;
1421
+ }
1422
+ }
1423
+
1424
+ template<typename Func_T, typename Self_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>
1425
+ VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T>::
1426
+ call(int argc, VALUE* argv, VALUE self)
1427
+ {
1428
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T> * wrapper = 0;
1429
+ try
1430
+ {
1431
+ Data_Object<Wrapped_Function> data(detail::method_data());
1432
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T> *)data.get();
1433
+ Arguments* args = wrapper->arguments_;
1434
+
1435
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6, varg7;
1436
+
1437
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6, &varg7);
1438
+
1439
+ Self_T * obj = from_ruby<Self_T *>(self);
1440
+
1441
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1442
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1443
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1444
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1445
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1446
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1447
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1448
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1449
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1450
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1451
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1452
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1453
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1454
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1455
+ typedef typename sanitize< Arg7_T >::Type Arg7_Type;
1456
+ Arg7_Type arg7 = args->getArgumentOrDefault<Arg7_Type>(7, varg7);
1457
+ Func func = wrapper->func_;
1458
+ (*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
1459
+ return Qnil;
1460
+ }
1461
+ catch(...)
1462
+ {
1463
+ RUBY_TRY
1464
+ {
1465
+ if(wrapper)
1466
+ {
1467
+ return wrapper->handler_->handle_exception();
1468
+ }
1469
+ else
1470
+ {
1471
+ throw;
1472
+ }
1473
+ }
1474
+ RUBY_CATCH
1475
+ }
1476
+ }
1477
+
1478
+ // ---------------------------------------------------------------------
1479
+ template<typename Func_T, typename Ret_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T>
1480
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T>::
1481
+ Auto_Member_Function_Wrapper(
1482
+ Func func,
1483
+ Data_Object<Exception_Handler> handler,
1484
+ Arguments* arguments)
1485
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1486
+ , func_(func)
1487
+ , handler_(handler)
1488
+ , handler_guard_(&handler_)
1489
+ , arguments_(arguments)
1490
+ {
1491
+ if(arguments == 0) {
1492
+ arguments_ = new Arguments();
1493
+ } else {
1494
+ arguments_ = arguments;
1495
+ }
1496
+ }
1497
+
1498
+ template<typename Func_T, typename Ret_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T>
1499
+ VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T>::
1500
+ call(int argc, VALUE* argv, VALUE self)
1501
+ {
1502
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T> * wrapper = 0;
1503
+ try
1504
+ {
1505
+ Data_Object<Wrapped_Function> data(detail::method_data());
1506
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T> *)data.get();
1507
+ Arguments* args = wrapper->arguments_;
1508
+
1509
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6;
1510
+
1511
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
1512
+
1513
+ Self_T * obj = from_ruby<Self_T *>(self);
1514
+
1515
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1516
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1517
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1518
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1519
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1520
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1521
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1522
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1523
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1524
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1525
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1526
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1527
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1528
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1529
+ Func func = wrapper->func_;
1530
+ return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6));
1531
+ }
1532
+ catch(...)
1533
+ {
1534
+ RUBY_TRY
1535
+ {
1536
+ if(wrapper)
1537
+ {
1538
+ return wrapper->handler_->handle_exception();
1539
+ }
1540
+ else
1541
+ {
1542
+ throw;
1543
+ }
1544
+ }
1545
+ RUBY_CATCH
1546
+ }
1547
+ }
1548
+
1549
+ template<typename Func_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T>
1550
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T>::
1551
+ Auto_Member_Function_Wrapper(
1552
+ Func func,
1553
+ Data_Object<Exception_Handler> handler,
1554
+ Arguments* arguments)
1555
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1556
+ , func_(func)
1557
+ , handler_(handler)
1558
+ , handler_guard_(&handler_)
1559
+ , arguments_(arguments)
1560
+ {
1561
+ if(arguments == 0) {
1562
+ arguments_ = new Arguments();
1563
+ } else {
1564
+ arguments_ = arguments;
1565
+ }
1566
+ }
1567
+
1568
+ template<typename Func_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T>
1569
+ VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T>::
1570
+ call(int argc, VALUE* argv, VALUE self)
1571
+ {
1572
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T> * wrapper = 0;
1573
+ try
1574
+ {
1575
+ Data_Object<Wrapped_Function> data(detail::method_data());
1576
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T> *)data.get();
1577
+ Arguments* args = wrapper->arguments_;
1578
+
1579
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5, varg6;
1580
+
1581
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5, &varg6);
1582
+
1583
+ Self_T * obj = from_ruby<Self_T *>(self);
1584
+
1585
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1586
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1587
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1588
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1589
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1590
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1591
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1592
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1593
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1594
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1595
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1596
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1597
+ typedef typename sanitize< Arg6_T >::Type Arg6_Type;
1598
+ Arg6_Type arg6 = args->getArgumentOrDefault<Arg6_Type>(6, varg6);
1599
+ Func func = wrapper->func_;
1600
+ (*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
1601
+ return Qnil;
1602
+ }
1603
+ catch(...)
1604
+ {
1605
+ RUBY_TRY
1606
+ {
1607
+ if(wrapper)
1608
+ {
1609
+ return wrapper->handler_->handle_exception();
1610
+ }
1611
+ else
1612
+ {
1613
+ throw;
1614
+ }
1615
+ }
1616
+ RUBY_CATCH
1617
+ }
1618
+ }
1619
+
1620
+ // ---------------------------------------------------------------------
1621
+ template<typename Func_T, typename Ret_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T>
1622
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T>::
1623
+ Auto_Member_Function_Wrapper(
1624
+ Func func,
1625
+ Data_Object<Exception_Handler> handler,
1626
+ Arguments* arguments)
1627
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1628
+ , func_(func)
1629
+ , handler_(handler)
1630
+ , handler_guard_(&handler_)
1631
+ , arguments_(arguments)
1632
+ {
1633
+ if(arguments == 0) {
1634
+ arguments_ = new Arguments();
1635
+ } else {
1636
+ arguments_ = arguments;
1637
+ }
1638
+ }
1639
+
1640
+ template<typename Func_T, typename Ret_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T>
1641
+ VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T>::
1642
+ call(int argc, VALUE* argv, VALUE self)
1643
+ {
1644
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T> * wrapper = 0;
1645
+ try
1646
+ {
1647
+ Data_Object<Wrapped_Function> data(detail::method_data());
1648
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T> *)data.get();
1649
+ Arguments* args = wrapper->arguments_;
1650
+
1651
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5;
1652
+
1653
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
1654
+
1655
+ Self_T * obj = from_ruby<Self_T *>(self);
1656
+
1657
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1658
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1659
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1660
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1661
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1662
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1663
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1664
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1665
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1666
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1667
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1668
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1669
+ Func func = wrapper->func_;
1670
+ return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5));
1671
+ }
1672
+ catch(...)
1673
+ {
1674
+ RUBY_TRY
1675
+ {
1676
+ if(wrapper)
1677
+ {
1678
+ return wrapper->handler_->handle_exception();
1679
+ }
1680
+ else
1681
+ {
1682
+ throw;
1683
+ }
1684
+ }
1685
+ RUBY_CATCH
1686
+ }
1687
+ }
1688
+
1689
+ template<typename Func_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T>
1690
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T>::
1691
+ Auto_Member_Function_Wrapper(
1692
+ Func func,
1693
+ Data_Object<Exception_Handler> handler,
1694
+ Arguments* arguments)
1695
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1696
+ , func_(func)
1697
+ , handler_(handler)
1698
+ , handler_guard_(&handler_)
1699
+ , arguments_(arguments)
1700
+ {
1701
+ if(arguments == 0) {
1702
+ arguments_ = new Arguments();
1703
+ } else {
1704
+ arguments_ = arguments;
1705
+ }
1706
+ }
1707
+
1708
+ template<typename Func_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T>
1709
+ VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T>::
1710
+ call(int argc, VALUE* argv, VALUE self)
1711
+ {
1712
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T> * wrapper = 0;
1713
+ try
1714
+ {
1715
+ Data_Object<Wrapped_Function> data(detail::method_data());
1716
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T> *)data.get();
1717
+ Arguments* args = wrapper->arguments_;
1718
+
1719
+ VALUE varg0, varg1, varg2, varg3, varg4, varg5;
1720
+
1721
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4, &varg5);
1722
+
1723
+ Self_T * obj = from_ruby<Self_T *>(self);
1724
+
1725
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1726
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1727
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1728
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1729
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1730
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1731
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1732
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1733
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1734
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1735
+ typedef typename sanitize< Arg5_T >::Type Arg5_Type;
1736
+ Arg5_Type arg5 = args->getArgumentOrDefault<Arg5_Type>(5, varg5);
1737
+ Func func = wrapper->func_;
1738
+ (*obj.*func)(arg0, arg1, arg2, arg3, arg4, arg5);
1739
+ return Qnil;
1740
+ }
1741
+ catch(...)
1742
+ {
1743
+ RUBY_TRY
1744
+ {
1745
+ if(wrapper)
1746
+ {
1747
+ return wrapper->handler_->handle_exception();
1748
+ }
1749
+ else
1750
+ {
1751
+ throw;
1752
+ }
1753
+ }
1754
+ RUBY_CATCH
1755
+ }
1756
+ }
1757
+
1758
+ // ---------------------------------------------------------------------
1759
+ template<typename Func_T, typename Ret_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T>
1760
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T>::
1761
+ Auto_Member_Function_Wrapper(
1762
+ Func func,
1763
+ Data_Object<Exception_Handler> handler,
1764
+ Arguments* arguments)
1765
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1766
+ , func_(func)
1767
+ , handler_(handler)
1768
+ , handler_guard_(&handler_)
1769
+ , arguments_(arguments)
1770
+ {
1771
+ if(arguments == 0) {
1772
+ arguments_ = new Arguments();
1773
+ } else {
1774
+ arguments_ = arguments;
1775
+ }
1776
+ }
1777
+
1778
+ template<typename Func_T, typename Ret_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T>
1779
+ VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T>::
1780
+ call(int argc, VALUE* argv, VALUE self)
1781
+ {
1782
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T> * wrapper = 0;
1783
+ try
1784
+ {
1785
+ Data_Object<Wrapped_Function> data(detail::method_data());
1786
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T> *)data.get();
1787
+ Arguments* args = wrapper->arguments_;
1788
+
1789
+ VALUE varg0, varg1, varg2, varg3, varg4;
1790
+
1791
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4);
1792
+
1793
+ Self_T * obj = from_ruby<Self_T *>(self);
1794
+
1795
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1796
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1797
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1798
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1799
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1800
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1801
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1802
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1803
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1804
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1805
+ Func func = wrapper->func_;
1806
+ return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3, arg4));
1807
+ }
1808
+ catch(...)
1809
+ {
1810
+ RUBY_TRY
1811
+ {
1812
+ if(wrapper)
1813
+ {
1814
+ return wrapper->handler_->handle_exception();
1815
+ }
1816
+ else
1817
+ {
1818
+ throw;
1819
+ }
1820
+ }
1821
+ RUBY_CATCH
1822
+ }
1823
+ }
1824
+
1825
+ template<typename Func_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T>
1826
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T>::
1827
+ Auto_Member_Function_Wrapper(
1828
+ Func func,
1829
+ Data_Object<Exception_Handler> handler,
1830
+ Arguments* arguments)
1831
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1832
+ , func_(func)
1833
+ , handler_(handler)
1834
+ , handler_guard_(&handler_)
1835
+ , arguments_(arguments)
1836
+ {
1837
+ if(arguments == 0) {
1838
+ arguments_ = new Arguments();
1839
+ } else {
1840
+ arguments_ = arguments;
1841
+ }
1842
+ }
1843
+
1844
+ template<typename Func_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T>
1845
+ VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T>::
1846
+ call(int argc, VALUE* argv, VALUE self)
1847
+ {
1848
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T> * wrapper = 0;
1849
+ try
1850
+ {
1851
+ Data_Object<Wrapped_Function> data(detail::method_data());
1852
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T> *)data.get();
1853
+ Arguments* args = wrapper->arguments_;
1854
+
1855
+ VALUE varg0, varg1, varg2, varg3, varg4;
1856
+
1857
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3, &varg4);
1858
+
1859
+ Self_T * obj = from_ruby<Self_T *>(self);
1860
+
1861
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1862
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1863
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1864
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1865
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1866
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1867
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1868
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1869
+ typedef typename sanitize< Arg4_T >::Type Arg4_Type;
1870
+ Arg4_Type arg4 = args->getArgumentOrDefault<Arg4_Type>(4, varg4);
1871
+ Func func = wrapper->func_;
1872
+ (*obj.*func)(arg0, arg1, arg2, arg3, arg4);
1873
+ return Qnil;
1874
+ }
1875
+ catch(...)
1876
+ {
1877
+ RUBY_TRY
1878
+ {
1879
+ if(wrapper)
1880
+ {
1881
+ return wrapper->handler_->handle_exception();
1882
+ }
1883
+ else
1884
+ {
1885
+ throw;
1886
+ }
1887
+ }
1888
+ RUBY_CATCH
1889
+ }
1890
+ }
1891
+
1892
+ // ---------------------------------------------------------------------
1893
+ template<typename Func_T, typename Ret_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T>
1894
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T>::
1895
+ Auto_Member_Function_Wrapper(
1896
+ Func func,
1897
+ Data_Object<Exception_Handler> handler,
1898
+ Arguments* arguments)
1899
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1900
+ , func_(func)
1901
+ , handler_(handler)
1902
+ , handler_guard_(&handler_)
1903
+ , arguments_(arguments)
1904
+ {
1905
+ if(arguments == 0) {
1906
+ arguments_ = new Arguments();
1907
+ } else {
1908
+ arguments_ = arguments;
1909
+ }
1910
+ }
1911
+
1912
+ template<typename Func_T, typename Ret_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T>
1913
+ VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T>::
1914
+ call(int argc, VALUE* argv, VALUE self)
1915
+ {
1916
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T> * wrapper = 0;
1917
+ try
1918
+ {
1919
+ Data_Object<Wrapped_Function> data(detail::method_data());
1920
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T> *)data.get();
1921
+ Arguments* args = wrapper->arguments_;
1922
+
1923
+ VALUE varg0, varg1, varg2, varg3;
1924
+
1925
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3);
1926
+
1927
+ Self_T * obj = from_ruby<Self_T *>(self);
1928
+
1929
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1930
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1931
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1932
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1933
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1934
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1935
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
1936
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
1937
+ Func func = wrapper->func_;
1938
+ return to_ruby((*obj.*func)(arg0, arg1, arg2, arg3));
1939
+ }
1940
+ catch(...)
1941
+ {
1942
+ RUBY_TRY
1943
+ {
1944
+ if(wrapper)
1945
+ {
1946
+ return wrapper->handler_->handle_exception();
1947
+ }
1948
+ else
1949
+ {
1950
+ throw;
1951
+ }
1952
+ }
1953
+ RUBY_CATCH
1954
+ }
1955
+ }
1956
+
1957
+ template<typename Func_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T>
1958
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T>::
1959
+ Auto_Member_Function_Wrapper(
1960
+ Func func,
1961
+ Data_Object<Exception_Handler> handler,
1962
+ Arguments* arguments)
1963
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
1964
+ , func_(func)
1965
+ , handler_(handler)
1966
+ , handler_guard_(&handler_)
1967
+ , arguments_(arguments)
1968
+ {
1969
+ if(arguments == 0) {
1970
+ arguments_ = new Arguments();
1971
+ } else {
1972
+ arguments_ = arguments;
1973
+ }
1974
+ }
1975
+
1976
+ template<typename Func_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T>
1977
+ VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T>::
1978
+ call(int argc, VALUE* argv, VALUE self)
1979
+ {
1980
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T> * wrapper = 0;
1981
+ try
1982
+ {
1983
+ Data_Object<Wrapped_Function> data(detail::method_data());
1984
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T, Arg3_T> *)data.get();
1985
+ Arguments* args = wrapper->arguments_;
1986
+
1987
+ VALUE varg0, varg1, varg2, varg3;
1988
+
1989
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2, &varg3);
1990
+
1991
+ Self_T * obj = from_ruby<Self_T *>(self);
1992
+
1993
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
1994
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
1995
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
1996
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
1997
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
1998
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
1999
+ typedef typename sanitize< Arg3_T >::Type Arg3_Type;
2000
+ Arg3_Type arg3 = args->getArgumentOrDefault<Arg3_Type>(3, varg3);
2001
+ Func func = wrapper->func_;
2002
+ (*obj.*func)(arg0, arg1, arg2, arg3);
2003
+ return Qnil;
2004
+ }
2005
+ catch(...)
2006
+ {
2007
+ RUBY_TRY
2008
+ {
2009
+ if(wrapper)
2010
+ {
2011
+ return wrapper->handler_->handle_exception();
2012
+ }
2013
+ else
2014
+ {
2015
+ throw;
2016
+ }
2017
+ }
2018
+ RUBY_CATCH
2019
+ }
2020
+ }
2021
+
2022
+ // ---------------------------------------------------------------------
2023
+ template<typename Func_T, typename Ret_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T>
2024
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T>::
2025
+ Auto_Member_Function_Wrapper(
2026
+ Func func,
2027
+ Data_Object<Exception_Handler> handler,
2028
+ Arguments* arguments)
2029
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
2030
+ , func_(func)
2031
+ , handler_(handler)
2032
+ , handler_guard_(&handler_)
2033
+ , arguments_(arguments)
2034
+ {
2035
+ if(arguments == 0) {
2036
+ arguments_ = new Arguments();
2037
+ } else {
2038
+ arguments_ = arguments;
2039
+ }
2040
+ }
2041
+
2042
+ template<typename Func_T, typename Ret_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T>
2043
+ VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T>::
2044
+ call(int argc, VALUE* argv, VALUE self)
2045
+ {
2046
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T> * wrapper = 0;
2047
+ try
2048
+ {
2049
+ Data_Object<Wrapped_Function> data(detail::method_data());
2050
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T, Arg2_T> *)data.get();
2051
+ Arguments* args = wrapper->arguments_;
2052
+
2053
+ VALUE varg0, varg1, varg2;
2054
+
2055
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2);
2056
+
2057
+ Self_T * obj = from_ruby<Self_T *>(self);
2058
+
2059
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2060
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2061
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2062
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2063
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2064
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2065
+ Func func = wrapper->func_;
2066
+ return to_ruby((*obj.*func)(arg0, arg1, arg2));
2067
+ }
2068
+ catch(...)
2069
+ {
2070
+ RUBY_TRY
2071
+ {
2072
+ if(wrapper)
2073
+ {
2074
+ return wrapper->handler_->handle_exception();
2075
+ }
2076
+ else
2077
+ {
2078
+ throw;
2079
+ }
2080
+ }
2081
+ RUBY_CATCH
2082
+ }
2083
+ }
2084
+
2085
+ template<typename Func_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T>
2086
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T>::
2087
+ Auto_Member_Function_Wrapper(
2088
+ Func func,
2089
+ Data_Object<Exception_Handler> handler,
2090
+ Arguments* arguments)
2091
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
2092
+ , func_(func)
2093
+ , handler_(handler)
2094
+ , handler_guard_(&handler_)
2095
+ , arguments_(arguments)
2096
+ {
2097
+ if(arguments == 0) {
2098
+ arguments_ = new Arguments();
2099
+ } else {
2100
+ arguments_ = arguments;
2101
+ }
2102
+ }
2103
+
2104
+ template<typename Func_T, typename Self_T, typename Arg0_T, typename Arg1_T, typename Arg2_T>
2105
+ VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T>::
2106
+ call(int argc, VALUE* argv, VALUE self)
2107
+ {
2108
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T> * wrapper = 0;
2109
+ try
2110
+ {
2111
+ Data_Object<Wrapped_Function> data(detail::method_data());
2112
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T, Arg2_T> *)data.get();
2113
+ Arguments* args = wrapper->arguments_;
2114
+
2115
+ VALUE varg0, varg1, varg2;
2116
+
2117
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1, &varg2);
2118
+
2119
+ Self_T * obj = from_ruby<Self_T *>(self);
2120
+
2121
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2122
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2123
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2124
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2125
+ typedef typename sanitize< Arg2_T >::Type Arg2_Type;
2126
+ Arg2_Type arg2 = args->getArgumentOrDefault<Arg2_Type>(2, varg2);
2127
+ Func func = wrapper->func_;
2128
+ (*obj.*func)(arg0, arg1, arg2);
2129
+ return Qnil;
2130
+ }
2131
+ catch(...)
2132
+ {
2133
+ RUBY_TRY
2134
+ {
2135
+ if(wrapper)
2136
+ {
2137
+ return wrapper->handler_->handle_exception();
2138
+ }
2139
+ else
2140
+ {
2141
+ throw;
2142
+ }
2143
+ }
2144
+ RUBY_CATCH
2145
+ }
2146
+ }
2147
+
2148
+ // ---------------------------------------------------------------------
2149
+ template<typename Func_T, typename Ret_T, typename Self_T, typename Arg0_T, typename Arg1_T>
2150
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T>::
2151
+ Auto_Member_Function_Wrapper(
2152
+ Func func,
2153
+ Data_Object<Exception_Handler> handler,
2154
+ Arguments* arguments)
2155
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
2156
+ , func_(func)
2157
+ , handler_(handler)
2158
+ , handler_guard_(&handler_)
2159
+ , arguments_(arguments)
2160
+ {
2161
+ if(arguments == 0) {
2162
+ arguments_ = new Arguments();
2163
+ } else {
2164
+ arguments_ = arguments;
2165
+ }
2166
+ }
2167
+
2168
+ template<typename Func_T, typename Ret_T, typename Self_T, typename Arg0_T, typename Arg1_T>
2169
+ VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T>::
2170
+ call(int argc, VALUE* argv, VALUE self)
2171
+ {
2172
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T> * wrapper = 0;
2173
+ try
2174
+ {
2175
+ Data_Object<Wrapped_Function> data(detail::method_data());
2176
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T, Arg1_T> *)data.get();
2177
+ Arguments* args = wrapper->arguments_;
2178
+
2179
+ VALUE varg0, varg1;
2180
+
2181
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1);
2182
+
2183
+ Self_T * obj = from_ruby<Self_T *>(self);
2184
+
2185
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2186
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2187
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2188
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2189
+ Func func = wrapper->func_;
2190
+ return to_ruby((*obj.*func)(arg0, arg1));
2191
+ }
2192
+ catch(...)
2193
+ {
2194
+ RUBY_TRY
2195
+ {
2196
+ if(wrapper)
2197
+ {
2198
+ return wrapper->handler_->handle_exception();
2199
+ }
2200
+ else
2201
+ {
2202
+ throw;
2203
+ }
2204
+ }
2205
+ RUBY_CATCH
2206
+ }
2207
+ }
2208
+
2209
+ template<typename Func_T, typename Self_T, typename Arg0_T, typename Arg1_T>
2210
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T>::
2211
+ Auto_Member_Function_Wrapper(
2212
+ Func func,
2213
+ Data_Object<Exception_Handler> handler,
2214
+ Arguments* arguments)
2215
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
2216
+ , func_(func)
2217
+ , handler_(handler)
2218
+ , handler_guard_(&handler_)
2219
+ , arguments_(arguments)
2220
+ {
2221
+ if(arguments == 0) {
2222
+ arguments_ = new Arguments();
2223
+ } else {
2224
+ arguments_ = arguments;
2225
+ }
2226
+ }
2227
+
2228
+ template<typename Func_T, typename Self_T, typename Arg0_T, typename Arg1_T>
2229
+ VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T>::
2230
+ call(int argc, VALUE* argv, VALUE self)
2231
+ {
2232
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T> * wrapper = 0;
2233
+ try
2234
+ {
2235
+ Data_Object<Wrapped_Function> data(detail::method_data());
2236
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T, Arg1_T> *)data.get();
2237
+ Arguments* args = wrapper->arguments_;
2238
+
2239
+ VALUE varg0, varg1;
2240
+
2241
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0, &varg1);
2242
+
2243
+ Self_T * obj = from_ruby<Self_T *>(self);
2244
+
2245
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2246
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2247
+ typedef typename sanitize< Arg1_T >::Type Arg1_Type;
2248
+ Arg1_Type arg1 = args->getArgumentOrDefault<Arg1_Type>(1, varg1);
2249
+ Func func = wrapper->func_;
2250
+ (*obj.*func)(arg0, arg1);
2251
+ return Qnil;
2252
+ }
2253
+ catch(...)
2254
+ {
2255
+ RUBY_TRY
2256
+ {
2257
+ if(wrapper)
2258
+ {
2259
+ return wrapper->handler_->handle_exception();
2260
+ }
2261
+ else
2262
+ {
2263
+ throw;
2264
+ }
2265
+ }
2266
+ RUBY_CATCH
2267
+ }
2268
+ }
2269
+
2270
+ // ---------------------------------------------------------------------
2271
+ template<typename Func_T, typename Ret_T, typename Self_T, typename Arg0_T>
2272
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T>::
2273
+ Auto_Member_Function_Wrapper(
2274
+ Func func,
2275
+ Data_Object<Exception_Handler> handler,
2276
+ Arguments* arguments)
2277
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
2278
+ , func_(func)
2279
+ , handler_(handler)
2280
+ , handler_guard_(&handler_)
2281
+ , arguments_(arguments)
2282
+ {
2283
+ if(arguments == 0) {
2284
+ arguments_ = new Arguments();
2285
+ } else {
2286
+ arguments_ = arguments;
2287
+ }
2288
+ }
2289
+
2290
+ template<typename Func_T, typename Ret_T, typename Self_T, typename Arg0_T>
2291
+ VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T>::
2292
+ call(int argc, VALUE* argv, VALUE self)
2293
+ {
2294
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T> * wrapper = 0;
2295
+ try
2296
+ {
2297
+ Data_Object<Wrapped_Function> data(detail::method_data());
2298
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T, Arg0_T> *)data.get();
2299
+ Arguments* args = wrapper->arguments_;
2300
+
2301
+ VALUE varg0;
2302
+
2303
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0);
2304
+
2305
+ Self_T * obj = from_ruby<Self_T *>(self);
2306
+
2307
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2308
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2309
+ Func func = wrapper->func_;
2310
+ return to_ruby((*obj.*func)(arg0));
2311
+ }
2312
+ catch(...)
2313
+ {
2314
+ RUBY_TRY
2315
+ {
2316
+ if(wrapper)
2317
+ {
2318
+ return wrapper->handler_->handle_exception();
2319
+ }
2320
+ else
2321
+ {
2322
+ throw;
2323
+ }
2324
+ }
2325
+ RUBY_CATCH
2326
+ }
2327
+ }
2328
+
2329
+ template<typename Func_T, typename Self_T, typename Arg0_T>
2330
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T>::
2331
+ Auto_Member_Function_Wrapper(
2332
+ Func func,
2333
+ Data_Object<Exception_Handler> handler,
2334
+ Arguments* arguments)
2335
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
2336
+ , func_(func)
2337
+ , handler_(handler)
2338
+ , handler_guard_(&handler_)
2339
+ , arguments_(arguments)
2340
+ {
2341
+ if(arguments == 0) {
2342
+ arguments_ = new Arguments();
2343
+ } else {
2344
+ arguments_ = arguments;
2345
+ }
2346
+ }
2347
+
2348
+ template<typename Func_T, typename Self_T, typename Arg0_T>
2349
+ VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T>::
2350
+ call(int argc, VALUE* argv, VALUE self)
2351
+ {
2352
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T> * wrapper = 0;
2353
+ try
2354
+ {
2355
+ Data_Object<Wrapped_Function> data(detail::method_data());
2356
+ wrapper = (Auto_Member_Function_Wrapper<Func_T, void, Self_T, Arg0_T> *)data.get();
2357
+ Arguments* args = wrapper->arguments_;
2358
+
2359
+ VALUE varg0;
2360
+
2361
+ rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(), &varg0);
2362
+
2363
+ Self_T * obj = from_ruby<Self_T *>(self);
2364
+
2365
+ typedef typename sanitize< Arg0_T >::Type Arg0_Type;
2366
+ Arg0_Type arg0 = args->getArgumentOrDefault<Arg0_Type>(0, varg0);
2367
+ Func func = wrapper->func_;
2368
+ (*obj.*func)(arg0);
2369
+ return Qnil;
2370
+ }
2371
+ catch(...)
2372
+ {
2373
+ RUBY_TRY
2374
+ {
2375
+ if(wrapper)
2376
+ {
2377
+ return wrapper->handler_->handle_exception();
2378
+ }
2379
+ else
2380
+ {
2381
+ throw;
2382
+ }
2383
+ }
2384
+ RUBY_CATCH
2385
+ }
2386
+ }
2387
+
2388
+ // ---------------------------------------------------------------------
2389
+ template<typename Func_T, typename Ret_T, typename Self_T>
2390
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T>::
2391
+ Auto_Member_Function_Wrapper(
2392
+ Func func,
2393
+ Data_Object<Exception_Handler> handler,
2394
+ Arguments* arguments)
2395
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
2396
+ , func_(func)
2397
+ , handler_(handler)
2398
+ , handler_guard_(&handler_)
2399
+ , arguments_(arguments)
2400
+ {
2401
+ if(arguments == 0) {
2402
+ arguments_ = new Arguments();
2403
+ } else {
2404
+ arguments_ = arguments;
2405
+ }
2406
+ }
2407
+
2408
+ template<typename Func_T, typename Ret_T, typename Self_T>
2409
+ VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T>::
2410
+ call(int argc, VALUE* argv, VALUE self)
2411
+ {
2412
+ Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T> * wrapper = 0;
2413
+ try
2414
+ {
2415
+ Data_Object<Wrapped_Function> data(detail::method_data());
2416
+ wrapper =
2417
+ (Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T> *)data.get();
2418
+
2419
+ rb_scan_args(argc, argv, "0");
2420
+ Self_T * obj = from_ruby<Self_T *>(self);
2421
+
2422
+ Func func = wrapper->func_;
2423
+ return to_ruby((*obj.*func)());
2424
+ }
2425
+ catch(...)
2426
+ {
2427
+ RUBY_TRY
2428
+ {
2429
+ if(wrapper)
2430
+ {
2431
+ return wrapper->handler_->handle_exception();
2432
+ }
2433
+ else
2434
+ {
2435
+ throw;
2436
+ }
2437
+ }
2438
+ RUBY_CATCH
2439
+ }
2440
+ }
2441
+
2442
+ template<typename Func_T, typename Self_T>
2443
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T>::
2444
+ Auto_Member_Function_Wrapper(
2445
+ Func func,
2446
+ Data_Object<Exception_Handler> handler,
2447
+ Arguments* arguments)
2448
+ : Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
2449
+ , func_(func)
2450
+ , handler_(handler)
2451
+ , handler_guard_(&handler_)
2452
+ , arguments_(arguments)
2453
+ {
2454
+ if(arguments == 0) {
2455
+ arguments_ = new Arguments();
2456
+ } else {
2457
+ arguments_ = arguments;
2458
+ }
2459
+ }
2460
+
2461
+ template<typename Func_T, typename Self_T>
2462
+ VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_T>::
2463
+ call(int argc, VALUE* argv, VALUE self)
2464
+ {
2465
+ Auto_Member_Function_Wrapper<Func_T, void, Self_T> * wrapper = 0;
2466
+ try
2467
+ {
2468
+ Data_Object<Wrapped_Function> data(detail::method_data());
2469
+ wrapper =
2470
+ (Auto_Member_Function_Wrapper<Func_T, void, Self_T> *)data.get();
2471
+ rb_scan_args(argc, argv, "0");
2472
+ Self_T * obj = from_ruby<Self_T *>(self);
2473
+
2474
+ Func func = wrapper->func_;
2475
+ (*obj.*func)();
2476
+ return Qnil;
2477
+ }
2478
+ catch(...)
2479
+ {
2480
+ RUBY_TRY
2481
+ {
2482
+ if(wrapper)
2483
+ {
2484
+ return wrapper->handler_->handle_exception();
2485
+ }
2486
+ else
2487
+ {
2488
+ throw;
2489
+ }
2490
+ }
2491
+ RUBY_CATCH
2492
+ }
2493
+ }
2494
+
2495
+ // ---------------------------------------------------------------------
2496
+
2497
+ } // namespace detail
2498
+
2499
+ } // namespace Rice
2500
+
2501
+
2502
+ #endif // Rice__detail__Auto_Member_Function_Wrapper__ipp_
2503
+