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.6 by pcg, Tue Nov 29 19:21:09 2005 UTC vs.
Revision 1.10 by pcg, Sun Dec 2 00:54:52 2007 UTC

1#!/usr/bin/perl 1#!/usr/bin/perl
2
3use strict;
2 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: callback.pl is part of the GVPE 7// THIS IS A GENERATED FILE: callback.pl is part of the GVPE
6// THIS IS A GENERATED FILE: distribution. 8// THIS IS A GENERATED FILE: distribution.
7 9
8/* 10/*
9 callback.h -- C++ callback mechanism 11 callback.h -- C++ callback mechanism
10 Copyright (C) 2003-2005 Marc Lehmann <pcg\@goof.com> 12 Copyright (C) 2003-2007 Marc Lehmann <pcg\@goof.com>
11 13
12 This file is part of GVPE. 14 This file is part of GVPE.
13 15
14 GVPE is free software; you can redistribute it and/or modify 16 GVPE is free software; you can redistribute it and/or modify
15 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
… …
27*/ 29*/
28 30
29#ifndef CALLBACK_H__ 31#ifndef CALLBACK_H__
30#define CALLBACK_H__ 32#define CALLBACK_H__
31 33
34#define CALLBACK_H_VERSION 3
35
36template<class signature>
37struct callback_funtype_trait;
38
39template<int arity, class signature>
40struct callback_get_impl;
41
32EOF 42EOF
33 43
34for my $a (0..7) { 44for my $a (0..10) {
35 my $CLASS = join "", map ", class A$_", 1..$a; 45 my $CLASS = join "", map ", class A$_", 1..$a;
36 my $TYPE = join ", ", map "A$_", 1..$a; 46 my $TYPE = join ", ", map "A$_", 1..$a;
37 my $ARG = join ", ", map "a$_", 1..$a; 47 my $ARG = join ", ", map "a$_", 1..$a;
38 my $TYPEARG = join ", ", map "A$_ a$_", 1..$a; 48 my $TYPEARG = join ", ", map "A$_ a$_", 1..$a;
39 my $_ARG = $ARG ? ", $ARG" : ""; 49 my $TYPEDEFS = join " ", map "typedef A$_ arg$_\_type;", 1..$a;
50 my $TYPEvoid = $TYPE ? $TYPE : "void";
40 my $_TYPEARG = $TYPEARG ? ", $TYPEARG" : ""; 51 my $_TYPE = $TYPE ? ", $TYPE" : "";
52 my $_TTYPE = $a ? join "", map ", typename T::arg$_\_type", 1..$a : "";
41 53
42 print <<EOF; 54 print <<EOF;
43template<class R$CLASS> 55template<class R$CLASS>
44class callback$a { 56class callback$a
45 struct object { }; 57{
58 struct klass; // it is vital that this is never defined
46 59
47 void *obj; 60 typedef R (klass::*ptr_type)($TYPE);
48 R (object::*meth)($TYPE);
49 61
50 /* a proxy is a kind of recipe on how to call a specific class method */ 62 klass *o;
51 struct proxy_base { 63 R (klass::*m)($TYPE);
52 virtual R call (void *obj, R (object::*meth)($TYPE)$_TYPEARG) = 0;
53 };
54 template<class O1, class O2>
55 struct proxy : proxy_base {
56 virtual R call (void *obj, R (object::*meth)($TYPE)$_TYPEARG)
57 {
58 ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)($TYPE)>(meth)))
59 ($ARG);
60 }
61 };
62
63 proxy_base *prxy;
64 64
65public: 65public:
66 template<class O1, class O2> 66 template<class O1, class O2>
67 callback$a (O1 *object, R (O2::*method)($TYPE)) 67 explicit callback$a (O1 *object, R (O2::*method)($TYPE))
68 { 68 {
69 static proxy<O1,O2> p;
70 obj = reinterpret_cast<void *>(object); 69 o = reinterpret_cast<klass *>(object);
71 meth = reinterpret_cast<R (object::*)($TYPE)>(method); 70 m = reinterpret_cast<R (klass::*)($TYPE)>(method);
72 prxy = &p;
73 } 71 }
74 72
73 // this works because a standards-compliant C++ compiler
74 // basically can't help it: it doesn't have the knowledge
75 // required to miscompile (klass is not defined anywhere
76 // and nothing is known about the constructor arguments) :)
75 R call($TYPEARG) const 77 R call($TYPEARG) const
76 { 78 {
77 return prxy->call (obj, meth$_ARG); 79 return (o->*m) ($ARG);
78 } 80 }
79 81
80 R operator ()($TYPEARG) const 82 R operator ()($TYPEARG) const
81 { 83 {
82 return call ($ARG); 84 return call ($ARG);
83 } 85 }
84}; 86};
85 87
88template<class R$CLASS>
89struct callback_funtype_trait$a
90{
91 static const int arity = $a;
92 typedef R type ($TYPEvoid);
93 typedef R result_type;
94 $TYPEDEFS
95};
96
97template<class R$CLASS>
98struct callback_funtype_trait<R ($TYPE)> : callback_funtype_trait$a<R$_TYPE>
99{
100};
101
102template<class signature>
103struct callback_get_impl<$a, signature>
104{
105 typedef callback_funtype_trait<signature> T;
106 typedef callback$a<typename T::result_type$_TTYPE> type;
107};
108
86EOF 109EOF
87} 110}
88 111
89print <<EOF 112print <<EOF
113
114template<class signature>
115struct callback : callback_get_impl<callback_funtype_trait<signature>::arity, signature>::type
116{
117 typedef typename callback_get_impl<callback_funtype_trait<signature>::arity, signature>::type base_type;
118
119 template<class O, class M>
120 explicit callback (O object, M method)
121 : base_type (object, method)
122 {
123 }
124};
125
90#endif 126#endif
91EOF 127EOF
92 128

Diff Legend

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