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;

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);

  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);
  }

private:

  void *self;
  ptr_type func;

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

EOF
}

print <<EOF

#endif
EOF

Revision:	1.13
Committed:	Wed Dec 5 18:19:50 2007 UTC (16 years, 5 months ago) by pcg
Content type:	text/plain
Branch:	MAIN
Changes since 1.12:	+12 -24 lines
Log Message:	* empty log message *
#	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.1	EOF
40
41	pcg	1.9	for my $a (0..10) {
42	pcg	1.1	my $CLASS = join "", map ", class A$_", 1..$a;
43			my $TYPE = join ", ", map "A$_", 1..$a;
44			my $ARG = join ", ", map "a$_", 1..$a;
45			my $TYPEARG = join ", ", map "A$_ a$_", 1..$a;
46	pcg	1.9	my $TYPEDEFS = join " ", map "typedef A$_ arg$_\_type;", 1..$a;
47			my $TYPEvoid = $TYPE ? $TYPE : "void";
48	pcg	1.11	my $_ARG = $ARG ? ", $ARG" : "";
49	pcg	1.9	my $_TYPE = $TYPE ? ", $TYPE" : "";
50	pcg	1.11	my $_TYPEARG = $TYPEARG ? ", $TYPEARG" : "";
51	pcg	1.9	my $_TTYPE = $a ? join "", map ", typename T::arg$_\_type", 1..$a : "";
52	pcg	1.1
53			print <<EOF;
54			template<class R$CLASS>
55	pcg	1.11	struct callback<R ($TYPE)>
56	pcg	1.9	{
57	pcg	1.11	typedef R (ptr_type)(void self$_TYPE);
58	pcg	1.9
59	pcg	1.11	template<class K, R (K::*method)($TYPE)>
60			void set (K *object)
61	pcg	1.10	{
62	pcg	1.11	self = object;
63			func = thunk<K, method>;
64	pcg	1.10	}
65
66	pcg	1.11	R call ($TYPEARG) const
67	pcg	1.10	{
68	pcg	1.11	return func (self$_ARG);
69	pcg	1.10	}
70	pcg	1.1
71			R operator ()($TYPEARG) const
72	pcg	1.10	{
73			return call ($ARG);
74			}
75	pcg	1.13
76			private:
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	pcg	1.1	};
88
89			EOF
90			}
91
92			print <<EOF
93	pcg	1.9
94	pcg	1.1	#endif
95			EOF
96