1 #if 0 /* -*-perl-*- */
2
3 # /*
4 # $Id$
5 #
6 # This header file was automatically generated by itself.
7 # (Yup, it's a C++ header file and a perl script.)
8 #
9
10 # Copyright (C) 1998-2004 David Mazieres (dm@uun.org)
11 #
12 # This program is free software; you can redistribute it and/or
13 # modify it under the terms of the GNU General Public License as
14 # published by the Free Software Foundation; either version 2, or (at
15 # your option) any later version.
16 #
17 # This program is distributed in the hope that it will be useful, but
18 # WITHOUT ANY WARRANTY; without even the implied warranty of
19 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 # General Public License for more details.
21 #
22 # You should have received a copy of the GNU General Public License
23 # along with this program; if not, write to the Free Software
24 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
25 # USA
26 #
27 # Note: For the purposes of the GNU General Public License, source
28 # includes the source to the perl script, not just the resulting
29 # header file, callback.h. However, since the perl script is
30 # conveniently embedded in the header file, you needn't do anything
31 # special to distribute source as long as you don't take the perl out
32 # of the header.
33
34 #
35 # WHAT IS THIS?
36 #
37 # This C++ header file defines the template class callback--a type
38 # that approximates function currying.
39 #
40 # An object of type callback<R, B1, B2> contains a member R operator()
41 # (B1, B2)--Thus callbacks are function objects with the first
42 # template type specifying the return of the function and the
43 # remaining arguments specifying the types of the arguments to pass
44 # the function.
45 #
46 # Callbacks can have any number of arguments up to $NA below.
47 # Template arguments that aren't specified default to void and don't
48 # need to be passed in. Thus, a callback<int> acts like a function
49 # with signature "int fn ()", a callback<int, char *> acts like a
50 # function with signature "int fn (char *)", and so forth.
51 #
52 # Each callback class has two type members, ptr and ref, specyfing
53 # refcounted pointers and references to the callback object
54 # respectively. (See refcnt.h for an explanation of ptr and ref).
55 #
56 # The function wrap is used to create references to callbacks. Given
57 # a function with signature "R fn (A1, A2, A3)", wrap can generate
58 # the following references:
59 #
60 # wrap (fn) -> callback<R, A1, A2, A3>::ref
61 # wrap (fn, a1) -> callback<R, A2, A3>::ref
62 # wrap (fn, a1, a2) -> callback<R, A3>::ref
63 # wrap (fn, a1, a2, a3) -> callback<R>::ref
64 #
65 # When the resulting callback is actually called, it invokes fn. The
66 # argument list it passes fn starts with whatever arguments were
67 # initially passed to wrap and then contains whatever arguments are
68 # given to the callback object. For example, given fn above, this
69 # code ends up calling "fn (a1, a2, a3)" and assigning the return
70 # value to r;
71 #
72 # R r;
73 # A1 a1;
74 # A2 a2;
75 # A3 a3;
76 # callback<R, A1>::ptr cb;
77 #
78 # cb = wrap (fn, a1);
79 # r = (*cb) (a2, a3);
80 #
81 # One can create callbacks from class methods as well as global
82 # functions. To do this, simply pass the object as the first
83 # parameter to wrap, and the method as the second. For example:
84 #
85 # struct foo {
86 # void bar (int, char *);
87 # callback<void, char *>::ref baz () {
88 # return wrap (this, &foo::bar, 7);
89 # }
90 # };
91 #
92 # Note the only way to generate pointers to class members in ANSI C++
93 # is with fully qualified member names. "&foo::bar" cannot be
94 # abbreviated to "&bar" in the above example, though most C++
95 # compilers still accept that syntax.
96 #
97 # If wrap is called with a refcounted ref or ptr to a object, instead
98 # of a simple pointer, the resulting callback will maintain a
99 # reference to the object, ensuring it is not deleted. For example,
100 # in the following code, baz returns a callback with a reference to
101 # the current object. This ensures that a foo will not be deleted
102 # until after the callback has been deleted. Without mkref, if a
103 # callback happened after the reference count on a foo object went to
104 # zero, the foo object would previously have been deleted and its
105 # vtable pointer likely clobbered, resulting in a core dump.
106 #
107 # struct foo : public virtual refcount {
108 # virtual void bar (int, char *);
109 # callback<void, char *>::ref baz () {
110 # return wrap (mkref (this), &foo::bar, 7);
111 # }
112 # };
113 #
114 # An example:
115 #
116 # void
117 # printstrings (char *a, char *b, char *c)
118 # {
119 # printf ("%s %s %s\n", a, b, c);
120 # }
121 #
122 # int
123 # main ()
124 # {
125 # callback<void, char *>::ref cb1 = wrap (printstrings, "cb1a", "cb1b");
126 # callback<void, char *, char *>::ref cb2 = wrap (printstrings, "cb2a");
127 # callback<void, char *, char *, char *>::ref cb3 = wrap (printstrings);
128 #
129 # (*cb1) ("cb1c"); // prints: cb1a cb1b cb1c
130 # (*cb2) ("cb2b", "cb2c"); // prints: cb2a cb2b cb2c
131 # (*cb3) ("cb3a", "cb3b", "cb3c"); // prints: cb3a cb3b cb3c
132 #
133 # return 0;
134 # }
135
136
137 eval 'exec perl -w -S $0 ${1+"$@"}'
138 if 0;
139
140
141 use strict;
142
143 my $NA = 5;
144 my $NB = 3;
145
146 my $PARTIALSPEC = 0; # 0 May work around compiler bugs
147 my $RETURNVOID = 1; # 0 May work around compiler bugs
148
149 my $verbosedestruct = 0;
150 my ($ia, $ib);
151
152 my $enddebug = '#endif /' . '* WRAP_DEBUG *' . '/';
153 my $elsenotdebug = '#else /' . '* !WRAP_DEBUG *' . '/';
154 my $endnotdebug = '#endif /' . '* !WRAP_DEBUG *' . '/';
155 my $bc = '/' . '*';
156 my $ec = '*' . '/';
157
158 sub jc {
159 join (', ', @_);
160 }
161
162 sub mklist ($$) {
163 my ($pat, $n) = @_;
164 my @res = map { my $ret = $pat; $ret =~ s/%/$_/g; $ret; } (1 .. $n);
165 wantarray ? @res : jc (@res);
166 }
167
168 sub pcallback ($) {
169 my $b = shift;
170 my $tmpparam = jc ('class R', mklist ('class B%', $b));
171 my $tmpargs = jc ('R', mklist ('B%', $b));
172 my $specargs = $b == $NB ? '' : "<" . $tmpargs . ">";
173 my $cbargs = mklist ('B%', $b);
174
175 print <<"EOF";
176
177 template<$tmpparam>
178 class callback$specargs {
179 public:
180 typedef struct ref<callback<$tmpargs> > ref;
181 typedef struct ptr<callback<$tmpargs> > ptr;
182
183 #if WRAP_DEBUG
184 const char *const dest;
185 const char *const src;
186 const char *const line;
187 callback (const char *df, const char *f, const char *l)
188 : dest (df[0] == '&' ? df + 1 : df), src (f), line (l) {}
189 $enddebug
190 virtual R operator() ($cbargs) = 0;
191 virtual ~callback () {}
192 };
193
194 EOF
195
196 return if (!$PARTIALSPEC);
197
198 my $rbparam = jc ('class R', mklist ('class B%', $b));
199 my $bargs = jc (mklist ('const B% &b%', $b));
200 my $blist = jc (mklist ('b%', $b));
201
202 print <<"EOF";
203 template<$rbparam>
204 class refops<callback<$tmpargs> >
205 typedef callback<$tmpargs> cb_t;
206 REFOPS_DEFAULT (cb_t);
207 R operator() ($bargs) const
208 { return (*p) ($blist); }
209 };
210
211 EOF
212
213 return if ($RETURNVOID);
214
215 my $bparam = mklist ('class B%', $b);
216 $tmpargs = jc ('void', mklist ('B%', $b));
217
218 print <<"EOF";
219 template<$bparam>
220 class refops<callback<$tmpargs> >
221 typedef callback<$tmpargs> cb_t;
222 REFOPS_DEFAULT (cb_t);
223 void operator() ($bargs) const
224 { (*p) ($blist); }
225 };
226
227 EOF
228 }
229
230 sub pcallback_b_a ($$) {
231 my ($b, $a) = @_;
232 my $type = "callback_${b}_${a}";
233 my $tmpparam = jc ('class R', mklist ('class B%', $b),
234 mklist ('class A%', $a));
235 my $RBlist = jc ('R', mklist ('B%', $b));
236 my $ABlist = jc (mklist ('A%', $a), mklist ('B%', $b));
237 my $adecl = join ('', mklist (" A% a%;\n", $a));
238 my $aargs = jc ('cb_t ff', mklist ('const A% &aa%', $a));
239 my $ainit = jc ('f (ff)', mklist ('a% (aa%)', $a));
240 my $bargs = mklist ('B% b%', $b);
241 my $ablist = jc (mklist ('a%', $a), mklist ('b%', $b));
242
243 print <<"EOF";
244
245 template<$tmpparam>
246 class $type
247 : public callback<$RBlist> {
248 typedef R (*cb_t) ($ABlist);
249 cb_t f;
250 ${adecl}public:
251 $type (callback_line_param $aargs)
252 : callback_line_init (callback<$RBlist>) $ainit {}
253 R operator() ($bargs)
254 { return f ($ablist); }
255 };
256 EOF
257
258 return if ($RETURNVOID);
259
260 my $specparam = jc (mklist ('class B%', $b), mklist ('class A%', $a));
261 my $specargs = jc ('void', mklist ('B%', $b), mklist ('A%', $a));
262 $RBlist = jc ('void', mklist ('B%', $b));
263
264 print <<"EOF";
265
266 template<$specparam>
267 class $type<$specargs>
268 : public callback<$RBlist> {
269 typedef void (*cb_t) ($ABlist);
270 cb_t f;
271 ${adecl}public:
272 $type (callback_line_param $aargs)
273 : callback_line_init (callback<$RBlist>) $ainit {}
274 void operator() ($bargs)
275 { f ($ablist); }
276 };
277 EOF
278 }
279
280 sub pcallback_c_b_a ($$) {
281 my ($b, $a) = @_;
282 my $type = "callback_c_${b}_${a}";
283 my $tmpparam = jc ('class P, class C, class R', mklist ('class B%', $b),
284 mklist ('class A%', $a));
285 my $RBlist = jc ('R', mklist ('B%', $b));
286 my $ABlist = jc (mklist ('A%', $a), mklist ('B%', $b));
287 my $adecl = join ('', mklist (" A% a%;\n", $a));
288 my $aargs = jc ('const P &cc, cb_t ff', mklist ('const A% &aa%', $a));
289 my $ainit = jc ('c (cc), f (ff)', mklist ('a% (aa%)', $a));
290 my $bargs = mklist ('B% b%', $b);
291 my $ablist = jc (mklist ('a%', $a), mklist ('b%', $b));
292
293 print <<"EOF";
294
295 template<$tmpparam>
296 class $type
297 : public callback<$RBlist> {
298 typedef R (C::*cb_t) ($ABlist);
299 P c;
300 cb_t f;
301 #if WRAP_USE_NODELETE
302 ${adecl} int deleted;
303 public:
304 $type (callback_line_param $aargs)
305 : callback_line_init (callback<$RBlist>) $ainit,
306 deleted (false)
307 { maybe_nodelete_addptr (c, this->line, &deleted); }
308 ~$type () { maybe_nodelete_remptr (c, this->line, &deleted); }
309 R operator() ($bargs)
310 {
311 if (deleted)
312 panic ("callback from %s to %s on deleted object\\n",
313 this->line, this->dest);
314 return ((*c).*f) ($ablist);
315 }
316 #else $bc !WRAP_USE_NODELETE $ec
317 ${adecl}public:
318 $type (callback_line_param $aargs)
319 : callback_line_init (callback<$RBlist>) $ainit {}
320 R operator() ($bargs)
321 { return ((*c).*f) ($ablist); }
322 #endif $bc !WRAP_USE_NODELETE $ec
323 };
324 EOF
325
326 return if ($RETURNVOID);
327
328 my $specparam = jc ('class P, class C', mklist ('class B%', $b),
329 mklist ('class A%', $a));
330 my $specargs = jc ('P, C, void' , mklist ('B%', $b), mklist ('A%', $a));
331 $RBlist = jc ('void', mklist ('B%', $b));
332
333 print <<"EOF";
334
335 template<$specparam>
336 class $type<$specargs>
337 : public callback<$RBlist> {
338 typedef void (C::*cb_t) ($ABlist);
339 P c;
340 cb_t f;
341 ${adecl}public:
342 $type (callback_line_param $aargs)
343 : callback_line_init (callback<$RBlist>) $ainit {}
344 void operator() ($bargs)
345 { ((*c).*f) ($ablist); }
346 };
347 EOF
348 }
349
350 sub pwrap_b_a ($$) {
351 my ($b, $a) = @_;
352 my $tmpparam = jc ('class R', mklist ('class B%', $b),
353 mklist ('class A%, class AA%', $a));
354 my $rtargs = jc ('R', mklist ('B%', $b), mklist ('A%', $a));
355 my $rtype = "refcounted<callback_${b}_${a}<$rtargs> >";
356 my $ABlist = jc (mklist ('A%', $a), mklist ('B%', $b));
357 my $fargs = jc ("R (*f) ($ABlist)", mklist ('const AA% &a%', $a));
358 my $falist = jc ('f', mklist ('a%', $a));
359
360 print <<"EOF";
361
362 template<$tmpparam>
363 static inline $rtype *
364 wrap (wrap_line_param $fargs)
365 {
366 return wNew ($rtype) (wrap_line_arg $falist);
367 }
368 EOF
369 }
370
371 sub pwrap_c_b_a ($$) {
372 my ($b, $a) = @_;
373 my $tmpparam = jc ('class C', 'class R', mklist ('class B%', $b),
374 mklist ('class A%, class AA%', $a));
375 my $rtargs = jc ('C *', 'C', 'R', mklist ('B%', $b), mklist ('A%', $a));
376 my $rtype = "refcounted<callback_c_${b}_${a}<$rtargs> >";
377 my $ABlist = jc (mklist ('A%', $a), mklist ('B%', $b));
378 my $fargs = jc ("C *p, R (C::*f) ($ABlist)", mklist ('const AA% &a%', $a));
379 my $falist = jc ('p, f', mklist ('a%', $a));
380
381 print <<"EOF";
382
383 template<$tmpparam>
384 static inline $rtype *
385 wrap (wrap_line_param $fargs)
386 {
387 return wNew ($rtype) (wrap_c_line_arg $falist);
388 }
389 EOF
390
391 $rtargs = jc ('ref<C>', 'C', 'R', mklist ('B%', $b), mklist ('A%', $a));
392 $rtype = "refcounted<callback_c_${b}_${a}<$rtargs> >";
393 $fargs = jc ("const ref<C> &p, R (C::*f) ($ABlist)",
394 mklist ('const AA% &a%', $a));
395 my $f2args = jc ("const ptr<C> &p, R (C::*f) ($ABlist)",
396 mklist ('const AA% &a%', $a));
397 my $f3args = jc ("const refcounted<C> *p, R (C::*f) ($ABlist)",
398 mklist ('const AA% &a%', $a));
399 $falist = jc ('p, f', mklist ('a%', $a));
400
401 print <<"EOF";
402
403 template<$tmpparam>
404 static inline $rtype *
405 wrap (wrap_line_param $fargs)
406 {
407 return wNew ($rtype) (wrap_c_line_arg $falist);
408 }
409 template<$tmpparam>
410 static inline $rtype *
411 wrap (wrap_line_param $f2args)
412 {
413 return wNew ($rtype) (wrap_c_line_arg $falist);
414 }
415 template<$tmpparam>
416 static inline $rtype *
417 wrap (wrap_line_param $f3args)
418 {
419 return wNew ($rtype) (wrap_c_line_arg $falist);
420 }
421 EOF
422 }
423
424
425 sub prefops () {
426 return if ($PARTIALSPEC);
427 my ($b, $opfn);
428
429 $opfn = "R operator() () const { return (*p) (); }\n";
430 for ($b = 1; $b <= $NB; $b++) {
431 my $tmpparam = mklist ("class BB%", $b);
432 my $bparam = mklist ("const BB% &b%", $b);
433 my $blist = mklist ("b%", $b);
434 $opfn .= sprintf <<"EOF",
435 template<$tmpparam>
436 R operator() ($bparam) const
437 { return (*p) ($blist); }
438 EOF
439 }
440
441 printf <<"EOF",
442
443 template<%s>
444 class refops<callback<%s> > {
445 typedef callback<%s> cb_t;
446 REFOPS_DEFAULT (cb_t);
447 $opfn};
448 EOF
449 jc ('class R', mklist ("class B%", $NB)),
450 jc ('R', mklist ("B%", $NB)),
451 jc ('R', mklist ("B%", $NB));
452
453 return if ($RETURNVOID);
454
455 $opfn = "void operator() () { return (*p) (); }\n";
456 for ($b = 1; $b <= $NB; $b++) {
457 my $tmpparam = mklist ("class BB%", $b);
458 my $bparam = mklist ("const BB% &b%", $b);
459 my $blist = mklist ("b%", $b);
460 $opfn .= sprintf <<"EOF",
461 template<$tmpparam>
462 void operator() ($bparam)
463 { (*p) ($blist); }
464 EOF
465 }
466
467 printf <<"EOF",
468
469 template<%s>
470 class refops<callback<%s> > {
471 typedef callback<%s> cb_t;
472 REFOPS_DEFAULT (cb_t);
473 $opfn};
474 EOF
475 scalar mklist ("class B%", $NB),
476 jc ('void', mklist ("B%", $NB)),
477 jc ('void', mklist ("B%", $NB));
478 }
479
480
481
482 sub pfile () {
483 printf "template<%s> class callback;\n",
484 jc ('class R', mklist ('class B% = void', $NB));
485
486 my ($a, $b);
487 for ($b = 0; $b <= $NB; $b++) {
488 pcallback ($b);
489 for ($a = 0; $a <= $NA; $a++) {
490 pcallback_b_a ($b, $a);
491 pwrap_b_a ($b, $a);
492 pcallback_c_b_a ($b, $a);
493 pwrap_c_b_a ($b, $a);
494 }
495 }
496 prefops;
497 }
498
499 seek DATA, 0, 0;
500 while (<DATA>) {
501 print;
502 last if m/^\#endif \/\* perl \*\/$/;
503 }
504
505 # Note: The debugging feature requires GCC varargs macros
506
507 print <<'EOF';
508
509 #ifndef _CALLBACK_H_INCLUDED_
510 #define _CALLBACK_H_INCLUDED_ 1
511
512 #include "refcnt.h"
513
514 #ifndef WRAP_DEBUG
515 # if defined (DMALLOC) && __GNUC__ >= 2
516 # define WRAP_DEBUG 1
517 EOF
518
519 print '# endif /', '* DMALLOC && gcc >= 2 *', "/\n";
520 print '#endif /', '* !WRAP_DEBUG *', "/\n";
521
522 print <<"EOF";
523 #define wNew New
524 #if WRAP_DEBUG
525 # define callback_line_param \\
526 const char *dfunc, const char *func, const char *line,
527 # define wrap_line_param const char *wa1, const char *wa2, \\
528 const char *func, const char *line,
529 # define wrap_line_arg wa1, func, line,
530 # define wrap_c_line_arg wa2, func, line,
531 # define callback_line_init(super...) super (dfunc, func, line),
532 # define wrap _wrap
533 # ifdef DMALLOC
534 # undef wNew
535 # define wNew new (dmalloc, line, __LINE__)
536 # define WRAP_USE_NODELETE 1
537 template<class C> inline void
538 maybe_nodelete_addptr (const ref<C> &p, const char *fl, int *fp)
539 {
540 }
541 template<class C> inline void
542 maybe_nodelete_addptr (const ptr<C> &p, const char *fl, int *fp)
543 {
544 }
545 template<class C> inline void
546 maybe_nodelete_addptr (C *p, const char *fl, int *fp)
547 {
548 nodelete_addptr (p, fl, fp);
549 }
550 template<class C> inline void
551 maybe_nodelete_remptr (const ref<C> &p, const char *fl, int *fp)
552 {
553 }
554 template<class C> inline void
555 maybe_nodelete_remptr (const ptr<C> &p, const char *fl, int *fp)
556 {
557 }
558 template<class C> inline void
559 maybe_nodelete_remptr (C *p, const char *fl, int *fp)
560 {
561 nodelete_remptr (p, fl, fp);
562 }
563 EOF
564 print '# endif /', '* DMALLOC *', "/\n";
565 print '#else /', '* !WRAP_DEBUG *', "/\n";
566 print <<'EOF';
567 # define callback_line_param
568 # define wrap_line_param
569 # define wrap_line_arg
570 # define wrap_c_line_arg
571 # define callback_line_init(super...)
572 EOF
573 print '#endif /', '* !WRAP_DEBUG *', "/\n\n";
574
575 pfile;
576
577 print <<"EOF";
578
579 #undef callback_line_param
580 #undef wrap_line_param
581 #undef wrap_line_arg
582 #undef wrap_c_line_arg
583 #if WRAP_DEBUG
584 # undef wrap
585 # define wrap_arg1(arg_1, arg_rest...) #arg_1
586 # define wrap_arg2(arg_1, arg_rest...) wrap_arg1 (arg_rest)
587 # define do_wrap(__func_name, __do_wrap_args...) \\
588 _wrap (wrap_arg1(__do_wrap_args), wrap_arg2(__do_wrap_args), \\
589 __func_name, __FL__, ## __do_wrap_args)
590 # define wrap(__wrap_args...) do_wrap(__PRETTY_FUNCTION__, __wrap_args)
591 # define gwrap(__wrap_args...) \\
592 (nodelete_ignore () ? do_wrap(__FL__, __wrap_args) : 0)
593 $elsenotdebug
594 # define gwrap wrap
595 $endnotdebug
596
597 EOF
598
599 # Note that gwrap is for use outside of functions, because with some
600 # versions of gcc, using __PRETTY_FUNCTION__ outside of any function
601 # causes link-time errors
602
603 print "\n", '#endif /', '* !_CALLBACK_H_INCLUDED_ *', '/', "\n";
604
605 __END__
606 # */
607 #endif /* perl */
608
609 #ifndef _CALLBACK_H_INCLUDED_
610 #define _CALLBACK_H_INCLUDED_ 1
611
612 #include "refcnt.h"
613
614 #ifndef WRAP_DEBUG
615 # if defined (DMALLOC) && __GNUC__ >= 2
616 # define WRAP_DEBUG 1
617 # endif /* DMALLOC && gcc >= 2 */
618 #endif /* !WRAP_DEBUG */
619 #define wNew New
620 #if WRAP_DEBUG
621 # define callback_line_param \
622 const char *dfunc, const char *func, const char *line,
623 # define wrap_line_param const char *wa1, const char *wa2, \
624 const char *func, const char *line,
625 # define wrap_line_arg wa1, func, line,
626 # define wrap_c_line_arg wa2, func, line,
627 # define callback_line_init(super...) super (dfunc, func, line),
628 # define wrap _wrap
629 # ifdef DMALLOC
630 # undef wNew
631 # define wNew new (dmalloc, line, __LINE__)
632 # define WRAP_USE_NODELETE 1
633 template<class C> inline void
maybe_nodelete_addptr(const ref<C> & p,const char * fl,int * fp)634 maybe_nodelete_addptr (const ref<C> &p, const char *fl, int *fp)
635 {
636 }
637 template<class C> inline void
maybe_nodelete_addptr(const ptr<C> & p,const char * fl,int * fp)638 maybe_nodelete_addptr (const ptr<C> &p, const char *fl, int *fp)
639 {
640 }
641 template<class C> inline void
maybe_nodelete_addptr(C * p,const char * fl,int * fp)642 maybe_nodelete_addptr (C *p, const char *fl, int *fp)
643 {
644 nodelete_addptr (p, fl, fp);
645 }
646 template<class C> inline void
maybe_nodelete_remptr(const ref<C> & p,const char * fl,int * fp)647 maybe_nodelete_remptr (const ref<C> &p, const char *fl, int *fp)
648 {
649 }
650 template<class C> inline void
maybe_nodelete_remptr(const ptr<C> & p,const char * fl,int * fp)651 maybe_nodelete_remptr (const ptr<C> &p, const char *fl, int *fp)
652 {
653 }
654 template<class C> inline void
maybe_nodelete_remptr(C * p,const char * fl,int * fp)655 maybe_nodelete_remptr (C *p, const char *fl, int *fp)
656 {
657 nodelete_remptr (p, fl, fp);
658 }
659 # endif /* DMALLOC */
660 #else /* !WRAP_DEBUG */
661 # define callback_line_param
662 # define wrap_line_param
663 # define wrap_line_arg
664 # define wrap_c_line_arg
665 # define callback_line_init(super...)
666 #endif /* !WRAP_DEBUG */
667
668 template<class R, class B1 = void, class B2 = void, class B3 = void> class callback;
669
670 template<class R>
671 class callback<R> {
672 public:
673 typedef struct ref<callback<R> > ref;
674 typedef struct ptr<callback<R> > ptr;
675
676 #if WRAP_DEBUG
677 const char *const dest;
678 const char *const src;
679 const char *const line;
680 callback (const char *df, const char *f, const char *l)
681 : dest (df[0] == '&' ? df + 1 : df), src (f), line (l) {}
682 #endif /* WRAP_DEBUG */
683 virtual R operator() () = 0;
684 virtual ~callback () {}
685 };
686
687
688 template<class R>
689 class callback_0_0
690 : public callback<R> {
691 typedef R (*cb_t) ();
692 cb_t f;
693 public:
694 callback_0_0 (callback_line_param cb_t ff)
695 : callback_line_init (callback<R>) f (ff) {}
696 R operator() ()
697 { return f (); }
698 };
699
700 template<class R>
701 static inline refcounted<callback_0_0<R> > *
702 wrap (wrap_line_param R (*f) ())
703 {
704 return wNew (refcounted<callback_0_0<R> >) (wrap_line_arg f);
705 }
706
707 template<class P, class C, class R>
708 class callback_c_0_0
709 : public callback<R> {
710 typedef R (C::*cb_t) ();
711 P c;
712 cb_t f;
713 #if WRAP_USE_NODELETE
714 int deleted;
715 public:
716 callback_c_0_0 (callback_line_param const P &cc, cb_t ff)
717 : callback_line_init (callback<R>) c (cc), f (ff),
718 deleted (false)
719 { maybe_nodelete_addptr (c, this->line, &deleted); }
720 ~callback_c_0_0 () { maybe_nodelete_remptr (c, this->line, &deleted); }
721 R operator() ()
722 {
723 if (deleted)
724 panic ("callback from %s to %s on deleted object\n",
725 this->line, this->dest);
726 return ((*c).*f) ();
727 }
728 #else /* !WRAP_USE_NODELETE */
729 public:
730 callback_c_0_0 (callback_line_param const P &cc, cb_t ff)
731 : callback_line_init (callback<R>) c (cc), f (ff) {}
732 R operator() ()
733 { return ((*c).*f) (); }
734 #endif /* !WRAP_USE_NODELETE */
735 };
736
737 template<class C, class R>
738 static inline refcounted<callback_c_0_0<C *, C, R> > *
739 wrap (wrap_line_param C *p, R (C::*f) ())
740 {
741 return wNew (refcounted<callback_c_0_0<C *, C, R> >) (wrap_c_line_arg p, f);
742 }
743
744 template<class C, class R>
745 static inline refcounted<callback_c_0_0<ref<C>, C, R> > *
746 wrap (wrap_line_param const ref<C> &p, R (C::*f) ())
747 {
748 return wNew (refcounted<callback_c_0_0<ref<C>, C, R> >) (wrap_c_line_arg p, f);
749 }
750 template<class C, class R>
751 static inline refcounted<callback_c_0_0<ref<C>, C, R> > *
752 wrap (wrap_line_param const ptr<C> &p, R (C::*f) ())
753 {
754 return wNew (refcounted<callback_c_0_0<ref<C>, C, R> >) (wrap_c_line_arg p, f);
755 }
756 template<class C, class R>
757 static inline refcounted<callback_c_0_0<ref<C>, C, R> > *
758 wrap (wrap_line_param const refcounted<C> *p, R (C::*f) ())
759 {
760 return wNew (refcounted<callback_c_0_0<ref<C>, C, R> >) (wrap_c_line_arg p, f);
761 }
762
763 template<class R, class A1>
764 class callback_0_1
765 : public callback<R> {
766 typedef R (*cb_t) (A1);
767 cb_t f;
768 A1 a1;
769 public:
770 callback_0_1 (callback_line_param cb_t ff, const A1 &aa1)
771 : callback_line_init (callback<R>) f (ff), a1 (aa1) {}
772 R operator() ()
773 { return f (a1); }
774 };
775
776 template<class R, class A1, class AA1>
777 static inline refcounted<callback_0_1<R, A1> > *
778 wrap (wrap_line_param R (*f) (A1), const AA1 &a1)
779 {
780 return wNew (refcounted<callback_0_1<R, A1> >) (wrap_line_arg f, a1);
781 }
782
783 template<class P, class C, class R, class A1>
784 class callback_c_0_1
785 : public callback<R> {
786 typedef R (C::*cb_t) (A1);
787 P c;
788 cb_t f;
789 #if WRAP_USE_NODELETE
790 A1 a1;
791 int deleted;
792 public:
793 callback_c_0_1 (callback_line_param const P &cc, cb_t ff, const A1 &aa1)
794 : callback_line_init (callback<R>) c (cc), f (ff), a1 (aa1),
795 deleted (false)
796 { maybe_nodelete_addptr (c, this->line, &deleted); }
797 ~callback_c_0_1 () { maybe_nodelete_remptr (c, this->line, &deleted); }
798 R operator() ()
799 {
800 if (deleted)
801 panic ("callback from %s to %s on deleted object\n",
802 this->line, this->dest);
803 return ((*c).*f) (a1);
804 }
805 #else /* !WRAP_USE_NODELETE */
806 A1 a1;
807 public:
808 callback_c_0_1 (callback_line_param const P &cc, cb_t ff, const A1 &aa1)
809 : callback_line_init (callback<R>) c (cc), f (ff), a1 (aa1) {}
810 R operator() ()
811 { return ((*c).*f) (a1); }
812 #endif /* !WRAP_USE_NODELETE */
813 };
814
815 template<class C, class R, class A1, class AA1>
816 static inline refcounted<callback_c_0_1<C *, C, R, A1> > *
817 wrap (wrap_line_param C *p, R (C::*f) (A1), const AA1 &a1)
818 {
819 return wNew (refcounted<callback_c_0_1<C *, C, R, A1> >) (wrap_c_line_arg p, f, a1);
820 }
821
822 template<class C, class R, class A1, class AA1>
823 static inline refcounted<callback_c_0_1<ref<C>, C, R, A1> > *
824 wrap (wrap_line_param const ref<C> &p, R (C::*f) (A1), const AA1 &a1)
825 {
826 return wNew (refcounted<callback_c_0_1<ref<C>, C, R, A1> >) (wrap_c_line_arg p, f, a1);
827 }
828 template<class C, class R, class A1, class AA1>
829 static inline refcounted<callback_c_0_1<ref<C>, C, R, A1> > *
830 wrap (wrap_line_param const ptr<C> &p, R (C::*f) (A1), const AA1 &a1)
831 {
832 return wNew (refcounted<callback_c_0_1<ref<C>, C, R, A1> >) (wrap_c_line_arg p, f, a1);
833 }
834 template<class C, class R, class A1, class AA1>
835 static inline refcounted<callback_c_0_1<ref<C>, C, R, A1> > *
836 wrap (wrap_line_param const refcounted<C> *p, R (C::*f) (A1), const AA1 &a1)
837 {
838 return wNew (refcounted<callback_c_0_1<ref<C>, C, R, A1> >) (wrap_c_line_arg p, f, a1);
839 }
840
841 template<class R, class A1, class A2>
842 class callback_0_2
843 : public callback<R> {
844 typedef R (*cb_t) (A1, A2);
845 cb_t f;
846 A1 a1;
847 A2 a2;
848 public:
849 callback_0_2 (callback_line_param cb_t ff, const A1 &aa1, const A2 &aa2)
850 : callback_line_init (callback<R>) f (ff), a1 (aa1), a2 (aa2) {}
851 R operator() ()
852 { return f (a1, a2); }
853 };
854
855 template<class R, class A1, class AA1, class A2, class AA2>
856 static inline refcounted<callback_0_2<R, A1, A2> > *
857 wrap (wrap_line_param R (*f) (A1, A2), const AA1 &a1, const AA2 &a2)
858 {
859 return wNew (refcounted<callback_0_2<R, A1, A2> >) (wrap_line_arg f, a1, a2);
860 }
861
862 template<class P, class C, class R, class A1, class A2>
863 class callback_c_0_2
864 : public callback<R> {
865 typedef R (C::*cb_t) (A1, A2);
866 P c;
867 cb_t f;
868 #if WRAP_USE_NODELETE
869 A1 a1;
870 A2 a2;
871 int deleted;
872 public:
873 callback_c_0_2 (callback_line_param const P &cc, cb_t ff, const A1 &aa1, const A2 &aa2)
874 : callback_line_init (callback<R>) c (cc), f (ff), a1 (aa1), a2 (aa2),
875 deleted (false)
876 { maybe_nodelete_addptr (c, this->line, &deleted); }
877 ~callback_c_0_2 () { maybe_nodelete_remptr (c, this->line, &deleted); }
878 R operator() ()
879 {
880 if (deleted)
881 panic ("callback from %s to %s on deleted object\n",
882 this->line, this->dest);
883 return ((*c).*f) (a1, a2);
884 }
885 #else /* !WRAP_USE_NODELETE */
886 A1 a1;
887 A2 a2;
888 public:
889 callback_c_0_2 (callback_line_param const P &cc, cb_t ff, const A1 &aa1, const A2 &aa2)
890 : callback_line_init (callback<R>) c (cc), f (ff), a1 (aa1), a2 (aa2) {}
891 R operator() ()
892 { return ((*c).*f) (a1, a2); }
893 #endif /* !WRAP_USE_NODELETE */
894 };
895
896 template<class C, class R, class A1, class AA1, class A2, class AA2>
897 static inline refcounted<callback_c_0_2<C *, C, R, A1, A2> > *
898 wrap (wrap_line_param C *p, R (C::*f) (A1, A2), const AA1 &a1, const AA2 &a2)
899 {
900 return wNew (refcounted<callback_c_0_2<C *, C, R, A1, A2> >) (wrap_c_line_arg p, f, a1, a2);
901 }
902
903 template<class C, class R, class A1, class AA1, class A2, class AA2>
904 static inline refcounted<callback_c_0_2<ref<C>, C, R, A1, A2> > *
905 wrap (wrap_line_param const ref<C> &p, R (C::*f) (A1, A2), const AA1 &a1, const AA2 &a2)
906 {
907 return wNew (refcounted<callback_c_0_2<ref<C>, C, R, A1, A2> >) (wrap_c_line_arg p, f, a1, a2);
908 }
909 template<class C, class R, class A1, class AA1, class A2, class AA2>
910 static inline refcounted<callback_c_0_2<ref<C>, C, R, A1, A2> > *
911 wrap (wrap_line_param const ptr<C> &p, R (C::*f) (A1, A2), const AA1 &a1, const AA2 &a2)
912 {
913 return wNew (refcounted<callback_c_0_2<ref<C>, C, R, A1, A2> >) (wrap_c_line_arg p, f, a1, a2);
914 }
915 template<class C, class R, class A1, class AA1, class A2, class AA2>
916 static inline refcounted<callback_c_0_2<ref<C>, C, R, A1, A2> > *
917 wrap (wrap_line_param const refcounted<C> *p, R (C::*f) (A1, A2), const AA1 &a1, const AA2 &a2)
918 {
919 return wNew (refcounted<callback_c_0_2<ref<C>, C, R, A1, A2> >) (wrap_c_line_arg p, f, a1, a2);
920 }
921
922 template<class R, class A1, class A2, class A3>
923 class callback_0_3
924 : public callback<R> {
925 typedef R (*cb_t) (A1, A2, A3);
926 cb_t f;
927 A1 a1;
928 A2 a2;
929 A3 a3;
930 public:
931 callback_0_3 (callback_line_param cb_t ff, const A1 &aa1, const A2 &aa2, const A3 &aa3)
932 : callback_line_init (callback<R>) f (ff), a1 (aa1), a2 (aa2), a3 (aa3) {}
933 R operator() ()
934 { return f (a1, a2, a3); }
935 };
936
937 template<class R, class A1, class AA1, class A2, class AA2, class A3, class AA3>
938 static inline refcounted<callback_0_3<R, A1, A2, A3> > *
939 wrap (wrap_line_param R (*f) (A1, A2, A3), const AA1 &a1, const AA2 &a2, const AA3 &a3)
940 {
941 return wNew (refcounted<callback_0_3<R, A1, A2, A3> >) (wrap_line_arg f, a1, a2, a3);
942 }
943
944 template<class P, class C, class R, class A1, class A2, class A3>
945 class callback_c_0_3
946 : public callback<R> {
947 typedef R (C::*cb_t) (A1, A2, A3);
948 P c;
949 cb_t f;
950 #if WRAP_USE_NODELETE
951 A1 a1;
952 A2 a2;
953 A3 a3;
954 int deleted;
955 public:
956 callback_c_0_3 (callback_line_param const P &cc, cb_t ff, const A1 &aa1, const A2 &aa2, const A3 &aa3)
957 : callback_line_init (callback<R>) c (cc), f (ff), a1 (aa1), a2 (aa2), a3 (aa3),
958 deleted (false)
959 { maybe_nodelete_addptr (c, this->line, &deleted); }
960 ~callback_c_0_3 () { maybe_nodelete_remptr (c, this->line, &deleted); }
961 R operator() ()
962 {
963 if (deleted)
964 panic ("callback from %s to %s on deleted object\n",
965 this->line, this->dest);
966 return ((*c).*f) (a1, a2, a3);
967 }
968 #else /* !WRAP_USE_NODELETE */
969 A1 a1;
970 A2 a2;
971 A3 a3;
972 public:
973 callback_c_0_3 (callback_line_param const P &cc, cb_t ff, const A1 &aa1, const A2 &aa2, const A3 &aa3)
974 : callback_line_init (callback<R>) c (cc), f (ff), a1 (aa1), a2 (aa2), a3 (aa3) {}
975 R operator() ()
976 { return ((*c).*f) (a1, a2, a3); }
977 #endif /* !WRAP_USE_NODELETE */
978 };
979
980 template<class C, class R, class A1, class AA1, class A2, class AA2, class A3, class AA3>
981 static inline refcounted<callback_c_0_3<C *, C, R, A1, A2, A3> > *
982 wrap (wrap_line_param C *p, R (C::*f) (A1, A2, A3), const AA1 &a1, const AA2 &a2, const AA3 &a3)
983 {
984 return wNew (refcounted<callback_c_0_3<C *, C, R, A1, A2, A3> >) (wrap_c_line_arg p, f, a1, a2, a3);
985 }
986
987 template<class C, class R, class A1, class AA1, class A2, class AA2, class A3, class AA3>
988 static inline refcounted<callback_c_0_3<ref<C>, C, R, A1, A2, A3> > *
989 wrap (wrap_line_param const ref<C> &p, R (C::*f) (A1, A2, A3), const AA1 &a1, const AA2 &a2, const AA3 &a3)
990 {
991 return wNew (refcounted<callback_c_0_3<ref<C>, C, R, A1, A2, A3> >) (wrap_c_line_arg p, f, a1, a2, a3);
992 }
993 template<class C, class R, class A1, class AA1, class A2, class AA2, class A3, class AA3>
994 static inline refcounted<callback_c_0_3<ref<C>, C, R, A1, A2, A3> > *
995 wrap (wrap_line_param const ptr<C> &p, R (C::*f) (A1, A2, A3), const AA1 &a1, const AA2 &a2, const AA3 &a3)
996 {
997 return wNew (refcounted<callback_c_0_3<ref<C>, C, R, A1, A2, A3> >) (wrap_c_line_arg p, f, a1, a2, a3);
998 }
999 template<class C, class R, class A1, class AA1, class A2, class AA2, class A3, class AA3>
1000 static inline refcounted<callback_c_0_3<ref<C>, C, R, A1, A2, A3> > *
1001 wrap (wrap_line_param const refcounted<C> *p, R (C::*f) (A1, A2, A3), const AA1 &a1, const AA2 &a2, const AA3 &a3)
1002 {
1003 return wNew (refcounted<callback_c_0_3<ref<C>, C, R, A1, A2, A3> >) (wrap_c_line_arg p, f, a1, a2, a3);
1004 }
1005
1006 template<class R, class A1, class A2, class A3, class A4>
1007 class callback_0_4
1008 : public callback<R> {
1009 typedef R (*cb_t) (A1, A2, A3, A4);
1010 cb_t f;
1011 A1 a1;
1012 A2 a2;
1013 A3 a3;
1014 A4 a4;
1015 public:
1016 callback_0_4 (callback_line_param cb_t ff, const A1 &aa1, const A2 &aa2, const A3 &aa3, const A4 &aa4)
1017 : callback_line_init (callback<R>) f (ff), a1 (aa1), a2 (aa2), a3 (aa3), a4 (aa4) {}
1018 R operator() ()
1019 { return f (a1, a2, a3, a4); }
1020 };
1021
1022 template<class R, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4>
1023 static inline refcounted<callback_0_4<R, A1, A2, A3, A4> > *
1024 wrap (wrap_line_param R (*f) (A1, A2, A3, A4), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4)
1025 {
1026 return wNew (refcounted<callback_0_4<R, A1, A2, A3, A4> >) (wrap_line_arg f, a1, a2, a3, a4);
1027 }
1028
1029 template<class P, class C, class R, class A1, class A2, class A3, class A4>
1030 class callback_c_0_4
1031 : public callback<R> {
1032 typedef R (C::*cb_t) (A1, A2, A3, A4);
1033 P c;
1034 cb_t f;
1035 #if WRAP_USE_NODELETE
1036 A1 a1;
1037 A2 a2;
1038 A3 a3;
1039 A4 a4;
1040 int deleted;
1041 public:
1042 callback_c_0_4 (callback_line_param const P &cc, cb_t ff, const A1 &aa1, const A2 &aa2, const A3 &aa3, const A4 &aa4)
1043 : callback_line_init (callback<R>) c (cc), f (ff), a1 (aa1), a2 (aa2), a3 (aa3), a4 (aa4),
1044 deleted (false)
1045 { maybe_nodelete_addptr (c, this->line, &deleted); }
1046 ~callback_c_0_4 () { maybe_nodelete_remptr (c, this->line, &deleted); }
1047 R operator() ()
1048 {
1049 if (deleted)
1050 panic ("callback from %s to %s on deleted object\n",
1051 this->line, this->dest);
1052 return ((*c).*f) (a1, a2, a3, a4);
1053 }
1054 #else /* !WRAP_USE_NODELETE */
1055 A1 a1;
1056 A2 a2;
1057 A3 a3;
1058 A4 a4;
1059 public:
1060 callback_c_0_4 (callback_line_param const P &cc, cb_t ff, const A1 &aa1, const A2 &aa2, const A3 &aa3, const A4 &aa4)
1061 : callback_line_init (callback<R>) c (cc), f (ff), a1 (aa1), a2 (aa2), a3 (aa3), a4 (aa4) {}
1062 R operator() ()
1063 { return ((*c).*f) (a1, a2, a3, a4); }
1064 #endif /* !WRAP_USE_NODELETE */
1065 };
1066
1067 template<class C, class R, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4>
1068 static inline refcounted<callback_c_0_4<C *, C, R, A1, A2, A3, A4> > *
1069 wrap (wrap_line_param C *p, R (C::*f) (A1, A2, A3, A4), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4)
1070 {
1071 return wNew (refcounted<callback_c_0_4<C *, C, R, A1, A2, A3, A4> >) (wrap_c_line_arg p, f, a1, a2, a3, a4);
1072 }
1073
1074 template<class C, class R, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4>
1075 static inline refcounted<callback_c_0_4<ref<C>, C, R, A1, A2, A3, A4> > *
1076 wrap (wrap_line_param const ref<C> &p, R (C::*f) (A1, A2, A3, A4), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4)
1077 {
1078 return wNew (refcounted<callback_c_0_4<ref<C>, C, R, A1, A2, A3, A4> >) (wrap_c_line_arg p, f, a1, a2, a3, a4);
1079 }
1080 template<class C, class R, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4>
1081 static inline refcounted<callback_c_0_4<ref<C>, C, R, A1, A2, A3, A4> > *
1082 wrap (wrap_line_param const ptr<C> &p, R (C::*f) (A1, A2, A3, A4), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4)
1083 {
1084 return wNew (refcounted<callback_c_0_4<ref<C>, C, R, A1, A2, A3, A4> >) (wrap_c_line_arg p, f, a1, a2, a3, a4);
1085 }
1086 template<class C, class R, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4>
1087 static inline refcounted<callback_c_0_4<ref<C>, C, R, A1, A2, A3, A4> > *
1088 wrap (wrap_line_param const refcounted<C> *p, R (C::*f) (A1, A2, A3, A4), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4)
1089 {
1090 return wNew (refcounted<callback_c_0_4<ref<C>, C, R, A1, A2, A3, A4> >) (wrap_c_line_arg p, f, a1, a2, a3, a4);
1091 }
1092
1093 template<class R, class A1, class A2, class A3, class A4, class A5>
1094 class callback_0_5
1095 : public callback<R> {
1096 typedef R (*cb_t) (A1, A2, A3, A4, A5);
1097 cb_t f;
1098 A1 a1;
1099 A2 a2;
1100 A3 a3;
1101 A4 a4;
1102 A5 a5;
1103 public:
1104 callback_0_5 (callback_line_param cb_t ff, const A1 &aa1, const A2 &aa2, const A3 &aa3, const A4 &aa4, const A5 &aa5)
1105 : callback_line_init (callback<R>) f (ff), a1 (aa1), a2 (aa2), a3 (aa3), a4 (aa4), a5 (aa5) {}
1106 R operator() ()
1107 { return f (a1, a2, a3, a4, a5); }
1108 };
1109
1110 template<class R, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4, class A5, class AA5>
1111 static inline refcounted<callback_0_5<R, A1, A2, A3, A4, A5> > *
1112 wrap (wrap_line_param R (*f) (A1, A2, A3, A4, A5), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4, const AA5 &a5)
1113 {
1114 return wNew (refcounted<callback_0_5<R, A1, A2, A3, A4, A5> >) (wrap_line_arg f, a1, a2, a3, a4, a5);
1115 }
1116
1117 template<class P, class C, class R, class A1, class A2, class A3, class A4, class A5>
1118 class callback_c_0_5
1119 : public callback<R> {
1120 typedef R (C::*cb_t) (A1, A2, A3, A4, A5);
1121 P c;
1122 cb_t f;
1123 #if WRAP_USE_NODELETE
1124 A1 a1;
1125 A2 a2;
1126 A3 a3;
1127 A4 a4;
1128 A5 a5;
1129 int deleted;
1130 public:
1131 callback_c_0_5 (callback_line_param const P &cc, cb_t ff, const A1 &aa1, const A2 &aa2, const A3 &aa3, const A4 &aa4, const A5 &aa5)
1132 : callback_line_init (callback<R>) c (cc), f (ff), a1 (aa1), a2 (aa2), a3 (aa3), a4 (aa4), a5 (aa5),
1133 deleted (false)
1134 { maybe_nodelete_addptr (c, this->line, &deleted); }
1135 ~callback_c_0_5 () { maybe_nodelete_remptr (c, this->line, &deleted); }
1136 R operator() ()
1137 {
1138 if (deleted)
1139 panic ("callback from %s to %s on deleted object\n",
1140 this->line, this->dest);
1141 return ((*c).*f) (a1, a2, a3, a4, a5);
1142 }
1143 #else /* !WRAP_USE_NODELETE */
1144 A1 a1;
1145 A2 a2;
1146 A3 a3;
1147 A4 a4;
1148 A5 a5;
1149 public:
1150 callback_c_0_5 (callback_line_param const P &cc, cb_t ff, const A1 &aa1, const A2 &aa2, const A3 &aa3, const A4 &aa4, const A5 &aa5)
1151 : callback_line_init (callback<R>) c (cc), f (ff), a1 (aa1), a2 (aa2), a3 (aa3), a4 (aa4), a5 (aa5) {}
1152 R operator() ()
1153 { return ((*c).*f) (a1, a2, a3, a4, a5); }
1154 #endif /* !WRAP_USE_NODELETE */
1155 };
1156
1157 template<class C, class R, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4, class A5, class AA5>
1158 static inline refcounted<callback_c_0_5<C *, C, R, A1, A2, A3, A4, A5> > *
1159 wrap (wrap_line_param C *p, R (C::*f) (A1, A2, A3, A4, A5), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4, const AA5 &a5)
1160 {
1161 return wNew (refcounted<callback_c_0_5<C *, C, R, A1, A2, A3, A4, A5> >) (wrap_c_line_arg p, f, a1, a2, a3, a4, a5);
1162 }
1163
1164 template<class C, class R, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4, class A5, class AA5>
1165 static inline refcounted<callback_c_0_5<ref<C>, C, R, A1, A2, A3, A4, A5> > *
1166 wrap (wrap_line_param const ref<C> &p, R (C::*f) (A1, A2, A3, A4, A5), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4, const AA5 &a5)
1167 {
1168 return wNew (refcounted<callback_c_0_5<ref<C>, C, R, A1, A2, A3, A4, A5> >) (wrap_c_line_arg p, f, a1, a2, a3, a4, a5);
1169 }
1170 template<class C, class R, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4, class A5, class AA5>
1171 static inline refcounted<callback_c_0_5<ref<C>, C, R, A1, A2, A3, A4, A5> > *
1172 wrap (wrap_line_param const ptr<C> &p, R (C::*f) (A1, A2, A3, A4, A5), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4, const AA5 &a5)
1173 {
1174 return wNew (refcounted<callback_c_0_5<ref<C>, C, R, A1, A2, A3, A4, A5> >) (wrap_c_line_arg p, f, a1, a2, a3, a4, a5);
1175 }
1176 template<class C, class R, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4, class A5, class AA5>
1177 static inline refcounted<callback_c_0_5<ref<C>, C, R, A1, A2, A3, A4, A5> > *
1178 wrap (wrap_line_param const refcounted<C> *p, R (C::*f) (A1, A2, A3, A4, A5), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4, const AA5 &a5)
1179 {
1180 return wNew (refcounted<callback_c_0_5<ref<C>, C, R, A1, A2, A3, A4, A5> >) (wrap_c_line_arg p, f, a1, a2, a3, a4, a5);
1181 }
1182
1183 template<class R, class B1>
1184 class callback<R, B1> {
1185 public:
1186 typedef struct ref<callback<R, B1> > ref;
1187 typedef struct ptr<callback<R, B1> > ptr;
1188
1189 #if WRAP_DEBUG
1190 const char *const dest;
1191 const char *const src;
1192 const char *const line;
1193 callback (const char *df, const char *f, const char *l)
1194 : dest (df[0] == '&' ? df + 1 : df), src (f), line (l) {}
1195 #endif /* WRAP_DEBUG */
1196 virtual R operator() (B1) = 0;
1197 virtual ~callback () {}
1198 };
1199
1200
1201 template<class R, class B1>
1202 class callback_1_0
1203 : public callback<R, B1> {
1204 typedef R (*cb_t) (B1);
1205 cb_t f;
1206 public:
1207 callback_1_0 (callback_line_param cb_t ff)
1208 : callback_line_init (callback<R, B1>) f (ff) {}
1209 R operator() (B1 b1)
1210 { return f (b1); }
1211 };
1212
1213 template<class R, class B1>
1214 static inline refcounted<callback_1_0<R, B1> > *
1215 wrap (wrap_line_param R (*f) (B1))
1216 {
1217 return wNew (refcounted<callback_1_0<R, B1> >) (wrap_line_arg f);
1218 }
1219
1220 template<class P, class C, class R, class B1>
1221 class callback_c_1_0
1222 : public callback<R, B1> {
1223 typedef R (C::*cb_t) (B1);
1224 P c;
1225 cb_t f;
1226 #if WRAP_USE_NODELETE
1227 int deleted;
1228 public:
1229 callback_c_1_0 (callback_line_param const P &cc, cb_t ff)
1230 : callback_line_init (callback<R, B1>) c (cc), f (ff),
1231 deleted (false)
1232 { maybe_nodelete_addptr (c, this->line, &deleted); }
1233 ~callback_c_1_0 () { maybe_nodelete_remptr (c, this->line, &deleted); }
1234 R operator() (B1 b1)
1235 {
1236 if (deleted)
1237 panic ("callback from %s to %s on deleted object\n",
1238 this->line, this->dest);
1239 return ((*c).*f) (b1);
1240 }
1241 #else /* !WRAP_USE_NODELETE */
1242 public:
1243 callback_c_1_0 (callback_line_param const P &cc, cb_t ff)
1244 : callback_line_init (callback<R, B1>) c (cc), f (ff) {}
1245 R operator() (B1 b1)
1246 { return ((*c).*f) (b1); }
1247 #endif /* !WRAP_USE_NODELETE */
1248 };
1249
1250 template<class C, class R, class B1>
1251 static inline refcounted<callback_c_1_0<C *, C, R, B1> > *
1252 wrap (wrap_line_param C *p, R (C::*f) (B1))
1253 {
1254 return wNew (refcounted<callback_c_1_0<C *, C, R, B1> >) (wrap_c_line_arg p, f);
1255 }
1256
1257 template<class C, class R, class B1>
1258 static inline refcounted<callback_c_1_0<ref<C>, C, R, B1> > *
1259 wrap (wrap_line_param const ref<C> &p, R (C::*f) (B1))
1260 {
1261 return wNew (refcounted<callback_c_1_0<ref<C>, C, R, B1> >) (wrap_c_line_arg p, f);
1262 }
1263 template<class C, class R, class B1>
1264 static inline refcounted<callback_c_1_0<ref<C>, C, R, B1> > *
1265 wrap (wrap_line_param const ptr<C> &p, R (C::*f) (B1))
1266 {
1267 return wNew (refcounted<callback_c_1_0<ref<C>, C, R, B1> >) (wrap_c_line_arg p, f);
1268 }
1269 template<class C, class R, class B1>
1270 static inline refcounted<callback_c_1_0<ref<C>, C, R, B1> > *
1271 wrap (wrap_line_param const refcounted<C> *p, R (C::*f) (B1))
1272 {
1273 return wNew (refcounted<callback_c_1_0<ref<C>, C, R, B1> >) (wrap_c_line_arg p, f);
1274 }
1275
1276 template<class R, class B1, class A1>
1277 class callback_1_1
1278 : public callback<R, B1> {
1279 typedef R (*cb_t) (A1, B1);
1280 cb_t f;
1281 A1 a1;
1282 public:
1283 callback_1_1 (callback_line_param cb_t ff, const A1 &aa1)
1284 : callback_line_init (callback<R, B1>) f (ff), a1 (aa1) {}
1285 R operator() (B1 b1)
1286 { return f (a1, b1); }
1287 };
1288
1289 template<class R, class B1, class A1, class AA1>
1290 static inline refcounted<callback_1_1<R, B1, A1> > *
1291 wrap (wrap_line_param R (*f) (A1, B1), const AA1 &a1)
1292 {
1293 return wNew (refcounted<callback_1_1<R, B1, A1> >) (wrap_line_arg f, a1);
1294 }
1295
1296 template<class P, class C, class R, class B1, class A1>
1297 class callback_c_1_1
1298 : public callback<R, B1> {
1299 typedef R (C::*cb_t) (A1, B1);
1300 P c;
1301 cb_t f;
1302 #if WRAP_USE_NODELETE
1303 A1 a1;
1304 int deleted;
1305 public:
1306 callback_c_1_1 (callback_line_param const P &cc, cb_t ff, const A1 &aa1)
1307 : callback_line_init (callback<R, B1>) c (cc), f (ff), a1 (aa1),
1308 deleted (false)
1309 { maybe_nodelete_addptr (c, this->line, &deleted); }
1310 ~callback_c_1_1 () { maybe_nodelete_remptr (c, this->line, &deleted); }
1311 R operator() (B1 b1)
1312 {
1313 if (deleted)
1314 panic ("callback from %s to %s on deleted object\n",
1315 this->line, this->dest);
1316 return ((*c).*f) (a1, b1);
1317 }
1318 #else /* !WRAP_USE_NODELETE */
1319 A1 a1;
1320 public:
1321 callback_c_1_1 (callback_line_param const P &cc, cb_t ff, const A1 &aa1)
1322 : callback_line_init (callback<R, B1>) c (cc), f (ff), a1 (aa1) {}
1323 R operator() (B1 b1)
1324 { return ((*c).*f) (a1, b1); }
1325 #endif /* !WRAP_USE_NODELETE */
1326 };
1327
1328 template<class C, class R, class B1, class A1, class AA1>
1329 static inline refcounted<callback_c_1_1<C *, C, R, B1, A1> > *
1330 wrap (wrap_line_param C *p, R (C::*f) (A1, B1), const AA1 &a1)
1331 {
1332 return wNew (refcounted<callback_c_1_1<C *, C, R, B1, A1> >) (wrap_c_line_arg p, f, a1);
1333 }
1334
1335 template<class C, class R, class B1, class A1, class AA1>
1336 static inline refcounted<callback_c_1_1<ref<C>, C, R, B1, A1> > *
1337 wrap (wrap_line_param const ref<C> &p, R (C::*f) (A1, B1), const AA1 &a1)
1338 {
1339 return wNew (refcounted<callback_c_1_1<ref<C>, C, R, B1, A1> >) (wrap_c_line_arg p, f, a1);
1340 }
1341 template<class C, class R, class B1, class A1, class AA1>
1342 static inline refcounted<callback_c_1_1<ref<C>, C, R, B1, A1> > *
1343 wrap (wrap_line_param const ptr<C> &p, R (C::*f) (A1, B1), const AA1 &a1)
1344 {
1345 return wNew (refcounted<callback_c_1_1<ref<C>, C, R, B1, A1> >) (wrap_c_line_arg p, f, a1);
1346 }
1347 template<class C, class R, class B1, class A1, class AA1>
1348 static inline refcounted<callback_c_1_1<ref<C>, C, R, B1, A1> > *
1349 wrap (wrap_line_param const refcounted<C> *p, R (C::*f) (A1, B1), const AA1 &a1)
1350 {
1351 return wNew (refcounted<callback_c_1_1<ref<C>, C, R, B1, A1> >) (wrap_c_line_arg p, f, a1);
1352 }
1353
1354 template<class R, class B1, class A1, class A2>
1355 class callback_1_2
1356 : public callback<R, B1> {
1357 typedef R (*cb_t) (A1, A2, B1);
1358 cb_t f;
1359 A1 a1;
1360 A2 a2;
1361 public:
1362 callback_1_2 (callback_line_param cb_t ff, const A1 &aa1, const A2 &aa2)
1363 : callback_line_init (callback<R, B1>) f (ff), a1 (aa1), a2 (aa2) {}
1364 R operator() (B1 b1)
1365 { return f (a1, a2, b1); }
1366 };
1367
1368 template<class R, class B1, class A1, class AA1, class A2, class AA2>
1369 static inline refcounted<callback_1_2<R, B1, A1, A2> > *
1370 wrap (wrap_line_param R (*f) (A1, A2, B1), const AA1 &a1, const AA2 &a2)
1371 {
1372 return wNew (refcounted<callback_1_2<R, B1, A1, A2> >) (wrap_line_arg f, a1, a2);
1373 }
1374
1375 template<class P, class C, class R, class B1, class A1, class A2>
1376 class callback_c_1_2
1377 : public callback<R, B1> {
1378 typedef R (C::*cb_t) (A1, A2, B1);
1379 P c;
1380 cb_t f;
1381 #if WRAP_USE_NODELETE
1382 A1 a1;
1383 A2 a2;
1384 int deleted;
1385 public:
1386 callback_c_1_2 (callback_line_param const P &cc, cb_t ff, const A1 &aa1, const A2 &aa2)
1387 : callback_line_init (callback<R, B1>) c (cc), f (ff), a1 (aa1), a2 (aa2),
1388 deleted (false)
1389 { maybe_nodelete_addptr (c, this->line, &deleted); }
1390 ~callback_c_1_2 () { maybe_nodelete_remptr (c, this->line, &deleted); }
1391 R operator() (B1 b1)
1392 {
1393 if (deleted)
1394 panic ("callback from %s to %s on deleted object\n",
1395 this->line, this->dest);
1396 return ((*c).*f) (a1, a2, b1);
1397 }
1398 #else /* !WRAP_USE_NODELETE */
1399 A1 a1;
1400 A2 a2;
1401 public:
1402 callback_c_1_2 (callback_line_param const P &cc, cb_t ff, const A1 &aa1, const A2 &aa2)
1403 : callback_line_init (callback<R, B1>) c (cc), f (ff), a1 (aa1), a2 (aa2) {}
1404 R operator() (B1 b1)
1405 { return ((*c).*f) (a1, a2, b1); }
1406 #endif /* !WRAP_USE_NODELETE */
1407 };
1408
1409 template<class C, class R, class B1, class A1, class AA1, class A2, class AA2>
1410 static inline refcounted<callback_c_1_2<C *, C, R, B1, A1, A2> > *
1411 wrap (wrap_line_param C *p, R (C::*f) (A1, A2, B1), const AA1 &a1, const AA2 &a2)
1412 {
1413 return wNew (refcounted<callback_c_1_2<C *, C, R, B1, A1, A2> >) (wrap_c_line_arg p, f, a1, a2);
1414 }
1415
1416 template<class C, class R, class B1, class A1, class AA1, class A2, class AA2>
1417 static inline refcounted<callback_c_1_2<ref<C>, C, R, B1, A1, A2> > *
1418 wrap (wrap_line_param const ref<C> &p, R (C::*f) (A1, A2, B1), const AA1 &a1, const AA2 &a2)
1419 {
1420 return wNew (refcounted<callback_c_1_2<ref<C>, C, R, B1, A1, A2> >) (wrap_c_line_arg p, f, a1, a2);
1421 }
1422 template<class C, class R, class B1, class A1, class AA1, class A2, class AA2>
1423 static inline refcounted<callback_c_1_2<ref<C>, C, R, B1, A1, A2> > *
1424 wrap (wrap_line_param const ptr<C> &p, R (C::*f) (A1, A2, B1), const AA1 &a1, const AA2 &a2)
1425 {
1426 return wNew (refcounted<callback_c_1_2<ref<C>, C, R, B1, A1, A2> >) (wrap_c_line_arg p, f, a1, a2);
1427 }
1428 template<class C, class R, class B1, class A1, class AA1, class A2, class AA2>
1429 static inline refcounted<callback_c_1_2<ref<C>, C, R, B1, A1, A2> > *
1430 wrap (wrap_line_param const refcounted<C> *p, R (C::*f) (A1, A2, B1), const AA1 &a1, const AA2 &a2)
1431 {
1432 return wNew (refcounted<callback_c_1_2<ref<C>, C, R, B1, A1, A2> >) (wrap_c_line_arg p, f, a1, a2);
1433 }
1434
1435 template<class R, class B1, class A1, class A2, class A3>
1436 class callback_1_3
1437 : public callback<R, B1> {
1438 typedef R (*cb_t) (A1, A2, A3, B1);
1439 cb_t f;
1440 A1 a1;
1441 A2 a2;
1442 A3 a3;
1443 public:
1444 callback_1_3 (callback_line_param cb_t ff, const A1 &aa1, const A2 &aa2, const A3 &aa3)
1445 : callback_line_init (callback<R, B1>) f (ff), a1 (aa1), a2 (aa2), a3 (aa3) {}
1446 R operator() (B1 b1)
1447 { return f (a1, a2, a3, b1); }
1448 };
1449
1450 template<class R, class B1, class A1, class AA1, class A2, class AA2, class A3, class AA3>
1451 static inline refcounted<callback_1_3<R, B1, A1, A2, A3> > *
1452 wrap (wrap_line_param R (*f) (A1, A2, A3, B1), const AA1 &a1, const AA2 &a2, const AA3 &a3)
1453 {
1454 return wNew (refcounted<callback_1_3<R, B1, A1, A2, A3> >) (wrap_line_arg f, a1, a2, a3);
1455 }
1456
1457 template<class P, class C, class R, class B1, class A1, class A2, class A3>
1458 class callback_c_1_3
1459 : public callback<R, B1> {
1460 typedef R (C::*cb_t) (A1, A2, A3, B1);
1461 P c;
1462 cb_t f;
1463 #if WRAP_USE_NODELETE
1464 A1 a1;
1465 A2 a2;
1466 A3 a3;
1467 int deleted;
1468 public:
1469 callback_c_1_3 (callback_line_param const P &cc, cb_t ff, const A1 &aa1, const A2 &aa2, const A3 &aa3)
1470 : callback_line_init (callback<R, B1>) c (cc), f (ff), a1 (aa1), a2 (aa2), a3 (aa3),
1471 deleted (false)
1472 { maybe_nodelete_addptr (c, this->line, &deleted); }
1473 ~callback_c_1_3 () { maybe_nodelete_remptr (c, this->line, &deleted); }
1474 R operator() (B1 b1)
1475 {
1476 if (deleted)
1477 panic ("callback from %s to %s on deleted object\n",
1478 this->line, this->dest);
1479 return ((*c).*f) (a1, a2, a3, b1);
1480 }
1481 #else /* !WRAP_USE_NODELETE */
1482 A1 a1;
1483 A2 a2;
1484 A3 a3;
1485 public:
1486 callback_c_1_3 (callback_line_param const P &cc, cb_t ff, const A1 &aa1, const A2 &aa2, const A3 &aa3)
1487 : callback_line_init (callback<R, B1>) c (cc), f (ff), a1 (aa1), a2 (aa2), a3 (aa3) {}
1488 R operator() (B1 b1)
1489 { return ((*c).*f) (a1, a2, a3, b1); }
1490 #endif /* !WRAP_USE_NODELETE */
1491 };
1492
1493 template<class C, class R, class B1, class A1, class AA1, class A2, class AA2, class A3, class AA3>
1494 static inline refcounted<callback_c_1_3<C *, C, R, B1, A1, A2, A3> > *
1495 wrap (wrap_line_param C *p, R (C::*f) (A1, A2, A3, B1), const AA1 &a1, const AA2 &a2, const AA3 &a3)
1496 {
1497 return wNew (refcounted<callback_c_1_3<C *, C, R, B1, A1, A2, A3> >) (wrap_c_line_arg p, f, a1, a2, a3);
1498 }
1499
1500 template<class C, class R, class B1, class A1, class AA1, class A2, class AA2, class A3, class AA3>
1501 static inline refcounted<callback_c_1_3<ref<C>, C, R, B1, A1, A2, A3> > *
1502 wrap (wrap_line_param const ref<C> &p, R (C::*f) (A1, A2, A3, B1), const AA1 &a1, const AA2 &a2, const AA3 &a3)
1503 {
1504 return wNew (refcounted<callback_c_1_3<ref<C>, C, R, B1, A1, A2, A3> >) (wrap_c_line_arg p, f, a1, a2, a3);
1505 }
1506 template<class C, class R, class B1, class A1, class AA1, class A2, class AA2, class A3, class AA3>
1507 static inline refcounted<callback_c_1_3<ref<C>, C, R, B1, A1, A2, A3> > *
1508 wrap (wrap_line_param const ptr<C> &p, R (C::*f) (A1, A2, A3, B1), const AA1 &a1, const AA2 &a2, const AA3 &a3)
1509 {
1510 return wNew (refcounted<callback_c_1_3<ref<C>, C, R, B1, A1, A2, A3> >) (wrap_c_line_arg p, f, a1, a2, a3);
1511 }
1512 template<class C, class R, class B1, class A1, class AA1, class A2, class AA2, class A3, class AA3>
1513 static inline refcounted<callback_c_1_3<ref<C>, C, R, B1, A1, A2, A3> > *
1514 wrap (wrap_line_param const refcounted<C> *p, R (C::*f) (A1, A2, A3, B1), const AA1 &a1, const AA2 &a2, const AA3 &a3)
1515 {
1516 return wNew (refcounted<callback_c_1_3<ref<C>, C, R, B1, A1, A2, A3> >) (wrap_c_line_arg p, f, a1, a2, a3);
1517 }
1518
1519 template<class R, class B1, class A1, class A2, class A3, class A4>
1520 class callback_1_4
1521 : public callback<R, B1> {
1522 typedef R (*cb_t) (A1, A2, A3, A4, B1);
1523 cb_t f;
1524 A1 a1;
1525 A2 a2;
1526 A3 a3;
1527 A4 a4;
1528 public:
1529 callback_1_4 (callback_line_param cb_t ff, const A1 &aa1, const A2 &aa2, const A3 &aa3, const A4 &aa4)
1530 : callback_line_init (callback<R, B1>) f (ff), a1 (aa1), a2 (aa2), a3 (aa3), a4 (aa4) {}
1531 R operator() (B1 b1)
1532 { return f (a1, a2, a3, a4, b1); }
1533 };
1534
1535 template<class R, class B1, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4>
1536 static inline refcounted<callback_1_4<R, B1, A1, A2, A3, A4> > *
1537 wrap (wrap_line_param R (*f) (A1, A2, A3, A4, B1), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4)
1538 {
1539 return wNew (refcounted<callback_1_4<R, B1, A1, A2, A3, A4> >) (wrap_line_arg f, a1, a2, a3, a4);
1540 }
1541
1542 template<class P, class C, class R, class B1, class A1, class A2, class A3, class A4>
1543 class callback_c_1_4
1544 : public callback<R, B1> {
1545 typedef R (C::*cb_t) (A1, A2, A3, A4, B1);
1546 P c;
1547 cb_t f;
1548 #if WRAP_USE_NODELETE
1549 A1 a1;
1550 A2 a2;
1551 A3 a3;
1552 A4 a4;
1553 int deleted;
1554 public:
1555 callback_c_1_4 (callback_line_param const P &cc, cb_t ff, const A1 &aa1, const A2 &aa2, const A3 &aa3, const A4 &aa4)
1556 : callback_line_init (callback<R, B1>) c (cc), f (ff), a1 (aa1), a2 (aa2), a3 (aa3), a4 (aa4),
1557 deleted (false)
1558 { maybe_nodelete_addptr (c, this->line, &deleted); }
1559 ~callback_c_1_4 () { maybe_nodelete_remptr (c, this->line, &deleted); }
1560 R operator() (B1 b1)
1561 {
1562 if (deleted)
1563 panic ("callback from %s to %s on deleted object\n",
1564 this->line, this->dest);
1565 return ((*c).*f) (a1, a2, a3, a4, b1);
1566 }
1567 #else /* !WRAP_USE_NODELETE */
1568 A1 a1;
1569 A2 a2;
1570 A3 a3;
1571 A4 a4;
1572 public:
1573 callback_c_1_4 (callback_line_param const P &cc, cb_t ff, const A1 &aa1, const A2 &aa2, const A3 &aa3, const A4 &aa4)
1574 : callback_line_init (callback<R, B1>) c (cc), f (ff), a1 (aa1), a2 (aa2), a3 (aa3), a4 (aa4) {}
1575 R operator() (B1 b1)
1576 { return ((*c).*f) (a1, a2, a3, a4, b1); }
1577 #endif /* !WRAP_USE_NODELETE */
1578 };
1579
1580 template<class C, class R, class B1, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4>
1581 static inline refcounted<callback_c_1_4<C *, C, R, B1, A1, A2, A3, A4> > *
1582 wrap (wrap_line_param C *p, R (C::*f) (A1, A2, A3, A4, B1), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4)
1583 {
1584 return wNew (refcounted<callback_c_1_4<C *, C, R, B1, A1, A2, A3, A4> >) (wrap_c_line_arg p, f, a1, a2, a3, a4);
1585 }
1586
1587 template<class C, class R, class B1, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4>
1588 static inline refcounted<callback_c_1_4<ref<C>, C, R, B1, A1, A2, A3, A4> > *
1589 wrap (wrap_line_param const ref<C> &p, R (C::*f) (A1, A2, A3, A4, B1), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4)
1590 {
1591 return wNew (refcounted<callback_c_1_4<ref<C>, C, R, B1, A1, A2, A3, A4> >) (wrap_c_line_arg p, f, a1, a2, a3, a4);
1592 }
1593 template<class C, class R, class B1, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4>
1594 static inline refcounted<callback_c_1_4<ref<C>, C, R, B1, A1, A2, A3, A4> > *
1595 wrap (wrap_line_param const ptr<C> &p, R (C::*f) (A1, A2, A3, A4, B1), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4)
1596 {
1597 return wNew (refcounted<callback_c_1_4<ref<C>, C, R, B1, A1, A2, A3, A4> >) (wrap_c_line_arg p, f, a1, a2, a3, a4);
1598 }
1599 template<class C, class R, class B1, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4>
1600 static inline refcounted<callback_c_1_4<ref<C>, C, R, B1, A1, A2, A3, A4> > *
1601 wrap (wrap_line_param const refcounted<C> *p, R (C::*f) (A1, A2, A3, A4, B1), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4)
1602 {
1603 return wNew (refcounted<callback_c_1_4<ref<C>, C, R, B1, A1, A2, A3, A4> >) (wrap_c_line_arg p, f, a1, a2, a3, a4);
1604 }
1605
1606 template<class R, class B1, class A1, class A2, class A3, class A4, class A5>
1607 class callback_1_5
1608 : public callback<R, B1> {
1609 typedef R (*cb_t) (A1, A2, A3, A4, A5, B1);
1610 cb_t f;
1611 A1 a1;
1612 A2 a2;
1613 A3 a3;
1614 A4 a4;
1615 A5 a5;
1616 public:
1617 callback_1_5 (callback_line_param cb_t ff, const A1 &aa1, const A2 &aa2, const A3 &aa3, const A4 &aa4, const A5 &aa5)
1618 : callback_line_init (callback<R, B1>) f (ff), a1 (aa1), a2 (aa2), a3 (aa3), a4 (aa4), a5 (aa5) {}
1619 R operator() (B1 b1)
1620 { return f (a1, a2, a3, a4, a5, b1); }
1621 };
1622
1623 template<class R, class B1, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4, class A5, class AA5>
1624 static inline refcounted<callback_1_5<R, B1, A1, A2, A3, A4, A5> > *
1625 wrap (wrap_line_param R (*f) (A1, A2, A3, A4, A5, B1), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4, const AA5 &a5)
1626 {
1627 return wNew (refcounted<callback_1_5<R, B1, A1, A2, A3, A4, A5> >) (wrap_line_arg f, a1, a2, a3, a4, a5);
1628 }
1629
1630 template<class P, class C, class R, class B1, class A1, class A2, class A3, class A4, class A5>
1631 class callback_c_1_5
1632 : public callback<R, B1> {
1633 typedef R (C::*cb_t) (A1, A2, A3, A4, A5, B1);
1634 P c;
1635 cb_t f;
1636 #if WRAP_USE_NODELETE
1637 A1 a1;
1638 A2 a2;
1639 A3 a3;
1640 A4 a4;
1641 A5 a5;
1642 int deleted;
1643 public:
1644 callback_c_1_5 (callback_line_param const P &cc, cb_t ff, const A1 &aa1, const A2 &aa2, const A3 &aa3, const A4 &aa4, const A5 &aa5)
1645 : callback_line_init (callback<R, B1>) c (cc), f (ff), a1 (aa1), a2 (aa2), a3 (aa3), a4 (aa4), a5 (aa5),
1646 deleted (false)
1647 { maybe_nodelete_addptr (c, this->line, &deleted); }
1648 ~callback_c_1_5 () { maybe_nodelete_remptr (c, this->line, &deleted); }
1649 R operator() (B1 b1)
1650 {
1651 if (deleted)
1652 panic ("callback from %s to %s on deleted object\n",
1653 this->line, this->dest);
1654 return ((*c).*f) (a1, a2, a3, a4, a5, b1);
1655 }
1656 #else /* !WRAP_USE_NODELETE */
1657 A1 a1;
1658 A2 a2;
1659 A3 a3;
1660 A4 a4;
1661 A5 a5;
1662 public:
1663 callback_c_1_5 (callback_line_param const P &cc, cb_t ff, const A1 &aa1, const A2 &aa2, const A3 &aa3, const A4 &aa4, const A5 &aa5)
1664 : callback_line_init (callback<R, B1>) c (cc), f (ff), a1 (aa1), a2 (aa2), a3 (aa3), a4 (aa4), a5 (aa5) {}
1665 R operator() (B1 b1)
1666 { return ((*c).*f) (a1, a2, a3, a4, a5, b1); }
1667 #endif /* !WRAP_USE_NODELETE */
1668 };
1669
1670 template<class C, class R, class B1, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4, class A5, class AA5>
1671 static inline refcounted<callback_c_1_5<C *, C, R, B1, A1, A2, A3, A4, A5> > *
1672 wrap (wrap_line_param C *p, R (C::*f) (A1, A2, A3, A4, A5, B1), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4, const AA5 &a5)
1673 {
1674 return wNew (refcounted<callback_c_1_5<C *, C, R, B1, A1, A2, A3, A4, A5> >) (wrap_c_line_arg p, f, a1, a2, a3, a4, a5);
1675 }
1676
1677 template<class C, class R, class B1, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4, class A5, class AA5>
1678 static inline refcounted<callback_c_1_5<ref<C>, C, R, B1, A1, A2, A3, A4, A5> > *
1679 wrap (wrap_line_param const ref<C> &p, R (C::*f) (A1, A2, A3, A4, A5, B1), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4, const AA5 &a5)
1680 {
1681 return wNew (refcounted<callback_c_1_5<ref<C>, C, R, B1, A1, A2, A3, A4, A5> >) (wrap_c_line_arg p, f, a1, a2, a3, a4, a5);
1682 }
1683 template<class C, class R, class B1, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4, class A5, class AA5>
1684 static inline refcounted<callback_c_1_5<ref<C>, C, R, B1, A1, A2, A3, A4, A5> > *
1685 wrap (wrap_line_param const ptr<C> &p, R (C::*f) (A1, A2, A3, A4, A5, B1), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4, const AA5 &a5)
1686 {
1687 return wNew (refcounted<callback_c_1_5<ref<C>, C, R, B1, A1, A2, A3, A4, A5> >) (wrap_c_line_arg p, f, a1, a2, a3, a4, a5);
1688 }
1689 template<class C, class R, class B1, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4, class A5, class AA5>
1690 static inline refcounted<callback_c_1_5<ref<C>, C, R, B1, A1, A2, A3, A4, A5> > *
1691 wrap (wrap_line_param const refcounted<C> *p, R (C::*f) (A1, A2, A3, A4, A5, B1), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4, const AA5 &a5)
1692 {
1693 return wNew (refcounted<callback_c_1_5<ref<C>, C, R, B1, A1, A2, A3, A4, A5> >) (wrap_c_line_arg p, f, a1, a2, a3, a4, a5);
1694 }
1695
1696 template<class R, class B1, class B2>
1697 class callback<R, B1, B2> {
1698 public:
1699 typedef struct ref<callback<R, B1, B2> > ref;
1700 typedef struct ptr<callback<R, B1, B2> > ptr;
1701
1702 #if WRAP_DEBUG
1703 const char *const dest;
1704 const char *const src;
1705 const char *const line;
1706 callback (const char *df, const char *f, const char *l)
1707 : dest (df[0] == '&' ? df + 1 : df), src (f), line (l) {}
1708 #endif /* WRAP_DEBUG */
1709 virtual R operator() (B1, B2) = 0;
1710 virtual ~callback () {}
1711 };
1712
1713
1714 template<class R, class B1, class B2>
1715 class callback_2_0
1716 : public callback<R, B1, B2> {
1717 typedef R (*cb_t) (B1, B2);
1718 cb_t f;
1719 public:
1720 callback_2_0 (callback_line_param cb_t ff)
1721 : callback_line_init (callback<R, B1, B2>) f (ff) {}
1722 R operator() (B1 b1, B2 b2)
1723 { return f (b1, b2); }
1724 };
1725
1726 template<class R, class B1, class B2>
1727 static inline refcounted<callback_2_0<R, B1, B2> > *
1728 wrap (wrap_line_param R (*f) (B1, B2))
1729 {
1730 return wNew (refcounted<callback_2_0<R, B1, B2> >) (wrap_line_arg f);
1731 }
1732
1733 template<class P, class C, class R, class B1, class B2>
1734 class callback_c_2_0
1735 : public callback<R, B1, B2> {
1736 typedef R (C::*cb_t) (B1, B2);
1737 P c;
1738 cb_t f;
1739 #if WRAP_USE_NODELETE
1740 int deleted;
1741 public:
1742 callback_c_2_0 (callback_line_param const P &cc, cb_t ff)
1743 : callback_line_init (callback<R, B1, B2>) c (cc), f (ff),
1744 deleted (false)
1745 { maybe_nodelete_addptr (c, this->line, &deleted); }
1746 ~callback_c_2_0 () { maybe_nodelete_remptr (c, this->line, &deleted); }
1747 R operator() (B1 b1, B2 b2)
1748 {
1749 if (deleted)
1750 panic ("callback from %s to %s on deleted object\n",
1751 this->line, this->dest);
1752 return ((*c).*f) (b1, b2);
1753 }
1754 #else /* !WRAP_USE_NODELETE */
1755 public:
1756 callback_c_2_0 (callback_line_param const P &cc, cb_t ff)
1757 : callback_line_init (callback<R, B1, B2>) c (cc), f (ff) {}
1758 R operator() (B1 b1, B2 b2)
1759 { return ((*c).*f) (b1, b2); }
1760 #endif /* !WRAP_USE_NODELETE */
1761 };
1762
1763 template<class C, class R, class B1, class B2>
1764 static inline refcounted<callback_c_2_0<C *, C, R, B1, B2> > *
1765 wrap (wrap_line_param C *p, R (C::*f) (B1, B2))
1766 {
1767 return wNew (refcounted<callback_c_2_0<C *, C, R, B1, B2> >) (wrap_c_line_arg p, f);
1768 }
1769
1770 template<class C, class R, class B1, class B2>
1771 static inline refcounted<callback_c_2_0<ref<C>, C, R, B1, B2> > *
1772 wrap (wrap_line_param const ref<C> &p, R (C::*f) (B1, B2))
1773 {
1774 return wNew (refcounted<callback_c_2_0<ref<C>, C, R, B1, B2> >) (wrap_c_line_arg p, f);
1775 }
1776 template<class C, class R, class B1, class B2>
1777 static inline refcounted<callback_c_2_0<ref<C>, C, R, B1, B2> > *
1778 wrap (wrap_line_param const ptr<C> &p, R (C::*f) (B1, B2))
1779 {
1780 return wNew (refcounted<callback_c_2_0<ref<C>, C, R, B1, B2> >) (wrap_c_line_arg p, f);
1781 }
1782 template<class C, class R, class B1, class B2>
1783 static inline refcounted<callback_c_2_0<ref<C>, C, R, B1, B2> > *
1784 wrap (wrap_line_param const refcounted<C> *p, R (C::*f) (B1, B2))
1785 {
1786 return wNew (refcounted<callback_c_2_0<ref<C>, C, R, B1, B2> >) (wrap_c_line_arg p, f);
1787 }
1788
1789 template<class R, class B1, class B2, class A1>
1790 class callback_2_1
1791 : public callback<R, B1, B2> {
1792 typedef R (*cb_t) (A1, B1, B2);
1793 cb_t f;
1794 A1 a1;
1795 public:
1796 callback_2_1 (callback_line_param cb_t ff, const A1 &aa1)
1797 : callback_line_init (callback<R, B1, B2>) f (ff), a1 (aa1) {}
1798 R operator() (B1 b1, B2 b2)
1799 { return f (a1, b1, b2); }
1800 };
1801
1802 template<class R, class B1, class B2, class A1, class AA1>
1803 static inline refcounted<callback_2_1<R, B1, B2, A1> > *
1804 wrap (wrap_line_param R (*f) (A1, B1, B2), const AA1 &a1)
1805 {
1806 return wNew (refcounted<callback_2_1<R, B1, B2, A1> >) (wrap_line_arg f, a1);
1807 }
1808
1809 template<class P, class C, class R, class B1, class B2, class A1>
1810 class callback_c_2_1
1811 : public callback<R, B1, B2> {
1812 typedef R (C::*cb_t) (A1, B1, B2);
1813 P c;
1814 cb_t f;
1815 #if WRAP_USE_NODELETE
1816 A1 a1;
1817 int deleted;
1818 public:
1819 callback_c_2_1 (callback_line_param const P &cc, cb_t ff, const A1 &aa1)
1820 : callback_line_init (callback<R, B1, B2>) c (cc), f (ff), a1 (aa1),
1821 deleted (false)
1822 { maybe_nodelete_addptr (c, this->line, &deleted); }
1823 ~callback_c_2_1 () { maybe_nodelete_remptr (c, this->line, &deleted); }
1824 R operator() (B1 b1, B2 b2)
1825 {
1826 if (deleted)
1827 panic ("callback from %s to %s on deleted object\n",
1828 this->line, this->dest);
1829 return ((*c).*f) (a1, b1, b2);
1830 }
1831 #else /* !WRAP_USE_NODELETE */
1832 A1 a1;
1833 public:
1834 callback_c_2_1 (callback_line_param const P &cc, cb_t ff, const A1 &aa1)
1835 : callback_line_init (callback<R, B1, B2>) c (cc), f (ff), a1 (aa1) {}
1836 R operator() (B1 b1, B2 b2)
1837 { return ((*c).*f) (a1, b1, b2); }
1838 #endif /* !WRAP_USE_NODELETE */
1839 };
1840
1841 template<class C, class R, class B1, class B2, class A1, class AA1>
1842 static inline refcounted<callback_c_2_1<C *, C, R, B1, B2, A1> > *
1843 wrap (wrap_line_param C *p, R (C::*f) (A1, B1, B2), const AA1 &a1)
1844 {
1845 return wNew (refcounted<callback_c_2_1<C *, C, R, B1, B2, A1> >) (wrap_c_line_arg p, f, a1);
1846 }
1847
1848 template<class C, class R, class B1, class B2, class A1, class AA1>
1849 static inline refcounted<callback_c_2_1<ref<C>, C, R, B1, B2, A1> > *
1850 wrap (wrap_line_param const ref<C> &p, R (C::*f) (A1, B1, B2), const AA1 &a1)
1851 {
1852 return wNew (refcounted<callback_c_2_1<ref<C>, C, R, B1, B2, A1> >) (wrap_c_line_arg p, f, a1);
1853 }
1854 template<class C, class R, class B1, class B2, class A1, class AA1>
1855 static inline refcounted<callback_c_2_1<ref<C>, C, R, B1, B2, A1> > *
1856 wrap (wrap_line_param const ptr<C> &p, R (C::*f) (A1, B1, B2), const AA1 &a1)
1857 {
1858 return wNew (refcounted<callback_c_2_1<ref<C>, C, R, B1, B2, A1> >) (wrap_c_line_arg p, f, a1);
1859 }
1860 template<class C, class R, class B1, class B2, class A1, class AA1>
1861 static inline refcounted<callback_c_2_1<ref<C>, C, R, B1, B2, A1> > *
1862 wrap (wrap_line_param const refcounted<C> *p, R (C::*f) (A1, B1, B2), const AA1 &a1)
1863 {
1864 return wNew (refcounted<callback_c_2_1<ref<C>, C, R, B1, B2, A1> >) (wrap_c_line_arg p, f, a1);
1865 }
1866
1867 template<class R, class B1, class B2, class A1, class A2>
1868 class callback_2_2
1869 : public callback<R, B1, B2> {
1870 typedef R (*cb_t) (A1, A2, B1, B2);
1871 cb_t f;
1872 A1 a1;
1873 A2 a2;
1874 public:
1875 callback_2_2 (callback_line_param cb_t ff, const A1 &aa1, const A2 &aa2)
1876 : callback_line_init (callback<R, B1, B2>) f (ff), a1 (aa1), a2 (aa2) {}
1877 R operator() (B1 b1, B2 b2)
1878 { return f (a1, a2, b1, b2); }
1879 };
1880
1881 template<class R, class B1, class B2, class A1, class AA1, class A2, class AA2>
1882 static inline refcounted<callback_2_2<R, B1, B2, A1, A2> > *
1883 wrap (wrap_line_param R (*f) (A1, A2, B1, B2), const AA1 &a1, const AA2 &a2)
1884 {
1885 return wNew (refcounted<callback_2_2<R, B1, B2, A1, A2> >) (wrap_line_arg f, a1, a2);
1886 }
1887
1888 template<class P, class C, class R, class B1, class B2, class A1, class A2>
1889 class callback_c_2_2
1890 : public callback<R, B1, B2> {
1891 typedef R (C::*cb_t) (A1, A2, B1, B2);
1892 P c;
1893 cb_t f;
1894 #if WRAP_USE_NODELETE
1895 A1 a1;
1896 A2 a2;
1897 int deleted;
1898 public:
1899 callback_c_2_2 (callback_line_param const P &cc, cb_t ff, const A1 &aa1, const A2 &aa2)
1900 : callback_line_init (callback<R, B1, B2>) c (cc), f (ff), a1 (aa1), a2 (aa2),
1901 deleted (false)
1902 { maybe_nodelete_addptr (c, this->line, &deleted); }
1903 ~callback_c_2_2 () { maybe_nodelete_remptr (c, this->line, &deleted); }
1904 R operator() (B1 b1, B2 b2)
1905 {
1906 if (deleted)
1907 panic ("callback from %s to %s on deleted object\n",
1908 this->line, this->dest);
1909 return ((*c).*f) (a1, a2, b1, b2);
1910 }
1911 #else /* !WRAP_USE_NODELETE */
1912 A1 a1;
1913 A2 a2;
1914 public:
1915 callback_c_2_2 (callback_line_param const P &cc, cb_t ff, const A1 &aa1, const A2 &aa2)
1916 : callback_line_init (callback<R, B1, B2>) c (cc), f (ff), a1 (aa1), a2 (aa2) {}
1917 R operator() (B1 b1, B2 b2)
1918 { return ((*c).*f) (a1, a2, b1, b2); }
1919 #endif /* !WRAP_USE_NODELETE */
1920 };
1921
1922 template<class C, class R, class B1, class B2, class A1, class AA1, class A2, class AA2>
1923 static inline refcounted<callback_c_2_2<C *, C, R, B1, B2, A1, A2> > *
1924 wrap (wrap_line_param C *p, R (C::*f) (A1, A2, B1, B2), const AA1 &a1, const AA2 &a2)
1925 {
1926 return wNew (refcounted<callback_c_2_2<C *, C, R, B1, B2, A1, A2> >) (wrap_c_line_arg p, f, a1, a2);
1927 }
1928
1929 template<class C, class R, class B1, class B2, class A1, class AA1, class A2, class AA2>
1930 static inline refcounted<callback_c_2_2<ref<C>, C, R, B1, B2, A1, A2> > *
1931 wrap (wrap_line_param const ref<C> &p, R (C::*f) (A1, A2, B1, B2), const AA1 &a1, const AA2 &a2)
1932 {
1933 return wNew (refcounted<callback_c_2_2<ref<C>, C, R, B1, B2, A1, A2> >) (wrap_c_line_arg p, f, a1, a2);
1934 }
1935 template<class C, class R, class B1, class B2, class A1, class AA1, class A2, class AA2>
1936 static inline refcounted<callback_c_2_2<ref<C>, C, R, B1, B2, A1, A2> > *
1937 wrap (wrap_line_param const ptr<C> &p, R (C::*f) (A1, A2, B1, B2), const AA1 &a1, const AA2 &a2)
1938 {
1939 return wNew (refcounted<callback_c_2_2<ref<C>, C, R, B1, B2, A1, A2> >) (wrap_c_line_arg p, f, a1, a2);
1940 }
1941 template<class C, class R, class B1, class B2, class A1, class AA1, class A2, class AA2>
1942 static inline refcounted<callback_c_2_2<ref<C>, C, R, B1, B2, A1, A2> > *
1943 wrap (wrap_line_param const refcounted<C> *p, R (C::*f) (A1, A2, B1, B2), const AA1 &a1, const AA2 &a2)
1944 {
1945 return wNew (refcounted<callback_c_2_2<ref<C>, C, R, B1, B2, A1, A2> >) (wrap_c_line_arg p, f, a1, a2);
1946 }
1947
1948 template<class R, class B1, class B2, class A1, class A2, class A3>
1949 class callback_2_3
1950 : public callback<R, B1, B2> {
1951 typedef R (*cb_t) (A1, A2, A3, B1, B2);
1952 cb_t f;
1953 A1 a1;
1954 A2 a2;
1955 A3 a3;
1956 public:
1957 callback_2_3 (callback_line_param cb_t ff, const A1 &aa1, const A2 &aa2, const A3 &aa3)
1958 : callback_line_init (callback<R, B1, B2>) f (ff), a1 (aa1), a2 (aa2), a3 (aa3) {}
1959 R operator() (B1 b1, B2 b2)
1960 { return f (a1, a2, a3, b1, b2); }
1961 };
1962
1963 template<class R, class B1, class B2, class A1, class AA1, class A2, class AA2, class A3, class AA3>
1964 static inline refcounted<callback_2_3<R, B1, B2, A1, A2, A3> > *
1965 wrap (wrap_line_param R (*f) (A1, A2, A3, B1, B2), const AA1 &a1, const AA2 &a2, const AA3 &a3)
1966 {
1967 return wNew (refcounted<callback_2_3<R, B1, B2, A1, A2, A3> >) (wrap_line_arg f, a1, a2, a3);
1968 }
1969
1970 template<class P, class C, class R, class B1, class B2, class A1, class A2, class A3>
1971 class callback_c_2_3
1972 : public callback<R, B1, B2> {
1973 typedef R (C::*cb_t) (A1, A2, A3, B1, B2);
1974 P c;
1975 cb_t f;
1976 #if WRAP_USE_NODELETE
1977 A1 a1;
1978 A2 a2;
1979 A3 a3;
1980 int deleted;
1981 public:
1982 callback_c_2_3 (callback_line_param const P &cc, cb_t ff, const A1 &aa1, const A2 &aa2, const A3 &aa3)
1983 : callback_line_init (callback<R, B1, B2>) c (cc), f (ff), a1 (aa1), a2 (aa2), a3 (aa3),
1984 deleted (false)
1985 { maybe_nodelete_addptr (c, this->line, &deleted); }
1986 ~callback_c_2_3 () { maybe_nodelete_remptr (c, this->line, &deleted); }
1987 R operator() (B1 b1, B2 b2)
1988 {
1989 if (deleted)
1990 panic ("callback from %s to %s on deleted object\n",
1991 this->line, this->dest);
1992 return ((*c).*f) (a1, a2, a3, b1, b2);
1993 }
1994 #else /* !WRAP_USE_NODELETE */
1995 A1 a1;
1996 A2 a2;
1997 A3 a3;
1998 public:
1999 callback_c_2_3 (callback_line_param const P &cc, cb_t ff, const A1 &aa1, const A2 &aa2, const A3 &aa3)
2000 : callback_line_init (callback<R, B1, B2>) c (cc), f (ff), a1 (aa1), a2 (aa2), a3 (aa3) {}
2001 R operator() (B1 b1, B2 b2)
2002 { return ((*c).*f) (a1, a2, a3, b1, b2); }
2003 #endif /* !WRAP_USE_NODELETE */
2004 };
2005
2006 template<class C, class R, class B1, class B2, class A1, class AA1, class A2, class AA2, class A3, class AA3>
2007 static inline refcounted<callback_c_2_3<C *, C, R, B1, B2, A1, A2, A3> > *
2008 wrap (wrap_line_param C *p, R (C::*f) (A1, A2, A3, B1, B2), const AA1 &a1, const AA2 &a2, const AA3 &a3)
2009 {
2010 return wNew (refcounted<callback_c_2_3<C *, C, R, B1, B2, A1, A2, A3> >) (wrap_c_line_arg p, f, a1, a2, a3);
2011 }
2012
2013 template<class C, class R, class B1, class B2, class A1, class AA1, class A2, class AA2, class A3, class AA3>
2014 static inline refcounted<callback_c_2_3<ref<C>, C, R, B1, B2, A1, A2, A3> > *
2015 wrap (wrap_line_param const ref<C> &p, R (C::*f) (A1, A2, A3, B1, B2), const AA1 &a1, const AA2 &a2, const AA3 &a3)
2016 {
2017 return wNew (refcounted<callback_c_2_3<ref<C>, C, R, B1, B2, A1, A2, A3> >) (wrap_c_line_arg p, f, a1, a2, a3);
2018 }
2019 template<class C, class R, class B1, class B2, class A1, class AA1, class A2, class AA2, class A3, class AA3>
2020 static inline refcounted<callback_c_2_3<ref<C>, C, R, B1, B2, A1, A2, A3> > *
2021 wrap (wrap_line_param const ptr<C> &p, R (C::*f) (A1, A2, A3, B1, B2), const AA1 &a1, const AA2 &a2, const AA3 &a3)
2022 {
2023 return wNew (refcounted<callback_c_2_3<ref<C>, C, R, B1, B2, A1, A2, A3> >) (wrap_c_line_arg p, f, a1, a2, a3);
2024 }
2025 template<class C, class R, class B1, class B2, class A1, class AA1, class A2, class AA2, class A3, class AA3>
2026 static inline refcounted<callback_c_2_3<ref<C>, C, R, B1, B2, A1, A2, A3> > *
2027 wrap (wrap_line_param const refcounted<C> *p, R (C::*f) (A1, A2, A3, B1, B2), const AA1 &a1, const AA2 &a2, const AA3 &a3)
2028 {
2029 return wNew (refcounted<callback_c_2_3<ref<C>, C, R, B1, B2, A1, A2, A3> >) (wrap_c_line_arg p, f, a1, a2, a3);
2030 }
2031
2032 template<class R, class B1, class B2, class A1, class A2, class A3, class A4>
2033 class callback_2_4
2034 : public callback<R, B1, B2> {
2035 typedef R (*cb_t) (A1, A2, A3, A4, B1, B2);
2036 cb_t f;
2037 A1 a1;
2038 A2 a2;
2039 A3 a3;
2040 A4 a4;
2041 public:
2042 callback_2_4 (callback_line_param cb_t ff, const A1 &aa1, const A2 &aa2, const A3 &aa3, const A4 &aa4)
2043 : callback_line_init (callback<R, B1, B2>) f (ff), a1 (aa1), a2 (aa2), a3 (aa3), a4 (aa4) {}
2044 R operator() (B1 b1, B2 b2)
2045 { return f (a1, a2, a3, a4, b1, b2); }
2046 };
2047
2048 template<class R, class B1, class B2, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4>
2049 static inline refcounted<callback_2_4<R, B1, B2, A1, A2, A3, A4> > *
2050 wrap (wrap_line_param R (*f) (A1, A2, A3, A4, B1, B2), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4)
2051 {
2052 return wNew (refcounted<callback_2_4<R, B1, B2, A1, A2, A3, A4> >) (wrap_line_arg f, a1, a2, a3, a4);
2053 }
2054
2055 template<class P, class C, class R, class B1, class B2, class A1, class A2, class A3, class A4>
2056 class callback_c_2_4
2057 : public callback<R, B1, B2> {
2058 typedef R (C::*cb_t) (A1, A2, A3, A4, B1, B2);
2059 P c;
2060 cb_t f;
2061 #if WRAP_USE_NODELETE
2062 A1 a1;
2063 A2 a2;
2064 A3 a3;
2065 A4 a4;
2066 int deleted;
2067 public:
2068 callback_c_2_4 (callback_line_param const P &cc, cb_t ff, const A1 &aa1, const A2 &aa2, const A3 &aa3, const A4 &aa4)
2069 : callback_line_init (callback<R, B1, B2>) c (cc), f (ff), a1 (aa1), a2 (aa2), a3 (aa3), a4 (aa4),
2070 deleted (false)
2071 { maybe_nodelete_addptr (c, this->line, &deleted); }
2072 ~callback_c_2_4 () { maybe_nodelete_remptr (c, this->line, &deleted); }
2073 R operator() (B1 b1, B2 b2)
2074 {
2075 if (deleted)
2076 panic ("callback from %s to %s on deleted object\n",
2077 this->line, this->dest);
2078 return ((*c).*f) (a1, a2, a3, a4, b1, b2);
2079 }
2080 #else /* !WRAP_USE_NODELETE */
2081 A1 a1;
2082 A2 a2;
2083 A3 a3;
2084 A4 a4;
2085 public:
2086 callback_c_2_4 (callback_line_param const P &cc, cb_t ff, const A1 &aa1, const A2 &aa2, const A3 &aa3, const A4 &aa4)
2087 : callback_line_init (callback<R, B1, B2>) c (cc), f (ff), a1 (aa1), a2 (aa2), a3 (aa3), a4 (aa4) {}
2088 R operator() (B1 b1, B2 b2)
2089 { return ((*c).*f) (a1, a2, a3, a4, b1, b2); }
2090 #endif /* !WRAP_USE_NODELETE */
2091 };
2092
2093 template<class C, class R, class B1, class B2, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4>
2094 static inline refcounted<callback_c_2_4<C *, C, R, B1, B2, A1, A2, A3, A4> > *
2095 wrap (wrap_line_param C *p, R (C::*f) (A1, A2, A3, A4, B1, B2), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4)
2096 {
2097 return wNew (refcounted<callback_c_2_4<C *, C, R, B1, B2, A1, A2, A3, A4> >) (wrap_c_line_arg p, f, a1, a2, a3, a4);
2098 }
2099
2100 template<class C, class R, class B1, class B2, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4>
2101 static inline refcounted<callback_c_2_4<ref<C>, C, R, B1, B2, A1, A2, A3, A4> > *
2102 wrap (wrap_line_param const ref<C> &p, R (C::*f) (A1, A2, A3, A4, B1, B2), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4)
2103 {
2104 return wNew (refcounted<callback_c_2_4<ref<C>, C, R, B1, B2, A1, A2, A3, A4> >) (wrap_c_line_arg p, f, a1, a2, a3, a4);
2105 }
2106 template<class C, class R, class B1, class B2, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4>
2107 static inline refcounted<callback_c_2_4<ref<C>, C, R, B1, B2, A1, A2, A3, A4> > *
2108 wrap (wrap_line_param const ptr<C> &p, R (C::*f) (A1, A2, A3, A4, B1, B2), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4)
2109 {
2110 return wNew (refcounted<callback_c_2_4<ref<C>, C, R, B1, B2, A1, A2, A3, A4> >) (wrap_c_line_arg p, f, a1, a2, a3, a4);
2111 }
2112 template<class C, class R, class B1, class B2, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4>
2113 static inline refcounted<callback_c_2_4<ref<C>, C, R, B1, B2, A1, A2, A3, A4> > *
2114 wrap (wrap_line_param const refcounted<C> *p, R (C::*f) (A1, A2, A3, A4, B1, B2), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4)
2115 {
2116 return wNew (refcounted<callback_c_2_4<ref<C>, C, R, B1, B2, A1, A2, A3, A4> >) (wrap_c_line_arg p, f, a1, a2, a3, a4);
2117 }
2118
2119 template<class R, class B1, class B2, class A1, class A2, class A3, class A4, class A5>
2120 class callback_2_5
2121 : public callback<R, B1, B2> {
2122 typedef R (*cb_t) (A1, A2, A3, A4, A5, B1, B2);
2123 cb_t f;
2124 A1 a1;
2125 A2 a2;
2126 A3 a3;
2127 A4 a4;
2128 A5 a5;
2129 public:
2130 callback_2_5 (callback_line_param cb_t ff, const A1 &aa1, const A2 &aa2, const A3 &aa3, const A4 &aa4, const A5 &aa5)
2131 : callback_line_init (callback<R, B1, B2>) f (ff), a1 (aa1), a2 (aa2), a3 (aa3), a4 (aa4), a5 (aa5) {}
2132 R operator() (B1 b1, B2 b2)
2133 { return f (a1, a2, a3, a4, a5, b1, b2); }
2134 };
2135
2136 template<class R, class B1, class B2, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4, class A5, class AA5>
2137 static inline refcounted<callback_2_5<R, B1, B2, A1, A2, A3, A4, A5> > *
2138 wrap (wrap_line_param R (*f) (A1, A2, A3, A4, A5, B1, B2), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4, const AA5 &a5)
2139 {
2140 return wNew (refcounted<callback_2_5<R, B1, B2, A1, A2, A3, A4, A5> >) (wrap_line_arg f, a1, a2, a3, a4, a5);
2141 }
2142
2143 template<class P, class C, class R, class B1, class B2, class A1, class A2, class A3, class A4, class A5>
2144 class callback_c_2_5
2145 : public callback<R, B1, B2> {
2146 typedef R (C::*cb_t) (A1, A2, A3, A4, A5, B1, B2);
2147 P c;
2148 cb_t f;
2149 #if WRAP_USE_NODELETE
2150 A1 a1;
2151 A2 a2;
2152 A3 a3;
2153 A4 a4;
2154 A5 a5;
2155 int deleted;
2156 public:
2157 callback_c_2_5 (callback_line_param const P &cc, cb_t ff, const A1 &aa1, const A2 &aa2, const A3 &aa3, const A4 &aa4, const A5 &aa5)
2158 : callback_line_init (callback<R, B1, B2>) c (cc), f (ff), a1 (aa1), a2 (aa2), a3 (aa3), a4 (aa4), a5 (aa5),
2159 deleted (false)
2160 { maybe_nodelete_addptr (c, this->line, &deleted); }
2161 ~callback_c_2_5 () { maybe_nodelete_remptr (c, this->line, &deleted); }
2162 R operator() (B1 b1, B2 b2)
2163 {
2164 if (deleted)
2165 panic ("callback from %s to %s on deleted object\n",
2166 this->line, this->dest);
2167 return ((*c).*f) (a1, a2, a3, a4, a5, b1, b2);
2168 }
2169 #else /* !WRAP_USE_NODELETE */
2170 A1 a1;
2171 A2 a2;
2172 A3 a3;
2173 A4 a4;
2174 A5 a5;
2175 public:
2176 callback_c_2_5 (callback_line_param const P &cc, cb_t ff, const A1 &aa1, const A2 &aa2, const A3 &aa3, const A4 &aa4, const A5 &aa5)
2177 : callback_line_init (callback<R, B1, B2>) c (cc), f (ff), a1 (aa1), a2 (aa2), a3 (aa3), a4 (aa4), a5 (aa5) {}
2178 R operator() (B1 b1, B2 b2)
2179 { return ((*c).*f) (a1, a2, a3, a4, a5, b1, b2); }
2180 #endif /* !WRAP_USE_NODELETE */
2181 };
2182
2183 template<class C, class R, class B1, class B2, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4, class A5, class AA5>
2184 static inline refcounted<callback_c_2_5<C *, C, R, B1, B2, A1, A2, A3, A4, A5> > *
2185 wrap (wrap_line_param C *p, R (C::*f) (A1, A2, A3, A4, A5, B1, B2), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4, const AA5 &a5)
2186 {
2187 return wNew (refcounted<callback_c_2_5<C *, C, R, B1, B2, A1, A2, A3, A4, A5> >) (wrap_c_line_arg p, f, a1, a2, a3, a4, a5);
2188 }
2189
2190 template<class C, class R, class B1, class B2, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4, class A5, class AA5>
2191 static inline refcounted<callback_c_2_5<ref<C>, C, R, B1, B2, A1, A2, A3, A4, A5> > *
2192 wrap (wrap_line_param const ref<C> &p, R (C::*f) (A1, A2, A3, A4, A5, B1, B2), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4, const AA5 &a5)
2193 {
2194 return wNew (refcounted<callback_c_2_5<ref<C>, C, R, B1, B2, A1, A2, A3, A4, A5> >) (wrap_c_line_arg p, f, a1, a2, a3, a4, a5);
2195 }
2196 template<class C, class R, class B1, class B2, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4, class A5, class AA5>
2197 static inline refcounted<callback_c_2_5<ref<C>, C, R, B1, B2, A1, A2, A3, A4, A5> > *
2198 wrap (wrap_line_param const ptr<C> &p, R (C::*f) (A1, A2, A3, A4, A5, B1, B2), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4, const AA5 &a5)
2199 {
2200 return wNew (refcounted<callback_c_2_5<ref<C>, C, R, B1, B2, A1, A2, A3, A4, A5> >) (wrap_c_line_arg p, f, a1, a2, a3, a4, a5);
2201 }
2202 template<class C, class R, class B1, class B2, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4, class A5, class AA5>
2203 static inline refcounted<callback_c_2_5<ref<C>, C, R, B1, B2, A1, A2, A3, A4, A5> > *
2204 wrap (wrap_line_param const refcounted<C> *p, R (C::*f) (A1, A2, A3, A4, A5, B1, B2), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4, const AA5 &a5)
2205 {
2206 return wNew (refcounted<callback_c_2_5<ref<C>, C, R, B1, B2, A1, A2, A3, A4, A5> >) (wrap_c_line_arg p, f, a1, a2, a3, a4, a5);
2207 }
2208
2209 template<class R, class B1, class B2, class B3>
2210 class callback {
2211 public:
2212 typedef struct ref<callback<R, B1, B2, B3> > ref;
2213 typedef struct ptr<callback<R, B1, B2, B3> > ptr;
2214
2215 #if WRAP_DEBUG
2216 const char *const dest;
2217 const char *const src;
2218 const char *const line;
2219 callback (const char *df, const char *f, const char *l)
2220 : dest (df[0] == '&' ? df + 1 : df), src (f), line (l) {}
2221 #endif /* WRAP_DEBUG */
2222 virtual R operator() (B1, B2, B3) = 0;
2223 virtual ~callback () {}
2224 };
2225
2226
2227 template<class R, class B1, class B2, class B3>
2228 class callback_3_0
2229 : public callback<R, B1, B2, B3> {
2230 typedef R (*cb_t) (B1, B2, B3);
2231 cb_t f;
2232 public:
2233 callback_3_0 (callback_line_param cb_t ff)
2234 : callback_line_init (callback<R, B1, B2, B3>) f (ff) {}
2235 R operator() (B1 b1, B2 b2, B3 b3)
2236 { return f (b1, b2, b3); }
2237 };
2238
2239 template<class R, class B1, class B2, class B3>
2240 static inline refcounted<callback_3_0<R, B1, B2, B3> > *
2241 wrap (wrap_line_param R (*f) (B1, B2, B3))
2242 {
2243 return wNew (refcounted<callback_3_0<R, B1, B2, B3> >) (wrap_line_arg f);
2244 }
2245
2246 template<class P, class C, class R, class B1, class B2, class B3>
2247 class callback_c_3_0
2248 : public callback<R, B1, B2, B3> {
2249 typedef R (C::*cb_t) (B1, B2, B3);
2250 P c;
2251 cb_t f;
2252 #if WRAP_USE_NODELETE
2253 int deleted;
2254 public:
2255 callback_c_3_0 (callback_line_param const P &cc, cb_t ff)
2256 : callback_line_init (callback<R, B1, B2, B3>) c (cc), f (ff),
2257 deleted (false)
2258 { maybe_nodelete_addptr (c, this->line, &deleted); }
2259 ~callback_c_3_0 () { maybe_nodelete_remptr (c, this->line, &deleted); }
2260 R operator() (B1 b1, B2 b2, B3 b3)
2261 {
2262 if (deleted)
2263 panic ("callback from %s to %s on deleted object\n",
2264 this->line, this->dest);
2265 return ((*c).*f) (b1, b2, b3);
2266 }
2267 #else /* !WRAP_USE_NODELETE */
2268 public:
2269 callback_c_3_0 (callback_line_param const P &cc, cb_t ff)
2270 : callback_line_init (callback<R, B1, B2, B3>) c (cc), f (ff) {}
2271 R operator() (B1 b1, B2 b2, B3 b3)
2272 { return ((*c).*f) (b1, b2, b3); }
2273 #endif /* !WRAP_USE_NODELETE */
2274 };
2275
2276 template<class C, class R, class B1, class B2, class B3>
2277 static inline refcounted<callback_c_3_0<C *, C, R, B1, B2, B3> > *
2278 wrap (wrap_line_param C *p, R (C::*f) (B1, B2, B3))
2279 {
2280 return wNew (refcounted<callback_c_3_0<C *, C, R, B1, B2, B3> >) (wrap_c_line_arg p, f);
2281 }
2282
2283 template<class C, class R, class B1, class B2, class B3>
2284 static inline refcounted<callback_c_3_0<ref<C>, C, R, B1, B2, B3> > *
2285 wrap (wrap_line_param const ref<C> &p, R (C::*f) (B1, B2, B3))
2286 {
2287 return wNew (refcounted<callback_c_3_0<ref<C>, C, R, B1, B2, B3> >) (wrap_c_line_arg p, f);
2288 }
2289 template<class C, class R, class B1, class B2, class B3>
2290 static inline refcounted<callback_c_3_0<ref<C>, C, R, B1, B2, B3> > *
2291 wrap (wrap_line_param const ptr<C> &p, R (C::*f) (B1, B2, B3))
2292 {
2293 return wNew (refcounted<callback_c_3_0<ref<C>, C, R, B1, B2, B3> >) (wrap_c_line_arg p, f);
2294 }
2295 template<class C, class R, class B1, class B2, class B3>
2296 static inline refcounted<callback_c_3_0<ref<C>, C, R, B1, B2, B3> > *
2297 wrap (wrap_line_param const refcounted<C> *p, R (C::*f) (B1, B2, B3))
2298 {
2299 return wNew (refcounted<callback_c_3_0<ref<C>, C, R, B1, B2, B3> >) (wrap_c_line_arg p, f);
2300 }
2301
2302 template<class R, class B1, class B2, class B3, class A1>
2303 class callback_3_1
2304 : public callback<R, B1, B2, B3> {
2305 typedef R (*cb_t) (A1, B1, B2, B3);
2306 cb_t f;
2307 A1 a1;
2308 public:
2309 callback_3_1 (callback_line_param cb_t ff, const A1 &aa1)
2310 : callback_line_init (callback<R, B1, B2, B3>) f (ff), a1 (aa1) {}
2311 R operator() (B1 b1, B2 b2, B3 b3)
2312 { return f (a1, b1, b2, b3); }
2313 };
2314
2315 template<class R, class B1, class B2, class B3, class A1, class AA1>
2316 static inline refcounted<callback_3_1<R, B1, B2, B3, A1> > *
2317 wrap (wrap_line_param R (*f) (A1, B1, B2, B3), const AA1 &a1)
2318 {
2319 return wNew (refcounted<callback_3_1<R, B1, B2, B3, A1> >) (wrap_line_arg f, a1);
2320 }
2321
2322 template<class P, class C, class R, class B1, class B2, class B3, class A1>
2323 class callback_c_3_1
2324 : public callback<R, B1, B2, B3> {
2325 typedef R (C::*cb_t) (A1, B1, B2, B3);
2326 P c;
2327 cb_t f;
2328 #if WRAP_USE_NODELETE
2329 A1 a1;
2330 int deleted;
2331 public:
2332 callback_c_3_1 (callback_line_param const P &cc, cb_t ff, const A1 &aa1)
2333 : callback_line_init (callback<R, B1, B2, B3>) c (cc), f (ff), a1 (aa1),
2334 deleted (false)
2335 { maybe_nodelete_addptr (c, this->line, &deleted); }
2336 ~callback_c_3_1 () { maybe_nodelete_remptr (c, this->line, &deleted); }
2337 R operator() (B1 b1, B2 b2, B3 b3)
2338 {
2339 if (deleted)
2340 panic ("callback from %s to %s on deleted object\n",
2341 this->line, this->dest);
2342 return ((*c).*f) (a1, b1, b2, b3);
2343 }
2344 #else /* !WRAP_USE_NODELETE */
2345 A1 a1;
2346 public:
2347 callback_c_3_1 (callback_line_param const P &cc, cb_t ff, const A1 &aa1)
2348 : callback_line_init (callback<R, B1, B2, B3>) c (cc), f (ff), a1 (aa1) {}
2349 R operator() (B1 b1, B2 b2, B3 b3)
2350 { return ((*c).*f) (a1, b1, b2, b3); }
2351 #endif /* !WRAP_USE_NODELETE */
2352 };
2353
2354 template<class C, class R, class B1, class B2, class B3, class A1, class AA1>
2355 static inline refcounted<callback_c_3_1<C *, C, R, B1, B2, B3, A1> > *
2356 wrap (wrap_line_param C *p, R (C::*f) (A1, B1, B2, B3), const AA1 &a1)
2357 {
2358 return wNew (refcounted<callback_c_3_1<C *, C, R, B1, B2, B3, A1> >) (wrap_c_line_arg p, f, a1);
2359 }
2360
2361 template<class C, class R, class B1, class B2, class B3, class A1, class AA1>
2362 static inline refcounted<callback_c_3_1<ref<C>, C, R, B1, B2, B3, A1> > *
2363 wrap (wrap_line_param const ref<C> &p, R (C::*f) (A1, B1, B2, B3), const AA1 &a1)
2364 {
2365 return wNew (refcounted<callback_c_3_1<ref<C>, C, R, B1, B2, B3, A1> >) (wrap_c_line_arg p, f, a1);
2366 }
2367 template<class C, class R, class B1, class B2, class B3, class A1, class AA1>
2368 static inline refcounted<callback_c_3_1<ref<C>, C, R, B1, B2, B3, A1> > *
2369 wrap (wrap_line_param const ptr<C> &p, R (C::*f) (A1, B1, B2, B3), const AA1 &a1)
2370 {
2371 return wNew (refcounted<callback_c_3_1<ref<C>, C, R, B1, B2, B3, A1> >) (wrap_c_line_arg p, f, a1);
2372 }
2373 template<class C, class R, class B1, class B2, class B3, class A1, class AA1>
2374 static inline refcounted<callback_c_3_1<ref<C>, C, R, B1, B2, B3, A1> > *
2375 wrap (wrap_line_param const refcounted<C> *p, R (C::*f) (A1, B1, B2, B3), const AA1 &a1)
2376 {
2377 return wNew (refcounted<callback_c_3_1<ref<C>, C, R, B1, B2, B3, A1> >) (wrap_c_line_arg p, f, a1);
2378 }
2379
2380 template<class R, class B1, class B2, class B3, class A1, class A2>
2381 class callback_3_2
2382 : public callback<R, B1, B2, B3> {
2383 typedef R (*cb_t) (A1, A2, B1, B2, B3);
2384 cb_t f;
2385 A1 a1;
2386 A2 a2;
2387 public:
2388 callback_3_2 (callback_line_param cb_t ff, const A1 &aa1, const A2 &aa2)
2389 : callback_line_init (callback<R, B1, B2, B3>) f (ff), a1 (aa1), a2 (aa2) {}
2390 R operator() (B1 b1, B2 b2, B3 b3)
2391 { return f (a1, a2, b1, b2, b3); }
2392 };
2393
2394 template<class R, class B1, class B2, class B3, class A1, class AA1, class A2, class AA2>
2395 static inline refcounted<callback_3_2<R, B1, B2, B3, A1, A2> > *
2396 wrap (wrap_line_param R (*f) (A1, A2, B1, B2, B3), const AA1 &a1, const AA2 &a2)
2397 {
2398 return wNew (refcounted<callback_3_2<R, B1, B2, B3, A1, A2> >) (wrap_line_arg f, a1, a2);
2399 }
2400
2401 template<class P, class C, class R, class B1, class B2, class B3, class A1, class A2>
2402 class callback_c_3_2
2403 : public callback<R, B1, B2, B3> {
2404 typedef R (C::*cb_t) (A1, A2, B1, B2, B3);
2405 P c;
2406 cb_t f;
2407 #if WRAP_USE_NODELETE
2408 A1 a1;
2409 A2 a2;
2410 int deleted;
2411 public:
2412 callback_c_3_2 (callback_line_param const P &cc, cb_t ff, const A1 &aa1, const A2 &aa2)
2413 : callback_line_init (callback<R, B1, B2, B3>) c (cc), f (ff), a1 (aa1), a2 (aa2),
2414 deleted (false)
2415 { maybe_nodelete_addptr (c, this->line, &deleted); }
2416 ~callback_c_3_2 () { maybe_nodelete_remptr (c, this->line, &deleted); }
2417 R operator() (B1 b1, B2 b2, B3 b3)
2418 {
2419 if (deleted)
2420 panic ("callback from %s to %s on deleted object\n",
2421 this->line, this->dest);
2422 return ((*c).*f) (a1, a2, b1, b2, b3);
2423 }
2424 #else /* !WRAP_USE_NODELETE */
2425 A1 a1;
2426 A2 a2;
2427 public:
2428 callback_c_3_2 (callback_line_param const P &cc, cb_t ff, const A1 &aa1, const A2 &aa2)
2429 : callback_line_init (callback<R, B1, B2, B3>) c (cc), f (ff), a1 (aa1), a2 (aa2) {}
2430 R operator() (B1 b1, B2 b2, B3 b3)
2431 { return ((*c).*f) (a1, a2, b1, b2, b3); }
2432 #endif /* !WRAP_USE_NODELETE */
2433 };
2434
2435 template<class C, class R, class B1, class B2, class B3, class A1, class AA1, class A2, class AA2>
2436 static inline refcounted<callback_c_3_2<C *, C, R, B1, B2, B3, A1, A2> > *
2437 wrap (wrap_line_param C *p, R (C::*f) (A1, A2, B1, B2, B3), const AA1 &a1, const AA2 &a2)
2438 {
2439 return wNew (refcounted<callback_c_3_2<C *, C, R, B1, B2, B3, A1, A2> >) (wrap_c_line_arg p, f, a1, a2);
2440 }
2441
2442 template<class C, class R, class B1, class B2, class B3, class A1, class AA1, class A2, class AA2>
2443 static inline refcounted<callback_c_3_2<ref<C>, C, R, B1, B2, B3, A1, A2> > *
2444 wrap (wrap_line_param const ref<C> &p, R (C::*f) (A1, A2, B1, B2, B3), const AA1 &a1, const AA2 &a2)
2445 {
2446 return wNew (refcounted<callback_c_3_2<ref<C>, C, R, B1, B2, B3, A1, A2> >) (wrap_c_line_arg p, f, a1, a2);
2447 }
2448 template<class C, class R, class B1, class B2, class B3, class A1, class AA1, class A2, class AA2>
2449 static inline refcounted<callback_c_3_2<ref<C>, C, R, B1, B2, B3, A1, A2> > *
2450 wrap (wrap_line_param const ptr<C> &p, R (C::*f) (A1, A2, B1, B2, B3), const AA1 &a1, const AA2 &a2)
2451 {
2452 return wNew (refcounted<callback_c_3_2<ref<C>, C, R, B1, B2, B3, A1, A2> >) (wrap_c_line_arg p, f, a1, a2);
2453 }
2454 template<class C, class R, class B1, class B2, class B3, class A1, class AA1, class A2, class AA2>
2455 static inline refcounted<callback_c_3_2<ref<C>, C, R, B1, B2, B3, A1, A2> > *
2456 wrap (wrap_line_param const refcounted<C> *p, R (C::*f) (A1, A2, B1, B2, B3), const AA1 &a1, const AA2 &a2)
2457 {
2458 return wNew (refcounted<callback_c_3_2<ref<C>, C, R, B1, B2, B3, A1, A2> >) (wrap_c_line_arg p, f, a1, a2);
2459 }
2460
2461 template<class R, class B1, class B2, class B3, class A1, class A2, class A3>
2462 class callback_3_3
2463 : public callback<R, B1, B2, B3> {
2464 typedef R (*cb_t) (A1, A2, A3, B1, B2, B3);
2465 cb_t f;
2466 A1 a1;
2467 A2 a2;
2468 A3 a3;
2469 public:
2470 callback_3_3 (callback_line_param cb_t ff, const A1 &aa1, const A2 &aa2, const A3 &aa3)
2471 : callback_line_init (callback<R, B1, B2, B3>) f (ff), a1 (aa1), a2 (aa2), a3 (aa3) {}
2472 R operator() (B1 b1, B2 b2, B3 b3)
2473 { return f (a1, a2, a3, b1, b2, b3); }
2474 };
2475
2476 template<class R, class B1, class B2, class B3, class A1, class AA1, class A2, class AA2, class A3, class AA3>
2477 static inline refcounted<callback_3_3<R, B1, B2, B3, A1, A2, A3> > *
2478 wrap (wrap_line_param R (*f) (A1, A2, A3, B1, B2, B3), const AA1 &a1, const AA2 &a2, const AA3 &a3)
2479 {
2480 return wNew (refcounted<callback_3_3<R, B1, B2, B3, A1, A2, A3> >) (wrap_line_arg f, a1, a2, a3);
2481 }
2482
2483 template<class P, class C, class R, class B1, class B2, class B3, class A1, class A2, class A3>
2484 class callback_c_3_3
2485 : public callback<R, B1, B2, B3> {
2486 typedef R (C::*cb_t) (A1, A2, A3, B1, B2, B3);
2487 P c;
2488 cb_t f;
2489 #if WRAP_USE_NODELETE
2490 A1 a1;
2491 A2 a2;
2492 A3 a3;
2493 int deleted;
2494 public:
2495 callback_c_3_3 (callback_line_param const P &cc, cb_t ff, const A1 &aa1, const A2 &aa2, const A3 &aa3)
2496 : callback_line_init (callback<R, B1, B2, B3>) c (cc), f (ff), a1 (aa1), a2 (aa2), a3 (aa3),
2497 deleted (false)
2498 { maybe_nodelete_addptr (c, this->line, &deleted); }
2499 ~callback_c_3_3 () { maybe_nodelete_remptr (c, this->line, &deleted); }
2500 R operator() (B1 b1, B2 b2, B3 b3)
2501 {
2502 if (deleted)
2503 panic ("callback from %s to %s on deleted object\n",
2504 this->line, this->dest);
2505 return ((*c).*f) (a1, a2, a3, b1, b2, b3);
2506 }
2507 #else /* !WRAP_USE_NODELETE */
2508 A1 a1;
2509 A2 a2;
2510 A3 a3;
2511 public:
2512 callback_c_3_3 (callback_line_param const P &cc, cb_t ff, const A1 &aa1, const A2 &aa2, const A3 &aa3)
2513 : callback_line_init (callback<R, B1, B2, B3>) c (cc), f (ff), a1 (aa1), a2 (aa2), a3 (aa3) {}
2514 R operator() (B1 b1, B2 b2, B3 b3)
2515 { return ((*c).*f) (a1, a2, a3, b1, b2, b3); }
2516 #endif /* !WRAP_USE_NODELETE */
2517 };
2518
2519 template<class C, class R, class B1, class B2, class B3, class A1, class AA1, class A2, class AA2, class A3, class AA3>
2520 static inline refcounted<callback_c_3_3<C *, C, R, B1, B2, B3, A1, A2, A3> > *
2521 wrap (wrap_line_param C *p, R (C::*f) (A1, A2, A3, B1, B2, B3), const AA1 &a1, const AA2 &a2, const AA3 &a3)
2522 {
2523 return wNew (refcounted<callback_c_3_3<C *, C, R, B1, B2, B3, A1, A2, A3> >) (wrap_c_line_arg p, f, a1, a2, a3);
2524 }
2525
2526 template<class C, class R, class B1, class B2, class B3, class A1, class AA1, class A2, class AA2, class A3, class AA3>
2527 static inline refcounted<callback_c_3_3<ref<C>, C, R, B1, B2, B3, A1, A2, A3> > *
2528 wrap (wrap_line_param const ref<C> &p, R (C::*f) (A1, A2, A3, B1, B2, B3), const AA1 &a1, const AA2 &a2, const AA3 &a3)
2529 {
2530 return wNew (refcounted<callback_c_3_3<ref<C>, C, R, B1, B2, B3, A1, A2, A3> >) (wrap_c_line_arg p, f, a1, a2, a3);
2531 }
2532 template<class C, class R, class B1, class B2, class B3, class A1, class AA1, class A2, class AA2, class A3, class AA3>
2533 static inline refcounted<callback_c_3_3<ref<C>, C, R, B1, B2, B3, A1, A2, A3> > *
2534 wrap (wrap_line_param const ptr<C> &p, R (C::*f) (A1, A2, A3, B1, B2, B3), const AA1 &a1, const AA2 &a2, const AA3 &a3)
2535 {
2536 return wNew (refcounted<callback_c_3_3<ref<C>, C, R, B1, B2, B3, A1, A2, A3> >) (wrap_c_line_arg p, f, a1, a2, a3);
2537 }
2538 template<class C, class R, class B1, class B2, class B3, class A1, class AA1, class A2, class AA2, class A3, class AA3>
2539 static inline refcounted<callback_c_3_3<ref<C>, C, R, B1, B2, B3, A1, A2, A3> > *
2540 wrap (wrap_line_param const refcounted<C> *p, R (C::*f) (A1, A2, A3, B1, B2, B3), const AA1 &a1, const AA2 &a2, const AA3 &a3)
2541 {
2542 return wNew (refcounted<callback_c_3_3<ref<C>, C, R, B1, B2, B3, A1, A2, A3> >) (wrap_c_line_arg p, f, a1, a2, a3);
2543 }
2544
2545 template<class R, class B1, class B2, class B3, class A1, class A2, class A3, class A4>
2546 class callback_3_4
2547 : public callback<R, B1, B2, B3> {
2548 typedef R (*cb_t) (A1, A2, A3, A4, B1, B2, B3);
2549 cb_t f;
2550 A1 a1;
2551 A2 a2;
2552 A3 a3;
2553 A4 a4;
2554 public:
2555 callback_3_4 (callback_line_param cb_t ff, const A1 &aa1, const A2 &aa2, const A3 &aa3, const A4 &aa4)
2556 : callback_line_init (callback<R, B1, B2, B3>) f (ff), a1 (aa1), a2 (aa2), a3 (aa3), a4 (aa4) {}
2557 R operator() (B1 b1, B2 b2, B3 b3)
2558 { return f (a1, a2, a3, a4, b1, b2, b3); }
2559 };
2560
2561 template<class R, class B1, class B2, class B3, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4>
2562 static inline refcounted<callback_3_4<R, B1, B2, B3, A1, A2, A3, A4> > *
2563 wrap (wrap_line_param R (*f) (A1, A2, A3, A4, B1, B2, B3), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4)
2564 {
2565 return wNew (refcounted<callback_3_4<R, B1, B2, B3, A1, A2, A3, A4> >) (wrap_line_arg f, a1, a2, a3, a4);
2566 }
2567
2568 template<class P, class C, class R, class B1, class B2, class B3, class A1, class A2, class A3, class A4>
2569 class callback_c_3_4
2570 : public callback<R, B1, B2, B3> {
2571 typedef R (C::*cb_t) (A1, A2, A3, A4, B1, B2, B3);
2572 P c;
2573 cb_t f;
2574 #if WRAP_USE_NODELETE
2575 A1 a1;
2576 A2 a2;
2577 A3 a3;
2578 A4 a4;
2579 int deleted;
2580 public:
2581 callback_c_3_4 (callback_line_param const P &cc, cb_t ff, const A1 &aa1, const A2 &aa2, const A3 &aa3, const A4 &aa4)
2582 : callback_line_init (callback<R, B1, B2, B3>) c (cc), f (ff), a1 (aa1), a2 (aa2), a3 (aa3), a4 (aa4),
2583 deleted (false)
2584 { maybe_nodelete_addptr (c, this->line, &deleted); }
2585 ~callback_c_3_4 () { maybe_nodelete_remptr (c, this->line, &deleted); }
2586 R operator() (B1 b1, B2 b2, B3 b3)
2587 {
2588 if (deleted)
2589 panic ("callback from %s to %s on deleted object\n",
2590 this->line, this->dest);
2591 return ((*c).*f) (a1, a2, a3, a4, b1, b2, b3);
2592 }
2593 #else /* !WRAP_USE_NODELETE */
2594 A1 a1;
2595 A2 a2;
2596 A3 a3;
2597 A4 a4;
2598 public:
2599 callback_c_3_4 (callback_line_param const P &cc, cb_t ff, const A1 &aa1, const A2 &aa2, const A3 &aa3, const A4 &aa4)
2600 : callback_line_init (callback<R, B1, B2, B3>) c (cc), f (ff), a1 (aa1), a2 (aa2), a3 (aa3), a4 (aa4) {}
2601 R operator() (B1 b1, B2 b2, B3 b3)
2602 { return ((*c).*f) (a1, a2, a3, a4, b1, b2, b3); }
2603 #endif /* !WRAP_USE_NODELETE */
2604 };
2605
2606 template<class C, class R, class B1, class B2, class B3, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4>
2607 static inline refcounted<callback_c_3_4<C *, C, R, B1, B2, B3, A1, A2, A3, A4> > *
2608 wrap (wrap_line_param C *p, R (C::*f) (A1, A2, A3, A4, B1, B2, B3), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4)
2609 {
2610 return wNew (refcounted<callback_c_3_4<C *, C, R, B1, B2, B3, A1, A2, A3, A4> >) (wrap_c_line_arg p, f, a1, a2, a3, a4);
2611 }
2612
2613 template<class C, class R, class B1, class B2, class B3, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4>
2614 static inline refcounted<callback_c_3_4<ref<C>, C, R, B1, B2, B3, A1, A2, A3, A4> > *
2615 wrap (wrap_line_param const ref<C> &p, R (C::*f) (A1, A2, A3, A4, B1, B2, B3), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4)
2616 {
2617 return wNew (refcounted<callback_c_3_4<ref<C>, C, R, B1, B2, B3, A1, A2, A3, A4> >) (wrap_c_line_arg p, f, a1, a2, a3, a4);
2618 }
2619 template<class C, class R, class B1, class B2, class B3, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4>
2620 static inline refcounted<callback_c_3_4<ref<C>, C, R, B1, B2, B3, A1, A2, A3, A4> > *
2621 wrap (wrap_line_param const ptr<C> &p, R (C::*f) (A1, A2, A3, A4, B1, B2, B3), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4)
2622 {
2623 return wNew (refcounted<callback_c_3_4<ref<C>, C, R, B1, B2, B3, A1, A2, A3, A4> >) (wrap_c_line_arg p, f, a1, a2, a3, a4);
2624 }
2625 template<class C, class R, class B1, class B2, class B3, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4>
2626 static inline refcounted<callback_c_3_4<ref<C>, C, R, B1, B2, B3, A1, A2, A3, A4> > *
2627 wrap (wrap_line_param const refcounted<C> *p, R (C::*f) (A1, A2, A3, A4, B1, B2, B3), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4)
2628 {
2629 return wNew (refcounted<callback_c_3_4<ref<C>, C, R, B1, B2, B3, A1, A2, A3, A4> >) (wrap_c_line_arg p, f, a1, a2, a3, a4);
2630 }
2631
2632 template<class R, class B1, class B2, class B3, class A1, class A2, class A3, class A4, class A5>
2633 class callback_3_5
2634 : public callback<R, B1, B2, B3> {
2635 typedef R (*cb_t) (A1, A2, A3, A4, A5, B1, B2, B3);
2636 cb_t f;
2637 A1 a1;
2638 A2 a2;
2639 A3 a3;
2640 A4 a4;
2641 A5 a5;
2642 public:
2643 callback_3_5 (callback_line_param cb_t ff, const A1 &aa1, const A2 &aa2, const A3 &aa3, const A4 &aa4, const A5 &aa5)
2644 : callback_line_init (callback<R, B1, B2, B3>) f (ff), a1 (aa1), a2 (aa2), a3 (aa3), a4 (aa4), a5 (aa5) {}
2645 R operator() (B1 b1, B2 b2, B3 b3)
2646 { return f (a1, a2, a3, a4, a5, b1, b2, b3); }
2647 };
2648
2649 template<class R, class B1, class B2, class B3, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4, class A5, class AA5>
2650 static inline refcounted<callback_3_5<R, B1, B2, B3, A1, A2, A3, A4, A5> > *
2651 wrap (wrap_line_param R (*f) (A1, A2, A3, A4, A5, B1, B2, B3), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4, const AA5 &a5)
2652 {
2653 return wNew (refcounted<callback_3_5<R, B1, B2, B3, A1, A2, A3, A4, A5> >) (wrap_line_arg f, a1, a2, a3, a4, a5);
2654 }
2655
2656 template<class P, class C, class R, class B1, class B2, class B3, class A1, class A2, class A3, class A4, class A5>
2657 class callback_c_3_5
2658 : public callback<R, B1, B2, B3> {
2659 typedef R (C::*cb_t) (A1, A2, A3, A4, A5, B1, B2, B3);
2660 P c;
2661 cb_t f;
2662 #if WRAP_USE_NODELETE
2663 A1 a1;
2664 A2 a2;
2665 A3 a3;
2666 A4 a4;
2667 A5 a5;
2668 int deleted;
2669 public:
2670 callback_c_3_5 (callback_line_param const P &cc, cb_t ff, const A1 &aa1, const A2 &aa2, const A3 &aa3, const A4 &aa4, const A5 &aa5)
2671 : callback_line_init (callback<R, B1, B2, B3>) c (cc), f (ff), a1 (aa1), a2 (aa2), a3 (aa3), a4 (aa4), a5 (aa5),
2672 deleted (false)
2673 { maybe_nodelete_addptr (c, this->line, &deleted); }
2674 ~callback_c_3_5 () { maybe_nodelete_remptr (c, this->line, &deleted); }
2675 R operator() (B1 b1, B2 b2, B3 b3)
2676 {
2677 if (deleted)
2678 panic ("callback from %s to %s on deleted object\n",
2679 this->line, this->dest);
2680 return ((*c).*f) (a1, a2, a3, a4, a5, b1, b2, b3);
2681 }
2682 #else /* !WRAP_USE_NODELETE */
2683 A1 a1;
2684 A2 a2;
2685 A3 a3;
2686 A4 a4;
2687 A5 a5;
2688 public:
2689 callback_c_3_5 (callback_line_param const P &cc, cb_t ff, const A1 &aa1, const A2 &aa2, const A3 &aa3, const A4 &aa4, const A5 &aa5)
2690 : callback_line_init (callback<R, B1, B2, B3>) c (cc), f (ff), a1 (aa1), a2 (aa2), a3 (aa3), a4 (aa4), a5 (aa5) {}
2691 R operator() (B1 b1, B2 b2, B3 b3)
2692 { return ((*c).*f) (a1, a2, a3, a4, a5, b1, b2, b3); }
2693 #endif /* !WRAP_USE_NODELETE */
2694 };
2695
2696 template<class C, class R, class B1, class B2, class B3, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4, class A5, class AA5>
2697 static inline refcounted<callback_c_3_5<C *, C, R, B1, B2, B3, A1, A2, A3, A4, A5> > *
2698 wrap (wrap_line_param C *p, R (C::*f) (A1, A2, A3, A4, A5, B1, B2, B3), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4, const AA5 &a5)
2699 {
2700 return wNew (refcounted<callback_c_3_5<C *, C, R, B1, B2, B3, A1, A2, A3, A4, A5> >) (wrap_c_line_arg p, f, a1, a2, a3, a4, a5);
2701 }
2702
2703 template<class C, class R, class B1, class B2, class B3, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4, class A5, class AA5>
2704 static inline refcounted<callback_c_3_5<ref<C>, C, R, B1, B2, B3, A1, A2, A3, A4, A5> > *
2705 wrap (wrap_line_param const ref<C> &p, R (C::*f) (A1, A2, A3, A4, A5, B1, B2, B3), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4, const AA5 &a5)
2706 {
2707 return wNew (refcounted<callback_c_3_5<ref<C>, C, R, B1, B2, B3, A1, A2, A3, A4, A5> >) (wrap_c_line_arg p, f, a1, a2, a3, a4, a5);
2708 }
2709 template<class C, class R, class B1, class B2, class B3, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4, class A5, class AA5>
2710 static inline refcounted<callback_c_3_5<ref<C>, C, R, B1, B2, B3, A1, A2, A3, A4, A5> > *
2711 wrap (wrap_line_param const ptr<C> &p, R (C::*f) (A1, A2, A3, A4, A5, B1, B2, B3), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4, const AA5 &a5)
2712 {
2713 return wNew (refcounted<callback_c_3_5<ref<C>, C, R, B1, B2, B3, A1, A2, A3, A4, A5> >) (wrap_c_line_arg p, f, a1, a2, a3, a4, a5);
2714 }
2715 template<class C, class R, class B1, class B2, class B3, class A1, class AA1, class A2, class AA2, class A3, class AA3, class A4, class AA4, class A5, class AA5>
2716 static inline refcounted<callback_c_3_5<ref<C>, C, R, B1, B2, B3, A1, A2, A3, A4, A5> > *
2717 wrap (wrap_line_param const refcounted<C> *p, R (C::*f) (A1, A2, A3, A4, A5, B1, B2, B3), const AA1 &a1, const AA2 &a2, const AA3 &a3, const AA4 &a4, const AA5 &a5)
2718 {
2719 return wNew (refcounted<callback_c_3_5<ref<C>, C, R, B1, B2, B3, A1, A2, A3, A4, A5> >) (wrap_c_line_arg p, f, a1, a2, a3, a4, a5);
2720 }
2721
2722 template<class R, class B1, class B2, class B3>
2723 class refops<callback<R, B1, B2, B3> > {
2724 typedef callback<R, B1, B2, B3> cb_t;
2725 REFOPS_DEFAULT (cb_t);
2726 R operator() () const { return (*p) (); }
2727 template<class BB1>
2728 R operator() (const BB1 &b1) const
2729 { return (*p) (b1); }
2730 template<class BB1, class BB2>
2731 R operator() (const BB1 &b1, const BB2 &b2) const
2732 { return (*p) (b1, b2); }
2733 template<class BB1, class BB2, class BB3>
2734 R operator() (const BB1 &b1, const BB2 &b2, const BB3 &b3) const
2735 { return (*p) (b1, b2, b3); }
2736 };
2737
2738 #undef callback_line_param
2739 #undef wrap_line_param
2740 #undef wrap_line_arg
2741 #undef wrap_c_line_arg
2742 #if WRAP_DEBUG
2743 # undef wrap
2744 # define wrap_arg1(arg_1, arg_rest...) #arg_1
2745 # define wrap_arg2(arg_1, arg_rest...) wrap_arg1 (arg_rest)
2746 # define do_wrap(__func_name, __do_wrap_args...) \
2747 _wrap (wrap_arg1(__do_wrap_args), wrap_arg2(__do_wrap_args), \
2748 __func_name, __FL__, ## __do_wrap_args)
2749 # define wrap(__wrap_args...) do_wrap(__PRETTY_FUNCTION__, __wrap_args)
2750 # define gwrap(__wrap_args...) \
2751 (nodelete_ignore () ? do_wrap(__FL__, __wrap_args) : 0)
2752 #else /* !WRAP_DEBUG */
2753 # define gwrap wrap
2754 #endif /* !WRAP_DEBUG */
2755
2756
2757 #endif /* !_CALLBACK_H_INCLUDED_ */
2758