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.
@@ -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
-