ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/gvpe/src/callback.pl
(Generate patch)

Comparing gvpe/src/callback.pl (file contents):
Revision 1.4 by pcg, Thu Mar 3 16:54:34 2005 UTC vs.
Revision 1.13 by pcg, Wed Dec 5 18:19:50 2007 UTC

1#!/usr/bin/perl 1#!/usr/bin/perl
2 2
3use strict;
4
3print <<EOF; 5print <<EOF;
4// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it 6// THIS IS A GENERATED FILE: RUN callback.pl to regenerate it
5// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it 7// THIS IS A GENERATED FILE: callback.pl is part of the GVPE
6// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it 8// THIS IS A GENERATED FILE: distribution.
7// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
8// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
9// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
10 9
11/* 10/*
12 callback.h -- C++ callback mechanism 11 callback.h -- C++ callback mechanism
13 Copyright (C) 2003 Marc Lehmann <pcg\@goof.com> 12 Copyright (C) 2003-2007 Marc Lehmann <pcg\@goof.com>
14 13
15 This file is part of GVPE. 14 This file is part of GVPE.
16 15
17 GVPE is free software; you can redistribute it and/or modify 16 GVPE is free software; you can redistribute it and/or modify
18 it under the terms of the GNU General Public License as published by 17 it under the terms of the GNU General Public License as published by
… …
24 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25 GNU General Public License for more details. 24 GNU General Public License for more details.
26 25
27 You should have received a copy of the GNU General Public License 26 You should have received a copy of the GNU General Public License
28 along with gvpe; if not, write to the Free Software 27 along with gvpe; if not, write to the Free Software
29 Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 28 Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30*/ 29*/
31 30
32#ifndef CALLBACK_H__ 31#ifndef CALLBACK_H__
33#define CALLBACK_H__ 32#define CALLBACK_H__
34 33
34#define CALLBACK_H_VERSION 3
35
36template<typename signature>
37struct callback;
38
35EOF 39EOF
36 40
37for my $a (0..7) { 41for my $a (0..10) {
38 my $CLASS = join "", map ", class A$_", 1..$a; 42 my $CLASS = join "", map ", class A$_", 1..$a;
39 my $TYPE = join ", ", map "A$_", 1..$a; 43 my $TYPE = join ", ", map "A$_", 1..$a;
40 my $ARG = join ", ", map "a$_", 1..$a; 44 my $ARG = join ", ", map "a$_", 1..$a;
41 my $TYPEARG = join ", ", map "A$_ a$_", 1..$a; 45 my $TYPEARG = join ", ", map "A$_ a$_", 1..$a;
46 my $TYPEDEFS = join " ", map "typedef A$_ arg$_\_type;", 1..$a;
47 my $TYPEvoid = $TYPE ? $TYPE : "void";
42 my $_ARG = $ARG ? ", $ARG" : ""; 48 my $_ARG = $ARG ? ", $ARG" : "";
49 my $_TYPE = $TYPE ? ", $TYPE" : "";
43 my $_TYPEARG = $TYPEARG ? ", $TYPEARG" : ""; 50 my $_TYPEARG = $TYPEARG ? ", $TYPEARG" : "";
51 my $_TTYPE = $a ? join "", map ", typename T::arg$_\_type", 1..$a : "";
44 52
45 print <<EOF; 53 print <<EOF;
46template<class R$CLASS> 54template<class R$CLASS>
47class callback$a { 55struct callback<R ($TYPE)>
48 struct object { }; 56{
57 typedef R (*ptr_type)(void *self$_TYPE);
49 58
50 void *obj; 59 template<class K, R (K::*method)($TYPE)>
51 R (object::*meth)($TYPE); 60 void set (K *object)
61 {
62 self = object;
63 func = thunk<K, method>;
64 }
52 65
53 /* a proxy is a kind of recipe on how to call a specific class method */
54 struct proxy_base {
55 virtual R call (void *obj, R (object::*meth)($TYPE)$_TYPEARG) = 0;
56 };
57 template<class O1, class O2>
58 struct proxy : proxy_base {
59 virtual R call (void *obj, R (object::*meth)($TYPE)$_TYPEARG)
60 {
61 ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)($TYPE)>(meth)))
62 ($ARG);
63 }
64 };
65
66 proxy_base *prxy;
67
68public:
69 template<class O1, class O2>
70 callback$a (O1 *object, R (O2::*method)($TYPE))
71 {
72 static proxy<O1,O2> p;
73 obj = reinterpret_cast<void *>(object);
74 meth = reinterpret_cast<R (object::*)($TYPE)>(method);
75 prxy = &p;
76 }
77
78 R call($TYPEARG) const 66 R call ($TYPEARG) const
79 { 67 {
80 return prxy->call (obj, meth$_ARG); 68 return func (self$_ARG);
81 } 69 }
82 70
83 R operator ()($TYPEARG) const 71 R operator ()($TYPEARG) const
84 { 72 {
85 return call ($ARG); 73 return call ($ARG);
86 } 74 }
75
76private:
77
78 void *self;
79 ptr_type func;
80
81 template<class klass, R (klass::*method)($TYPE)>
82 static R thunk (void *self$_TYPEARG)
83 {
84 klass *obj = static_cast<klass *>(self);
85 return (obj->*method) ($ARG);
86 }
87}; 87};
88 88
89EOF 89EOF
90} 90}
91 91
92print <<EOF 92print <<EOF
93
93#endif 94#endif
94EOF 95EOF
95 96

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines