gvpe/src/callback.pl

#!/usr/bin/perl

use strict;

print <<EOF;
// THIS IS A GENERATED FILE: RUN callback.pl to regenerate it
// THIS IS A GENERATED FILE: callback.pl is part of the GVPE
// THIS IS A GENERATED FILE: distribution.

/*
    callback.h -- C++ callback mechanism
    Copyright (C) 2003-2007 Marc Lehmann <pcg\@goof.com>
 
    This file is part of GVPE.

    GVPE is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with gvpe; if not, write to the Free Software
    Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef CALLBACK_H__
#define CALLBACK_H__

#define CALLBACK_H_VERSION 3

template<typename signature>
struct callback;

#define callback_set(callback,obj,klass,method) callback.set<klass, &klass::method> (obj)

EOF

for my $a (0..10) {
   my $CLASS     = join "", map ", class A$_", 1..$a;
   my $TYPE      = join ", ", map "A$_", 1..$a;
   my $ARG       = join ", ", map "a$_", 1..$a;
   my $TYPEARG   = join ", ", map "A$_ a$_", 1..$a;
   my $TYPEDEFS  = join " ", map "typedef A$_ arg$_\_type;", 1..$a;
   my $TYPEvoid  = $TYPE    ? $TYPE        : "void";
   my $_ARG      = $ARG     ? ", $ARG"     : "";
   my $_TYPE     = $TYPE    ? ", $TYPE"    : "";
   my $_TYPEARG  = $TYPEARG ? ", $TYPEARG" : "";
   my $_TTYPE    = $a       ? join "", map ", typename T::arg$_\_type", 1..$a : "";
   
   print <<EOF;
template<class R$CLASS>
struct callback<R ($TYPE)>
{
  typedef R (*ptr_type)(void *self$_TYPE);

private:

  void *self;
  ptr_type func;

protected:

  template<typename method>
  struct thunktype;

  template<class klass>
  struct thunktype<R (klass::*)>
  {
    typedef klass K;
  };

  template<class klass, R (klass::*method)($TYPE)>
  static R thunk (void *self$_TYPEARG)
  {
    klass *obj = static_cast<klass *>(self);
    return (obj->*method) ($ARG);
  }

public:
  template<class K, R (K::*method)($TYPE)>
  void set (K *object)
  {
    self = object;
    func = thunk<K, method>;
  }

  R call ($TYPEARG) const
  {
    return func (self$_ARG);
  }

  R operator ()($TYPEARG) const
  {
    return call ($ARG);
  }
};

EOF
}

print <<EOF

#endif
EOF

Revision:	1.11
Committed:	Tue Dec 4 15:01:12 2007 UTC (16 years, 5 months ago) by pcg
Content type:	text/plain
Branch:	MAIN
Changes since 1.10:	+34 -52 lines
Log Message:	switch to new cb system
#	User	Rev	Content
1	pcg	1.1	#!/usr/bin/perl
2
3	pcg	1.10	use strict;
4
5	pcg	1.1	print <<EOF;
6	pcg	1.6	// THIS IS A GENERATED FILE: RUN callback.pl to regenerate it
7			// THIS IS A GENERATED FILE: callback.pl is part of the GVPE
8			// THIS IS A GENERATED FILE: distribution.
9	pcg	1.1
10			/*
11			callback.h -- C++ callback mechanism
12	pcg	1.10	Copyright (C) 2003-2007 Marc Lehmann <pcg\@goof.com>
13	pcg	1.1
14	pcg	1.4	This file is part of GVPE.
15
16			GVPE is free software; you can redistribute it and/or modify
17	pcg	1.1	it under the terms of the GNU General Public License as published by
18			the Free Software Foundation; either version 2 of the License, or
19			(at your option) any later version.
20
21			This program is distributed in the hope that it will be useful,
22			but WITHOUT ANY WARRANTY; without even the implied warranty of
23			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24			GNU General Public License for more details.
25
26			You should have received a copy of the GNU General Public License
27	pcg	1.4	along with gvpe; if not, write to the Free Software
28	pcg	1.5	Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
29	pcg	1.1	*/
30
31	pcg	1.3	#ifndef CALLBACK_H__
32			#define CALLBACK_H__
33	pcg	1.1
34	pcg	1.10	#define CALLBACK_H_VERSION 3
35	pcg	1.9
36	pcg	1.11	template<typename signature>
37			struct callback;
38	pcg	1.9
39	pcg	1.11	#define callback_set(callback,obj,klass,method) callback.set<klass, &klass::method> (obj)
40	pcg	1.9
41	pcg	1.1	EOF
42
43	pcg	1.9	for my $a (0..10) {
44	pcg	1.1	my $CLASS = join "", map ", class A$_", 1..$a;
45			my $TYPE = join ", ", map "A$_", 1..$a;
46			my $ARG = join ", ", map "a$_", 1..$a;
47			my $TYPEARG = join ", ", map "A$_ a$_", 1..$a;
48	pcg	1.9	my $TYPEDEFS = join " ", map "typedef A$_ arg$_\_type;", 1..$a;
49			my $TYPEvoid = $TYPE ? $TYPE : "void";
50	pcg	1.11	my $_ARG = $ARG ? ", $ARG" : "";
51	pcg	1.9	my $_TYPE = $TYPE ? ", $TYPE" : "";
52	pcg	1.11	my $_TYPEARG = $TYPEARG ? ", $TYPEARG" : "";
53	pcg	1.9	my $_TTYPE = $a ? join "", map ", typename T::arg$_\_type", 1..$a : "";
54	pcg	1.1
55			print <<EOF;
56			template<class R$CLASS>
57	pcg	1.11	struct callback<R ($TYPE)>
58	pcg	1.9	{
59	pcg	1.11	typedef R (ptr_type)(void self$_TYPE);
60	pcg	1.9
61	pcg	1.11	private:
62	pcg	1.1
63	pcg	1.11	void *self;
64			ptr_type func;
65
66			protected:
67
68			template<typename method>
69			struct thunktype;
70
71			template<class klass>
72			struct thunktype<R (klass::*)>
73			{
74			typedef klass K;
75			};
76
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			}
83	pcg	1.1
84			public:
85	pcg	1.11	template<class K, R (K::*method)($TYPE)>
86			void set (K *object)
87	pcg	1.10	{
88	pcg	1.11	self = object;
89			func = thunk<K, method>;
90	pcg	1.10	}
91
92	pcg	1.11	R call ($TYPEARG) const
93	pcg	1.10	{
94	pcg	1.11	return func (self$_ARG);
95	pcg	1.10	}
96	pcg	1.1
97			R operator ()($TYPEARG) const
98	pcg	1.10	{
99			return call ($ARG);
100			}
101	pcg	1.1	};
102
103			EOF
104			}
105
106			print <<EOF
107	pcg	1.9
108	pcg	1.1	#endif
109			EOF
110