--- gvpe/src/callback.pl	2005/12/27 16:36:16	1.7
+++ gvpe/src/callback.pl	2007/12/04 17:17:19	1.12
@@ -1,5 +1,7 @@
 #!/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
@@ -7,7 +9,7 @@
 
 /*
     callback.h -- C++ callback mechanism
-    Copyright (C) 2003-2005 Marc Lehmann <pcg\@goof.com>
+    Copyright (C) 2003-2007 Marc Lehmann <pcg\@goof.com>
  
     This file is part of GVPE.
 
@@ -29,64 +31,78 @@
 #ifndef CALLBACK_H__
 #define CALLBACK_H__
 
+#define CALLBACK_H_VERSION 3
+
+template<typename signature>
+struct callback;
+
 EOF
 
-for my $a (0..7) {
+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>
-class callback$a {
-  struct object { };
+struct callback<R ($TYPE)>
+{
+  typedef R (*ptr_type)(void *self$_TYPE);
 
-  void *obj;
-  R (object::*meth)($TYPE);
+private:
 
-  /* a proxy is a kind of recipe on how to call a specific class method	*/
-  struct proxy_base {
-    virtual R call (void *obj, R (object::*meth)($TYPE)$_TYPEARG) = 0;
-  };
-  template<class O1, class O2>
-  struct proxy : proxy_base {
-    virtual R call (void *obj, R (object::*meth)($TYPE)$_TYPEARG)
-      {
-        return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)($TYPE)>(meth)))
-          ($ARG);
-      }
+  void *self;
+  ptr_type func;
+
+protected:
+
+  template<typename method>
+  struct thunktype;
+
+  template<class klass>
+  struct thunktype<R (klass::*)>
+  {
+    typedef klass K;
   };
 
-  proxy_base *prxy;
+  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 O1, class O2>
-  callback$a (O1 *object, R (O2::*method)($TYPE))
-    {
-      static proxy<O1,O2> p;
-      obj  = reinterpret_cast<void *>(object);
-      meth = reinterpret_cast<R (object::*)($TYPE)>(method);
-      prxy = &p;
-    }
-
-  R call($TYPEARG) const
-    {
-      return prxy->call (obj, meth$_ARG);
-    }
+  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);
-    }
+  {
+    return call ($ARG);
+  }
 };
 
 EOF
 }
 
 print <<EOF
+
 #endif
 EOF