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.11 by pcg, Tue Dec 4 15:01:12 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
39#define callback_set(callback,obj,klass,method) callback.set<klass, &klass::method> (obj)
40
35EOF 41EOF
36 42
37for my $a (0..7) { 43for my $a (0..10) {
38 my $CLASS = join "", map ", class A$_", 1..$a; 44 my $CLASS = join "", map ", class A$_", 1..$a;
39 my $TYPE = join ", ", map "A$_", 1..$a; 45 my $TYPE = join ", ", map "A$_", 1..$a;
40 my $ARG = join ", ", map "a$_", 1..$a; 46 my $ARG = join ", ", map "a$_", 1..$a;
41 my $TYPEARG = join ", ", map "A$_ a$_", 1..$a; 47 my $TYPEARG = join ", ", map "A$_ a$_", 1..$a;
48 my $TYPEDEFS = join " ", map "typedef A$_ arg$_\_type;", 1..$a;
49 my $TYPEvoid = $TYPE ? $TYPE : "void";
42 my $_ARG = $ARG ? ", $ARG" : ""; 50 my $_ARG = $ARG ? ", $ARG" : "";
51 my $_TYPE = $TYPE ? ", $TYPE" : "";
43 my $_TYPEARG = $TYPEARG ? ", $TYPEARG" : ""; 52 my $_TYPEARG = $TYPEARG ? ", $TYPEARG" : "";
53 my $_TTYPE = $a ? join "", map ", typename T::arg$_\_type", 1..$a : "";
44 54
45 print <<EOF; 55 print <<EOF;
46template<class R$CLASS> 56template<class R$CLASS>
47class callback$a { 57struct callback<R ($TYPE)>
48 struct object { }; 58{
59 typedef R (*ptr_type)(void *self$_TYPE);
49 60
50 void *obj; 61private:
51 R (object::*meth)($TYPE);
52 62
53 /* a proxy is a kind of recipe on how to call a specific class method */ 63 void *self;
54 struct proxy_base { 64 ptr_type func;
55 virtual R call (void *obj, R (object::*meth)($TYPE)$_TYPEARG) = 0; 65
56 }; 66protected:
67
68 template<typename method>
69 struct thunktype;
70
57 template<class O1, class O2> 71 template<class klass>
58 struct proxy : proxy_base { 72 struct thunktype<R (klass::*)>
59 virtual R call (void *obj, R (object::*meth)($TYPE)$_TYPEARG) 73 {
60 { 74 typedef klass K;
61 ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)($TYPE)>(meth)))
62 ($ARG);
63 }
64 }; 75 };
65 76
66 proxy_base *prxy; 77 template<class klass, R (klass::*method)($TYPE)>
78 static R thunk (void *self$_TYPEARG)
79 {
80 klass *obj = static_cast<klass *>(self);
81 return (obj->*method) ($ARG);
82 }
67 83
68public: 84public:
69 template<class O1, class O2> 85 template<class K, R (K::*method)($TYPE)>
70 callback$a (O1 *object, R (O2::*method)($TYPE)) 86 void set (K *object)
71 { 87 {
72 static proxy<O1,O2> p; 88 self = object;
73 obj = reinterpret_cast<void *>(object); 89 func = thunk<K, method>;
74 meth = reinterpret_cast<R (object::*)($TYPE)>(method);
75 prxy = &p;
76 } 90 }
77 91
78 R call($TYPEARG) const 92 R call ($TYPEARG) const
79 { 93 {
80 return prxy->call (obj, meth$_ARG); 94 return func (self$_ARG);
81 } 95 }
82 96
83 R operator ()($TYPEARG) const 97 R operator ()($TYPEARG) const
84 { 98 {
85 return call ($ARG); 99 return call ($ARG);
86 } 100 }
87}; 101};
88 102
89EOF 103EOF
90} 104}
91 105
92print <<EOF 106print <<EOF
107
93#endif 108#endif
94EOF 109EOF
95 110

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines