rice 1.1.0 → 1.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (54) hide show
  1. data/Doxyfile +1 -1
  2. data/Makefile.in +3 -2
  3. data/README +247 -16
  4. data/aclocal.m4 +62 -51
  5. data/configure +1585 -1456
  6. data/extconf.rb +9 -1
  7. data/rice/Arg.hpp +8 -0
  8. data/rice/Arg_impl.hpp +124 -0
  9. data/rice/Arg_operators.cpp +21 -0
  10. data/rice/Arg_operators.hpp +19 -0
  11. data/rice/Constructor.hpp +150 -0
  12. data/rice/Data_Type.ipp +51 -6
  13. data/rice/Director.cpp +19 -0
  14. data/rice/Director.hpp +47 -0
  15. data/rice/Enum.hpp +2 -3
  16. data/rice/Enum.ipp +1 -1
  17. data/rice/Hash.hpp +1 -1
  18. data/rice/Makefile.am +7 -0
  19. data/rice/Makefile.in +18 -7
  20. data/rice/Module_impl.hpp +36 -3
  21. data/rice/Module_impl.ipp +56 -7
  22. data/rice/VM.cpp +2 -2
  23. data/rice/config.hpp +1 -1
  24. data/rice/detail/Arguments.hpp +118 -0
  25. data/rice/detail/Auto_Function_Wrapper.hpp +206 -96
  26. data/rice/detail/Auto_Function_Wrapper.ipp +1687 -144
  27. data/rice/detail/Auto_Member_Function_Wrapper.hpp +234 -123
  28. data/rice/detail/Auto_Member_Function_Wrapper.ipp +1133 -306
  29. data/rice/detail/Caster.hpp +3 -1
  30. data/rice/detail/creation_funcs.hpp +0 -8
  31. data/rice/detail/creation_funcs.ipp +1 -27
  32. data/rice/detail/define_method_and_auto_wrap.hpp +3 -1
  33. data/rice/detail/define_method_and_auto_wrap.ipp +4 -3
  34. data/rice/detail/object_call.ipp +1 -1
  35. data/rice/detail/ruby.hpp +1 -33
  36. data/rice/detail/wrap_function.hpp +103 -48
  37. data/rice/detail/wrap_function.ipp +154 -96
  38. data/rice/generate_code.rb +520 -55
  39. data/rice/global_function.hpp +12 -1
  40. data/rice/global_function.ipp +14 -2
  41. data/ruby/Makefile.in +5 -4
  42. data/ruby/lib/Makefile.in +4 -3
  43. data/ruby/lib/version.rb +1 -1
  44. data/sample/Makefile.in +4 -3
  45. data/test/Makefile.am +2 -0
  46. data/test/Makefile.in +32 -13
  47. data/test/test_Class.cpp +36 -14
  48. data/test/test_Constructor.cpp +176 -1
  49. data/test/test_Data_Type.cpp +121 -0
  50. data/test/test_Director.cpp +225 -0
  51. data/test/test_Enum.cpp +33 -0
  52. data/test/test_Module.cpp +175 -0
  53. data/test/test_global_functions.cpp +70 -1
  54. metadata +27 -7
data/rice/detail/Auto_Function_Wrapper.hpp CHANGED
@@ -27,18 +27,20 @@ public:
27
27
  // typedef Ret_T (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T, Arg15_T);
28
28
  typedef Func_T Func;
29
29
 
30
- static const int Num_Args = 15;
30
+ static const int Num_Args = 16;
31
31
 
32
32
  Auto_Function_Wrapper(
33
33
  Func func,
34
- Data_Object<Exception_Handler> handler);
34
+ Data_Object<Exception_Handler> handler,
35
+ Arguments* arguments = 0);
35
36
 
36
- static VALUE call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6, VALUE ruby_arg7, VALUE ruby_arg8, VALUE ruby_arg9, VALUE ruby_arg10, VALUE ruby_arg11, VALUE ruby_arg12, VALUE ruby_arg13, VALUE ruby_arg14, VALUE ruby_arg15);
37
+ static VALUE call(int argc, VALUE* args, VALUE self);
37
38
 
38
39
  private:
39
40
  Func func_;
40
41
  Data_Object<Exception_Handler> handler_;
41
42
  Address_Registration_Guard handler_guard_;
43
+ Arguments* arguments_;
42
44
  };
43
45
 
44
46
  template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T, typename Arg14_T, typename Arg15_T>
@@ -49,18 +51,20 @@ public:
49
51
  // typedef void (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T, Arg15_T);
50
52
  typedef Func_T Func;
51
53
 
52
- static const int Num_Args = 15;
54
+ static const int Num_Args = 16;
53
55
 
54
56
  Auto_Function_Wrapper(
55
57
  Func func,
56
- Data_Object<Exception_Handler> handler);
58
+ Data_Object<Exception_Handler> handler,
59
+ Arguments* arguments = 0);
57
60
 
58
- static VALUE call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6, VALUE ruby_arg7, VALUE ruby_arg8, VALUE ruby_arg9, VALUE ruby_arg10, VALUE ruby_arg11, VALUE ruby_arg12, VALUE ruby_arg13, VALUE ruby_arg14, VALUE ruby_arg15);
61
+ static VALUE call(int argc, VALUE* args, VALUE self);
59
62
 
60
63
  private:
61
64
  Func func_;
62
65
  Data_Object<Exception_Handler> handler_;
63
66
  Address_Registration_Guard handler_guard_;
67
+ Arguments* arguments_;
64
68
  };
65
69
 
66
70
  // ---------------------------------------------------------------------
@@ -72,18 +76,20 @@ public:
72
76
  // typedef Ret_T (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T);
73
77
  typedef Func_T Func;
74
78
 
75
- static const int Num_Args = 14;
79
+ static const int Num_Args = 15;
76
80
 
77
81
  Auto_Function_Wrapper(
78
82
  Func func,
79
- Data_Object<Exception_Handler> handler);
83
+ Data_Object<Exception_Handler> handler,
84
+ Arguments* arguments = 0);
80
85
 
81
- static VALUE call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6, VALUE ruby_arg7, VALUE ruby_arg8, VALUE ruby_arg9, VALUE ruby_arg10, VALUE ruby_arg11, VALUE ruby_arg12, VALUE ruby_arg13, VALUE ruby_arg14);
86
+ static VALUE call(int argc, VALUE* args, VALUE self);
82
87
 
83
88
  private:
84
89
  Func func_;
85
90
  Data_Object<Exception_Handler> handler_;
86
91
  Address_Registration_Guard handler_guard_;
92
+ Arguments* arguments_;
87
93
  };
88
94
 
89
95
  template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T, typename Arg14_T>
@@ -94,18 +100,20 @@ public:
94
100
  // typedef void (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T, Arg14_T);
95
101
  typedef Func_T Func;
96
102
 
97
- static const int Num_Args = 14;
103
+ static const int Num_Args = 15;
98
104
 
99
105
  Auto_Function_Wrapper(
100
106
  Func func,
101
- Data_Object<Exception_Handler> handler);
107
+ Data_Object<Exception_Handler> handler,
108
+ Arguments* arguments = 0);
102
109
 
103
- static VALUE call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6, VALUE ruby_arg7, VALUE ruby_arg8, VALUE ruby_arg9, VALUE ruby_arg10, VALUE ruby_arg11, VALUE ruby_arg12, VALUE ruby_arg13, VALUE ruby_arg14);
110
+ static VALUE call(int argc, VALUE* args, VALUE self);
104
111
 
105
112
  private:
106
113
  Func func_;
107
114
  Data_Object<Exception_Handler> handler_;
108
115
  Address_Registration_Guard handler_guard_;
116
+ Arguments* arguments_;
109
117
  };
110
118
 
111
119
  // ---------------------------------------------------------------------
@@ -117,18 +125,20 @@ public:
117
125
  // typedef Ret_T (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T);
118
126
  typedef Func_T Func;
119
127
 
120
- static const int Num_Args = 13;
128
+ static const int Num_Args = 14;
121
129
 
122
130
  Auto_Function_Wrapper(
123
131
  Func func,
124
- Data_Object<Exception_Handler> handler);
132
+ Data_Object<Exception_Handler> handler,
133
+ Arguments* arguments = 0);
125
134
 
126
- static VALUE call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6, VALUE ruby_arg7, VALUE ruby_arg8, VALUE ruby_arg9, VALUE ruby_arg10, VALUE ruby_arg11, VALUE ruby_arg12, VALUE ruby_arg13);
135
+ static VALUE call(int argc, VALUE* args, VALUE self);
127
136
 
128
137
  private:
129
138
  Func func_;
130
139
  Data_Object<Exception_Handler> handler_;
131
140
  Address_Registration_Guard handler_guard_;
141
+ Arguments* arguments_;
132
142
  };
133
143
 
134
144
  template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T, typename Arg13_T>
@@ -139,18 +149,20 @@ public:
139
149
  // typedef void (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T, Arg13_T);
140
150
  typedef Func_T Func;
141
151
 
142
- static const int Num_Args = 13;
152
+ static const int Num_Args = 14;
143
153
 
144
154
  Auto_Function_Wrapper(
145
155
  Func func,
146
- Data_Object<Exception_Handler> handler);
156
+ Data_Object<Exception_Handler> handler,
157
+ Arguments* arguments = 0);
147
158
 
148
- static VALUE call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6, VALUE ruby_arg7, VALUE ruby_arg8, VALUE ruby_arg9, VALUE ruby_arg10, VALUE ruby_arg11, VALUE ruby_arg12, VALUE ruby_arg13);
159
+ static VALUE call(int argc, VALUE* args, VALUE self);
149
160
 
150
161
  private:
151
162
  Func func_;
152
163
  Data_Object<Exception_Handler> handler_;
153
164
  Address_Registration_Guard handler_guard_;
165
+ Arguments* arguments_;
154
166
  };
155
167
 
156
168
  // ---------------------------------------------------------------------
@@ -162,18 +174,20 @@ public:
162
174
  // typedef Ret_T (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T);
163
175
  typedef Func_T Func;
164
176
 
165
- static const int Num_Args = 12;
177
+ static const int Num_Args = 13;
166
178
 
167
179
  Auto_Function_Wrapper(
168
180
  Func func,
169
- Data_Object<Exception_Handler> handler);
181
+ Data_Object<Exception_Handler> handler,
182
+ Arguments* arguments = 0);
170
183
 
171
- static VALUE call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6, VALUE ruby_arg7, VALUE ruby_arg8, VALUE ruby_arg9, VALUE ruby_arg10, VALUE ruby_arg11, VALUE ruby_arg12);
184
+ static VALUE call(int argc, VALUE* args, VALUE self);
172
185
 
173
186
  private:
174
187
  Func func_;
175
188
  Data_Object<Exception_Handler> handler_;
176
189
  Address_Registration_Guard handler_guard_;
190
+ Arguments* arguments_;
177
191
  };
178
192
 
179
193
  template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T, typename Arg12_T>
@@ -184,18 +198,20 @@ public:
184
198
  // typedef void (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T, Arg12_T);
185
199
  typedef Func_T Func;
186
200
 
187
- static const int Num_Args = 12;
201
+ static const int Num_Args = 13;
188
202
 
189
203
  Auto_Function_Wrapper(
190
204
  Func func,
191
- Data_Object<Exception_Handler> handler);
205
+ Data_Object<Exception_Handler> handler,
206
+ Arguments* arguments = 0);
192
207
 
193
- static VALUE call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6, VALUE ruby_arg7, VALUE ruby_arg8, VALUE ruby_arg9, VALUE ruby_arg10, VALUE ruby_arg11, VALUE ruby_arg12);
208
+ static VALUE call(int argc, VALUE* args, VALUE self);
194
209
 
195
210
  private:
196
211
  Func func_;
197
212
  Data_Object<Exception_Handler> handler_;
198
213
  Address_Registration_Guard handler_guard_;
214
+ Arguments* arguments_;
199
215
  };
200
216
 
201
217
  // ---------------------------------------------------------------------
@@ -207,18 +223,20 @@ public:
207
223
  // typedef Ret_T (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T);
208
224
  typedef Func_T Func;
209
225
 
210
- static const int Num_Args = 11;
226
+ static const int Num_Args = 12;
211
227
 
212
228
  Auto_Function_Wrapper(
213
229
  Func func,
214
- Data_Object<Exception_Handler> handler);
230
+ Data_Object<Exception_Handler> handler,
231
+ Arguments* arguments = 0);
215
232
 
216
- static VALUE call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6, VALUE ruby_arg7, VALUE ruby_arg8, VALUE ruby_arg9, VALUE ruby_arg10, VALUE ruby_arg11);
233
+ static VALUE call(int argc, VALUE* args, VALUE self);
217
234
 
218
235
  private:
219
236
  Func func_;
220
237
  Data_Object<Exception_Handler> handler_;
221
238
  Address_Registration_Guard handler_guard_;
239
+ Arguments* arguments_;
222
240
  };
223
241
 
224
242
  template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T, typename Arg11_T>
@@ -229,18 +247,20 @@ public:
229
247
  // typedef void (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T, Arg11_T);
230
248
  typedef Func_T Func;
231
249
 
232
- static const int Num_Args = 11;
250
+ static const int Num_Args = 12;
233
251
 
234
252
  Auto_Function_Wrapper(
235
253
  Func func,
236
- Data_Object<Exception_Handler> handler);
254
+ Data_Object<Exception_Handler> handler,
255
+ Arguments* arguments = 0);
237
256
 
238
- static VALUE call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6, VALUE ruby_arg7, VALUE ruby_arg8, VALUE ruby_arg9, VALUE ruby_arg10, VALUE ruby_arg11);
257
+ static VALUE call(int argc, VALUE* args, VALUE self);
239
258
 
240
259
  private:
241
260
  Func func_;
242
261
  Data_Object<Exception_Handler> handler_;
243
262
  Address_Registration_Guard handler_guard_;
263
+ Arguments* arguments_;
244
264
  };
245
265
 
246
266
  // ---------------------------------------------------------------------
@@ -252,18 +272,20 @@ public:
252
272
  // typedef Ret_T (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T);
253
273
  typedef Func_T Func;
254
274
 
255
- static const int Num_Args = 10;
275
+ static const int Num_Args = 11;
256
276
 
257
277
  Auto_Function_Wrapper(
258
278
  Func func,
259
- Data_Object<Exception_Handler> handler);
279
+ Data_Object<Exception_Handler> handler,
280
+ Arguments* arguments = 0);
260
281
 
261
- static VALUE call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6, VALUE ruby_arg7, VALUE ruby_arg8, VALUE ruby_arg9, VALUE ruby_arg10);
282
+ static VALUE call(int argc, VALUE* args, VALUE self);
262
283
 
263
284
  private:
264
285
  Func func_;
265
286
  Data_Object<Exception_Handler> handler_;
266
287
  Address_Registration_Guard handler_guard_;
288
+ Arguments* arguments_;
267
289
  };
268
290
 
269
291
  template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T, typename Arg10_T>
@@ -274,18 +296,20 @@ public:
274
296
  // typedef void (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T, Arg10_T);
275
297
  typedef Func_T Func;
276
298
 
277
- static const int Num_Args = 10;
299
+ static const int Num_Args = 11;
278
300
 
279
301
  Auto_Function_Wrapper(
280
302
  Func func,
281
- Data_Object<Exception_Handler> handler);
303
+ Data_Object<Exception_Handler> handler,
304
+ Arguments* arguments = 0);
282
305
 
283
- static VALUE call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6, VALUE ruby_arg7, VALUE ruby_arg8, VALUE ruby_arg9, VALUE ruby_arg10);
306
+ static VALUE call(int argc, VALUE* args, VALUE self);
284
307
 
285
308
  private:
286
309
  Func func_;
287
310
  Data_Object<Exception_Handler> handler_;
288
311
  Address_Registration_Guard handler_guard_;
312
+ Arguments* arguments_;
289
313
  };
290
314
 
291
315
  // ---------------------------------------------------------------------
@@ -297,18 +321,20 @@ public:
297
321
  // typedef Ret_T (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T);
298
322
  typedef Func_T Func;
299
323
 
300
- static const int Num_Args = 9;
324
+ static const int Num_Args = 10;
301
325
 
302
326
  Auto_Function_Wrapper(
303
327
  Func func,
304
- Data_Object<Exception_Handler> handler);
328
+ Data_Object<Exception_Handler> handler,
329
+ Arguments* arguments = 0);
305
330
 
306
- static VALUE call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6, VALUE ruby_arg7, VALUE ruby_arg8, VALUE ruby_arg9);
331
+ static VALUE call(int argc, VALUE* args, VALUE self);
307
332
 
308
333
  private:
309
334
  Func func_;
310
335
  Data_Object<Exception_Handler> handler_;
311
336
  Address_Registration_Guard handler_guard_;
337
+ Arguments* arguments_;
312
338
  };
313
339
 
314
340
  template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T, typename Arg9_T>
@@ -319,18 +345,20 @@ public:
319
345
  // typedef void (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T, Arg9_T);
320
346
  typedef Func_T Func;
321
347
 
322
- static const int Num_Args = 9;
348
+ static const int Num_Args = 10;
323
349
 
324
350
  Auto_Function_Wrapper(
325
351
  Func func,
326
- Data_Object<Exception_Handler> handler);
352
+ Data_Object<Exception_Handler> handler,
353
+ Arguments* arguments = 0);
327
354
 
328
- static VALUE call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6, VALUE ruby_arg7, VALUE ruby_arg8, VALUE ruby_arg9);
355
+ static VALUE call(int argc, VALUE* args, VALUE self);
329
356
 
330
357
  private:
331
358
  Func func_;
332
359
  Data_Object<Exception_Handler> handler_;
333
360
  Address_Registration_Guard handler_guard_;
361
+ Arguments* arguments_;
334
362
  };
335
363
 
336
364
  // ---------------------------------------------------------------------
@@ -342,18 +370,20 @@ public:
342
370
  // typedef Ret_T (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T);
343
371
  typedef Func_T Func;
344
372
 
345
- static const int Num_Args = 8;
373
+ static const int Num_Args = 9;
346
374
 
347
375
  Auto_Function_Wrapper(
348
376
  Func func,
349
- Data_Object<Exception_Handler> handler);
377
+ Data_Object<Exception_Handler> handler,
378
+ Arguments* arguments = 0);
350
379
 
351
- static VALUE call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6, VALUE ruby_arg7, VALUE ruby_arg8);
380
+ static VALUE call(int argc, VALUE* args, VALUE self);
352
381
 
353
382
  private:
354
383
  Func func_;
355
384
  Data_Object<Exception_Handler> handler_;
356
385
  Address_Registration_Guard handler_guard_;
386
+ Arguments* arguments_;
357
387
  };
358
388
 
359
389
  template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T, typename Arg8_T>
@@ -364,18 +394,20 @@ public:
364
394
  // typedef void (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T, Arg8_T);
365
395
  typedef Func_T Func;
366
396
 
367
- static const int Num_Args = 8;
397
+ static const int Num_Args = 9;
368
398
 
369
399
  Auto_Function_Wrapper(
370
400
  Func func,
371
- Data_Object<Exception_Handler> handler);
401
+ Data_Object<Exception_Handler> handler,
402
+ Arguments* arguments = 0);
372
403
 
373
- static VALUE call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6, VALUE ruby_arg7, VALUE ruby_arg8);
404
+ static VALUE call(int argc, VALUE* args, VALUE self);
374
405
 
375
406
  private:
376
407
  Func func_;
377
408
  Data_Object<Exception_Handler> handler_;
378
409
  Address_Registration_Guard handler_guard_;
410
+ Arguments* arguments_;
379
411
  };
380
412
 
381
413
  // ---------------------------------------------------------------------
@@ -387,18 +419,20 @@ public:
387
419
  // typedef Ret_T (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T);
388
420
  typedef Func_T Func;
389
421
 
390
- static const int Num_Args = 7;
422
+ static const int Num_Args = 8;
391
423
 
392
424
  Auto_Function_Wrapper(
393
425
  Func func,
394
- Data_Object<Exception_Handler> handler);
426
+ Data_Object<Exception_Handler> handler,
427
+ Arguments* arguments = 0);
395
428
 
396
- static VALUE call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6, VALUE ruby_arg7);
429
+ static VALUE call(int argc, VALUE* args, VALUE self);
397
430
 
398
431
  private:
399
432
  Func func_;
400
433
  Data_Object<Exception_Handler> handler_;
401
434
  Address_Registration_Guard handler_guard_;
435
+ Arguments* arguments_;
402
436
  };
403
437
 
404
438
  template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T, typename Arg7_T>
@@ -409,18 +443,20 @@ public:
409
443
  // typedef void (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T, Arg7_T);
410
444
  typedef Func_T Func;
411
445
 
412
- static const int Num_Args = 7;
446
+ static const int Num_Args = 8;
413
447
 
414
448
  Auto_Function_Wrapper(
415
449
  Func func,
416
- Data_Object<Exception_Handler> handler);
450
+ Data_Object<Exception_Handler> handler,
451
+ Arguments* arguments = 0);
417
452
 
418
- static VALUE call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6, VALUE ruby_arg7);
453
+ static VALUE call(int argc, VALUE* args, VALUE self);
419
454
 
420
455
  private:
421
456
  Func func_;
422
457
  Data_Object<Exception_Handler> handler_;
423
458
  Address_Registration_Guard handler_guard_;
459
+ Arguments* arguments_;
424
460
  };
425
461
 
426
462
  // ---------------------------------------------------------------------
@@ -432,18 +468,20 @@ public:
432
468
  // typedef Ret_T (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T);
433
469
  typedef Func_T Func;
434
470
 
435
- static const int Num_Args = 6;
471
+ static const int Num_Args = 7;
436
472
 
437
473
  Auto_Function_Wrapper(
438
474
  Func func,
439
- Data_Object<Exception_Handler> handler);
475
+ Data_Object<Exception_Handler> handler,
476
+ Arguments* arguments = 0);
440
477
 
441
- static VALUE call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6);
478
+ static VALUE call(int argc, VALUE* args, VALUE self);
442
479
 
443
480
  private:
444
481
  Func func_;
445
482
  Data_Object<Exception_Handler> handler_;
446
483
  Address_Registration_Guard handler_guard_;
484
+ Arguments* arguments_;
447
485
  };
448
486
 
449
487
  template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T, typename Arg6_T>
@@ -454,18 +492,20 @@ public:
454
492
  // typedef void (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T, Arg6_T);
455
493
  typedef Func_T Func;
456
494
 
457
- static const int Num_Args = 6;
495
+ static const int Num_Args = 7;
458
496
 
459
497
  Auto_Function_Wrapper(
460
498
  Func func,
461
- Data_Object<Exception_Handler> handler);
499
+ Data_Object<Exception_Handler> handler,
500
+ Arguments* arguments = 0);
462
501
 
463
- static VALUE call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5, VALUE ruby_arg6);
502
+ static VALUE call(int argc, VALUE* args, VALUE self);
464
503
 
465
504
  private:
466
505
  Func func_;
467
506
  Data_Object<Exception_Handler> handler_;
468
507
  Address_Registration_Guard handler_guard_;
508
+ Arguments* arguments_;
469
509
  };
470
510
 
471
511
  // ---------------------------------------------------------------------
@@ -477,18 +517,20 @@ public:
477
517
  // typedef Ret_T (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T);
478
518
  typedef Func_T Func;
479
519
 
480
- static const int Num_Args = 5;
520
+ static const int Num_Args = 6;
481
521
 
482
522
  Auto_Function_Wrapper(
483
523
  Func func,
484
- Data_Object<Exception_Handler> handler);
524
+ Data_Object<Exception_Handler> handler,
525
+ Arguments* arguments = 0);
485
526
 
486
- static VALUE call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5);
527
+ static VALUE call(int argc, VALUE* args, VALUE self);
487
528
 
488
529
  private:
489
530
  Func func_;
490
531
  Data_Object<Exception_Handler> handler_;
491
532
  Address_Registration_Guard handler_guard_;
533
+ Arguments* arguments_;
492
534
  };
493
535
 
494
536
  template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T, typename Arg5_T>
@@ -499,18 +541,20 @@ public:
499
541
  // typedef void (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T, Arg5_T);
500
542
  typedef Func_T Func;
501
543
 
502
- static const int Num_Args = 5;
544
+ static const int Num_Args = 6;
503
545
 
504
546
  Auto_Function_Wrapper(
505
547
  Func func,
506
- Data_Object<Exception_Handler> handler);
548
+ Data_Object<Exception_Handler> handler,
549
+ Arguments* arguments = 0);
507
550
 
508
- static VALUE call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4, VALUE ruby_arg5);
551
+ static VALUE call(int argc, VALUE* args, VALUE self);
509
552
 
510
553
  private:
511
554
  Func func_;
512
555
  Data_Object<Exception_Handler> handler_;
513
556
  Address_Registration_Guard handler_guard_;
557
+ Arguments* arguments_;
514
558
  };
515
559
 
516
560
  // ---------------------------------------------------------------------
@@ -522,18 +566,20 @@ public:
522
566
  // typedef Ret_T (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T);
523
567
  typedef Func_T Func;
524
568
 
525
- static const int Num_Args = 4;
569
+ static const int Num_Args = 5;
526
570
 
527
571
  Auto_Function_Wrapper(
528
572
  Func func,
529
- Data_Object<Exception_Handler> handler);
573
+ Data_Object<Exception_Handler> handler,
574
+ Arguments* arguments = 0);
530
575
 
531
- static VALUE call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4);
576
+ static VALUE call(int argc, VALUE* args, VALUE self);
532
577
 
533
578
  private:
534
579
  Func func_;
535
580
  Data_Object<Exception_Handler> handler_;
536
581
  Address_Registration_Guard handler_guard_;
582
+ Arguments* arguments_;
537
583
  };
538
584
 
539
585
  template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T, typename Arg4_T>
@@ -544,18 +590,20 @@ public:
544
590
  // typedef void (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T, Arg4_T);
545
591
  typedef Func_T Func;
546
592
 
547
- static const int Num_Args = 4;
593
+ static const int Num_Args = 5;
548
594
 
549
595
  Auto_Function_Wrapper(
550
596
  Func func,
551
- Data_Object<Exception_Handler> handler);
597
+ Data_Object<Exception_Handler> handler,
598
+ Arguments* arguments = 0);
552
599
 
553
- static VALUE call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3, VALUE ruby_arg4);
600
+ static VALUE call(int argc, VALUE* args, VALUE self);
554
601
 
555
602
  private:
556
603
  Func func_;
557
604
  Data_Object<Exception_Handler> handler_;
558
605
  Address_Registration_Guard handler_guard_;
606
+ Arguments* arguments_;
559
607
  };
560
608
 
561
609
  // ---------------------------------------------------------------------
@@ -567,18 +615,20 @@ public:
567
615
  // typedef Ret_T (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T);
568
616
  typedef Func_T Func;
569
617
 
570
- static const int Num_Args = 3;
618
+ static const int Num_Args = 4;
571
619
 
572
620
  Auto_Function_Wrapper(
573
621
  Func func,
574
- Data_Object<Exception_Handler> handler);
622
+ Data_Object<Exception_Handler> handler,
623
+ Arguments* arguments = 0);
575
624
 
576
- static VALUE call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3);
625
+ static VALUE call(int argc, VALUE* args, VALUE self);
577
626
 
578
627
  private:
579
628
  Func func_;
580
629
  Data_Object<Exception_Handler> handler_;
581
630
  Address_Registration_Guard handler_guard_;
631
+ Arguments* arguments_;
582
632
  };
583
633
 
584
634
  template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T, typename Arg3_T>
@@ -589,18 +639,20 @@ public:
589
639
  // typedef void (*Func)(Arg0_T, Arg1_T, Arg2_T, Arg3_T);
590
640
  typedef Func_T Func;
591
641
 
592
- static const int Num_Args = 3;
642
+ static const int Num_Args = 4;
593
643
 
594
644
  Auto_Function_Wrapper(
595
645
  Func func,
596
- Data_Object<Exception_Handler> handler);
646
+ Data_Object<Exception_Handler> handler,
647
+ Arguments* arguments = 0);
597
648
 
598
- static VALUE call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2, VALUE ruby_arg3);
649
+ static VALUE call(int argc, VALUE* args, VALUE self);
599
650
 
600
651
  private:
601
652
  Func func_;
602
653
  Data_Object<Exception_Handler> handler_;
603
654
  Address_Registration_Guard handler_guard_;
655
+ Arguments* arguments_;
604
656
  };
605
657
 
606
658
  // ---------------------------------------------------------------------
@@ -612,18 +664,20 @@ public:
612
664
  // typedef Ret_T (*Func)(Arg0_T, Arg1_T, Arg2_T);
613
665
  typedef Func_T Func;
614
666
 
615
- static const int Num_Args = 2;
667
+ static const int Num_Args = 3;
616
668
 
617
669
  Auto_Function_Wrapper(
618
670
  Func func,
619
- Data_Object<Exception_Handler> handler);
671
+ Data_Object<Exception_Handler> handler,
672
+ Arguments* arguments = 0);
620
673
 
621
- static VALUE call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2);
674
+ static VALUE call(int argc, VALUE* args, VALUE self);
622
675
 
623
676
  private:
624
677
  Func func_;
625
678
  Data_Object<Exception_Handler> handler_;
626
679
  Address_Registration_Guard handler_guard_;
680
+ Arguments* arguments_;
627
681
  };
628
682
 
629
683
  template<typename Func_T, typename Arg0_T, typename Arg1_T, typename Arg2_T>
@@ -634,18 +688,20 @@ public:
634
688
  // typedef void (*Func)(Arg0_T, Arg1_T, Arg2_T);
635
689
  typedef Func_T Func;
636
690
 
637
- static const int Num_Args = 2;
691
+ static const int Num_Args = 3;
638
692
 
639
693
  Auto_Function_Wrapper(
640
694
  Func func,
641
- Data_Object<Exception_Handler> handler);
695
+ Data_Object<Exception_Handler> handler,
696
+ Arguments* arguments = 0);
642
697
 
643
- static VALUE call(VALUE ruby_arg0, VALUE ruby_arg1, VALUE ruby_arg2);
698
+ static VALUE call(int argc, VALUE* args, VALUE self);
644
699
 
645
700
  private:
646
701
  Func func_;
647
702
  Data_Object<Exception_Handler> handler_;
648
703
  Address_Registration_Guard handler_guard_;
704
+ Arguments* arguments_;
649
705
  };
650
706
 
651
707
  // ---------------------------------------------------------------------
@@ -657,18 +713,20 @@ public:
657
713
  // typedef Ret_T (*Func)(Arg0_T, Arg1_T);
658
714
  typedef Func_T Func;
659
715
 
660
- static const int Num_Args = 1;
716
+ static const int Num_Args = 2;
661
717
 
662
718
  Auto_Function_Wrapper(
663
719
  Func func,
664
- Data_Object<Exception_Handler> handler);
720
+ Data_Object<Exception_Handler> handler,
721
+ Arguments* arguments = 0);
665
722
 
666
- static VALUE call(VALUE ruby_arg0, VALUE ruby_arg1);
723
+ static VALUE call(int argc, VALUE* args, VALUE self);
667
724
 
668
725
  private:
669
726
  Func func_;
670
727
  Data_Object<Exception_Handler> handler_;
671
728
  Address_Registration_Guard handler_guard_;
729
+ Arguments* arguments_;
672
730
  };
673
731
 
674
732
  template<typename Func_T, typename Arg0_T, typename Arg1_T>
@@ -679,18 +737,20 @@ public:
679
737
  // typedef void (*Func)(Arg0_T, Arg1_T);
680
738
  typedef Func_T Func;
681
739
 
682
- static const int Num_Args = 1;
740
+ static const int Num_Args = 2;
683
741
 
684
742
  Auto_Function_Wrapper(
685
743
  Func func,
686
- Data_Object<Exception_Handler> handler);
744
+ Data_Object<Exception_Handler> handler,
745
+ Arguments* arguments = 0);
687
746
 
688
- static VALUE call(VALUE ruby_arg0, VALUE ruby_arg1);
747
+ static VALUE call(int argc, VALUE* args, VALUE self);
689
748
 
690
749
  private:
691
750
  Func func_;
692
751
  Data_Object<Exception_Handler> handler_;
693
752
  Address_Registration_Guard handler_guard_;
753
+ Arguments* arguments_;
694
754
  };
695
755
 
696
756
  // ---------------------------------------------------------------------
@@ -702,18 +762,20 @@ public:
702
762
  // typedef Ret_T (*Func)(Arg0_T);
703
763
  typedef Func_T Func;
704
764
 
705
- static const int Num_Args = 0;
765
+ static const int Num_Args = 1;
706
766
 
707
767
  Auto_Function_Wrapper(
708
768
  Func func,
709
- Data_Object<Exception_Handler> handler);
769
+ Data_Object<Exception_Handler> handler,
770
+ Arguments* arguments = 0);
710
771
 
711
- static VALUE call(VALUE ruby_arg0);
772
+ static VALUE call(int argc, VALUE* args, VALUE self);
712
773
 
713
774
  private:
714
775
  Func func_;
715
776
  Data_Object<Exception_Handler> handler_;
716
777
  Address_Registration_Guard handler_guard_;
778
+ Arguments* arguments_;
717
779
  };
718
780
 
719
781
  template<typename Func_T, typename Arg0_T>
@@ -724,21 +786,69 @@ public:
724
786
  // typedef void (*Func)(Arg0_T);
725
787
  typedef Func_T Func;
726
788
 
727
- static const int Num_Args = 0;
789
+ static const int Num_Args = 1;
728
790
 
729
791
  Auto_Function_Wrapper(
730
792
  Func func,
731
- Data_Object<Exception_Handler> handler);
793
+ Data_Object<Exception_Handler> handler,
794
+ Arguments* arguments = 0);
732
795
 
733
- static VALUE call(VALUE ruby_arg0);
796
+ static VALUE call(int argc, VALUE* args, VALUE self);
734
797
 
735
798
  private:
736
799
  Func func_;
737
800
  Data_Object<Exception_Handler> handler_;
738
801
  Address_Registration_Guard handler_guard_;
802
+ Arguments* arguments_;
739
803
  };
740
804
 
741
805
  // ---------------------------------------------------------------------
806
+
807
+ template<typename Func_T, typename Ret_T>
808
+ class Auto_Function_Wrapper<Func_T, Ret_T>
809
+ : public Wrapped_Function
810
+ {
811
+ public:
812
+ // typedef void (*Func)();
813
+ typedef Func_T Func;
814
+
815
+ static const int Num_Args = 0;
816
+
817
+ Auto_Function_Wrapper(
818
+ Func func,
819
+ Data_Object<Exception_Handler> handler,
820
+ Arguments* arguments = new Arguments());
821
+
822
+ static VALUE call();
823
+
824
+ private:
825
+ Func func_;
826
+ Data_Object<Exception_Handler> handler_;
827
+ Arguments* arguments_;
828
+ };
829
+
830
+ template<typename Func_T>
831
+ class Auto_Function_Wrapper<Func_T, void>
832
+ : public Wrapped_Function
833
+ {
834
+ public:
835
+ // typedef void (*Func)();
836
+ typedef Func_T Func;
837
+
838
+ static const int Num_Args = 0;
839
+
840
+ Auto_Function_Wrapper(
841
+ Func func,
842
+ Data_Object<Exception_Handler> handler,
843
+ Arguments* arguments = new Arguments());
844
+
845
+ static VALUE call();
846
+
847
+ private:
848
+ Func func_;
849
+ Data_Object<Exception_Handler> handler_;
850
+ Arguments* arguments_;
851
+ };
742
852
  #endif // DOXYGEN
743
853
 
744
854
  } // namespace detail