--- gvpe/src/callback.pl	2006/05/31 00:31:47	1.9
+++ gvpe/src/callback.pl	2007/12/05 18:19:50	1.13
@@ -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-2006 Marc Lehmann <pcg\@goof.com>
+    Copyright (C) 2003-2007 Marc Lehmann <pcg\@goof.com>
  
     This file is part of GVPE.
 
@@ -29,13 +31,10 @@
 #ifndef CALLBACK_H__
 #define CALLBACK_H__
 
-#define CALLBACK_H_VERSION 2
-
-template<class signature>
-struct callback_funtype_trait;
+#define CALLBACK_H_VERSION 3
 
-template<int arity, class signature>
-struct callback_get_impl;
+template<typename signature>
+struct callback;
 
 EOF
 
@@ -46,96 +45,52 @@
    my $TYPEARG   = join ", ", map "A$_ a$_", 1..$a;
    my $TYPEDEFS  = join " ", map "typedef A$_ arg$_\_type;", 1..$a;
    my $TYPEvoid  = $TYPE    ? $TYPE        : "void";
-   my $_TYPE     = $TYPE    ? ", $TYPE"    : "";
    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 callback<R ($TYPE)>
 {
-  struct object { };
-
-  typedef R (object::*ptr_type)($TYPE);
-
-  void *obj;
-  R (object::*meth)($TYPE);
+  typedef R (*ptr_type)(void *self$_TYPE);
 
-  /* 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) const = 0;
-  };
-  template<class O1, class O2>
-  struct proxy : proxy_base {
-    virtual R call (void *obj, R (object::*meth)($TYPE)$_TYPEARG) const
-      {
-        return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)($TYPE)>(meth)))
-          ($ARG);
-      }
-  };
-
-  proxy_base *prxy;
-
-public:
-  template<class O1, class O2>
-  explicit 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);
+  }
+
+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);
+  }
 };
 
-template<class R$CLASS>
-struct callback_funtype_trait$a
-{
-  static const int arity = $a;
-  typedef R type ($TYPEvoid);
-  typedef R result_type;
-  $TYPEDEFS
-};
-
-template<class R$CLASS>
-struct callback_funtype_trait<R ($TYPE)> : callback_funtype_trait$a<R$_TYPE>
-{
-};
-
-template<class signature>
-struct callback_get_impl<$a, signature>
-{
-  typedef callback_funtype_trait<signature> T;
-  typedef callback$a<typename T::result_type$_TTYPE> type;
-};
-   
 EOF
 }
 
 print <<EOF
 
-template<class signature>
-struct callback : callback_get_impl<callback_funtype_trait<signature>::arity, signature>::type
-{
-  typedef typename callback_get_impl<callback_funtype_trait<signature>::arity, signature>::type base_type;
-
-  template<class O, class M>
-  explicit callback (O object, M method)
-    : base_type (object, method)
-    {
-    }
-};
-
 #endif
 EOF