rice 1.3.1 → 1.3.2
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.
- data/Doxyfile +1 -1
- data/Makefile.in +58 -142
- data/aclocal.m4 +112 -201
- data/config.guess +23 -84
- data/config.sub +23 -93
- data/configure +2727 -2406
- data/depcomp +14 -19
- data/install-sh +108 -120
- data/rice/Constructor.hpp +350 -322
- data/rice/Makefile.am +0 -1
- data/rice/Makefile.in +69 -119
- data/rice/config.hpp +2 -8
- data/rice/config.hpp.in +0 -6
- data/rice/detail/Auto_Function_Wrapper.hpp +1 -33
- data/rice/detail/Auto_Function_Wrapper.ipp +1009 -1060
- data/rice/detail/Auto_Member_Function_Wrapper.ipp +608 -672
- data/rice/detail/method_data.cpp +0 -4
- data/rice/detail/object_call.hpp +31 -48
- data/rice/detail/object_call.ipp +45 -61
- data/rice/detail/wrap_function.hpp +70 -74
- data/rice/detail/wrap_function.ipp +126 -143
- data/rice/protect.hpp +30 -30
- data/rice/protect.ipp +770 -696
- data/ruby.ac +0 -14
- data/ruby/Makefile.in +41 -108
- data/ruby/lib/Makefile.in +23 -64
- data/ruby/lib/version.rb +1 -1
- data/sample/Makefile.in +12 -36
- data/test/Makefile.in +59 -148
- data/test/ext/Makefile.in +12 -36
- data/test/test_Constructor.cpp +42 -153
- data/test/test_Module.cpp +4 -4
- metadata +132 -124
- data/rice/generate_code.rb +0 -1328
data/rice/generate_code.rb
DELETED
@@ -1,1328 +0,0 @@
|
|
1
|
-
require 'ftools'
|
2
|
-
|
3
|
-
MAX_ARGS = 15
|
4
|
-
|
5
|
-
# ======================================================================
|
6
|
-
# TODO: This doesn't properly handle escaped %'s
|
7
|
-
def fill_template(template_str, args)
|
8
|
-
result = template_str.dup
|
9
|
-
args_not_found = args.dup
|
10
|
-
result.gsub!(/%\(-(\w+)\)/) do |match|
|
11
|
-
args_not_found.delete($1.intern)
|
12
|
-
''
|
13
|
-
end
|
14
|
-
result.gsub!(/%\((\w+)\)/) do |match|
|
15
|
-
value = args[$1.intern]
|
16
|
-
raise ArgumentError, "#{match} not found in argument hash" if value.nil?
|
17
|
-
args_not_found.delete($1.intern)
|
18
|
-
value
|
19
|
-
end
|
20
|
-
if args_not_found.size != 0 then
|
21
|
-
args_not_found.each do |name, value|
|
22
|
-
raise "#{name} not found in template"
|
23
|
-
end
|
24
|
-
end
|
25
|
-
return result
|
26
|
-
end
|
27
|
-
|
28
|
-
GENERATED_FILE_WARNING = <<END
|
29
|
-
// This is a generated file. DO NOT EDIT!!%(-macro_name)
|
30
|
-
END
|
31
|
-
|
32
|
-
# TODO: shouldn't include ruby.h directly
|
33
|
-
HEADER_TOP = <<END
|
34
|
-
#ifndef %(macro_name)
|
35
|
-
#define %(macro_name)
|
36
|
-
|
37
|
-
#{GENERATED_FILE_WARNING}
|
38
|
-
|
39
|
-
// This causes problems with certain C++ libraries
|
40
|
-
#undef TYPE
|
41
|
-
|
42
|
-
END
|
43
|
-
HEADER_BOTTOM = <<END
|
44
|
-
|
45
|
-
#endif // %(macro_name)
|
46
|
-
|
47
|
-
END
|
48
|
-
|
49
|
-
$filenames = []
|
50
|
-
|
51
|
-
def wrap_header(
|
52
|
-
filename,
|
53
|
-
namespace=nil,
|
54
|
-
docstring=nil,
|
55
|
-
include_ipp=false,
|
56
|
-
head=nil,
|
57
|
-
tail=nil,
|
58
|
-
header_top=HEADER_TOP,
|
59
|
-
header_bottom=HEADER_BOTTOM,
|
60
|
-
&block)
|
61
|
-
$filenames << filename
|
62
|
-
File.open(filename, 'w') do |out|
|
63
|
-
namespace_str = namespace.nil? ? '' : "#{namespace}__"
|
64
|
-
trailer = File.basename(filename)
|
65
|
-
macro_name = namespace_str + trailer + '_'
|
66
|
-
macro_name.gsub!(/[.]/, '__')
|
67
|
-
macro_name.tr!(':', '_')
|
68
|
-
if header_top then
|
69
|
-
out.puts fill_template(header_top, { :macro_name => macro_name })
|
70
|
-
end
|
71
|
-
out.puts head if head
|
72
|
-
namespace_wrapper = namespace ? method(:wrap_namespace) : method(:null_wrap)
|
73
|
-
docstring_wrapper = docstring ? method(:wrap_docstring) : method(:null_wrap)
|
74
|
-
namespace_wrapper.call(out, namespace) do
|
75
|
-
docstring_wrapper.call(out, docstring) do
|
76
|
-
yield out
|
77
|
-
end
|
78
|
-
end
|
79
|
-
out.puts tail if tail
|
80
|
-
out.puts "#include \"#{File.basename(filename, '.hpp')}.ipp\"" if include_ipp
|
81
|
-
if header_bottom then
|
82
|
-
out.puts fill_template(header_bottom, { :macro_name => macro_name })
|
83
|
-
end
|
84
|
-
end
|
85
|
-
end
|
86
|
-
|
87
|
-
def null_wrap(*args)
|
88
|
-
yield(*args)
|
89
|
-
end
|
90
|
-
|
91
|
-
def wrap_docstring(out, docstring)
|
92
|
-
out.puts "#ifdef DOXYGEN"
|
93
|
-
out.puts docstring
|
94
|
-
out.puts "#else"
|
95
|
-
out.puts ""
|
96
|
-
yield out
|
97
|
-
out.puts "#endif // DOXYGEN"
|
98
|
-
end
|
99
|
-
|
100
|
-
def wrap_namespace(out, namespace)
|
101
|
-
namespaces = namespace.split('::')
|
102
|
-
namespaces.each do |namespace|
|
103
|
-
out.print "namespace #{namespace}\n{\n\n"
|
104
|
-
end
|
105
|
-
yield out
|
106
|
-
namespaces.reverse.each do |namespace|
|
107
|
-
out.print "\n} // namespace #{namespace}\n"
|
108
|
-
end
|
109
|
-
out.print "\n"
|
110
|
-
end
|
111
|
-
|
112
|
-
if __FILE__ == $0 then
|
113
|
-
|
114
|
-
# ======================================================================
|
115
|
-
# TODO: Can I make protect accept a function or functor that
|
116
|
-
# doesn't return a VALUE?
|
117
|
-
docstring = <<END
|
118
|
-
/*! \\file
|
119
|
-
* \\brief A collection of functions (overloaded on number of
|
120
|
-
* arguments) for calling C functions that might raise Ruby exceptions.
|
121
|
-
*/
|
122
|
-
|
123
|
-
//! Call the C function f with arguments (arg1, arg2, ...).
|
124
|
-
/*! E.g.:
|
125
|
-
* \\code
|
126
|
-
* VALUE x = protect(rb_ary_new);
|
127
|
-
* protect(rb_ary_push, x, INT2NUM(42));
|
128
|
-
* \\endcode
|
129
|
-
*
|
130
|
-
* Note that this function makes copies of all of its arguments; it
|
131
|
-
* does not take anything by reference. All of the copies are const so
|
132
|
-
* that protect will not work if f takes a non-const
|
133
|
-
* reference to any of its arguments (though you can use non-const
|
134
|
-
* pointers).
|
135
|
-
*/
|
136
|
-
VALUE protect(Function f, T1 arg1, T2 arg2, ...);
|
137
|
-
END
|
138
|
-
ipp_template = <<END
|
139
|
-
namespace detail
|
140
|
-
{
|
141
|
-
|
142
|
-
template<typename Ret_T, typename Fun%(typenames)>
|
143
|
-
class Ruby_Function_%(j)
|
144
|
-
{
|
145
|
-
public:
|
146
|
-
Ruby_Function_%(j)(Fun f%(member_args));
|
147
|
-
inline void operator()();
|
148
|
-
static inline VALUE call(Ruby_Function_%(j) * f);
|
149
|
-
Ret_T const & result() const { return result_; }
|
150
|
-
|
151
|
-
private:
|
152
|
-
Fun f_;
|
153
|
-
%(member_decls)
|
154
|
-
Ret_T result_; // TODO: use placement new
|
155
|
-
};
|
156
|
-
|
157
|
-
template<typename Ret_T, typename Fun%(typenames)>
|
158
|
-
inline Ruby_Function_%(j)<Ret_T, Fun%(types)>::
|
159
|
-
Ruby_Function_%(j)(Fun f%(member_args))
|
160
|
-
: f_(f)%(initializers)
|
161
|
-
{ }
|
162
|
-
|
163
|
-
template<typename Ret_T, typename Fun%(typenames)>
|
164
|
-
inline void Ruby_Function_%(j)<Ret_T, Fun%(types)>::
|
165
|
-
operator()()
|
166
|
-
{
|
167
|
-
result_ = f_(%(member_params));
|
168
|
-
}
|
169
|
-
|
170
|
-
template<typename Ret_T, typename Fun%(typenames)>
|
171
|
-
inline VALUE Ruby_Function_%(j)<Ret_T, Fun%(types)>::
|
172
|
-
call(Ruby_Function_%(j) * f)
|
173
|
-
{
|
174
|
-
(*f)();
|
175
|
-
return Qnil;
|
176
|
-
}
|
177
|
-
|
178
|
-
} // namespace detail
|
179
|
-
|
180
|
-
template<typename Ret_T, typename Fun%(typenames)>
|
181
|
-
inline Ret_T protect(Fun fun%(args))
|
182
|
-
{
|
183
|
-
typedef detail::Ruby_Function_%(j)<Ret_T, Fun%(types)> RF;
|
184
|
-
RF f(fun%(params));
|
185
|
-
detail::protect(
|
186
|
-
RUBY_VALUE_FUNC(RF::call),
|
187
|
-
reinterpret_cast<VALUE>(&f));
|
188
|
-
return f.result();
|
189
|
-
}
|
190
|
-
|
191
|
-
template<typename Fun%(typenames)>
|
192
|
-
inline VALUE protect(Fun fun%(args))
|
193
|
-
{
|
194
|
-
typedef detail::Ruby_Function_%(j)<VALUE, Fun%(types)> RF;
|
195
|
-
RF f(fun%(params));
|
196
|
-
detail::protect(
|
197
|
-
RUBY_VALUE_FUNC(RF::call),
|
198
|
-
reinterpret_cast<VALUE>(&f));
|
199
|
-
return f.result();
|
200
|
-
}
|
201
|
-
|
202
|
-
// ---------------------------------------------------------------------
|
203
|
-
END
|
204
|
-
hpp_template = <<END
|
205
|
-
template<typename Fun%(typenames)>
|
206
|
-
VALUE protect(Fun fun%(args));
|
207
|
-
END
|
208
|
-
ipp_head = <<END
|
209
|
-
#include "detail/protect.hpp"
|
210
|
-
END
|
211
|
-
hpp_head = <<END
|
212
|
-
#include "Object_defn.hpp"
|
213
|
-
END
|
214
|
-
ipp_filename = 'protect.ipp'
|
215
|
-
hpp_filename = 'protect.hpp'
|
216
|
-
wrap_header(ipp_filename, 'Rice', nil, false, ipp_head) do |ipp|
|
217
|
-
wrap_header(hpp_filename, 'Rice', docstring, true, hpp_head) do |hpp|
|
218
|
-
for j in 0..MAX_ARGS do
|
219
|
-
t_array = (1..j).to_a
|
220
|
-
type_list = t_array.map { |x| "T#{x}" }.join(', ')
|
221
|
-
init_list = t_array.map { |x| "t#{x}_(t#{x})" }.join(', ')
|
222
|
-
param_list = t_array.map { |x| "t#{x}" }.join(', ')
|
223
|
-
# arg_list = t_array.map { |x| "T#{x} t#{x}" }.join(', ')
|
224
|
-
arg_list = t_array.map { |x| "T#{x} const & t#{x}" }.join(', ')
|
225
|
-
member_param_list = t_array.map { |x| "t#{x}_" }.join(', ')
|
226
|
-
member_decl_list =
|
227
|
-
# t_array.map { |x| "typename detail::Copy_Type<T#{x}>::Type const t#{x}_; " }
|
228
|
-
t_array.map { |x| "T#{x} const & t#{x}_; " }
|
229
|
-
add_comma = (j == 0) ? '' : ', '
|
230
|
-
typename_list =
|
231
|
-
(j == 0) ? '' : t_array.map { |x| "typename T#{x}" }.join(', ')
|
232
|
-
member_arg_list =
|
233
|
-
# t_array.map { |x| "typename detail::Copy_Type<T#{x}>::Type t#{x}" }.join(', ')
|
234
|
-
t_array.map { |x| "T#{x} const & t#{x}" }.join(', ')
|
235
|
-
ipp.puts fill_template(ipp_template, {
|
236
|
-
:j => j,
|
237
|
-
:typenames => add_comma + typename_list,
|
238
|
-
:args => add_comma + arg_list,
|
239
|
-
:member_args => add_comma + member_arg_list,
|
240
|
-
:initializers => add_comma + init_list,
|
241
|
-
:member_params => member_param_list,
|
242
|
-
:member_decls => member_decl_list,
|
243
|
-
:types => add_comma + type_list,
|
244
|
-
:params => add_comma + param_list
|
245
|
-
})
|
246
|
-
ipp.puts ''
|
247
|
-
hpp.puts fill_template(hpp_template, {
|
248
|
-
:typenames => add_comma + typename_list,
|
249
|
-
:args => add_comma + arg_list,
|
250
|
-
})
|
251
|
-
hpp.puts ''
|
252
|
-
end
|
253
|
-
end
|
254
|
-
end
|
255
|
-
|
256
|
-
# ======================================================================
|
257
|
-
docstring = <<END
|
258
|
-
|
259
|
-
//! Call the Ruby method specified by 'id' on object 'obj'.
|
260
|
-
/*! Pass in arguments (arg1, arg2, ...). The arguments will be converted to
|
261
|
-
* Ruby objects with to_ruby<>. The return value will automatically be
|
262
|
-
* converted to type Retval_T with from_ruby<>.
|
263
|
-
*
|
264
|
-
* E.g.:
|
265
|
-
* \\code
|
266
|
-
* float y = x.call<float>("foo", z, 42);
|
267
|
-
* \\endcode
|
268
|
-
*/
|
269
|
-
template<typename Retval_T>
|
270
|
-
Retval_T call(Identifier id, T1 arg1, T2 arg2, ...) const;
|
271
|
-
|
272
|
-
//! Version of call which defaults to Object return type.
|
273
|
-
Object call(Identifier id, T1 arg1, T2 arg2, ...) const;
|
274
|
-
END
|
275
|
-
ipp_template = <<END
|
276
|
-
|
277
|
-
%(template)
|
278
|
-
inline Rice::Object Rice::Object::
|
279
|
-
call(Identifier id%(args)) const
|
280
|
-
{
|
281
|
-
VALUE args[] = { %(convert_list) };
|
282
|
-
return protect(rb_funcall2, value(), id, %(j), args);
|
283
|
-
}
|
284
|
-
END
|
285
|
-
hpp_template = <<END
|
286
|
-
%(template)
|
287
|
-
Object call(Identifier id%(args)) const;
|
288
|
-
|
289
|
-
END
|
290
|
-
ipp_head = <<END
|
291
|
-
#include "../protect.hpp"
|
292
|
-
#include "../to_from_ruby.hpp"
|
293
|
-
END
|
294
|
-
ipp_filename = 'detail/object_call.ipp'
|
295
|
-
hpp_filename = 'detail/object_call.hpp'
|
296
|
-
wrap_header(hpp_filename, nil, docstring, false, nil, nil, GENERATED_FILE_WARNING, nil) do |hpp|
|
297
|
-
wrap_header(ipp_filename, nil, nil, false, ipp_head, nil, GENERATED_FILE_WARNING, nil) do |ipp|
|
298
|
-
for j in 0..MAX_ARGS do
|
299
|
-
t_array = (1..j).to_a
|
300
|
-
arg_list = t_array.map { |x| ", T#{x} arg#{x}" }
|
301
|
-
if j == 0 then
|
302
|
-
template = ''
|
303
|
-
convert_list = '';
|
304
|
-
else
|
305
|
-
template = 'template<' + t_array.map { |x| "typename T#{x}" }.join(', ') + '>'
|
306
|
-
convert_list = t_array.map { |x| "to_ruby(arg#{x})" }.join(', ')
|
307
|
-
end
|
308
|
-
ipp.puts fill_template(ipp_template, {
|
309
|
-
:args => arg_list,
|
310
|
-
:convert_list => convert_list,
|
311
|
-
:j => j,
|
312
|
-
:template => template,
|
313
|
-
})
|
314
|
-
ipp.puts
|
315
|
-
hpp.puts fill_template(hpp_template, {
|
316
|
-
:args => arg_list,
|
317
|
-
:template => template,
|
318
|
-
})
|
319
|
-
hpp.puts
|
320
|
-
end
|
321
|
-
end
|
322
|
-
end
|
323
|
-
|
324
|
-
# ======================================================================
|
325
|
-
docstring = <<END
|
326
|
-
END
|
327
|
-
ipp_template = <<END
|
328
|
-
template<typename Func_T, typename Ret_T, %(typename_list)>
|
329
|
-
Auto_Function_Wrapper<Func_T, Ret_T, %(typenames)>::
|
330
|
-
Auto_Function_Wrapper(
|
331
|
-
Func func,
|
332
|
-
Data_Object<Exception_Handler> handler,
|
333
|
-
Arguments* arguments)
|
334
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
335
|
-
, func_(func)
|
336
|
-
, handler_(handler)
|
337
|
-
, handler_guard_(&handler_)
|
338
|
-
{
|
339
|
-
if(arguments == 0) {
|
340
|
-
arguments_ = new Arguments();
|
341
|
-
} else {
|
342
|
-
arguments_ = arguments;
|
343
|
-
}
|
344
|
-
}
|
345
|
-
|
346
|
-
template<typename Func_T, typename Ret_T, %(typename_list)>
|
347
|
-
VALUE Auto_Function_Wrapper<Func_T, Ret_T, %(typenames)>::
|
348
|
-
call(int argc, VALUE *argv, VALUE self)
|
349
|
-
{
|
350
|
-
Auto_Function_Wrapper<Func_T, Ret_T, %(typenames)> * wrapper = 0;
|
351
|
-
try
|
352
|
-
{
|
353
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
354
|
-
wrapper = (Auto_Function_Wrapper<Func_T, Ret_T, %(typenames)> *)data.get();
|
355
|
-
Arguments* args = wrapper->arguments_;
|
356
|
-
|
357
|
-
bool hasSelf = (self && self != Qnil);
|
358
|
-
if(args->count() >= 0) {
|
359
|
-
hasSelf = hasSelf && args->count() == Num_Args - 1;
|
360
|
-
} else {
|
361
|
-
hasSelf = hasSelf && argc == Num_Args -1;
|
362
|
-
}
|
363
|
-
|
364
|
-
VALUE %(scan_def_list);
|
365
|
-
|
366
|
-
if(hasSelf) {
|
367
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args - 1).c_str()
|
368
|
-
%(scan_args_list));
|
369
|
-
|
370
|
-
Arg0_T arg0 = from_ruby<Arg0_T>(self);
|
371
|
-
%(self_arg_convert_list)
|
372
|
-
|
373
|
-
return to_ruby(wrapper->func_(%(arg_list)));
|
374
|
-
} else {
|
375
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
|
376
|
-
%(scan_args_list));
|
377
|
-
|
378
|
-
%(arg_convert_list)
|
379
|
-
|
380
|
-
return to_ruby(wrapper->func_(%(arg_list)));
|
381
|
-
}
|
382
|
-
}
|
383
|
-
catch(...)
|
384
|
-
{
|
385
|
-
RUBY_TRY
|
386
|
-
{
|
387
|
-
if(wrapper)
|
388
|
-
{
|
389
|
-
return wrapper->handler_->handle_exception();
|
390
|
-
}
|
391
|
-
else
|
392
|
-
{
|
393
|
-
throw;
|
394
|
-
}
|
395
|
-
}
|
396
|
-
RUBY_CATCH
|
397
|
-
}
|
398
|
-
}
|
399
|
-
|
400
|
-
template<typename Func_T, %(typename_list)>
|
401
|
-
Auto_Function_Wrapper<Func_T, void, %(typenames)>::
|
402
|
-
Auto_Function_Wrapper(
|
403
|
-
Func func,
|
404
|
-
Data_Object<Exception_Handler> handler,
|
405
|
-
Arguments* arguments)
|
406
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
407
|
-
, func_(func)
|
408
|
-
, handler_(handler)
|
409
|
-
, handler_guard_(&handler_)
|
410
|
-
{
|
411
|
-
if(arguments == 0) {
|
412
|
-
arguments_ = new Arguments();
|
413
|
-
} else {
|
414
|
-
arguments_ = arguments;
|
415
|
-
}
|
416
|
-
}
|
417
|
-
|
418
|
-
template<typename Func_T, %(typename_list)>
|
419
|
-
VALUE Auto_Function_Wrapper<Func_T, void, %(typenames)>::
|
420
|
-
call(int argc, VALUE* argv, VALUE self)
|
421
|
-
{
|
422
|
-
Auto_Function_Wrapper<Func_T, void, %(typenames)> * wrapper = 0;
|
423
|
-
try
|
424
|
-
{
|
425
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
426
|
-
wrapper =
|
427
|
-
(Auto_Function_Wrapper<Func_T, void, %(typenames)> *)data.get();
|
428
|
-
Arguments* args = wrapper->arguments_;
|
429
|
-
|
430
|
-
bool hasSelf = (self && self != Qnil);
|
431
|
-
if(args->count() >= 0) {
|
432
|
-
hasSelf = hasSelf && args->count() == Num_Args - 1;
|
433
|
-
} else {
|
434
|
-
hasSelf = hasSelf && argc == Num_Args -1;
|
435
|
-
}
|
436
|
-
|
437
|
-
VALUE %(scan_def_list);
|
438
|
-
|
439
|
-
if(hasSelf) {
|
440
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args - 1) .c_str()
|
441
|
-
%(scan_args_list));
|
442
|
-
|
443
|
-
Arg0_T arg0 = from_ruby<Arg0_T>(self);
|
444
|
-
%(self_arg_convert_list)
|
445
|
-
|
446
|
-
wrapper->func_(%(arg_list));
|
447
|
-
return Qnil;
|
448
|
-
} else {
|
449
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args).c_str()
|
450
|
-
%(scan_args_list));
|
451
|
-
|
452
|
-
%(arg_convert_list)
|
453
|
-
|
454
|
-
wrapper->func_(%(arg_list));
|
455
|
-
return Qnil;
|
456
|
-
}
|
457
|
-
}
|
458
|
-
catch(...)
|
459
|
-
{
|
460
|
-
RUBY_TRY
|
461
|
-
{
|
462
|
-
if(wrapper)
|
463
|
-
{
|
464
|
-
return wrapper->handler_->handle_exception();
|
465
|
-
}
|
466
|
-
else
|
467
|
-
{
|
468
|
-
throw;
|
469
|
-
}
|
470
|
-
}
|
471
|
-
RUBY_CATCH
|
472
|
-
}
|
473
|
-
}
|
474
|
-
|
475
|
-
// ---------------------------------------------------------------------
|
476
|
-
END
|
477
|
-
|
478
|
-
# ======================================================================
|
479
|
-
# TODO: Should the handler copy the exception handler or keep a pointer
|
480
|
-
# to it?
|
481
|
-
hpp_template = <<END
|
482
|
-
template<typename Func_T, typename Ret_T, %(typename_list_d)>
|
483
|
-
class Auto_Function_Wrapper%(specializations)
|
484
|
-
: public Wrapped_Function
|
485
|
-
{
|
486
|
-
public:
|
487
|
-
// typedef Ret_T (*Func)(%(typenames));
|
488
|
-
typedef Func_T Func;
|
489
|
-
|
490
|
-
static const int Num_Args = %(j);
|
491
|
-
|
492
|
-
Auto_Function_Wrapper(
|
493
|
-
Func func,
|
494
|
-
Data_Object<Exception_Handler> handler,
|
495
|
-
Arguments* arguments = 0);
|
496
|
-
|
497
|
-
static VALUE call(int argc, VALUE* args, VALUE self);
|
498
|
-
|
499
|
-
private:
|
500
|
-
Func func_;
|
501
|
-
Data_Object<Exception_Handler> handler_;
|
502
|
-
Address_Registration_Guard handler_guard_;
|
503
|
-
Arguments* arguments_;
|
504
|
-
};
|
505
|
-
|
506
|
-
template<typename Func_T, %(typename_list)>
|
507
|
-
class Auto_Function_Wrapper<Func_T, void, %(typenames)>
|
508
|
-
: public Wrapped_Function
|
509
|
-
{
|
510
|
-
public:
|
511
|
-
// typedef void (*Func)(%(typenames));
|
512
|
-
typedef Func_T Func;
|
513
|
-
|
514
|
-
static const int Num_Args = %(j);
|
515
|
-
|
516
|
-
Auto_Function_Wrapper(
|
517
|
-
Func func,
|
518
|
-
Data_Object<Exception_Handler> handler,
|
519
|
-
Arguments* arguments = 0);
|
520
|
-
|
521
|
-
static VALUE call(int argc, VALUE* args, VALUE self);
|
522
|
-
|
523
|
-
private:
|
524
|
-
Func func_;
|
525
|
-
Data_Object<Exception_Handler> handler_;
|
526
|
-
Address_Registration_Guard handler_guard_;
|
527
|
-
Arguments* arguments_;
|
528
|
-
};
|
529
|
-
|
530
|
-
// ---------------------------------------------------------------------
|
531
|
-
END
|
532
|
-
hpp_head = <<END
|
533
|
-
#include "Exception_Handler_defn.hpp"
|
534
|
-
|
535
|
-
END
|
536
|
-
ipp_head = <<END
|
537
|
-
#include "method_data.hpp"
|
538
|
-
#include "../ruby_try_catch.hpp"
|
539
|
-
#include "../to_from_ruby.hpp"
|
540
|
-
#include "traits.hpp"
|
541
|
-
END
|
542
|
-
ipp_tail = <<END
|
543
|
-
template<typename Func_T, typename Ret_T>
|
544
|
-
Auto_Function_Wrapper<Func_T, Ret_T>::
|
545
|
-
Auto_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 ? handler : new Default_Exception_Handler)
|
552
|
-
, arguments_(arguments)
|
553
|
-
{
|
554
|
-
}
|
555
|
-
|
556
|
-
template<typename Func_T, typename Ret_T>
|
557
|
-
VALUE Auto_Function_Wrapper<Func_T, Ret_T>::
|
558
|
-
call()
|
559
|
-
{
|
560
|
-
Auto_Function_Wrapper<Func_T, Ret_T> * wrapper = 0;
|
561
|
-
try
|
562
|
-
{
|
563
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
564
|
-
wrapper = (Auto_Function_Wrapper<Func_T, Ret_T>*)data.get();
|
565
|
-
|
566
|
-
return to_ruby(wrapper->func_());
|
567
|
-
}
|
568
|
-
catch(...)
|
569
|
-
{
|
570
|
-
RUBY_TRY
|
571
|
-
{
|
572
|
-
if(wrapper)
|
573
|
-
{
|
574
|
-
return wrapper->handler_->handle_exception();
|
575
|
-
}
|
576
|
-
else
|
577
|
-
{
|
578
|
-
throw;
|
579
|
-
}
|
580
|
-
}
|
581
|
-
RUBY_CATCH
|
582
|
-
}
|
583
|
-
}
|
584
|
-
|
585
|
-
template<typename Func_T>
|
586
|
-
Auto_Function_Wrapper<Func_T, void>::
|
587
|
-
Auto_Function_Wrapper(
|
588
|
-
Func func,
|
589
|
-
Data_Object<Exception_Handler> handler,
|
590
|
-
Arguments* arguments)
|
591
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
592
|
-
, func_(func)
|
593
|
-
, handler_(handler ? handler : new Default_Exception_Handler)
|
594
|
-
, arguments_(arguments)
|
595
|
-
{
|
596
|
-
}
|
597
|
-
|
598
|
-
template<typename Func_T>
|
599
|
-
VALUE Auto_Function_Wrapper<Func_T, void>::
|
600
|
-
call()
|
601
|
-
{
|
602
|
-
Auto_Function_Wrapper<Func_T, void> * wrapper = 0;
|
603
|
-
try
|
604
|
-
{
|
605
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
606
|
-
wrapper =
|
607
|
-
(Auto_Function_Wrapper<Func_T, void> *)data.get();
|
608
|
-
|
609
|
-
wrapper->func_();
|
610
|
-
return Qnil;
|
611
|
-
}
|
612
|
-
catch(...)
|
613
|
-
{
|
614
|
-
RUBY_TRY
|
615
|
-
{
|
616
|
-
if(wrapper)
|
617
|
-
{
|
618
|
-
return wrapper->handler_->handle_exception();
|
619
|
-
}
|
620
|
-
else
|
621
|
-
{
|
622
|
-
throw;
|
623
|
-
}
|
624
|
-
}
|
625
|
-
RUBY_CATCH
|
626
|
-
}
|
627
|
-
}
|
628
|
-
END
|
629
|
-
hpp_tail = <<END
|
630
|
-
|
631
|
-
template<typename Func_T, typename Ret_T>
|
632
|
-
class Auto_Function_Wrapper<Func_T, Ret_T>
|
633
|
-
: public Wrapped_Function
|
634
|
-
{
|
635
|
-
public:
|
636
|
-
// typedef void (*Func)();
|
637
|
-
typedef Func_T Func;
|
638
|
-
|
639
|
-
static const int Num_Args = 0;
|
640
|
-
|
641
|
-
Auto_Function_Wrapper(
|
642
|
-
Func func,
|
643
|
-
Data_Object<Exception_Handler> handler,
|
644
|
-
Arguments* arguments = new Arguments());
|
645
|
-
|
646
|
-
static VALUE call();
|
647
|
-
|
648
|
-
private:
|
649
|
-
Func func_;
|
650
|
-
Data_Object<Exception_Handler> handler_;
|
651
|
-
Arguments* arguments_;
|
652
|
-
};
|
653
|
-
|
654
|
-
template<typename Func_T>
|
655
|
-
class Auto_Function_Wrapper<Func_T, void>
|
656
|
-
: public Wrapped_Function
|
657
|
-
{
|
658
|
-
public:
|
659
|
-
// typedef void (*Func)();
|
660
|
-
typedef Func_T Func;
|
661
|
-
|
662
|
-
static const int Num_Args = 0;
|
663
|
-
|
664
|
-
Auto_Function_Wrapper(
|
665
|
-
Func func,
|
666
|
-
Data_Object<Exception_Handler> handler,
|
667
|
-
Arguments* arguments = new Arguments());
|
668
|
-
|
669
|
-
static VALUE call();
|
670
|
-
|
671
|
-
private:
|
672
|
-
Func func_;
|
673
|
-
Data_Object<Exception_Handler> handler_;
|
674
|
-
Arguments* arguments_;
|
675
|
-
};
|
676
|
-
END
|
677
|
-
ipp_filename = 'detail/Auto_Function_Wrapper.ipp'
|
678
|
-
hpp_filename = 'detail/Auto_Function_Wrapper.hpp'
|
679
|
-
wrap_header(hpp_filename, 'Rice::detail', docstring, true, hpp_head) do |hpp|
|
680
|
-
wrap_header(ipp_filename, 'Rice::detail', nil, false, ipp_head) do |ipp|
|
681
|
-
MAX_ARGS.downto(0) do |j|
|
682
|
-
t_array = (0..j).to_a
|
683
|
-
scan_def_list = t_array.map { |x| "varg#{x}" }.join(', ')
|
684
|
-
arg_def_list = t_array.map { |x| "Arg#{x}_T arg#{x};"}
|
685
|
-
arg_list = t_array.map { |x| "arg#{x}" }.join(', ')
|
686
|
-
scan_args_list = t_array.map { |x| ", &varg#{x}"}
|
687
|
-
typenames = t_array.map { |x| "Arg#{x}_T" }.join(', ')
|
688
|
-
arg_convert_list = t_array.map do |x|
|
689
|
-
"typedef typename sanitize< Arg#{x}_T >::Type Arg#{x}_Type;\n\t\t" +
|
690
|
-
"Arg#{x}_Type arg#{x} = args->getArgumentOrDefault<Arg#{x}_Type>(#{x}, varg#{x});"
|
691
|
-
end.join("\n\t\t\t")
|
692
|
-
self_arg_convert_list = (0...j).to_a.map do |x|
|
693
|
-
n = x + 1
|
694
|
-
"typedef typename sanitize< Arg#{n}_T >::Type Arg#{n}_Type;\n\t\t" +
|
695
|
-
"Arg#{n}_Type arg#{n} = args->getArgumentOrDefault<Arg#{n}_Type>(#{x}, varg#{x});"
|
696
|
-
end.join("\n\t\t\t")
|
697
|
-
if j == MAX_ARGS then
|
698
|
-
typename_list = t_array.map { |x| "typename Arg#{x}_T" }.join(', ')
|
699
|
-
typename_list_d = t_array.map { |x| "typename Arg#{x}_T = void" }.join(', ')
|
700
|
-
specializations = ''
|
701
|
-
else
|
702
|
-
typename_list = t_array.map { |x| "typename Arg#{x}_T" }.join(', ')
|
703
|
-
typename_list_d = typename_list
|
704
|
-
specializations = "<Func_T, Ret_T, #{typenames}>"
|
705
|
-
end
|
706
|
-
ipp.puts fill_template(ipp_template, {
|
707
|
-
:scan_def_list => scan_def_list,
|
708
|
-
:arg_list => arg_list,
|
709
|
-
:typenames => typenames,
|
710
|
-
:typename_list => typename_list,
|
711
|
-
:arg_convert_list => arg_convert_list,
|
712
|
-
:scan_args_list => scan_args_list,
|
713
|
-
:self_arg_convert_list => self_arg_convert_list,
|
714
|
-
})
|
715
|
-
hpp.puts fill_template(hpp_template, {
|
716
|
-
:typenames => typenames,
|
717
|
-
:typename_list_d => typename_list_d,
|
718
|
-
:typename_list => typename_list,
|
719
|
-
:j => j + 1,
|
720
|
-
:specializations => specializations,
|
721
|
-
})
|
722
|
-
end
|
723
|
-
ipp.puts ipp_tail
|
724
|
-
hpp.puts hpp_tail
|
725
|
-
end
|
726
|
-
end
|
727
|
-
|
728
|
-
# ======================================================================
|
729
|
-
# TODO: Can I add another call() that works if from_ruby is defined
|
730
|
-
# for a reference to self instead of a pointer to self (and same for
|
731
|
-
# const reference and const pointer?)
|
732
|
-
docstring = <<END
|
733
|
-
END
|
734
|
-
ipp_template = <<END
|
735
|
-
template<typename Func_T, typename Ret_T, typename Self_T%(typename_list)>
|
736
|
-
Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T%(typenames)>::
|
737
|
-
Auto_Member_Function_Wrapper(
|
738
|
-
Func func,
|
739
|
-
Data_Object<Exception_Handler> handler,
|
740
|
-
Arguments* arguments)
|
741
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
742
|
-
, func_(func)
|
743
|
-
, handler_(handler)
|
744
|
-
, handler_guard_(&handler_)
|
745
|
-
, arguments_(arguments)
|
746
|
-
{
|
747
|
-
if(arguments == 0) {
|
748
|
-
arguments_ = new Arguments();
|
749
|
-
} else {
|
750
|
-
arguments_ = arguments;
|
751
|
-
}
|
752
|
-
}
|
753
|
-
|
754
|
-
template<typename Func_T, typename Ret_T, typename Self_T%(typename_list)>
|
755
|
-
VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T%(typenames)>::
|
756
|
-
call(int argc, VALUE* argv, VALUE self)
|
757
|
-
{
|
758
|
-
Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T%(typenames)> * wrapper = 0;
|
759
|
-
try
|
760
|
-
{
|
761
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
762
|
-
wrapper =
|
763
|
-
(Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T%(typenames)> *)data.get();
|
764
|
-
Arguments* args = wrapper->arguments_;
|
765
|
-
|
766
|
-
VALUE %(scan_def_list);
|
767
|
-
|
768
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(),
|
769
|
-
%(scan_args_list));
|
770
|
-
|
771
|
-
Self_T * obj = from_ruby<Self_T *>(self);
|
772
|
-
%(arg_convert_list)
|
773
|
-
|
774
|
-
Func func = wrapper->func_;
|
775
|
-
return to_ruby((*obj.*func)(%(arg_list)));
|
776
|
-
}
|
777
|
-
catch(...)
|
778
|
-
{
|
779
|
-
RUBY_TRY
|
780
|
-
{
|
781
|
-
if(wrapper)
|
782
|
-
{
|
783
|
-
return wrapper->handler_->handle_exception();
|
784
|
-
}
|
785
|
-
else
|
786
|
-
{
|
787
|
-
throw;
|
788
|
-
}
|
789
|
-
}
|
790
|
-
RUBY_CATCH
|
791
|
-
}
|
792
|
-
}
|
793
|
-
|
794
|
-
template<typename Func_T, typename Self_T%(typename_list)>
|
795
|
-
Auto_Member_Function_Wrapper<Func_T, void, Self_T%(typenames)>::
|
796
|
-
Auto_Member_Function_Wrapper(
|
797
|
-
Func func,
|
798
|
-
Data_Object<Exception_Handler> handler,
|
799
|
-
Arguments* arguments)
|
800
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
801
|
-
, func_(func)
|
802
|
-
, handler_(handler)
|
803
|
-
, handler_guard_(&handler_)
|
804
|
-
, arguments_(arguments)
|
805
|
-
{
|
806
|
-
if(arguments == 0) {
|
807
|
-
arguments_ = new Arguments();
|
808
|
-
} else {
|
809
|
-
arguments_ = arguments;
|
810
|
-
}
|
811
|
-
}
|
812
|
-
|
813
|
-
template<typename Func_T, typename Self_T%(typename_list)>
|
814
|
-
VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_T%(typenames)>::
|
815
|
-
call(int argc, VALUE* argv, VALUE self)
|
816
|
-
{
|
817
|
-
Auto_Member_Function_Wrapper<Func_T, void, Self_T%(typenames)> * wrapper = 0;
|
818
|
-
try
|
819
|
-
{
|
820
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
821
|
-
wrapper =
|
822
|
-
(Auto_Member_Function_Wrapper<Func_T, void, Self_T%(typenames)> *)data.get();
|
823
|
-
Arguments* args = wrapper->arguments_;
|
824
|
-
|
825
|
-
VALUE %(scan_def_list);
|
826
|
-
|
827
|
-
rb_scan_args(argc, argv, args->formatString(Num_Args).c_str(),
|
828
|
-
%(scan_args_list));
|
829
|
-
|
830
|
-
Self_T * obj = from_ruby<Self_T *>(self);
|
831
|
-
%(arg_convert_list)
|
832
|
-
|
833
|
-
Func func = wrapper->func_;
|
834
|
-
(*obj.*func)(%(arg_list));
|
835
|
-
return Qnil;
|
836
|
-
}
|
837
|
-
catch(...)
|
838
|
-
{
|
839
|
-
RUBY_TRY
|
840
|
-
{
|
841
|
-
if(wrapper)
|
842
|
-
{
|
843
|
-
return wrapper->handler_->handle_exception();
|
844
|
-
}
|
845
|
-
else
|
846
|
-
{
|
847
|
-
throw;
|
848
|
-
}
|
849
|
-
}
|
850
|
-
RUBY_CATCH
|
851
|
-
}
|
852
|
-
}
|
853
|
-
|
854
|
-
// ---------------------------------------------------------------------
|
855
|
-
END
|
856
|
-
ipp_tail = <<END
|
857
|
-
template<typename Func_T, typename Ret_T, typename Self_T>
|
858
|
-
Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T>::
|
859
|
-
Auto_Member_Function_Wrapper(
|
860
|
-
Func func,
|
861
|
-
Data_Object<Exception_Handler> handler,
|
862
|
-
Arguments* arguments)
|
863
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
864
|
-
, func_(func)
|
865
|
-
, handler_(handler)
|
866
|
-
, handler_guard_(&handler_)
|
867
|
-
, arguments_(arguments)
|
868
|
-
{
|
869
|
-
if(arguments == 0) {
|
870
|
-
arguments_ = new Arguments();
|
871
|
-
} else {
|
872
|
-
arguments_ = arguments;
|
873
|
-
}
|
874
|
-
}
|
875
|
-
|
876
|
-
template<typename Func_T, typename Ret_T, typename Self_T>
|
877
|
-
VALUE Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T>::
|
878
|
-
call(int argc, VALUE* argv, VALUE self)
|
879
|
-
{
|
880
|
-
Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T> * wrapper = 0;
|
881
|
-
try
|
882
|
-
{
|
883
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
884
|
-
wrapper =
|
885
|
-
(Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T> *)data.get();
|
886
|
-
|
887
|
-
rb_scan_args(argc, argv, "0");
|
888
|
-
Self_T * obj = from_ruby<Self_T *>(self);
|
889
|
-
|
890
|
-
Func func = wrapper->func_;
|
891
|
-
return to_ruby((*obj.*func)());
|
892
|
-
}
|
893
|
-
catch(...)
|
894
|
-
{
|
895
|
-
RUBY_TRY
|
896
|
-
{
|
897
|
-
if(wrapper)
|
898
|
-
{
|
899
|
-
return wrapper->handler_->handle_exception();
|
900
|
-
}
|
901
|
-
else
|
902
|
-
{
|
903
|
-
throw;
|
904
|
-
}
|
905
|
-
}
|
906
|
-
RUBY_CATCH
|
907
|
-
}
|
908
|
-
}
|
909
|
-
|
910
|
-
template<typename Func_T, typename Self_T>
|
911
|
-
Auto_Member_Function_Wrapper<Func_T, void, Self_T>::
|
912
|
-
Auto_Member_Function_Wrapper(
|
913
|
-
Func func,
|
914
|
-
Data_Object<Exception_Handler> handler,
|
915
|
-
Arguments* arguments)
|
916
|
-
: Wrapped_Function(RUBY_METHOD_FUNC(call), Num_Args)
|
917
|
-
, func_(func)
|
918
|
-
, handler_(handler)
|
919
|
-
, handler_guard_(&handler_)
|
920
|
-
, arguments_(arguments)
|
921
|
-
{
|
922
|
-
if(arguments == 0) {
|
923
|
-
arguments_ = new Arguments();
|
924
|
-
} else {
|
925
|
-
arguments_ = arguments;
|
926
|
-
}
|
927
|
-
}
|
928
|
-
|
929
|
-
template<typename Func_T, typename Self_T>
|
930
|
-
VALUE Auto_Member_Function_Wrapper<Func_T, void, Self_T>::
|
931
|
-
call(int argc, VALUE* argv, VALUE self)
|
932
|
-
{
|
933
|
-
Auto_Member_Function_Wrapper<Func_T, void, Self_T> * wrapper = 0;
|
934
|
-
try
|
935
|
-
{
|
936
|
-
Data_Object<Wrapped_Function> data(detail::method_data());
|
937
|
-
wrapper =
|
938
|
-
(Auto_Member_Function_Wrapper<Func_T, void, Self_T> *)data.get();
|
939
|
-
rb_scan_args(argc, argv, "0");
|
940
|
-
Self_T * obj = from_ruby<Self_T *>(self);
|
941
|
-
|
942
|
-
Func func = wrapper->func_;
|
943
|
-
(*obj.*func)();
|
944
|
-
return Qnil;
|
945
|
-
}
|
946
|
-
catch(...)
|
947
|
-
{
|
948
|
-
RUBY_TRY
|
949
|
-
{
|
950
|
-
if(wrapper)
|
951
|
-
{
|
952
|
-
return wrapper->handler_->handle_exception();
|
953
|
-
}
|
954
|
-
else
|
955
|
-
{
|
956
|
-
throw;
|
957
|
-
}
|
958
|
-
}
|
959
|
-
RUBY_CATCH
|
960
|
-
}
|
961
|
-
}
|
962
|
-
|
963
|
-
// ---------------------------------------------------------------------
|
964
|
-
END
|
965
|
-
hpp_template = <<END
|
966
|
-
template<typename Func_T, typename Ret_T, typename Self_T%(typename_list_d)>
|
967
|
-
class Auto_Member_Function_Wrapper%(specializations)
|
968
|
-
: public Wrapped_Function
|
969
|
-
{
|
970
|
-
public:
|
971
|
-
typedef Func_T Func;
|
972
|
-
|
973
|
-
static const int Num_Args = %(j);
|
974
|
-
|
975
|
-
Auto_Member_Function_Wrapper(
|
976
|
-
Func func,
|
977
|
-
Data_Object<Exception_Handler> handler,
|
978
|
-
Arguments* arguments = 0);
|
979
|
-
|
980
|
-
static VALUE call(int argc, VALUE* argv, VALUE self);
|
981
|
-
|
982
|
-
private:
|
983
|
-
Func func_;
|
984
|
-
Data_Object<Exception_Handler> handler_;
|
985
|
-
Address_Registration_Guard handler_guard_;
|
986
|
-
Arguments* arguments_;
|
987
|
-
};
|
988
|
-
|
989
|
-
template<typename Func_T, typename Self_T%(typename_list)>
|
990
|
-
class Auto_Member_Function_Wrapper<Func_T, void, Self_T%(typenames)>
|
991
|
-
: public Wrapped_Function
|
992
|
-
{
|
993
|
-
public:
|
994
|
-
typedef Func_T Func;
|
995
|
-
|
996
|
-
static const int Num_Args = %(j);
|
997
|
-
|
998
|
-
Auto_Member_Function_Wrapper(
|
999
|
-
Func func,
|
1000
|
-
Data_Object<Exception_Handler> handler,
|
1001
|
-
Arguments* arguments = 0);
|
1002
|
-
|
1003
|
-
static VALUE call(int argc, VALUE* argv, VALUE self);
|
1004
|
-
|
1005
|
-
private:
|
1006
|
-
Func func_;
|
1007
|
-
Data_Object<Exception_Handler> handler_;
|
1008
|
-
Address_Registration_Guard handler_guard_;
|
1009
|
-
Arguments* arguments_;
|
1010
|
-
};
|
1011
|
-
|
1012
|
-
// ---------------------------------------------------------------------
|
1013
|
-
END
|
1014
|
-
hpp_tail = <<END
|
1015
|
-
template<typename Func_T, typename Ret_T, typename Self_T>
|
1016
|
-
class Auto_Member_Function_Wrapper<Func_T, Ret_T, Self_T>
|
1017
|
-
: public Wrapped_Function
|
1018
|
-
{
|
1019
|
-
public:
|
1020
|
-
typedef Func_T Func;
|
1021
|
-
|
1022
|
-
static const int Num_Args = 0;
|
1023
|
-
|
1024
|
-
Auto_Member_Function_Wrapper(
|
1025
|
-
Func func,
|
1026
|
-
Data_Object<Exception_Handler> handler,
|
1027
|
-
Arguments* arguments = 0);
|
1028
|
-
|
1029
|
-
static VALUE call(int argc, VALUE* argv, VALUE self);
|
1030
|
-
|
1031
|
-
private:
|
1032
|
-
Func func_;
|
1033
|
-
Data_Object<Exception_Handler> handler_;
|
1034
|
-
Address_Registration_Guard handler_guard_;
|
1035
|
-
Arguments* arguments_;
|
1036
|
-
};
|
1037
|
-
|
1038
|
-
template<typename Func_T, typename Self_T>
|
1039
|
-
class Auto_Member_Function_Wrapper<Func_T, void, Self_T>
|
1040
|
-
: public Wrapped_Function
|
1041
|
-
{
|
1042
|
-
public:
|
1043
|
-
typedef Func_T Func;
|
1044
|
-
|
1045
|
-
static const int Num_Args = 0;
|
1046
|
-
|
1047
|
-
Auto_Member_Function_Wrapper(
|
1048
|
-
Func func,
|
1049
|
-
Data_Object<Exception_Handler> handler,
|
1050
|
-
Arguments* arguments = 0);
|
1051
|
-
|
1052
|
-
static VALUE call(int argc, VALUE* argv, VALUE self);
|
1053
|
-
|
1054
|
-
private:
|
1055
|
-
Func func_;
|
1056
|
-
Data_Object<Exception_Handler> handler_;
|
1057
|
-
Address_Registration_Guard handler_guard_;
|
1058
|
-
Arguments* arguments_;
|
1059
|
-
};
|
1060
|
-
|
1061
|
-
// ---------------------------------------------------------------------
|
1062
|
-
END
|
1063
|
-
ipp_head = <<END
|
1064
|
-
#include "method_data.hpp"
|
1065
|
-
#include "../ruby_try_catch.hpp"
|
1066
|
-
#include "../to_from_ruby.hpp"
|
1067
|
-
#include "traits.hpp"
|
1068
|
-
#include <typeinfo>
|
1069
|
-
END
|
1070
|
-
ipp_filename = 'detail/Auto_Member_Function_Wrapper.ipp'
|
1071
|
-
hpp_filename = 'detail/Auto_Member_Function_Wrapper.hpp'
|
1072
|
-
wrap_header(hpp_filename, 'Rice::detail', docstring, true) do |hpp|
|
1073
|
-
wrap_header(ipp_filename, 'Rice::detail', nil, false, ipp_head) do |ipp|
|
1074
|
-
MAX_ARGS.downto(0) do |j|
|
1075
|
-
t_array = (0..j).to_a
|
1076
|
-
scan_def_list = t_array.map { |x| "varg#{x}" }.join(', ')
|
1077
|
-
arg_list = t_array.map { |x| "arg#{x}" }.join(', ')
|
1078
|
-
scan_args_list = t_array.map { |x| "&varg#{x}"}.join(', ')
|
1079
|
-
typenames = t_array.map { |x| ", Arg#{x}_T" }
|
1080
|
-
typenames_n = t_array.map { |x| "Arg#{x}_T" }.join(', ')
|
1081
|
-
arg_convert_list = t_array.map do |x|
|
1082
|
-
"typedef typename sanitize< Arg#{x}_T >::Type Arg#{x}_Type;\n\t\t" +
|
1083
|
-
"Arg#{x}_Type arg#{x} = args->getArgumentOrDefault<Arg#{x}_Type>(#{x}, varg#{x});"
|
1084
|
-
end.join("\n\t\t")
|
1085
|
-
if j == MAX_ARGS then
|
1086
|
-
typename_list = t_array.map { |x| ", typename Arg#{x}_T" }.join
|
1087
|
-
typename_list_d = t_array.map { |x| ", typename Arg#{x}_T = void" }.join
|
1088
|
-
specializations = ''
|
1089
|
-
else
|
1090
|
-
typename_list = t_array.map { |x| ", typename Arg#{x}_T" }.join
|
1091
|
-
typename_list_d = typename_list
|
1092
|
-
specializations = "<Func_T, Ret_T, Self_T#{typenames}>"
|
1093
|
-
end
|
1094
|
-
ipp.puts fill_template(ipp_template, {
|
1095
|
-
:scan_def_list => scan_def_list,
|
1096
|
-
:arg_list => arg_list,
|
1097
|
-
:typenames => typenames,
|
1098
|
-
:typename_list => typename_list,
|
1099
|
-
:scan_args_list => scan_args_list,
|
1100
|
-
:arg_convert_list => arg_convert_list,
|
1101
|
-
})
|
1102
|
-
hpp.puts fill_template(hpp_template, {
|
1103
|
-
:typenames => typenames,
|
1104
|
-
:typename_list => typename_list,
|
1105
|
-
:typename_list_d => typename_list_d,
|
1106
|
-
:j => j + 1,
|
1107
|
-
:specializations => specializations,
|
1108
|
-
})
|
1109
|
-
end
|
1110
|
-
hpp.puts hpp_tail
|
1111
|
-
ipp.puts ipp_tail
|
1112
|
-
end
|
1113
|
-
end
|
1114
|
-
|
1115
|
-
docstring = <<END
|
1116
|
-
END
|
1117
|
-
ipp_template = <<END
|
1118
|
-
template<typename Ret_T, %(typename_list)>
|
1119
|
-
Wrapped_Function * wrap_function(
|
1120
|
-
Ret_T (*func)(%(typenames)),
|
1121
|
-
Data_Object<Exception_Handler> handler,
|
1122
|
-
Arguments* arguments)
|
1123
|
-
{
|
1124
|
-
typedef Ret_T (*Func)(%(typenames));
|
1125
|
-
return new Auto_Function_Wrapper<Func, Ret_T, %(typenames)>(func, handler, arguments);
|
1126
|
-
}
|
1127
|
-
|
1128
|
-
template<typename Ret_T, typename Self_T%(typename_list_no_self)>
|
1129
|
-
Wrapped_Function * wrap_function(
|
1130
|
-
Ret_T (Self_T::*func)(%(typenames_no_self_no_comma)),
|
1131
|
-
Data_Object<Exception_Handler> handler,
|
1132
|
-
Arguments* arguments)
|
1133
|
-
{
|
1134
|
-
typedef Ret_T (Self_T::*Func)(%(typenames_no_self_no_comma));
|
1135
|
-
return new Auto_Member_Function_Wrapper<Func, Ret_T, Self_T%(typenames_no_self)>(func, handler, arguments);
|
1136
|
-
}
|
1137
|
-
|
1138
|
-
template<typename Ret_T, typename Self_T%(typename_list_no_self)>
|
1139
|
-
Wrapped_Function * wrap_function(
|
1140
|
-
Ret_T (Self_T::*func)(%(typenames_no_self_no_comma)) const,
|
1141
|
-
Data_Object<Exception_Handler> handler,
|
1142
|
-
Arguments* arguments)
|
1143
|
-
{
|
1144
|
-
typedef Ret_T (Self_T::*Func)(%(typenames_no_self_no_comma)) const;
|
1145
|
-
return new Auto_Member_Function_Wrapper<Func, Ret_T, Self_T%(typenames_no_self)>(func, handler, arguments);
|
1146
|
-
}
|
1147
|
-
|
1148
|
-
// ---------------------------------------------------------------------
|
1149
|
-
END
|
1150
|
-
hpp_template = <<END
|
1151
|
-
template<typename Ret_T, %(typename_list)>
|
1152
|
-
Wrapped_Function * wrap_function(
|
1153
|
-
Ret_T (*func)(%(typenames)),
|
1154
|
-
Data_Object<Exception_Handler> handler = Rice::Nil,
|
1155
|
-
Arguments* arguments = 0);
|
1156
|
-
|
1157
|
-
template<typename Ret_T, typename Self_T%(typename_list_no_self)>
|
1158
|
-
Wrapped_Function * wrap_function(
|
1159
|
-
Ret_T (Self_T::*func)(%(typenames_no_self_no_comma)),
|
1160
|
-
Data_Object<Exception_Handler> handler = Rice::Nil,
|
1161
|
-
Arguments* arguments = 0);
|
1162
|
-
|
1163
|
-
template<typename Ret_T, typename Self_T%(typename_list_no_self)>
|
1164
|
-
Wrapped_Function * wrap_function(
|
1165
|
-
Ret_T (Self_T::*func)(%(typenames_no_self_no_comma)) const,
|
1166
|
-
Data_Object<Exception_Handler> handler = Rice::Nil,
|
1167
|
-
Arguments* arguments = 0);
|
1168
|
-
|
1169
|
-
// ---------------------------------------------------------------------
|
1170
|
-
END
|
1171
|
-
hpp_head = <<END
|
1172
|
-
#include "Exception_Handler.hpp"
|
1173
|
-
#include "Wrapped_Function.hpp"
|
1174
|
-
#include "../Object_defn.hpp"
|
1175
|
-
#include "../Data_Object.hpp"
|
1176
|
-
#include "Arguments.hpp"
|
1177
|
-
|
1178
|
-
END
|
1179
|
-
hpp_start = <<END
|
1180
|
-
template<typename Ret_T>
|
1181
|
-
Wrapped_Function * wrap_function(
|
1182
|
-
Ret_T (*func)(),
|
1183
|
-
Data_Object<Exception_Handler> handler = Rice::Nil,
|
1184
|
-
Arguments* arguments = 0);
|
1185
|
-
|
1186
|
-
END
|
1187
|
-
ipp_head = <<END
|
1188
|
-
#include "Auto_Function_Wrapper.hpp"
|
1189
|
-
#include "Auto_Member_Function_Wrapper.hpp"
|
1190
|
-
END
|
1191
|
-
ipp_start = <<END
|
1192
|
-
template<typename Ret_T>
|
1193
|
-
Wrapped_Function * wrap_function(
|
1194
|
-
Ret_T (*func)(),
|
1195
|
-
Data_Object<Exception_Handler> handler,
|
1196
|
-
Arguments* arguments)
|
1197
|
-
{
|
1198
|
-
typedef Ret_T (*Func)();
|
1199
|
-
return new Auto_Function_Wrapper<Func, Ret_T>(func, handler, arguments);
|
1200
|
-
}
|
1201
|
-
|
1202
|
-
END
|
1203
|
-
ipp_filename = 'detail/wrap_function.ipp'
|
1204
|
-
hpp_filename = 'detail/wrap_function.hpp'
|
1205
|
-
wrap_header(hpp_filename, 'Rice::detail', docstring, true, hpp_head) do |hpp|
|
1206
|
-
wrap_header(ipp_filename, 'Rice::detail', nil, false, ipp_head) do |ipp|
|
1207
|
-
ipp.puts ipp_start
|
1208
|
-
hpp.puts hpp_start
|
1209
|
-
for j in 0..MAX_ARGS do
|
1210
|
-
t_array = (0..j).to_a
|
1211
|
-
typenames = t_array.map { |x| "Arg#{x}_T" }.join(', ')
|
1212
|
-
typename_list = t_array.map { |x| "typename Arg#{x}_T" }.join(', ')
|
1213
|
-
t_array.shift
|
1214
|
-
typenames_no_self = t_array.map { |x| ", Arg#{x}_T" }
|
1215
|
-
typename_list_no_self = t_array.map { |x| ", typename Arg#{x}_T" }
|
1216
|
-
typenames_no_self_no_comma = typenames_no_self.to_s.sub(', ', '')
|
1217
|
-
ipp.puts fill_template(ipp_template, {
|
1218
|
-
:typenames => typenames,
|
1219
|
-
:typename_list => typename_list,
|
1220
|
-
:typenames_no_self => typenames_no_self,
|
1221
|
-
:typename_list_no_self => typename_list_no_self,
|
1222
|
-
:typenames_no_self_no_comma => typenames_no_self_no_comma,
|
1223
|
-
})
|
1224
|
-
hpp.puts fill_template(hpp_template, {
|
1225
|
-
:typenames => typenames,
|
1226
|
-
:typename_list => typename_list,
|
1227
|
-
:typename_list_no_self => typename_list_no_self,
|
1228
|
-
:typenames_no_self_no_comma => typenames_no_self_no_comma,
|
1229
|
-
})
|
1230
|
-
end
|
1231
|
-
end
|
1232
|
-
end
|
1233
|
-
|
1234
|
-
# ======================================================================
|
1235
|
-
# TODO: we have to implement this function in the class definition due
|
1236
|
-
# to a bug in g++
|
1237
|
-
void_list = (0..MAX_ARGS).to_a.map { |x| ", typename Arg#{x}_T=void" }
|
1238
|
-
hpp_start = <<END
|
1239
|
-
template<typename T#{void_list}>
|
1240
|
-
class Constructor
|
1241
|
-
{
|
1242
|
-
private:
|
1243
|
-
Constructor()
|
1244
|
-
{
|
1245
|
-
}
|
1246
|
-
};
|
1247
|
-
|
1248
|
-
END
|
1249
|
-
hpp_template = <<END
|
1250
|
-
template<typename T%(typename_list)>
|
1251
|
-
class Constructor<T%(type_list)%(void_list)>
|
1252
|
-
{
|
1253
|
-
public:
|
1254
|
-
static void construct(Object self%(arg_list))
|
1255
|
-
{
|
1256
|
-
DATA_PTR(self.value()) = new T(%(arg_names));
|
1257
|
-
}
|
1258
|
-
};
|
1259
|
-
|
1260
|
-
END
|
1261
|
-
|
1262
|
-
hpp_self_template = <<END
|
1263
|
-
template<typename T%(typename_list)>
|
1264
|
-
class Constructor<T, Object%(type_list)%(void_list)>
|
1265
|
-
{
|
1266
|
-
public:
|
1267
|
-
static void construct(Object self%(arg_list))
|
1268
|
-
{
|
1269
|
-
DATA_PTR(self.value()) = new T(self%(arg_names));
|
1270
|
-
}
|
1271
|
-
};
|
1272
|
-
|
1273
|
-
END
|
1274
|
-
hpp_head = <<END
|
1275
|
-
#include "to_from_ruby_defn.hpp"
|
1276
|
-
#include "detail/method_data.hpp"
|
1277
|
-
END
|
1278
|
-
hpp_filename = 'Constructor.hpp'
|
1279
|
-
wrap_header(hpp_filename, 'Rice', nil, false, hpp_head) do |hpp|
|
1280
|
-
hpp.puts hpp_start
|
1281
|
-
for j in 0..MAX_ARGS do
|
1282
|
-
t_array = (1..j).to_a
|
1283
|
-
o_array = (j..MAX_ARGS).to_a
|
1284
|
-
typename_list = t_array.map { |x| ", typename Arg#{x}_T" }
|
1285
|
-
type_list = t_array.map { |x| ", Arg#{x}_T" }
|
1286
|
-
void_list = o_array.map { |x| ", void" }
|
1287
|
-
|
1288
|
-
arg_list = t_array.map { |x| ", Arg#{x}_T arg#{x}" }
|
1289
|
-
arg_names = t_array.map { |x| "arg#{x}" }.join(', ')
|
1290
|
-
|
1291
|
-
hpp.puts fill_template(hpp_template, {
|
1292
|
-
:typename_list => typename_list,
|
1293
|
-
:type_list => type_list,
|
1294
|
-
:void_list => void_list,
|
1295
|
-
:arg_list => arg_list,
|
1296
|
-
:arg_names => arg_names
|
1297
|
-
})
|
1298
|
-
end
|
1299
|
-
|
1300
|
-
# For the self / Director system
|
1301
|
-
for j in 0..(MAX_ARGS - 1) do
|
1302
|
-
t_array = (1..j).to_a
|
1303
|
-
o_array = (j..(MAX_ARGS - 1)).to_a
|
1304
|
-
typename_list = t_array.map { |x| ", typename Arg#{x}_T" }
|
1305
|
-
type_list = t_array.map { |x| ", Arg#{x}_T" }
|
1306
|
-
void_list = o_array.map { |x| ", void" }
|
1307
|
-
|
1308
|
-
arg_list = t_array.map { |x| ", Arg#{x}_T arg#{x}" }
|
1309
|
-
arg_names = t_array.map { |x| ", arg#{x}" }
|
1310
|
-
|
1311
|
-
hpp.puts fill_template(hpp_self_template, {
|
1312
|
-
:typename_list => typename_list,
|
1313
|
-
:type_list => type_list,
|
1314
|
-
:void_list => void_list,
|
1315
|
-
:arg_list => arg_list,
|
1316
|
-
:arg_names => arg_names
|
1317
|
-
})
|
1318
|
-
end
|
1319
|
-
end
|
1320
|
-
|
1321
|
-
if ARGV[0] == '--clean' then
|
1322
|
-
$filenames.each do |filename|
|
1323
|
-
File.rm_f(filename)
|
1324
|
-
end
|
1325
|
-
end
|
1326
|
-
|
1327
|
-
end # if __FILE__ == $0 then
|
1328
|
-
|