rice 1.1.0 → 1.2.0

Sign up to get free protection for your applications and to get access to all the features.
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